From b05fedb76ecc8c8e408a974ed057bb121c9a984e Mon Sep 17 00:00:00 2001 From: g-spacewhale Date: Fri, 17 Nov 2017 22:10:36 +0100 Subject: [PATCH] added folder structure --- Source/a.out | Bin 0 -> 23000 bytes Source/header/input.h | 30 +- Source/main.cpp | 38 +- TeamCMU/Basic_Structure.txt | 34 ++ TeamCMU/Revision_01/Puzzle.h | 375 ++++++++++++++++ TeamCMU/Revision_01/main.cpp | 160 +++++++ TeamCMU/Revision_02/a.out | Bin 0 -> 75216 bytes TeamCMU/Revision_02/main.cpp | 305 +++++++++++++ TeamCMU/Revision_02/puzzle.h | 469 ++++++++++++++++++++ TeamCMU/Revision_02/test_puzzle.h | 406 +++++++++++++++++ TeamCMU/Revision_03/a.out | Bin 0 -> 65008 bytes TeamCMU/Revision_03/main.cpp | 115 +++++ TeamCMU/Revision_03/puzzle.h | 467 +++++++++++++++++++ TeamCMU/Revision_03/test_puzzle.h | 406 +++++++++++++++++ TeamCMU/Revision_03/test_puzzle_long40x40.h | 400 +++++++++++++++++ 15 files changed, 3171 insertions(+), 34 deletions(-) create mode 100644 Source/a.out create mode 100644 TeamCMU/Basic_Structure.txt create mode 100644 TeamCMU/Revision_01/Puzzle.h create mode 100644 TeamCMU/Revision_01/main.cpp create mode 100644 TeamCMU/Revision_02/a.out create mode 100644 TeamCMU/Revision_02/main.cpp create mode 100644 TeamCMU/Revision_02/puzzle.h create mode 100644 TeamCMU/Revision_02/test_puzzle.h create mode 100644 TeamCMU/Revision_03/a.out create mode 100644 TeamCMU/Revision_03/main.cpp create mode 100644 TeamCMU/Revision_03/puzzle.h create mode 100644 TeamCMU/Revision_03/test_puzzle.h create mode 100644 TeamCMU/Revision_03/test_puzzle_long40x40.h diff --git a/Source/a.out b/Source/a.out new file mode 100644 index 0000000000000000000000000000000000000000..2d32f8d66db9dd9246c3ba0a399ed4737ebd0fc5 GIT binary patch literal 23000 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 literal 0 HcmV?d00001 diff --git a/Source/header/input.h b/Source/header/input.h index 5367cc3..f93c63c 100644 --- a/Source/header/input.h +++ b/Source/header/input.h @@ -1,16 +1,16 @@ -#include - -class Part -{ -public: - Part(): connections(0){} - ~Part() {} - uint8_t getConnections() const - {return connections;} - - void setConnections(uint8_t newconnections) - {connections = newconnections;} - -private: - uint8_t connections; +#include + +class Part +{ +public: + Part(): connections(0){} + ~Part() {} + uint8_t getConnections() const + {return connections;} + + void setConnections(uint8_t newconnections) + {connections = newconnections;} + +private: + uint8_t connections; }; \ No newline at end of file diff --git a/Source/main.cpp b/Source/main.cpp index 5b41fb2..878e264 100644 --- a/Source/main.cpp +++ b/Source/main.cpp @@ -1,19 +1,19 @@ -#include -#include -#include -#include -#include -#include - -#include "header/input.h" - -using namespace std; - -int main() -{ - vector myFirstPuzzle; - Part myFirstPart; - myFirstPart.setConnections(0b00101000); - myFirstPuzzle.push_back(myFirstPart); - cout << "Hello World" << endl; -} +#include +#include +#include +#include +#include +#include + +#include "header/input.h" + +using namespace std; + +int main() +{ + vector myFirstPuzzle; + Part myFirstPart; + myFirstPart.setConnections(0b00101000); + myFirstPuzzle.push_back(myFirstPart); + cout << "Hello World" << endl; +} diff --git a/TeamCMU/Basic_Structure.txt b/TeamCMU/Basic_Structure.txt new file mode 100644 index 0000000..fe185fc --- /dev/null +++ b/TeamCMU/Basic_Structure.txt @@ -0,0 +1,34 @@ +Übergangstruktur + +next() +{ + calculate best next move out of information in log + solve(with m and n or a puzzlepiece from box) +} + +solve() +{ + solve algorithm + + if(no solution) backtrack! + if(multiple solutions) set multiple solutions into log...setsolution(); + if(one solution) set solution into log...setsolution(); + + return{no solution, multiple solutions, one solution} + +} + +setsolution() +{ + set pointer(s) in log + set pointer to log into matrix +} + +backtrack() +{ + go into log, remove last piece + + goes back to next() +} + + diff --git a/TeamCMU/Revision_01/Puzzle.h b/TeamCMU/Revision_01/Puzzle.h new file mode 100644 index 0000000..854a95d --- /dev/null +++ b/TeamCMU/Revision_01/Puzzle.h @@ -0,0 +1,375 @@ +//Raphael Maenle - 11.11.2017 + +#include +#include +#include +#include +#include +#include + +using namespace std; + +class PuzzlePiece +{ +public: + + unsigned char Ringbuffer; + + PuzzlePiece(unsigned int flag = 0) + { + shifts=0; + boxidentifier=-1; + switch(flag) + { + case 0: + Ringbuffer=0b00000000; + break; + case 1: + Ringbuffer=0b11111111; + break; + case 3: + randomCenterPiece(); + break; + } + + } + + void Shift(unsigned int moves) + { + //Shift ringbuffer to the right n number of times + shifts = (shifts+moves)%4; + Ringbuffer = ((Ringbuffer >> (moves*2)) | (Ringbuffer << sizeof(unsigned char)*8 - (moves*2))); + } + + void printPiece() + { + cout << bitset (Ringbuffer); + } + //makes piece to random center piece + void randomCenterPiece() + { + this->Ringbuffer= 0b00000000; + + if(rand()%2) + this->Ringbuffer |= 0b01000000; + else + this->Ringbuffer |= 0b10000000; + + if(rand()%2) + this->Ringbuffer |= 0b00010000; + else + this->Ringbuffer |= 0b00100000; + + if(rand()%2) + this->Ringbuffer |= 0b00000100; + else + this->Ringbuffer |= 0b00001000; + + if(rand()%2) + this->Ringbuffer |= 0b00000001; + else + this->Ringbuffer |= 0b00000010; + } + + void assignIdentifier() + { + identifier = idcount; + idcount++; + } + + unsigned int getIdentifier() + { + return identifier; + } + void setBoxIdentifier(int new_boxid) + { + boxidentifier = new_boxid; + } + int getBoxIdentifier() + { + return boxidentifier; + } +private: + unsigned int shifts; + unsigned int identifier; + int boxidentifier; + static unsigned int idcount; + + +}; + +unsigned int PuzzlePiece::idcount(0); + +//saves a matrix cluster of puzzlepieces +class Puzzle +{ +public: + Puzzle(uint m = 7, uint n = 4): col(m), row(n) + { + Matrix = new PuzzlePiece* [n+2]; + //Box = new PuzzlePiece[n*m]; + for(int i = 0;iPlaceOfPartGood(m,n,newPiece)) + { + Matrix[n+1][m+1] = newPiece; + return 1; + } + return 0; + } + bool removePiece(uint m,uint n) + { + + Matrix[n+1][m+1] = 0b11111111; + return 1; + + } + + PuzzlePiece getPiece(uint m,uint n) + { + return Matrix[n+1][m+1]; + } + PuzzlePiece sudogetPiece(uint m,uint n) + { + return Matrix[n][m]; + } + + //check if place of the part in the matrix is correct + bool PlaceOfPartGood(unsigned int m, unsigned int n, PuzzlePiece& myPart); + bool testRotationPiece(unsigned int m, unsigned int n, PuzzlePiece& myPart); + unsigned int tryAllPieces(unsigned int m, unsigned int n, vector& myBox, unsigned int separator); + unsigned int putBackIntoBox(unsigned int m, unsigned int n, vector& myBox); + + void printPuzzle(); + + uint getCols() + { + return col; + } + + uint getRows() + { + return row; + } + //creates a random puzzle of size m columns, n rows + void createRandomPuzzle(); + //shuffles Box; + vector Shuffle(); + //prints box + void printBox(); + +private: + uint row; + uint col; + + PuzzlePiece** Matrix; + vector Box; + + void sudosetPiece(uint m,uint n,PuzzlePiece newPiece) + { + if(this->PlaceOfPartGood(m,n,newPiece)) + Matrix[n][m] = newPiece; + } + void sudoprintPuzzle() + { + for(int i=0;i (topPart) << endl; + + unsigned char rightPart = ((negativePart.Ringbuffer & 0b00110000) ^ (tmpPuzzlePiece.Ringbuffer & 0b00110000)); + cout << "rightPart: " << bitset (rightPart) << endl; + + unsigned char lowPart = ((negativePart.Ringbuffer & 0b00001100) ^ (tmpPuzzlePiece.Ringbuffer & 0b00001100)); + cout << "lowPart: " << bitset (lowPart) << endl; + + unsigned char leftPart = ((negativePart.Ringbuffer & 0b00000011) ^ (tmpPuzzlePiece.Ringbuffer & 0b00000011)); + cout << "leftPart: " << bitset (leftPart) << endl; +*/ + + if ( //simplify + ( ((((negativePart.Ringbuffer & 0b11000000) ^ (tmpPuzzlePiece.Ringbuffer & 0b11000000)) != 0b00000000) && (tmpPuzzlePiece.Ringbuffer & 0b11000000) != 0b00000000) + || ((((negativePart.Ringbuffer & 0b11000000) == 0b11000000) || ((tmpPuzzlePiece.Ringbuffer & 0b11000000) == 0b11000000)) && (tmpPuzzlePiece.Ringbuffer & 0b11000000) != 0b00000000) + || (((negativePart.Ringbuffer & 0b11000000) == 0b00000000) && ((tmpPuzzlePiece.Ringbuffer & 0b11000000) == 0b00000000)) ) + && + ( ((((negativePart.Ringbuffer & 0b00110000) ^ (tmpPuzzlePiece.Ringbuffer & 0b00110000)) != 0b00000000) && (tmpPuzzlePiece.Ringbuffer & 0b001100) != 0b00000000) + || ((((negativePart.Ringbuffer & 0b00110000) == 0b00110000) || ((tmpPuzzlePiece.Ringbuffer & 0b00110000) == 0b00110000)) && (tmpPuzzlePiece.Ringbuffer & 0b00110000) != 0b00000000) + || (((negativePart.Ringbuffer & 0b00110000) == 0b00000000) && ((tmpPuzzlePiece.Ringbuffer & 0b00110000) == 0b00000000)) ) + && + ( ((((negativePart.Ringbuffer & 0b00001100) ^ (tmpPuzzlePiece.Ringbuffer & 0b00001100)) != 0b00000000) && (tmpPuzzlePiece.Ringbuffer & 0b00001100) != 0b00000000) + || ((((negativePart.Ringbuffer & 0b00001100) == 0b00001100) || ((tmpPuzzlePiece.Ringbuffer & 0b00001100) == 0b00001100)) && (tmpPuzzlePiece.Ringbuffer & 0b00001100) != 0b00000000) + || (((negativePart.Ringbuffer & 0b00001100) == 0b00000000) && ((tmpPuzzlePiece.Ringbuffer & 0b00001100) == 0b00000000)) ) + && + ( ((((negativePart.Ringbuffer & 0b00000011) ^ (tmpPuzzlePiece.Ringbuffer & 0b00000011)) != 0b00000000) && (tmpPuzzlePiece.Ringbuffer & 0b00000011) != 0b00000000) + || ((((negativePart.Ringbuffer & 0b00000011) == 0b00000011) || ((tmpPuzzlePiece.Ringbuffer & 0b00000011) == 0b00000011)) && (tmpPuzzlePiece.Ringbuffer & 0b00000011) != 0b00000000) + || (((negativePart.Ringbuffer & 0b00000011) == 0b00000000) && ((tmpPuzzlePiece.Ringbuffer & 0b00000011) == 0b00000000)) ) + ) + + return 1; + + + return 0; +} + +void Puzzle::printPuzzle() +{ + for(int i=1;i::iterator i = Box.begin(); i != Box.end(); i++) + { + (*i).printPiece(); + cout << ' '; + } + cout << endl; +} + +vector Puzzle::Shuffle() +{ + random_shuffle(Box.begin(),Box.end()); + return Box; +} + +bool Puzzle::testRotationPiece(unsigned int m, unsigned int n, PuzzlePiece& myPart) +{ + for(int rotation=0; rotation < 4; rotation++) + { + myPart.Shift(1); + myPart.printPiece(); + cout << endl; + if(PlaceOfPartGood(m,n, myPart)) + { + + return 1; + } + } + return 0; +} + +//tries all pieces in box from separator to end and places fitting into matrix. removes fitting piece +//use separator if you have to retract to a position +unsigned int Puzzle::tryAllPieces(unsigned int m, unsigned int n, vector& myBox, unsigned int separator) +{ + + for(int i=separator; i& myBox) +{ + for(int i = 0; i < myBox.size();i++) + { + if(myBox[i].getBoxIdentifier()>getPiece(m,n).getBoxIdentifier()) + { + myBox.insert(myBox.begin()+i,getPiece(m,n)); + removePiece(m,n); + return i; + } + } +} + +vector createBox(uint m, uint n) +{ + Puzzle myFirstPuzzle(m,n); + myFirstPuzzle.createRandomPuzzle(); + return myFirstPuzzle.Shuffle(); +} diff --git a/TeamCMU/Revision_01/main.cpp b/TeamCMU/Revision_01/main.cpp new file mode 100644 index 0000000..9269d3a --- /dev/null +++ b/TeamCMU/Revision_01/main.cpp @@ -0,0 +1,160 @@ +//Raphael Maenle - 11.11.2017 +#include +#include +#include +#include +#include +#include + +#include "puzzle.h" +//#include "Solver.h" + +using namespace std; + +void numerateBox(vector& myBox); +Puzzle solveOuterFirst( unsigned int rows, unsigned int cols, vector& myFirstBox); +void retractOuterFirst(int& i, int& j, int cols, int rows, int perimiter); + +int main() +{ + srand(time(0)); + + //Puzzle myFirstPuzzle(3,4); + + int rows = 2, cols = 3; + + vector myFirstBox = createBox(cols, rows); + numerateBox(myFirstBox); + cout << "now in solve: " << endl << endl; + solveOuterFirst(rows,cols,myFirstBox); +} + +//set box identifiers +void numerateBox(vector& myBox) +{ + for(int i = 0; i< myBox.size();i++) + myBox[i].setBoxIdentifier(i); + + return; +} + +//goes round and round puzzle and tries all pieces +Puzzle solveOuterFirst( unsigned int rows, unsigned int cols, vector& myFirstBox) +{ + int i = 0, j= 0, Boxsize = rows*cols, separator=0; + Puzzle myFirstPuzzle(cols, rows); + //first Piece + cout << "#0 i: " << i << ", j: " << j << endl; + + if(myFirstPuzzle.tryAllPieces(j, i, myFirstBox,separator) == -1) + { + cout << "error at first piece" << endl; + } + myFirstPuzzle.printPuzzle(); +/* + Boxsize--; + + //rotate through puzzle + for(int perimiter = 0; perimiter <= (cols>rows?rows:cols)/2;) + { + cout << "perimiter: " << perimiter << endl; + while(( i == 0+perimiter && j < cols-perimiter-1) && Boxsize) + { + j++; + Boxsize--; + cout << "#1 i: " << i << ", j: " << j << endl; + + if(myFirstPuzzle.tryAllPieces(j, i, myFirstBox,separator) == -1) + { + retractOuterFirst(i,j,cols,rows,perimiter); + Boxsize++; + break; + } + else + { + Boxsize--; + } + } + + while(( i < rows-perimiter-1 && j == cols-perimiter-1) && Boxsize) + { + i++; + Boxsize--; + cout << "#2 i: " << i << ", j: " << j << endl; + if(myFirstPuzzle.tryAllPieces(j, i, myFirstBox,separator) == -1) + { + retractOuterFirst(i,j,cols,rows,perimiter); + Boxsize++; + break; + } + else + { + Boxsize--; + } + } + + while(( i == rows-perimiter-1 && j > 0+perimiter) && Boxsize) + { + j--; + Boxsize--; + cout << "#3 i: " << i << ", j: " << j << endl; + if(myFirstPuzzle.tryAllPieces(j, i, myFirstBox,separator) == -1) + { + retractOuterFirst(i,j,cols,rows,perimiter); + Boxsize++; + break; + } + else + { + Boxsize--; + } + } + + while(( i > 0+perimiter+1 && j == 0+perimiter) && Boxsize) + { + i--; + cout << "#4 i: " << i << ", j: " << j << endl; + if(myFirstPuzzle.tryAllPieces(j, i, myFirstBox,separator) == -1) + { + retractOuterFirst(i,j,cols,rows,perimiter); + Boxsize++; + break; + } + else + { + Boxsize--; + perimiter++; + } + } + } + myFirstPuzzle.printPuzzle(); +*/ + return myFirstPuzzle; +} + +//move i and j to position before +void retractOuterFirst(int& i, int& j, int cols, int rows, int perimiter) +{ + + if(( i == 0+perimiter && j <= cols-perimiter-1)) + { + j--; + } + + else if(( i <= rows-perimiter-1 && j == cols-perimiter-1)) + { + i--; + } + + else if(( i == rows-perimiter-1 && j >= 0+perimiter)) + { + j++; + } + + else if(( i >= 0+perimiter+1 && j == 0+perimiter)) + { + i++; + } + +} + diff --git a/TeamCMU/Revision_02/a.out b/TeamCMU/Revision_02/a.out new file mode 100644 index 0000000000000000000000000000000000000000..a6efa5efd4ddf2521752e72536d52339a9267b68 GIT binary patch literal 75216 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 ZTMv_;#NSo-zxt=Z{R#V8grD^O{|6a +#include +#include +#include +#include +#include + +#define debug + +#include "puzzle.h" + +#include "test_puzzle.h" + +using namespace std; + +Puzzle solveOuterFirst( unsigned int rows, unsigned int cols, vector& myFirstBox); +void retractOuterFirst(int& i, int& j, int cols, int rows, int& perimiter); + +int main() +{ + srand(time(0)); + + vector part_array(NR_PARTS); + vector corners_array(NR_CORNERS); + vector edges_array(NR_EDGES); + vector inners_array(NR_INNERS); + + //randomBox myPuzzle(cols,rows); + //myPuzzle.createRandomPuzzle(); + + + unsigned int rows=5, cols=5; + + //vector myFirstBox = createBox(cols, rows); + + //create4040hardBox(myFirstBox); + /*myFirstBox[0].setConnections(0b01100010); + myFirstBox[1].setConnections(0b00010100); + myFirstBox[2].setConnections(0b00011010); + myFirstBox[3].setConnections(0b10000001); + myFirstBox[4].setConnections(0b00011000); + myFirstBox[5].setConnections(0b01100000);*/ + + Puzzle myFirstPuzzle(3,4); + PuzzlePiece myFirstPiece(1); + myFirstPiece.setConnections(0b00010100); + + if(myFirstPuzzle.PlaceOfPartGood(myFirstPiece)); + cout << "good" << endl; + + //printBox(myFirstBox); + cout << endl; + + //Puzzle newPuzzle = solveOuterFirst(cols, rows, myFirstBox); + return 0; +} + + +//rotates in snail form clockwise around board and tries placing puzzle pieces. +//if no piece fits in position it tries next piece of the piece before +Puzzle solveOuterFirst( unsigned int cols, unsigned int rows, vector& myFirstBox) +{ + int i = 0, j= 0, Boxsize = rows*cols, separator=0; + Puzzle myFirstPuzzle(cols, rows); + //first Piece + + + //rotate through puzzle + int perimiter; + int numberofsolutions=0; + int newPerimiter = 1; + for(perimiter = 0; /*perimiter <= (cols>rows?rows:cols)/2;*/;) + { + if(Boxsize) + { +#ifdef debug +cout << "perimiter: " << perimiter << endl; +#endif + } + else + { + break; + retractOuterFirst(i,j,cols,rows,perimiter); + Boxsize++; + separator = myFirstPuzzle.putBackIntoBox(j, i, myFirstBox); + numberofsolutions++; + } + + if((i==rows/2 && j==cols/2 )&& cols==rows) + { + if(myFirstPuzzle.tryAllPieces(j, i, myFirstBox,separator) == -1) + { + retractOuterFirst(i,j,cols,rows,perimiter); + Boxsize++; + separator = myFirstPuzzle.putBackIntoBox(j, i, myFirstBox); + } + else + { + break; + separator=0; + Boxsize--; + } + } + + + if((i==perimiter+1 && j==perimiter)) + { +#ifdef debug +cout << "#0 i: " << i << ", j: " << j << endl; +#endif + if(myFirstPuzzle.tryAllPieces(j, i, myFirstBox,separator) == -1) + { + retractOuterFirst(i,j,cols,rows,perimiter); + Boxsize++; + separator = myFirstPuzzle.putBackIntoBox(j, i, myFirstBox); +#ifdef debug +cout << "New Box: "; +printBox(myFirstBox); +cout << endl; +myFirstPuzzle.printPuzzle(); +cout << "Boxsize: " << Boxsize << endl; +cout << "separator: " << separator << endl; +#endif + } + else + { + perimiter=newPerimiter; + newPerimiter++; + j++; + separator=0; + Boxsize--; +#ifdef debug +cout << " Perimiter: " << perimiter << endl; +myFirstPuzzle.printPuzzle(); +#endif + } + + } + else + { + + + //cout << "general information i: " << i << ", j: " << j << endl; + while(( i == 0+perimiter && j < cols-perimiter-1) && Boxsize) + { +#ifdef debug +cout << "#1 i: " << i << ", j: " << j << endl; +#endif + if(myFirstPuzzle.tryAllPieces(j, i, myFirstBox,separator) == -1) + { + retractOuterFirst(i,j,cols,rows,perimiter); + separator = myFirstPuzzle.putBackIntoBox(j, i, myFirstBox); + Boxsize++; +#ifdef debug +cout << "New Box: "; +printBox(myFirstBox); +cout << endl; +myFirstPuzzle.printPuzzle(); +cout << "Boxsize: " << Boxsize << endl; +cout << "separator: " << separator << endl; +#endif + break; + } + else + { + j++; + separator=0; + Boxsize--; +#ifdef debug +myFirstPuzzle.printPuzzle(); +#endif + } + } + while(( i < rows-perimiter-1 && j == cols-perimiter-1) && Boxsize) + { +#ifdef debug +cout << "#2 i: " << i << ", j: " << j << endl; +#endif + if(myFirstPuzzle.tryAllPieces(j, i, myFirstBox,separator) == -1) + { + retractOuterFirst(i,j,cols,rows,perimiter); + + separator = myFirstPuzzle.putBackIntoBox(j, i, myFirstBox); + Boxsize++; +#ifdef debug +cout << "New Box: "; +printBox(myFirstBox); +cout << endl; +myFirstPuzzle.printPuzzle(); + +cout << "Boxsize: " << Boxsize << endl; +cout << "separator: " << separator << endl; +#endif + break; + } + else + { + i++; + separator=0; + Boxsize--; +#ifdef debug +myFirstPuzzle.printPuzzle(); +#endif + } + } + + while(( i == rows-perimiter-1 && j > 0+perimiter) && Boxsize) + { + +#ifdef debug +cout << "#3 i: " << i << ", j: " << j << endl; +#endif + if(myFirstPuzzle.tryAllPieces(j, i, myFirstBox,separator) == -1) + { + retractOuterFirst(i,j,cols,rows,perimiter); + separator = myFirstPuzzle.putBackIntoBox(j, i, myFirstBox); + Boxsize++; +#ifdef debug +cout << "New Box: "; +printBox(myFirstBox); +cout << endl; +myFirstPuzzle.printPuzzle(); +cout << "Boxsize: " << Boxsize << endl; +cout << "separator: " << separator << endl; +#endif + break; + } + else + { + j--; + separator=0; + Boxsize--; +#ifdef debug +myFirstPuzzle.printPuzzle(); +#endif + } + } + + while(( i > 0+perimiter+1 && j == 0+perimiter) && Boxsize) + { +#ifdef debug +cout << "#4 i: " << i << ", j: " << j << endl; +#endif + if(myFirstPuzzle.tryAllPieces(j, i, myFirstBox,separator) == -1) + { + retractOuterFirst(i,j,cols,rows,perimiter); + separator = myFirstPuzzle.putBackIntoBox(j, i, myFirstBox); + Boxsize++; +#ifdef debug +cout << "New Box: "; +printBox(myFirstBox); +cout << endl; +myFirstPuzzle.printPuzzle(); + +cout << "Boxsize: " << Boxsize << endl; +cout << "separator: " << separator << endl; +#endif + break; + } + else + { + i--; + separator=0; + Boxsize--; +#ifdef debug +myFirstPuzzle.printPuzzle(); +#endif + } + } + } + } + myFirstPuzzle.printPuzzle(); + + return myFirstPuzzle; +} + +//move i and j to position before +void retractOuterFirst(int& i, int& j, int cols, int rows, int& perimiter) +{ +#ifdef debug + cout << "retracting: i=" << i << " j=" << j << endl; +#endif + if(( i == 0+perimiter && j <= cols-perimiter-1)) + { + j--; + } + else if(( i <= rows-perimiter-1 && j == cols-perimiter-1)) + { + i--; + } + + else if(( i == rows-perimiter-1 && j >= 0+perimiter)) + { + j++; + } + + else if(( i >= 0+perimiter+1 && j == 0+perimiter)) + { + i++; + } +#ifdef debug + cout << "to: i=" << i << " j=" << j << endl; +#endif +} \ No newline at end of file diff --git a/TeamCMU/Revision_02/puzzle.h b/TeamCMU/Revision_02/puzzle.h new file mode 100644 index 0000000..2b69445 --- /dev/null +++ b/TeamCMU/Revision_02/puzzle.h @@ -0,0 +1,469 @@ +#include + +#define NR_PARTS 1008 +#define NR_CORNERS 4 +#define NR_EDGES 120 +#define NR_INNERS 884 + +using namespace std; + +//part from group header file +class Part +{ +public: + Part(): connections(0){} + ~Part() {} + uint8_t getConnections() const + { + return connections; + } + void setConnections(uint8_t newconnections) + { + connections = newconnections; + } + +private: + uint8_t connections; +}; + +//puzzlepiece extens part with essential identifiers and functions +class PuzzlePiece: public Part +{ +public: + + PuzzlePiece(unsigned int flag = 0) + { + shifts=0; + boxidentifier=-1; + switch(flag) + { + case 0: + setConnections(0b00000000); + break; + case 1: + setConnections(0b11111111); + break; + case 3: + randomCenterPiece(); + break; + } + } + + void shift(unsigned int moves); + void randomCenterPiece(); + void printPiece() { cout << bitset (getConnections()); } + + void setBoxIdentifier(int new_boxid) { boxidentifier = new_boxid; } + int getBoxIdentifier() { return boxidentifier; } + void assignIdentifier() { identifier = idcount;idcount++; } + unsigned int getIdentifier() { return identifier;} + +private: + unsigned int shifts; + unsigned int boxidentifier; + unsigned int identifier; + static unsigned int idcount; +}; + +unsigned int PuzzlePiece::idcount(0); + +class Puzzle +{ + friend class randomBox; +public: + //constructor creates matrix with 00 outside and 11 inside + Puzzle(uint m = 7, uint n = 4): col(m), row(n) + { + Matrix = new PuzzlePiece* [n+2]; + for(int i = 0;i& myBox, unsigned int separator); + unsigned int putBackIntoBox(unsigned int m, unsigned int n, vector& myBox); + + +private: + uint row; + uint col; + + PuzzlePiece** Matrix; + +}; + +//use this for random puzzle creation +class randomBox: public Puzzle +{ +public: + + randomBox(unsigned int m, unsigned int n) : Puzzle(m,n) {} //passed m n to puzzle constructor + + void createRandomPuzzle(); + vector shuffle(); + void printBox(); + +private: + vector Box; + +}; + +//functiondefinitions +void printBox(vector myBox); +vector createBox(uint m, uint n); +void numerateBox(vector& myBox); + +//functions + +//shifts puzzle piece one to the right +void PuzzlePiece::shift(unsigned int moves) +{ + shifts = (shifts+moves)%4; + setConnections(((getConnections() >> (moves*2)) | (getConnections() << sizeof(unsigned char)*8 - (moves*2)))); +} + +//creates random centerpiece +void PuzzlePiece::randomCenterPiece() +{ + setConnections(0b00000000); + + if(rand()%2) + setConnections(getConnections() | 0b01000000); + else + setConnections(getConnections() | 0b10000000); + + if(rand()%2) + setConnections(getConnections() | 0b00010000); + else + setConnections(getConnections() | 0b00100000); + + if(rand()%2) + setConnections(getConnections() | 0b00000100); + else + setConnections(getConnections() | 0b00001000); + + if(rand()%2) + setConnections(getConnections() | 0b00000001); + else + setConnections(getConnections() | 0b00000010); +} + +//tries all pieces in box from separator to end and places fitting into matrix. removes fitting piece +//use separator if you have to retract to a position +//seperator may be bigger than box size, if all puzzle pieces have already been looked at. +// it immediately retracts again then (returns -1) +unsigned int Puzzle::tryAllPieces(unsigned int m, unsigned int n, vector& myBox, unsigned int separator) +{ + for(int i=separator; i& myBox) +{ +#ifdef debug +cout << "putting back" << endl; +cout << "Old Box: "; +printBox(myBox); +cout << endl; +#endif + for(int i = 0; i < myBox.size();i++) + { + if(myBox[i].getBoxIdentifier()>getPiece(m,n).getBoxIdentifier()) + { + myBox.insert(myBox.begin()+i,getPiece(m,n)); + removePiece(m,n); + return i+1; + } + } + //using push back, if the element was the last element in the vector chain + myBox.push_back(getPiece(m,n)); + removePiece(m,n); + return myBox.size(); +} + +//checks if the myPart in its current orientation is legal in position m, n +bool Puzzle::PlaceOfPartGood(unsigned int m,unsigned int n, PuzzlePiece& myPart) +{ + + PuzzlePiece negativePart(0); + + negativePart.setConnections(negativePart.getConnections() | (getPiece(m,n+1).getConnections() & 0b11000000)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m-1,n).getConnections() & 0b00110000)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m,n-1).getConnections() & 0b00001100)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m+1,n).getConnections() & 0b00000011)); + negativePart.shift(2); + + + + if ( + ( ((((negativePart.getConnections() & 0b11000000) ^ (myPart.getConnections() & 0b11000000)) != 0b00000000) && (((myPart.getConnections() & 0b11000000) != 0b00000000) && (negativePart.getConnections() & 0b11000000) != 0b00000000)) + || ((((negativePart.getConnections() & 0b11000000) == 0b11000000) || ((myPart.getConnections() & 0b11000000) == 0b11000000)) && (( myPart.getConnections() & 0b11000000) != 0b00000000) && (negativePart.getConnections() & 0b11000000) != 0b00000000) + || (((negativePart.getConnections() & 0b11000000) == 0b00000000) && ((myPart.getConnections() & 0b11000000) == 0b00000000)) ) + && + ( ((((negativePart.getConnections() & 0b00110000) ^ (myPart.getConnections() & 0b00110000)) != 0b00000000) && (((myPart.getConnections() & 0b00110000) != 0b00000000) && (negativePart.getConnections() & 0b00110000) != 0b00000000)) + || ((((negativePart.getConnections() & 0b00110000) == 0b00110000) || ((myPart.getConnections() & 0b00110000) == 0b00110000)) && (((myPart.getConnections() & 0b00110000) != 0b00000000) && (negativePart.getConnections() & 0b00110000) != 0b00000000)) + || (((negativePart.getConnections() & 0b00110000) == 0b00000000) && ((myPart.getConnections() & 0b00110000) == 0b00000000)) ) + && + ( ((((negativePart.getConnections() & 0b00001100) ^ (myPart.getConnections() & 0b00001100)) != 0b00000000) && (((myPart.getConnections() & 0b00001100) != 0b00000000) && (negativePart.getConnections() & 0b00001100) != 0b00000000)) + || ((((negativePart.getConnections() & 0b00001100) == 0b00001100) || ((myPart.getConnections() & 0b00001100) == 0b00001100)) && (((myPart.getConnections() & 0b00001100) != 0b00000000) && (negativePart.getConnections() & 0b00001100) != 0b00000000)) + || (((negativePart.getConnections() & 0b00001100) == 0b00000000) && ((myPart.getConnections() & 0b00001100) == 0b00000000)) ) + && + ( ((((negativePart.getConnections() & 0b00000011) ^ (myPart.getConnections() & 0b00000011)) != 0b00000000) && (((myPart.getConnections() & 0b00000011) != 0b00000000) && (negativePart.getConnections() & 0b00000011) != 0b00000000)) + || ((((negativePart.getConnections() & 0b00000011) == 0b00000011) || ((myPart.getConnections() & 0b00000011) == 0b00000011)) && (((myPart.getConnections() & 0b00000011) != 0b00000000) && (negativePart.getConnections() & 0b00000011) != 0b00000000)) + || (((negativePart.getConnections() & 0b00000011) == 0b00000000) && ((myPart.getConnections() & 0b00000011) == 0b00000000)) ) + ) + { +#ifdef debug +cout << "good Part: "; +myPart.printPiece(); +cout << endl; +#endif + return 1; + } + + + + return 0; +} + + +//TODO!! +//simpler algorithm to the first placeofpartgood +//not yet functional!!! +bool Puzzle::PlaceOfPart2Good(unsigned int m,unsigned int n, PuzzlePiece& myPart) +{ + /* + + PuzzlePiece negativePart(0); + + negativePart.setConnections(negativePart.getConnections() | (getPiece(m,n+1).getConnections() & 0b11000000)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m-1,n).getConnections() & 0b00110000)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m,n-1).getConnections() & 0b00001100)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m+1,n).getConnections() & 0b00000011)); + negativePart.shift(2); + + //A and D or B and C or not A and not B and not C and not D + + if ( + ( ( (negativePart.getConnections() & 0b10000000) & (myPart.getConnections() & 0b01000000)) + || ( (negativePart.getConnections() & 0b01000000) & (myPart.getConnections() & 0b10000000)) + || ((!(negativePart.getConnections() & 0b10000000) & !(myPart.getConnections() & 0b10000000)) & (!(negativePart.getConnections() & 0b01000000) & !(myPart.getConnections() & 0b01000000))) + ) + && + ( ( (negativePart.getConnections() & 0b00100000) & (myPart.getConnections() & 0b00010000)) + || ( (negativePart.getConnections() & 0b00010000) & (myPart.getConnections() & 0b00100000)) + || ((!(negativePart.getConnections() & 0b00100000) & !(myPart.getConnections() & 0b00100000)) & (!(negativePart.getConnections() & 0b00010000) & !(myPart.getConnections() & 0b00010000))) + ) + && + ( ( (negativePart.getConnections() & 0b00001000) & (myPart.getConnections() & 0b00000100)) + || ( (negativePart.getConnections() & 0b00000100) & (myPart.getConnections() & 0b00001000)) + || ((!(negativePart.getConnections() & 0b00001000) & !(myPart.getConnections() & 0b00001000)) & (!(negativePart.getConnections() & 0b00000100) & !(myPart.getConnections() & 0b00000100))) + ) + && + ( ( (negativePart.getConnections() & 0b00000010) & (myPart.getConnections() & 0b00000001)) + || ( (negativePart.getConnections() & 0b00000001) & (myPart.getConnections() & 0b00000010)) + || ((!(negativePart.getConnections() & 0b00000010) & !(myPart.getConnections() & 0b00000010)) & (!(negativePart.getConnections() & 0b00000001) & !(myPart.getConnections() & 0b00000001))) + ) + ) + + return 1; + + cout << "nogood" << endl; + return 0; + */ + + PuzzlePiece tmpPuzzlePiece = myPart; + + //make tmp a negativ part + if((tmpPuzzlePiece.Ringbuffer & 0b11000000) != 192 || 0) + tmpPuzzlePiece.Ringbuffer = (tmpPuzzlePiece.Ringbuffer ^ 0b11000000); + if((tmpPuzzlePiece.Ringbuffer & 0b00110000) != 48 || 0) + tmpPuzzlePiece.Ringbuffer = (tmpPuzzlePiece.Ringbuffer ^ 0b00110000); + if((tmpPuzzlePiece.Ringbuffer & 0b00001100) != 12 || 0) + tmpPuzzlePiece.Ringbuffer = (tmpPuzzlePiece.Ringbuffer ^ 0b00001100); + if((tmpPuzzlePiece.Ringbuffer & 0b00000011) != 3 || 0) + tmpPuzzlePiece.Ringbuffer = (tmpPuzzlePiece.Ringbuffer ^ 0b00000011); + + PuzzlePiece negativePart(0); + + negativePart.Ringbuffer = negativePart.Ringbuffer | (this->sudogetPiece(m,n+1).Ringbuffer & 0b11000000); + negativePart.Ringbuffer = negativePart.Ringbuffer | (this->sudogetPiece(m-1,n).Ringbuffer & 0b00110000); + negativePart.Ringbuffer = negativePart.Ringbuffer | (this->sudogetPiece(m,n-1).Ringbuffer & 0b00001100); + negativePart.Ringbuffer = negativePart.Ringbuffer | (this->sudogetPiece(m+1,n).Ringbuffer & 0b00000011); + + negativePart.Shift(2); + + //check tmp part with environment + if(((negativePart.Ringbuffer & 0b11000000) == (tmpPuzzlePiece & 0b11000000)) && ((negativePart.Ringbuffer & 0b00110000) == (tmpPuzzlePiece & 0b00110000)) + && ((negativePart.Ringbuffer & 0b00001100) == (tmpPuzzlePiece & 0b00001100)) && ((negativePart.Ringbuffer & 0b00000011) == (tmpPuzzlePiece & 0b00000011))) + return 1; + + return 0; +} + +//prints the true puzzle (without 0 edges) +void Puzzle::printPuzzle() +{ + cout << "current Puzzle: " << endl; + for(int i=1;i::iterator i = Box.begin(); i != Box.end(); i++) + { + (*i).printPiece(); + cout << ' '; + } + cout << endl; +} + +//shuffles around a box, randomizing pieces and orientation +vector randomBox::shuffle() +{ + random_shuffle(Box.begin(),Box.end()); + for (vector::iterator i = Box.begin(); i != Box.end(); i++) + (*i).shift(rand()%4); + numerateBox(Box); + return Box; +} + +//creates a random box size m, n, shuffles it, and then retuns it +vector createBox(uint m, uint n) +{ + randomBox myFirstPuzzleBox(m,n); + myFirstPuzzleBox.createRandomPuzzle(); + return myFirstPuzzleBox.shuffle(); +} + +//prints contents of box +void printBox(vector myBox) +{ + cout << "current Box: " << endl; + for (vector::iterator i = myBox.begin(); i != myBox.end(); i++) + { + (*i).printPiece(); + cout << ' '; + } + cout << endl; + return; +} + +//gives every element in box a box identifier. +void numerateBox(vector& myBox) +{ + for(int i = 0; i< myBox.size();i++) + myBox[i].setBoxIdentifier(i); + + return; +} \ No newline at end of file diff --git a/TeamCMU/Revision_02/test_puzzle.h b/TeamCMU/Revision_02/test_puzzle.h new file mode 100644 index 0000000..f893bf0 --- /dev/null +++ b/TeamCMU/Revision_02/test_puzzle.h @@ -0,0 +1,406 @@ + + void create4040hardBox(vector& myFirstBox) +{ +myFirstBox[0].setConnections(0b01101001); +myFirstBox[1].setConnections(0b10011001); +myFirstBox[2].setConnections(0b01100110); +myFirstBox[3].setConnections(0b01101001); +myFirstBox[4].setConnections(0b10100101); +myFirstBox[5].setConnections(0b10010010); +myFirstBox[6].setConnections(0b01101001); +myFirstBox[7].setConnections(0b00101010); +myFirstBox[8].setConnections(0b01000110); +myFirstBox[9].setConnections(0b01011010); +myFirstBox[10].setConnections(0b01011010); +myFirstBox[11].setConnections(0b10010101); +myFirstBox[12].setConnections(0b01010101); +myFirstBox[13].setConnections(0b10101001); +myFirstBox[14].setConnections(0b10010101); +myFirstBox[15].setConnections(0b10101010); +myFirstBox[16].setConnections(0b01101010); +myFirstBox[17].setConnections(0b01101010); +myFirstBox[18].setConnections(0b00100101); +myFirstBox[19].setConnections(0b01100101); +myFirstBox[20].setConnections(0b10010001); +myFirstBox[21].setConnections(0b10010101); +myFirstBox[22].setConnections(0b10101001); +myFirstBox[23].setConnections(0b01010110); +myFirstBox[24].setConnections(0b10101010); +myFirstBox[25].setConnections(0b01101000); +myFirstBox[26].setConnections(0b01101010); +myFirstBox[27].setConnections(0b10010101); +myFirstBox[28].setConnections(0b10011010); +myFirstBox[29].setConnections(0b10011001); +myFirstBox[30].setConnections(0b01101010); +myFirstBox[31].setConnections(0b01100001); +myFirstBox[32].setConnections(0b01101010); +myFirstBox[33].setConnections(0b01100101); +myFirstBox[34].setConnections(0b01010101); +myFirstBox[35].setConnections(0b01010110); +myFirstBox[36].setConnections(0b01101010); +myFirstBox[37].setConnections(0b01010110); +myFirstBox[38].setConnections(0b01100110); +myFirstBox[39].setConnections(0b01011010); +myFirstBox[40].setConnections(0b01100101); +myFirstBox[41].setConnections(0b01101001); +myFirstBox[42].setConnections(0b01010110); +myFirstBox[43].setConnections(0b01000110); +myFirstBox[44].setConnections(0b01011001); +myFirstBox[45].setConnections(0b01101001); +myFirstBox[46].setConnections(0b10000101); +myFirstBox[47].setConnections(0b10011010); +myFirstBox[48].setConnections(0b10010110); +myFirstBox[49].setConnections(0b01011010); +myFirstBox[50].setConnections(0b10011001); +myFirstBox[51].setConnections(0b01001001); +myFirstBox[52].setConnections(0b10100110); +myFirstBox[53].setConnections(0b01001010); +myFirstBox[54].setConnections(0b10010010); +myFirstBox[55].setConnections(0b01001010); +myFirstBox[56].setConnections(0b01101001); +myFirstBox[57].setConnections(0b10100110); +myFirstBox[58].setConnections(0b10010110); +myFirstBox[59].setConnections(0b10010110); +myFirstBox[60].setConnections(0b10101001); +myFirstBox[61].setConnections(0b00100101); +myFirstBox[62].setConnections(0b00101001); +myFirstBox[63].setConnections(0b01101001); +myFirstBox[64].setConnections(0b01101001); +myFirstBox[65].setConnections(0b00100101); +myFirstBox[66].setConnections(0b10010110); +myFirstBox[67].setConnections(0b10011010); +myFirstBox[68].setConnections(0b01100110); +myFirstBox[69].setConnections(0b10010110); +myFirstBox[70].setConnections(0b01010100); +myFirstBox[71].setConnections(0b01011010); +myFirstBox[72].setConnections(0b01100110); +myFirstBox[73].setConnections(0b01100101); +myFirstBox[74].setConnections(0b10011010); +myFirstBox[75].setConnections(0b10010101); +myFirstBox[76].setConnections(0b10011010); +myFirstBox[77].setConnections(0b01100101); +myFirstBox[78].setConnections(0b10011010); +myFirstBox[79].setConnections(0b01010110); +myFirstBox[80].setConnections(0b01101010); +myFirstBox[81].setConnections(0b01010101); +myFirstBox[82].setConnections(0b01100101); +myFirstBox[83].setConnections(0b10100101); +myFirstBox[84].setConnections(0b01010110); +myFirstBox[85].setConnections(0b01101010); +myFirstBox[86].setConnections(0b10011010); +myFirstBox[87].setConnections(0b10010110); +myFirstBox[88].setConnections(0b01101010); +myFirstBox[89].setConnections(0b01011010); +myFirstBox[90].setConnections(0b01010110); +myFirstBox[91].setConnections(0b01100101); +myFirstBox[92].setConnections(0b00100101); +myFirstBox[93].setConnections(0b10100101); +myFirstBox[94].setConnections(0b10010110); +myFirstBox[95].setConnections(0b01100110); +myFirstBox[96].setConnections(0b10000110); +myFirstBox[97].setConnections(0b01001001); +myFirstBox[98].setConnections(0b10010110); +myFirstBox[99].setConnections(0b10100110); +myFirstBox[100].setConnections(0b10100110); +myFirstBox[101].setConnections(0b01100010); +myFirstBox[102].setConnections(0b01101010); +myFirstBox[103].setConnections(0b10011001); +myFirstBox[104].setConnections(0b01010101); +myFirstBox[105].setConnections(0b10011010); +myFirstBox[106].setConnections(0b10101001); +myFirstBox[107].setConnections(0b01100110); +myFirstBox[108].setConnections(0b10101001); +myFirstBox[109].setConnections(0b10101001); +myFirstBox[110].setConnections(0b10010100); +myFirstBox[111].setConnections(0b01100110); +myFirstBox[112].setConnections(0b01010110); +myFirstBox[113].setConnections(0b10010101); +myFirstBox[114].setConnections(0b01011001); +myFirstBox[115].setConnections(0b01101010); +myFirstBox[116].setConnections(0b10100110); +myFirstBox[117].setConnections(0b10100101); +myFirstBox[118].setConnections(0b10101010); +myFirstBox[119].setConnections(0b01011010); +myFirstBox[120].setConnections(0b10011000); +myFirstBox[121].setConnections(0b10010101); +myFirstBox[122].setConnections(0b10100101); +myFirstBox[123].setConnections(0b10000110); +myFirstBox[124].setConnections(0b01100101); +myFirstBox[125].setConnections(0b10100110); +myFirstBox[126].setConnections(0b10101010); +myFirstBox[127].setConnections(0b01101001); +myFirstBox[128].setConnections(0b01010101); +myFirstBox[129].setConnections(0b01100101); +myFirstBox[130].setConnections(0b10001001); +myFirstBox[131].setConnections(0b01101010); +myFirstBox[132].setConnections(0b01101010); +myFirstBox[133].setConnections(0b01100010); +myFirstBox[134].setConnections(0b01100110); +myFirstBox[135].setConnections(0b10100001); +myFirstBox[136].setConnections(0b10011001); +myFirstBox[137].setConnections(0b01101010); +myFirstBox[138].setConnections(0b01011001); +myFirstBox[139].setConnections(0b10001001); +myFirstBox[140].setConnections(0b01010101); +myFirstBox[141].setConnections(0b10100101); +myFirstBox[142].setConnections(0b01100101); +myFirstBox[143].setConnections(0b10100101); +myFirstBox[144].setConnections(0b10011010); +myFirstBox[145].setConnections(0b10010001); +myFirstBox[146].setConnections(0b10100110); +myFirstBox[147].setConnections(0b01101010); +myFirstBox[148].setConnections(0b10010101); +myFirstBox[149].setConnections(0b01100101); +myFirstBox[150].setConnections(0b10100101); +myFirstBox[151].setConnections(0b10100110); +myFirstBox[152].setConnections(0b10010001); +myFirstBox[153].setConnections(0b10101000); +myFirstBox[154].setConnections(0b10011010); +myFirstBox[155].setConnections(0b10100110); +myFirstBox[156].setConnections(0b01100110); +myFirstBox[157].setConnections(0b10100110); +myFirstBox[158].setConnections(0b01011010); +myFirstBox[159].setConnections(0b10100001); +myFirstBox[160].setConnections(0b01010101); +myFirstBox[161].setConnections(0b10011010); +myFirstBox[162].setConnections(0b10101001); +myFirstBox[163].setConnections(0b01010110); +myFirstBox[164].setConnections(0b01100001); +myFirstBox[165].setConnections(0b01011001); +myFirstBox[166].setConnections(0b01101001); +myFirstBox[167].setConnections(0b10011001); +myFirstBox[168].setConnections(0b10010101); +myFirstBox[169].setConnections(0b01100010); +myFirstBox[170].setConnections(0b01010110); +myFirstBox[171].setConnections(0b00010101); +myFirstBox[172].setConnections(0b10100101); +myFirstBox[173].setConnections(0b10101010); +myFirstBox[174].setConnections(0b10011010); +myFirstBox[175].setConnections(0b01100101); +myFirstBox[176].setConnections(0b10100110); +myFirstBox[177].setConnections(0b10101001); +myFirstBox[178].setConnections(0b01011010); +myFirstBox[179].setConnections(0b01101001); +myFirstBox[180].setConnections(0b10010101); +myFirstBox[181].setConnections(0b01101010); +myFirstBox[182].setConnections(0b10010110); +myFirstBox[183].setConnections(0b10010110); +myFirstBox[184].setConnections(0b10011001); +myFirstBox[185].setConnections(0b10100101); +myFirstBox[186].setConnections(0b10010110); +myFirstBox[187].setConnections(0b10010110); +myFirstBox[188].setConnections(0b10011010); +myFirstBox[189].setConnections(0b10010101); +myFirstBox[190].setConnections(0b01010001); +myFirstBox[191].setConnections(0b01010100); +myFirstBox[192].setConnections(0b10101000); +myFirstBox[193].setConnections(0b10100110); +myFirstBox[194].setConnections(0b01010001); +myFirstBox[195].setConnections(0b01010101); +myFirstBox[196].setConnections(0b01100110); +myFirstBox[197].setConnections(0b10100101); +myFirstBox[198].setConnections(0b00100101); +myFirstBox[199].setConnections(0b00100101); +myFirstBox[200].setConnections(0b10101001); +myFirstBox[201].setConnections(0b10101001); +myFirstBox[202].setConnections(0b01011001); +myFirstBox[203].setConnections(0b00001010); +myFirstBox[204].setConnections(0b01010101); +myFirstBox[205].setConnections(0b10011010); +myFirstBox[206].setConnections(0b10100110); +myFirstBox[207].setConnections(0b10100101); +myFirstBox[208].setConnections(0b10011001); +myFirstBox[209].setConnections(0b10100110); +myFirstBox[210].setConnections(0b10101010); +myFirstBox[211].setConnections(0b01010110); +myFirstBox[212].setConnections(0b01010101); +myFirstBox[213].setConnections(0b01100010); +myFirstBox[214].setConnections(0b10010110); +myFirstBox[215].setConnections(0b10011010); +myFirstBox[216].setConnections(0b01100100); +myFirstBox[217].setConnections(0b01010101); +myFirstBox[218].setConnections(0b10011010); +myFirstBox[219].setConnections(0b01100101); +myFirstBox[220].setConnections(0b10101001); +myFirstBox[221].setConnections(0b10010101); +myFirstBox[222].setConnections(0b10100101); +myFirstBox[223].setConnections(0b10101001); +myFirstBox[224].setConnections(0b10100110); +myFirstBox[225].setConnections(0b10011001); +myFirstBox[226].setConnections(0b01011010); +myFirstBox[227].setConnections(0b01000101); +myFirstBox[228].setConnections(0b01100110); +myFirstBox[229].setConnections(0b10101010); +myFirstBox[230].setConnections(0b01010100); +myFirstBox[231].setConnections(0b10101010); +myFirstBox[232].setConnections(0b10011010); +myFirstBox[233].setConnections(0b10100110); +myFirstBox[234].setConnections(0b10011000); +myFirstBox[235].setConnections(0b10011001); +myFirstBox[236].setConnections(0b01010101); +myFirstBox[237].setConnections(0b01001010); +myFirstBox[238].setConnections(0b01100001); +myFirstBox[239].setConnections(0b10011010); +myFirstBox[240].setConnections(0b10010101); +myFirstBox[241].setConnections(0b10100110); +myFirstBox[242].setConnections(0b01010101); +myFirstBox[243].setConnections(0b10010101); +myFirstBox[244].setConnections(0b01101010); +myFirstBox[245].setConnections(0b01101010); +myFirstBox[246].setConnections(0b10100100); +myFirstBox[247].setConnections(0b00101010); +myFirstBox[248].setConnections(0b01100110); +myFirstBox[249].setConnections(0b01101000); +myFirstBox[250].setConnections(0b01101001); +myFirstBox[251].setConnections(0b10101001); +myFirstBox[252].setConnections(0b01010110); +myFirstBox[253].setConnections(0b10010110); +myFirstBox[254].setConnections(0b01100101); +myFirstBox[255].setConnections(0b01011001); +myFirstBox[256].setConnections(0b01100110); +myFirstBox[257].setConnections(0b00100101); +myFirstBox[258].setConnections(0b01101001); +myFirstBox[259].setConnections(0b10010110); +myFirstBox[260].setConnections(0b10011001); +myFirstBox[261].setConnections(0b10011001); +myFirstBox[262].setConnections(0b01101001); +myFirstBox[263].setConnections(0b01010010); +myFirstBox[264].setConnections(0b10101010); +myFirstBox[265].setConnections(0b01101001); +myFirstBox[266].setConnections(0b01101001); +myFirstBox[267].setConnections(0b01101001); +myFirstBox[268].setConnections(0b10010110); +myFirstBox[269].setConnections(0b10011001); +myFirstBox[270].setConnections(0b01101010); +myFirstBox[271].setConnections(0b10000110); +myFirstBox[272].setConnections(0b10010101); +myFirstBox[273].setConnections(0b00010101); +myFirstBox[274].setConnections(0b10101010); +myFirstBox[275].setConnections(0b01010110); +myFirstBox[276].setConnections(0b01100100); +myFirstBox[277].setConnections(0b01010101); +myFirstBox[278].setConnections(0b10010101); +myFirstBox[279].setConnections(0b01010101); +myFirstBox[280].setConnections(0b01011010); +myFirstBox[281].setConnections(0b10011010); +myFirstBox[282].setConnections(0b00010101); +myFirstBox[283].setConnections(0b10010110); +myFirstBox[284].setConnections(0b10100101); +myFirstBox[285].setConnections(0b10010101); +myFirstBox[286].setConnections(0b01101001); +myFirstBox[287].setConnections(0b10100101); +myFirstBox[288].setConnections(0b01101001); +myFirstBox[289].setConnections(0b10011001); +myFirstBox[290].setConnections(0b01011001); +myFirstBox[291].setConnections(0b10010110); +myFirstBox[292].setConnections(0b01010101); +myFirstBox[293].setConnections(0b10100110); +myFirstBox[294].setConnections(0b10101001); +myFirstBox[295].setConnections(0b10101001); +myFirstBox[296].setConnections(0b01011010); +myFirstBox[297].setConnections(0b10100101); +myFirstBox[298].setConnections(0b01011010); +myFirstBox[299].setConnections(0b01100110); +myFirstBox[300].setConnections(0b10010101); +myFirstBox[301].setConnections(0b10101001); +myFirstBox[302].setConnections(0b10011001); +myFirstBox[303].setConnections(0b01010101); +myFirstBox[304].setConnections(0b01010101); +myFirstBox[305].setConnections(0b10101001); +myFirstBox[306].setConnections(0b01100101); +myFirstBox[307].setConnections(0b01101000); +myFirstBox[308].setConnections(0b01010101); +myFirstBox[309].setConnections(0b10010110); +myFirstBox[310].setConnections(0b10010110); +myFirstBox[311].setConnections(0b01011010); +myFirstBox[312].setConnections(0b10010110); +myFirstBox[313].setConnections(0b01011001); +myFirstBox[314].setConnections(0b01010110); +myFirstBox[315].setConnections(0b01101001); +myFirstBox[316].setConnections(0b10100101); +myFirstBox[317].setConnections(0b10101010); +myFirstBox[318].setConnections(0b10011001); +myFirstBox[319].setConnections(0b01010110); +myFirstBox[320].setConnections(0b10100000); +myFirstBox[321].setConnections(0b10100101); +myFirstBox[322].setConnections(0b00010101); +myFirstBox[323].setConnections(0b01010110); +myFirstBox[324].setConnections(0b01101010); +myFirstBox[325].setConnections(0b10010110); +myFirstBox[326].setConnections(0b00001001); +myFirstBox[327].setConnections(0b10011010); +myFirstBox[328].setConnections(0b10101010); +myFirstBox[329].setConnections(0b01100101); +myFirstBox[330].setConnections(0b01011010); +myFirstBox[331].setConnections(0b01101010); +myFirstBox[332].setConnections(0b10100101); +myFirstBox[333].setConnections(0b10100101); +myFirstBox[334].setConnections(0b01011000); +myFirstBox[335].setConnections(0b01010110); +myFirstBox[336].setConnections(0b00100110); +myFirstBox[337].setConnections(0b01101010); +myFirstBox[338].setConnections(0b01101010); +myFirstBox[339].setConnections(0b10010110); +myFirstBox[340].setConnections(0b10101010); +myFirstBox[341].setConnections(0b01100110); +myFirstBox[342].setConnections(0b10011000); +myFirstBox[343].setConnections(0b10101010); +myFirstBox[344].setConnections(0b01011001); +myFirstBox[345].setConnections(0b01101001); +myFirstBox[346].setConnections(0b10010101); +myFirstBox[347].setConnections(0b10101010); +myFirstBox[348].setConnections(0b10011001); +myFirstBox[349].setConnections(0b01101001); +myFirstBox[350].setConnections(0b01010110); +myFirstBox[351].setConnections(0b10000110); +myFirstBox[352].setConnections(0b10010110); +myFirstBox[353].setConnections(0b10011010); +myFirstBox[354].setConnections(0b01010110); +myFirstBox[355].setConnections(0b10010010); +myFirstBox[356].setConnections(0b10100110); +myFirstBox[357].setConnections(0b10101001); +myFirstBox[358].setConnections(0b01011001); +myFirstBox[359].setConnections(0b01010000); +myFirstBox[360].setConnections(0b10011001); +myFirstBox[361].setConnections(0b01101001); +myFirstBox[362].setConnections(0b01100001); +myFirstBox[363].setConnections(0b10100110); +myFirstBox[364].setConnections(0b10100101); +myFirstBox[365].setConnections(0b01100101); +myFirstBox[366].setConnections(0b01001010); +myFirstBox[367].setConnections(0b10010110); +myFirstBox[368].setConnections(0b10010101); +myFirstBox[369].setConnections(0b10010100); +myFirstBox[370].setConnections(0b01010101); +myFirstBox[371].setConnections(0b01011000); +myFirstBox[372].setConnections(0b01100010); +myFirstBox[373].setConnections(0b10011001); +myFirstBox[374].setConnections(0b01100110); +myFirstBox[375].setConnections(0b10100101); +myFirstBox[376].setConnections(0b01000110); +myFirstBox[377].setConnections(0b01010101); +myFirstBox[378].setConnections(0b01100110); +myFirstBox[379].setConnections(0b10100110); +myFirstBox[380].setConnections(0b00100110); +myFirstBox[381].setConnections(0b01101001); +myFirstBox[382].setConnections(0b01100101); +myFirstBox[383].setConnections(0b10010101); +myFirstBox[384].setConnections(0b01101001); +myFirstBox[385].setConnections(0b10010110); +myFirstBox[386].setConnections(0b10010101); +myFirstBox[387].setConnections(0b10101001); +myFirstBox[388].setConnections(0b10011001); +myFirstBox[389].setConnections(0b01010110); +myFirstBox[390].setConnections(0b10100010); +myFirstBox[391].setConnections(0b10101001); +myFirstBox[392].setConnections(0b01101010); +myFirstBox[393].setConnections(0b10101010); +myFirstBox[394].setConnections(0b01100110); +myFirstBox[395].setConnections(0b01010101); +myFirstBox[396].setConnections(0b01101001); +myFirstBox[397].setConnections(0b10010101); +myFirstBox[398].setConnections(0b10100110); +myFirstBox[399].setConnections(0b01101010); +return; + +} \ No newline at end of file diff --git a/TeamCMU/Revision_03/a.out b/TeamCMU/Revision_03/a.out new file mode 100644 index 0000000000000000000000000000000000000000..cd327e8315ed25037d37c3b3d93cc7b904b7ec14 GIT binary patch literal 65008 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 Q-vEHC2;be9S9tmV4=L~mRR910 literal 0 HcmV?d00001 diff --git a/TeamCMU/Revision_03/main.cpp b/TeamCMU/Revision_03/main.cpp new file mode 100644 index 0000000..3701526 --- /dev/null +++ b/TeamCMU/Revision_03/main.cpp @@ -0,0 +1,115 @@ +//Raphael Maenle - 11.11.2017 +#include +#include +#include +#include +#include +#include + +#define debug + +#include "puzzle.h" +#include "test_puzzle.h" + +using namespace std; + +vector log; + +int main() +{ + srand(time(0)); + + vector part_array(NR_PARTS); + vector corners_array(NR_CORNERS); + vector edges_array(NR_EDGES); + vector inners_array(NR_INNERS); + + //randomBox myPuzzle(cols,rows); + //myPuzzle.createRandomPuzzle(); + + unsigned int rows=20, cols=20; + vector myFirstBox = createBox(cols, rows); + create4040hardBox(myFirstBox); + + printBox(myFirstBox); + cout << endl; + + + + + + + + + + + while(next()); + + + + + return 0; +} + +next() +{ + + //calculates next move according to log + + //case puzzle solved + //return 0; + + //case last log empty + //backtrack + + //case last log exactly one solution + //put all remaining puzzle pieces into new log entry + //try next piece/place with solve abstraction level 0 + + //case last log multiple entries + //advance abstraction layer of last log by one and solve() + //or pick first if highest level reached + + //return 1; +} + +solve() +{ + //case + //abstraction layer = 0 + //go to abstraction layer 0 solver + + //case + //abstraction layer = 1 + //go to abstraction layer 1 solver + //default + //random one of the parts +} + +abstractionlayer0solver() +{ + //throw all remaining puzzle pieces into log + //remove all impossible +} + +abstractionlayer1solver() +{ + //remove all impossible according to abstraction layer one +} + +setsolution() +{ + //put + //set pointer to log into matrix +} + +backtrack() +{ + //following possibilities: + //last log entry empty + //delete last log + backtrack + //last log entry only one solution + //delete last log + backtrack + //last log entry multiple solutions (and current one was randomed) + //delete randomed piece from puzzleCollector and go to next (which might random again depending on function) +} \ No newline at end of file diff --git a/TeamCMU/Revision_03/puzzle.h b/TeamCMU/Revision_03/puzzle.h new file mode 100644 index 0000000..2d61058 --- /dev/null +++ b/TeamCMU/Revision_03/puzzle.h @@ -0,0 +1,467 @@ +#include + +#define NR_PARTS 1008 +#define NR_CORNERS 4 +#define NR_EDGES 120 +#define NR_INNERS 884 + +using namespace std; + +//part from group header file +class Part +{ +public: + Part(): connections(0){} + ~Part() {} + uint8_t getConnections() const + { + return connections; + } + void setConnections(uint8_t newconnections) + { + connections = newconnections; + } + +private: + uint8_t connections; +}; + +//puzzlepiece extens part with essential identifiers and functions +class PuzzlePiece: public Part +{ +public: + + PuzzlePiece(unsigned int flag = 0) + { + shifts=0; + boxidentifier=-1; + switch(flag) + { + case 0: + setConnections(0b00000000); + break; + case 1: + setConnections(0b11111111); + break; + case 3: + randomCenterPiece(); + break; + } + } + + void shift(unsigned int moves); + void randomCenterPiece(); + void printPiece() { cout << bitset (getConnections()); } + + void setBoxIdentifier(int new_boxid) { boxidentifier = new_boxid; } + int getBoxIdentifier() { return boxidentifier; } + void assignIdentifier() { identifier = idcount;idcount++; } + unsigned int getIdentifier() { return identifier;} + +private: + unsigned int shifts; + unsigned int boxidentifier; + unsigned int identifier; + static unsigned int idcount; +}; + +unsigned int PuzzlePiece::idcount(0); + +class Puzzle +{ + friend class randomBox; +public: + //constructor creates matrix with 00 outside and 11 inside + Puzzle(uint m = 7, uint n = 4): col(m), row(n) + { + Matrix = new PuzzlePiece* [n+2]; + for(int i = 0;i& myBox, unsigned int separator); + unsigned int putBackIntoBox(unsigned int m, unsigned int n, vector& myBox); + + +private: + uint row; + uint col; + + PuzzlePiece** Matrix; + +}; + +//use this for random puzzle creation +class randomBox: public Puzzle +{ +public: + + randomBox(unsigned int m, unsigned int n) : Puzzle(m,n) {} //passed m n to puzzle constructor + + void createRandomPuzzle(); + vector shuffle(); + void printBox(); + +private: + vector Box; + +}; + +class coor +{ + int m, n; + coor(int newm,int newn): m(newm), n(newn) + {} +} + +class LogEntry +{ +public: + vector PieceCollector; + vector CoorCollector; + int abstractionLevel; + + uint myCoor; + PuzzlePiece* myPuzzlePiece; + + PuzzleCollector() + { + + myCoor.m=-1; + myCoor.n=-1; + abstractionLevel=0; + } +private: +} + + +//functiondefinitions +void printBox(vector myBox); +vector createBox(uint m, uint n); +void numerateBox(vector& myBox); + +//functions + +//shifts puzzle piece one to the right +void PuzzlePiece::shift(unsigned int moves) +{ + shifts = (shifts+moves)%4; + setConnections(((getConnections() >> (moves*2)) | (getConnections() << sizeof(unsigned char)*8 - (moves*2)))); +} + +//creates random centerpiece +void PuzzlePiece::randomCenterPiece() +{ + setConnections(0b00000000); + + if(rand()%2) + setConnections(getConnections() | 0b01000000); + else + setConnections(getConnections() | 0b10000000); + + if(rand()%2) + setConnections(getConnections() | 0b00010000); + else + setConnections(getConnections() | 0b00100000); + + if(rand()%2) + setConnections(getConnections() | 0b00000100); + else + setConnections(getConnections() | 0b00001000); + + if(rand()%2) + setConnections(getConnections() | 0b00000001); + else + setConnections(getConnections() | 0b00000010); +} + +//tries all pieces in box from separator to end and places fitting into matrix. removes fitting piece +//use separator if you have to retract to a position +//seperator may be bigger than box size, if all puzzle pieces have already been looked at. +// it immediately retracts again then (returns -1) +unsigned int Puzzle::tryAllPieces(unsigned int m, unsigned int n, vector& myBox, unsigned int separator) +{ + for(int i=separator; i& myBox) +{ +#ifdef debug +cout << "putting back" << endl; +cout << "Old Box: "; +printBox(myBox); +cout << endl; +#endif + for(int i = 0; i < myBox.size();i++) + { + if(myBox[i].getBoxIdentifier()>getPiece(m,n).getBoxIdentifier()) + { + myBox.insert(myBox.begin()+i,getPiece(m,n)); + removePiece(m,n); + return i+1; + } + } + //using push back, if the element was the last element in the vector chain + myBox.push_back(getPiece(m,n)); + removePiece(m,n); + return myBox.size(); +} + +//checks if the myPart in its current orientation is legal in position m, n +bool Puzzle::PlaceOfPartGood(unsigned int m,unsigned int n, PuzzlePiece& myPart) +{ + + PuzzlePiece negativePart(0); + + negativePart.setConnections(negativePart.getConnections() | (getPiece(m,n+1).getConnections() & 0b11000000)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m-1,n).getConnections() & 0b00110000)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m,n-1).getConnections() & 0b00001100)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m+1,n).getConnections() & 0b00000011)); + negativePart.shift(2); + + + + if ( + ( ((((negativePart.getConnections() & 0b11000000) ^ (myPart.getConnections() & 0b11000000)) != 0b00000000) && (((myPart.getConnections() & 0b11000000) != 0b00000000) && (negativePart.getConnections() & 0b11000000) != 0b00000000)) + || ((((negativePart.getConnections() & 0b11000000) == 0b11000000) || ((myPart.getConnections() & 0b11000000) == 0b11000000)) && (( myPart.getConnections() & 0b11000000) != 0b00000000) && (negativePart.getConnections() & 0b11000000) != 0b00000000) + || (((negativePart.getConnections() & 0b11000000) == 0b00000000) && ((myPart.getConnections() & 0b11000000) == 0b00000000)) ) + && + ( ((((negativePart.getConnections() & 0b00110000) ^ (myPart.getConnections() & 0b00110000)) != 0b00000000) && (((myPart.getConnections() & 0b00110000) != 0b00000000) && (negativePart.getConnections() & 0b00110000) != 0b00000000)) + || ((((negativePart.getConnections() & 0b00110000) == 0b00110000) || ((myPart.getConnections() & 0b00110000) == 0b00110000)) && (((myPart.getConnections() & 0b00110000) != 0b00000000) && (negativePart.getConnections() & 0b00110000) != 0b00000000)) + || (((negativePart.getConnections() & 0b00110000) == 0b00000000) && ((myPart.getConnections() & 0b00110000) == 0b00000000)) ) + && + ( ((((negativePart.getConnections() & 0b00001100) ^ (myPart.getConnections() & 0b00001100)) != 0b00000000) && (((myPart.getConnections() & 0b00001100) != 0b00000000) && (negativePart.getConnections() & 0b00001100) != 0b00000000)) + || ((((negativePart.getConnections() & 0b00001100) == 0b00001100) || ((myPart.getConnections() & 0b00001100) == 0b00001100)) && (((myPart.getConnections() & 0b00001100) != 0b00000000) && (negativePart.getConnections() & 0b00001100) != 0b00000000)) + || (((negativePart.getConnections() & 0b00001100) == 0b00000000) && ((myPart.getConnections() & 0b00001100) == 0b00000000)) ) + && + ( ((((negativePart.getConnections() & 0b00000011) ^ (myPart.getConnections() & 0b00000011)) != 0b00000000) && (((myPart.getConnections() & 0b00000011) != 0b00000000) && (negativePart.getConnections() & 0b00000011) != 0b00000000)) + || ((((negativePart.getConnections() & 0b00000011) == 0b00000011) || ((myPart.getConnections() & 0b00000011) == 0b00000011)) && (((myPart.getConnections() & 0b00000011) != 0b00000000) && (negativePart.getConnections() & 0b00000011) != 0b00000000)) + || (((negativePart.getConnections() & 0b00000011) == 0b00000000) && ((myPart.getConnections() & 0b00000011) == 0b00000000)) ) + ) + { +#ifdef debug +cout << "good Part: "; +myPart.printPiece(); +cout << endl; +#endif + return 1; + } + + + + return 0; +} + + +//TODO!! +//simpler algorithm to the first placeofpartgood +//not yet functional!!! +bool Puzzle::PlaceOfPart2Good(unsigned int m,unsigned int n, PuzzlePiece& myPart) +{ + + PuzzlePiece negativePart(0); + + negativePart.setConnections(negativePart.getConnections() | (getPiece(m,n+1).getConnections() & 0b11000000)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m-1,n).getConnections() & 0b00110000)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m,n-1).getConnections() & 0b00001100)); + negativePart.setConnections(negativePart.getConnections() | (getPiece(m+1,n).getConnections() & 0b00000011)); + negativePart.shift(2); + + //A and D or B and C or not A and not B and not C and not D + + if ( + ( ( (negativePart.getConnections() & 0b10000000) & (myPart.getConnections() & 0b01000000)) + || ( (negativePart.getConnections() & 0b01000000) & (myPart.getConnections() & 0b10000000)) + || ((!(negativePart.getConnections() & 0b10000000) & !(myPart.getConnections() & 0b10000000)) & (!(negativePart.getConnections() & 0b01000000) & !(myPart.getConnections() & 0b01000000))) + ) + && + ( ( (negativePart.getConnections() & 0b00100000) & (myPart.getConnections() & 0b00010000)) + || ( (negativePart.getConnections() & 0b00010000) & (myPart.getConnections() & 0b00100000)) + || ((!(negativePart.getConnections() & 0b00100000) & !(myPart.getConnections() & 0b00100000)) & (!(negativePart.getConnections() & 0b00010000) & !(myPart.getConnections() & 0b00010000))) + ) + && + ( ( (negativePart.getConnections() & 0b00001000) & (myPart.getConnections() & 0b00000100)) + || ( (negativePart.getConnections() & 0b00000100) & (myPart.getConnections() & 0b00001000)) + || ((!(negativePart.getConnections() & 0b00001000) & !(myPart.getConnections() & 0b00001000)) & (!(negativePart.getConnections() & 0b00000100) & !(myPart.getConnections() & 0b00000100))) + ) + && + ( ( (negativePart.getConnections() & 0b00000010) & (myPart.getConnections() & 0b00000001)) + || ( (negativePart.getConnections() & 0b00000001) & (myPart.getConnections() & 0b00000010)) + || ((!(negativePart.getConnections() & 0b00000010) & !(myPart.getConnections() & 0b00000010)) & (!(negativePart.getConnections() & 0b00000001) & !(myPart.getConnections() & 0b00000001))) + ) + ) + + return 1; + + cout << "nogood" << endl; + return 0; +} + +//prints the true puzzle (without 0 edges) +void Puzzle::printPuzzle() +{ + cout << "current Puzzle: " << endl; + for(int i=1;i::iterator i = Box.begin(); i != Box.end(); i++) + { + (*i).printPiece(); + cout << ' '; + } + cout << endl; +} + +//shuffles around a box, randomizing pieces and orientation +vector randomBox::shuffle() +{ + random_shuffle(Box.begin(),Box.end()); + for (vector::iterator i = Box.begin(); i != Box.end(); i++) + (*i).shift(rand()%4); + numerateBox(Box); + return Box; +} + +//creates a random box size m, n, shuffles it, and then retuns it +vector createBox(uint m, uint n) +{ + randomBox myFirstPuzzleBox(m,n); + myFirstPuzzleBox.createRandomPuzzle(); + return myFirstPuzzleBox.shuffle(); +} + +//prints contents of box +void printBox(vector myBox) +{ + cout << "current Box: " << endl; + for (vector::iterator i = myBox.begin(); i != myBox.end(); i++) + { + (*i).printPiece(); + cout << ' '; + } + cout << endl; + return; +} + +//gives every element in box a box identifier. +void numerateBox(vector& myBox) +{ + for(int i = 0; i< myBox.size();i++) + myBox[i].setBoxIdentifier(i); + + return; +} \ No newline at end of file diff --git a/TeamCMU/Revision_03/test_puzzle.h b/TeamCMU/Revision_03/test_puzzle.h new file mode 100644 index 0000000..f893bf0 --- /dev/null +++ b/TeamCMU/Revision_03/test_puzzle.h @@ -0,0 +1,406 @@ + + void create4040hardBox(vector& myFirstBox) +{ +myFirstBox[0].setConnections(0b01101001); +myFirstBox[1].setConnections(0b10011001); +myFirstBox[2].setConnections(0b01100110); +myFirstBox[3].setConnections(0b01101001); +myFirstBox[4].setConnections(0b10100101); +myFirstBox[5].setConnections(0b10010010); +myFirstBox[6].setConnections(0b01101001); +myFirstBox[7].setConnections(0b00101010); +myFirstBox[8].setConnections(0b01000110); +myFirstBox[9].setConnections(0b01011010); +myFirstBox[10].setConnections(0b01011010); +myFirstBox[11].setConnections(0b10010101); +myFirstBox[12].setConnections(0b01010101); +myFirstBox[13].setConnections(0b10101001); +myFirstBox[14].setConnections(0b10010101); +myFirstBox[15].setConnections(0b10101010); +myFirstBox[16].setConnections(0b01101010); +myFirstBox[17].setConnections(0b01101010); +myFirstBox[18].setConnections(0b00100101); +myFirstBox[19].setConnections(0b01100101); +myFirstBox[20].setConnections(0b10010001); +myFirstBox[21].setConnections(0b10010101); +myFirstBox[22].setConnections(0b10101001); +myFirstBox[23].setConnections(0b01010110); +myFirstBox[24].setConnections(0b10101010); +myFirstBox[25].setConnections(0b01101000); +myFirstBox[26].setConnections(0b01101010); +myFirstBox[27].setConnections(0b10010101); +myFirstBox[28].setConnections(0b10011010); +myFirstBox[29].setConnections(0b10011001); +myFirstBox[30].setConnections(0b01101010); +myFirstBox[31].setConnections(0b01100001); +myFirstBox[32].setConnections(0b01101010); +myFirstBox[33].setConnections(0b01100101); +myFirstBox[34].setConnections(0b01010101); +myFirstBox[35].setConnections(0b01010110); +myFirstBox[36].setConnections(0b01101010); +myFirstBox[37].setConnections(0b01010110); +myFirstBox[38].setConnections(0b01100110); +myFirstBox[39].setConnections(0b01011010); +myFirstBox[40].setConnections(0b01100101); +myFirstBox[41].setConnections(0b01101001); +myFirstBox[42].setConnections(0b01010110); +myFirstBox[43].setConnections(0b01000110); +myFirstBox[44].setConnections(0b01011001); +myFirstBox[45].setConnections(0b01101001); +myFirstBox[46].setConnections(0b10000101); +myFirstBox[47].setConnections(0b10011010); +myFirstBox[48].setConnections(0b10010110); +myFirstBox[49].setConnections(0b01011010); +myFirstBox[50].setConnections(0b10011001); +myFirstBox[51].setConnections(0b01001001); +myFirstBox[52].setConnections(0b10100110); +myFirstBox[53].setConnections(0b01001010); +myFirstBox[54].setConnections(0b10010010); +myFirstBox[55].setConnections(0b01001010); +myFirstBox[56].setConnections(0b01101001); +myFirstBox[57].setConnections(0b10100110); +myFirstBox[58].setConnections(0b10010110); +myFirstBox[59].setConnections(0b10010110); +myFirstBox[60].setConnections(0b10101001); +myFirstBox[61].setConnections(0b00100101); +myFirstBox[62].setConnections(0b00101001); +myFirstBox[63].setConnections(0b01101001); +myFirstBox[64].setConnections(0b01101001); +myFirstBox[65].setConnections(0b00100101); +myFirstBox[66].setConnections(0b10010110); +myFirstBox[67].setConnections(0b10011010); +myFirstBox[68].setConnections(0b01100110); +myFirstBox[69].setConnections(0b10010110); +myFirstBox[70].setConnections(0b01010100); +myFirstBox[71].setConnections(0b01011010); +myFirstBox[72].setConnections(0b01100110); +myFirstBox[73].setConnections(0b01100101); +myFirstBox[74].setConnections(0b10011010); +myFirstBox[75].setConnections(0b10010101); +myFirstBox[76].setConnections(0b10011010); +myFirstBox[77].setConnections(0b01100101); +myFirstBox[78].setConnections(0b10011010); +myFirstBox[79].setConnections(0b01010110); +myFirstBox[80].setConnections(0b01101010); +myFirstBox[81].setConnections(0b01010101); +myFirstBox[82].setConnections(0b01100101); +myFirstBox[83].setConnections(0b10100101); +myFirstBox[84].setConnections(0b01010110); +myFirstBox[85].setConnections(0b01101010); +myFirstBox[86].setConnections(0b10011010); +myFirstBox[87].setConnections(0b10010110); +myFirstBox[88].setConnections(0b01101010); +myFirstBox[89].setConnections(0b01011010); +myFirstBox[90].setConnections(0b01010110); +myFirstBox[91].setConnections(0b01100101); +myFirstBox[92].setConnections(0b00100101); +myFirstBox[93].setConnections(0b10100101); +myFirstBox[94].setConnections(0b10010110); +myFirstBox[95].setConnections(0b01100110); +myFirstBox[96].setConnections(0b10000110); +myFirstBox[97].setConnections(0b01001001); +myFirstBox[98].setConnections(0b10010110); +myFirstBox[99].setConnections(0b10100110); +myFirstBox[100].setConnections(0b10100110); +myFirstBox[101].setConnections(0b01100010); +myFirstBox[102].setConnections(0b01101010); +myFirstBox[103].setConnections(0b10011001); +myFirstBox[104].setConnections(0b01010101); +myFirstBox[105].setConnections(0b10011010); +myFirstBox[106].setConnections(0b10101001); +myFirstBox[107].setConnections(0b01100110); +myFirstBox[108].setConnections(0b10101001); +myFirstBox[109].setConnections(0b10101001); +myFirstBox[110].setConnections(0b10010100); +myFirstBox[111].setConnections(0b01100110); +myFirstBox[112].setConnections(0b01010110); +myFirstBox[113].setConnections(0b10010101); +myFirstBox[114].setConnections(0b01011001); +myFirstBox[115].setConnections(0b01101010); +myFirstBox[116].setConnections(0b10100110); +myFirstBox[117].setConnections(0b10100101); +myFirstBox[118].setConnections(0b10101010); +myFirstBox[119].setConnections(0b01011010); +myFirstBox[120].setConnections(0b10011000); +myFirstBox[121].setConnections(0b10010101); +myFirstBox[122].setConnections(0b10100101); +myFirstBox[123].setConnections(0b10000110); +myFirstBox[124].setConnections(0b01100101); +myFirstBox[125].setConnections(0b10100110); +myFirstBox[126].setConnections(0b10101010); +myFirstBox[127].setConnections(0b01101001); +myFirstBox[128].setConnections(0b01010101); +myFirstBox[129].setConnections(0b01100101); +myFirstBox[130].setConnections(0b10001001); +myFirstBox[131].setConnections(0b01101010); +myFirstBox[132].setConnections(0b01101010); +myFirstBox[133].setConnections(0b01100010); +myFirstBox[134].setConnections(0b01100110); +myFirstBox[135].setConnections(0b10100001); +myFirstBox[136].setConnections(0b10011001); +myFirstBox[137].setConnections(0b01101010); +myFirstBox[138].setConnections(0b01011001); +myFirstBox[139].setConnections(0b10001001); +myFirstBox[140].setConnections(0b01010101); +myFirstBox[141].setConnections(0b10100101); +myFirstBox[142].setConnections(0b01100101); +myFirstBox[143].setConnections(0b10100101); +myFirstBox[144].setConnections(0b10011010); +myFirstBox[145].setConnections(0b10010001); +myFirstBox[146].setConnections(0b10100110); +myFirstBox[147].setConnections(0b01101010); +myFirstBox[148].setConnections(0b10010101); +myFirstBox[149].setConnections(0b01100101); +myFirstBox[150].setConnections(0b10100101); +myFirstBox[151].setConnections(0b10100110); +myFirstBox[152].setConnections(0b10010001); +myFirstBox[153].setConnections(0b10101000); +myFirstBox[154].setConnections(0b10011010); +myFirstBox[155].setConnections(0b10100110); +myFirstBox[156].setConnections(0b01100110); +myFirstBox[157].setConnections(0b10100110); +myFirstBox[158].setConnections(0b01011010); +myFirstBox[159].setConnections(0b10100001); +myFirstBox[160].setConnections(0b01010101); +myFirstBox[161].setConnections(0b10011010); +myFirstBox[162].setConnections(0b10101001); +myFirstBox[163].setConnections(0b01010110); +myFirstBox[164].setConnections(0b01100001); +myFirstBox[165].setConnections(0b01011001); +myFirstBox[166].setConnections(0b01101001); +myFirstBox[167].setConnections(0b10011001); +myFirstBox[168].setConnections(0b10010101); +myFirstBox[169].setConnections(0b01100010); +myFirstBox[170].setConnections(0b01010110); +myFirstBox[171].setConnections(0b00010101); +myFirstBox[172].setConnections(0b10100101); +myFirstBox[173].setConnections(0b10101010); +myFirstBox[174].setConnections(0b10011010); +myFirstBox[175].setConnections(0b01100101); +myFirstBox[176].setConnections(0b10100110); +myFirstBox[177].setConnections(0b10101001); +myFirstBox[178].setConnections(0b01011010); +myFirstBox[179].setConnections(0b01101001); +myFirstBox[180].setConnections(0b10010101); +myFirstBox[181].setConnections(0b01101010); +myFirstBox[182].setConnections(0b10010110); +myFirstBox[183].setConnections(0b10010110); +myFirstBox[184].setConnections(0b10011001); +myFirstBox[185].setConnections(0b10100101); +myFirstBox[186].setConnections(0b10010110); +myFirstBox[187].setConnections(0b10010110); +myFirstBox[188].setConnections(0b10011010); +myFirstBox[189].setConnections(0b10010101); +myFirstBox[190].setConnections(0b01010001); +myFirstBox[191].setConnections(0b01010100); +myFirstBox[192].setConnections(0b10101000); +myFirstBox[193].setConnections(0b10100110); +myFirstBox[194].setConnections(0b01010001); +myFirstBox[195].setConnections(0b01010101); +myFirstBox[196].setConnections(0b01100110); +myFirstBox[197].setConnections(0b10100101); +myFirstBox[198].setConnections(0b00100101); +myFirstBox[199].setConnections(0b00100101); +myFirstBox[200].setConnections(0b10101001); +myFirstBox[201].setConnections(0b10101001); +myFirstBox[202].setConnections(0b01011001); +myFirstBox[203].setConnections(0b00001010); +myFirstBox[204].setConnections(0b01010101); +myFirstBox[205].setConnections(0b10011010); +myFirstBox[206].setConnections(0b10100110); +myFirstBox[207].setConnections(0b10100101); +myFirstBox[208].setConnections(0b10011001); +myFirstBox[209].setConnections(0b10100110); +myFirstBox[210].setConnections(0b10101010); +myFirstBox[211].setConnections(0b01010110); +myFirstBox[212].setConnections(0b01010101); +myFirstBox[213].setConnections(0b01100010); +myFirstBox[214].setConnections(0b10010110); +myFirstBox[215].setConnections(0b10011010); +myFirstBox[216].setConnections(0b01100100); +myFirstBox[217].setConnections(0b01010101); +myFirstBox[218].setConnections(0b10011010); +myFirstBox[219].setConnections(0b01100101); +myFirstBox[220].setConnections(0b10101001); +myFirstBox[221].setConnections(0b10010101); +myFirstBox[222].setConnections(0b10100101); +myFirstBox[223].setConnections(0b10101001); +myFirstBox[224].setConnections(0b10100110); +myFirstBox[225].setConnections(0b10011001); +myFirstBox[226].setConnections(0b01011010); +myFirstBox[227].setConnections(0b01000101); +myFirstBox[228].setConnections(0b01100110); +myFirstBox[229].setConnections(0b10101010); +myFirstBox[230].setConnections(0b01010100); +myFirstBox[231].setConnections(0b10101010); +myFirstBox[232].setConnections(0b10011010); +myFirstBox[233].setConnections(0b10100110); +myFirstBox[234].setConnections(0b10011000); +myFirstBox[235].setConnections(0b10011001); +myFirstBox[236].setConnections(0b01010101); +myFirstBox[237].setConnections(0b01001010); +myFirstBox[238].setConnections(0b01100001); +myFirstBox[239].setConnections(0b10011010); +myFirstBox[240].setConnections(0b10010101); +myFirstBox[241].setConnections(0b10100110); +myFirstBox[242].setConnections(0b01010101); +myFirstBox[243].setConnections(0b10010101); +myFirstBox[244].setConnections(0b01101010); +myFirstBox[245].setConnections(0b01101010); +myFirstBox[246].setConnections(0b10100100); +myFirstBox[247].setConnections(0b00101010); +myFirstBox[248].setConnections(0b01100110); +myFirstBox[249].setConnections(0b01101000); +myFirstBox[250].setConnections(0b01101001); +myFirstBox[251].setConnections(0b10101001); +myFirstBox[252].setConnections(0b01010110); +myFirstBox[253].setConnections(0b10010110); +myFirstBox[254].setConnections(0b01100101); +myFirstBox[255].setConnections(0b01011001); +myFirstBox[256].setConnections(0b01100110); +myFirstBox[257].setConnections(0b00100101); +myFirstBox[258].setConnections(0b01101001); +myFirstBox[259].setConnections(0b10010110); +myFirstBox[260].setConnections(0b10011001); +myFirstBox[261].setConnections(0b10011001); +myFirstBox[262].setConnections(0b01101001); +myFirstBox[263].setConnections(0b01010010); +myFirstBox[264].setConnections(0b10101010); +myFirstBox[265].setConnections(0b01101001); +myFirstBox[266].setConnections(0b01101001); +myFirstBox[267].setConnections(0b01101001); +myFirstBox[268].setConnections(0b10010110); +myFirstBox[269].setConnections(0b10011001); +myFirstBox[270].setConnections(0b01101010); +myFirstBox[271].setConnections(0b10000110); +myFirstBox[272].setConnections(0b10010101); +myFirstBox[273].setConnections(0b00010101); +myFirstBox[274].setConnections(0b10101010); +myFirstBox[275].setConnections(0b01010110); +myFirstBox[276].setConnections(0b01100100); +myFirstBox[277].setConnections(0b01010101); +myFirstBox[278].setConnections(0b10010101); +myFirstBox[279].setConnections(0b01010101); +myFirstBox[280].setConnections(0b01011010); +myFirstBox[281].setConnections(0b10011010); +myFirstBox[282].setConnections(0b00010101); +myFirstBox[283].setConnections(0b10010110); +myFirstBox[284].setConnections(0b10100101); +myFirstBox[285].setConnections(0b10010101); +myFirstBox[286].setConnections(0b01101001); +myFirstBox[287].setConnections(0b10100101); +myFirstBox[288].setConnections(0b01101001); +myFirstBox[289].setConnections(0b10011001); +myFirstBox[290].setConnections(0b01011001); +myFirstBox[291].setConnections(0b10010110); +myFirstBox[292].setConnections(0b01010101); +myFirstBox[293].setConnections(0b10100110); +myFirstBox[294].setConnections(0b10101001); +myFirstBox[295].setConnections(0b10101001); +myFirstBox[296].setConnections(0b01011010); +myFirstBox[297].setConnections(0b10100101); +myFirstBox[298].setConnections(0b01011010); +myFirstBox[299].setConnections(0b01100110); +myFirstBox[300].setConnections(0b10010101); +myFirstBox[301].setConnections(0b10101001); +myFirstBox[302].setConnections(0b10011001); +myFirstBox[303].setConnections(0b01010101); +myFirstBox[304].setConnections(0b01010101); +myFirstBox[305].setConnections(0b10101001); +myFirstBox[306].setConnections(0b01100101); +myFirstBox[307].setConnections(0b01101000); +myFirstBox[308].setConnections(0b01010101); +myFirstBox[309].setConnections(0b10010110); +myFirstBox[310].setConnections(0b10010110); +myFirstBox[311].setConnections(0b01011010); +myFirstBox[312].setConnections(0b10010110); +myFirstBox[313].setConnections(0b01011001); +myFirstBox[314].setConnections(0b01010110); +myFirstBox[315].setConnections(0b01101001); +myFirstBox[316].setConnections(0b10100101); +myFirstBox[317].setConnections(0b10101010); +myFirstBox[318].setConnections(0b10011001); +myFirstBox[319].setConnections(0b01010110); +myFirstBox[320].setConnections(0b10100000); +myFirstBox[321].setConnections(0b10100101); +myFirstBox[322].setConnections(0b00010101); +myFirstBox[323].setConnections(0b01010110); +myFirstBox[324].setConnections(0b01101010); +myFirstBox[325].setConnections(0b10010110); +myFirstBox[326].setConnections(0b00001001); +myFirstBox[327].setConnections(0b10011010); +myFirstBox[328].setConnections(0b10101010); +myFirstBox[329].setConnections(0b01100101); +myFirstBox[330].setConnections(0b01011010); +myFirstBox[331].setConnections(0b01101010); +myFirstBox[332].setConnections(0b10100101); +myFirstBox[333].setConnections(0b10100101); +myFirstBox[334].setConnections(0b01011000); +myFirstBox[335].setConnections(0b01010110); +myFirstBox[336].setConnections(0b00100110); +myFirstBox[337].setConnections(0b01101010); +myFirstBox[338].setConnections(0b01101010); +myFirstBox[339].setConnections(0b10010110); +myFirstBox[340].setConnections(0b10101010); +myFirstBox[341].setConnections(0b01100110); +myFirstBox[342].setConnections(0b10011000); +myFirstBox[343].setConnections(0b10101010); +myFirstBox[344].setConnections(0b01011001); +myFirstBox[345].setConnections(0b01101001); +myFirstBox[346].setConnections(0b10010101); +myFirstBox[347].setConnections(0b10101010); +myFirstBox[348].setConnections(0b10011001); +myFirstBox[349].setConnections(0b01101001); +myFirstBox[350].setConnections(0b01010110); +myFirstBox[351].setConnections(0b10000110); +myFirstBox[352].setConnections(0b10010110); +myFirstBox[353].setConnections(0b10011010); +myFirstBox[354].setConnections(0b01010110); +myFirstBox[355].setConnections(0b10010010); +myFirstBox[356].setConnections(0b10100110); +myFirstBox[357].setConnections(0b10101001); +myFirstBox[358].setConnections(0b01011001); +myFirstBox[359].setConnections(0b01010000); +myFirstBox[360].setConnections(0b10011001); +myFirstBox[361].setConnections(0b01101001); +myFirstBox[362].setConnections(0b01100001); +myFirstBox[363].setConnections(0b10100110); +myFirstBox[364].setConnections(0b10100101); +myFirstBox[365].setConnections(0b01100101); +myFirstBox[366].setConnections(0b01001010); +myFirstBox[367].setConnections(0b10010110); +myFirstBox[368].setConnections(0b10010101); +myFirstBox[369].setConnections(0b10010100); +myFirstBox[370].setConnections(0b01010101); +myFirstBox[371].setConnections(0b01011000); +myFirstBox[372].setConnections(0b01100010); +myFirstBox[373].setConnections(0b10011001); +myFirstBox[374].setConnections(0b01100110); +myFirstBox[375].setConnections(0b10100101); +myFirstBox[376].setConnections(0b01000110); +myFirstBox[377].setConnections(0b01010101); +myFirstBox[378].setConnections(0b01100110); +myFirstBox[379].setConnections(0b10100110); +myFirstBox[380].setConnections(0b00100110); +myFirstBox[381].setConnections(0b01101001); +myFirstBox[382].setConnections(0b01100101); +myFirstBox[383].setConnections(0b10010101); +myFirstBox[384].setConnections(0b01101001); +myFirstBox[385].setConnections(0b10010110); +myFirstBox[386].setConnections(0b10010101); +myFirstBox[387].setConnections(0b10101001); +myFirstBox[388].setConnections(0b10011001); +myFirstBox[389].setConnections(0b01010110); +myFirstBox[390].setConnections(0b10100010); +myFirstBox[391].setConnections(0b10101001); +myFirstBox[392].setConnections(0b01101010); +myFirstBox[393].setConnections(0b10101010); +myFirstBox[394].setConnections(0b01100110); +myFirstBox[395].setConnections(0b01010101); +myFirstBox[396].setConnections(0b01101001); +myFirstBox[397].setConnections(0b10010101); +myFirstBox[398].setConnections(0b10100110); +myFirstBox[399].setConnections(0b01101010); +return; + +} \ No newline at end of file diff --git a/TeamCMU/Revision_03/test_puzzle_long40x40.h b/TeamCMU/Revision_03/test_puzzle_long40x40.h new file mode 100644 index 0000000..5c24f00 --- /dev/null +++ b/TeamCMU/Revision_03/test_puzzle_long40x40.h @@ -0,0 +1,400 @@ +myFirstBox[0].setConections(01101001); +myFirstBox[1].setConections(10011001); +myFirstBox[2].setConections(01100110); +myFirstBox[3].setConections(01101001); +myFirstBox[4].setConections(10100101); +myFirstBox[5].setConections(10010010); +myFirstBox[6].setConections(01101001); +myFirstBox[7].setConections(00101010); +myFirstBox[8].setConections(01000110); +myFirstBox[9].setConections(01011010); +myFirstBox[10].setConections(01011010); +myFirstBox[11].setConections(10010101); +myFirstBox[12].setConections(01010101); +myFirstBox[13].setConections(10101001); +myFirstBox[14].setConections(10010101); +myFirstBox[15].setConections(10101010); +myFirstBox[16].setConections(01101010); +myFirstBox[17].setConections(01101010); +myFirstBox[18].setConections(00100101); +myFirstBox[19].setConections(01100101); +myFirstBox[20].setConections(10010001); +myFirstBox[21].setConections(10010101); +myFirstBox[22].setConections(10101001); +myFirstBox[23].setConections(01010110); +myFirstBox[24].setConections(10101010); +myFirstBox[25].setConections(01101000); +myFirstBox[26].setConections(01101010); +myFirstBox[27].setConections(10010101); +myFirstBox[28].setConections(10011010); +myFirstBox[29].setConections(10011001); +myFirstBox[30].setConections(01101010); +myFirstBox[31].setConections(01100001); +myFirstBox[32].setConections(01101010); +myFirstBox[33].setConections(01100101); +myFirstBox[34].setConections(01010101); +myFirstBox[35].setConections(01010110); +myFirstBox[36].setConections(01101010); +myFirstBox[37].setConections(01010110); +myFirstBox[38].setConections(01100110); +myFirstBox[39].setConections(01011010); +myFirstBox[40].setConections(01100101); +myFirstBox[41].setConections(01101001); +myFirstBox[42].setConections(01010110); +myFirstBox[43].setConections(01000110); +myFirstBox[44].setConections(01011001); +myFirstBox[45].setConections(01101001); +myFirstBox[46].setConections(10000101); +myFirstBox[47].setConections(10011010); +myFirstBox[48].setConections(10010110); +myFirstBox[49].setConections(01011010); +myFirstBox[50].setConections(10011001); +myFirstBox[51].setConections(01001001); +myFirstBox[52].setConections(10100110); +myFirstBox[53].setConections(01001010); +myFirstBox[54].setConections(10010010); +myFirstBox[55].setConections(01001010); +myFirstBox[56].setConections(01101001); +myFirstBox[57].setConections(10100110); +myFirstBox[58].setConections(10010110); +myFirstBox[59].setConections(10010110); +myFirstBox[60].setConections(10101001); +myFirstBox[61].setConections(00100101); +myFirstBox[62].setConections(00101001); +myFirstBox[63].setConections(01101001); +myFirstBox[64].setConections(01101001); +myFirstBox[65].setConections(00100101); +myFirstBox[66].setConections(10010110); +myFirstBox[67].setConections(10011010); +myFirstBox[68].setConections(01100110); +myFirstBox[69].setConections(10010110); +myFirstBox[70].setConections(01010100); +myFirstBox[71].setConections(01011010); +myFirstBox[72].setConections(01100110); +myFirstBox[73].setConections(01100101); +myFirstBox[74].setConections(10011010); +myFirstBox[75].setConections(10010101); +myFirstBox[76].setConections(10011010); +myFirstBox[77].setConections(01100101); +myFirstBox[78].setConections(10011010); +myFirstBox[79].setConections(01010110); +myFirstBox[80].setConections(01101010); +myFirstBox[81].setConections(01010101); +myFirstBox[82].setConections(01100101); +myFirstBox[83].setConections(10100101); +myFirstBox[84].setConections(01010110); +myFirstBox[85].setConections(01101010); +myFirstBox[86].setConections(10011010); +myFirstBox[87].setConections(10010110); +myFirstBox[88].setConections(01101010); +myFirstBox[89].setConections(01011010); +myFirstBox[90].setConections(01010110); +myFirstBox[91].setConections(01100101); +myFirstBox[92].setConections(00100101); +myFirstBox[93].setConections(10100101); +myFirstBox[94].setConections(10010110); +myFirstBox[95].setConections(01100110); +myFirstBox[96].setConections(10000110); +myFirstBox[97].setConections(01001001); +myFirstBox[98].setConections(10010110); +myFirstBox[99].setConections(10100110); +myFirstBox[100].setConections(10100110); +myFirstBox[101].setConections(01100010); +myFirstBox[102].setConections(01101010); +myFirstBox[103].setConections(10011001); +myFirstBox[104].setConections(01010101); +myFirstBox[105].setConections(10011010); +myFirstBox[106].setConections(10101001); +myFirstBox[107].setConections(01100110); +myFirstBox[108].setConections(10101001); +myFirstBox[109].setConections(10101001); +myFirstBox[110].setConections(10010100); +myFirstBox[111].setConections(01100110); +myFirstBox[112].setConections(01010110); +myFirstBox[113].setConections(10010101); +myFirstBox[114].setConections(01011001); +myFirstBox[115].setConections(01101010); +myFirstBox[116].setConections(10100110); +myFirstBox[117].setConections(10100101); +myFirstBox[118].setConections(10101010); +myFirstBox[119].setConections(01011010); +myFirstBox[120].setConections(10011000); +myFirstBox[121].setConections(10010101); +myFirstBox[122].setConections(10100101); +myFirstBox[123].setConections(10000110); +myFirstBox[124].setConections(01100101); +myFirstBox[125].setConections(10100110); +myFirstBox[126].setConections(10101010); +myFirstBox[127].setConections(01101001); +myFirstBox[128].setConections(01010101); +myFirstBox[129].setConections(01100101); +myFirstBox[130].setConections(10001001); +myFirstBox[131].setConections(01101010); +myFirstBox[132].setConections(01101010); +myFirstBox[133].setConections(01100010); +myFirstBox[134].setConections(01100110); +myFirstBox[135].setConections(10100001); +myFirstBox[136].setConections(10011001); +myFirstBox[137].setConections(01101010); +myFirstBox[138].setConections(01011001); +myFirstBox[139].setConections(10001001); +myFirstBox[140].setConections(01010101); +myFirstBox[141].setConections(10100101); +myFirstBox[142].setConections(01100101); +myFirstBox[143].setConections(10100101); +myFirstBox[144].setConections(10011010); +myFirstBox[145].setConections(10010001); +myFirstBox[146].setConections(10100110); +myFirstBox[147].setConections(01101010); +myFirstBox[148].setConections(10010101); +myFirstBox[149].setConections(01100101); +myFirstBox[150].setConections(10100101); +myFirstBox[151].setConections(10100110); +myFirstBox[152].setConections(10010001); +myFirstBox[153].setConections(10101000); +myFirstBox[154].setConections(10011010); +myFirstBox[155].setConections(10100110); +myFirstBox[156].setConections(01100110); +myFirstBox[157].setConections(10100110); +myFirstBox[158].setConections(01011010); +myFirstBox[159].setConections(10100001); +myFirstBox[160].setConections(01010101); +myFirstBox[161].setConections(10011010); +myFirstBox[162].setConections(10101001); +myFirstBox[163].setConections(01010110); +myFirstBox[164].setConections(01100001); +myFirstBox[165].setConections(01011001); +myFirstBox[166].setConections(01101001); +myFirstBox[167].setConections(10011001); +myFirstBox[168].setConections(10010101); +myFirstBox[169].setConections(01100010); +myFirstBox[170].setConections(01010110); +myFirstBox[171].setConections(00010101); +myFirstBox[172].setConections(10100101); +myFirstBox[173].setConections(10101010); +myFirstBox[174].setConections(10011010); +myFirstBox[175].setConections(01100101); +myFirstBox[176].setConections(10100110); +myFirstBox[177].setConections(10101001); +myFirstBox[178].setConections(01011010); +myFirstBox[179].setConections(01101001); +myFirstBox[180].setConections(10010101); +myFirstBox[181].setConections(01101010); +myFirstBox[182].setConections(10010110); +myFirstBox[183].setConections(10010110); +myFirstBox[184].setConections(10011001); +myFirstBox[185].setConections(10100101); +myFirstBox[186].setConections(10010110); +myFirstBox[187].setConections(10010110); +myFirstBox[188].setConections(10011010); +myFirstBox[189].setConections(10010101); +myFirstBox[190].setConections(01010001); +myFirstBox[191].setConections(01010100); +myFirstBox[192].setConections(10101000); +myFirstBox[193].setConections(10100110); +myFirstBox[194].setConections(01010001); +myFirstBox[195].setConections(01010101); +myFirstBox[196].setConections(01100110); +myFirstBox[197].setConections(10100101); +myFirstBox[198].setConections(00100101); +myFirstBox[199].setConections(00100101); +myFirstBox[200].setConections(10101001); +myFirstBox[201].setConections(10101001); +myFirstBox[202].setConections(01011001); +myFirstBox[203].setConections(00001010); +myFirstBox[204].setConections(01010101); +myFirstBox[205].setConections(10011010); +myFirstBox[206].setConections(10100110); +myFirstBox[207].setConections(10100101); +myFirstBox[208].setConections(10011001); +myFirstBox[209].setConections(10100110); +myFirstBox[210].setConections(10101010); +myFirstBox[211].setConections(01010110); +myFirstBox[212].setConections(01010101); +myFirstBox[213].setConections(01100010); +myFirstBox[214].setConections(10010110); +myFirstBox[215].setConections(10011010); +myFirstBox[216].setConections(01100100); +myFirstBox[217].setConections(01010101); +myFirstBox[218].setConections(10011010); +myFirstBox[219].setConections(01100101); +myFirstBox[220].setConections(10101001); +myFirstBox[221].setConections(10010101); +myFirstBox[222].setConections(10100101); +myFirstBox[223].setConections(10101001); +myFirstBox[224].setConections(10100110); +myFirstBox[225].setConections(10011001); +myFirstBox[226].setConections(01011010); +myFirstBox[227].setConections(01000101); +myFirstBox[228].setConections(01100110); +myFirstBox[229].setConections(10101010); +myFirstBox[230].setConections(01010100); +myFirstBox[231].setConections(10101010); +myFirstBox[232].setConections(10011010); +myFirstBox[233].setConections(10100110); +myFirstBox[234].setConections(10011000); +myFirstBox[235].setConections(10011001); +myFirstBox[236].setConections(01010101); +myFirstBox[237].setConections(01001010); +myFirstBox[238].setConections(01100001); +myFirstBox[239].setConections(10011010); +myFirstBox[240].setConections(10010101); +myFirstBox[241].setConections(10100110); +myFirstBox[242].setConections(01010101); +myFirstBox[243].setConections(10010101); +myFirstBox[244].setConections(01101010); +myFirstBox[245].setConections(01101010); +myFirstBox[246].setConections(10100100); +myFirstBox[247].setConections(00101010); +myFirstBox[248].setConections(01100110); +myFirstBox[249].setConections(01101000); +myFirstBox[250].setConections(01101001); +myFirstBox[251].setConections(10101001); +myFirstBox[252].setConections(01010110); +myFirstBox[253].setConections(10010110); +myFirstBox[254].setConections(01100101); +myFirstBox[255].setConections(01011001); +myFirstBox[256].setConections(01100110); +myFirstBox[257].setConections(00100101); +myFirstBox[258].setConections(01101001); +myFirstBox[259].setConections(10010110); +myFirstBox[260].setConections(10011001); +myFirstBox[261].setConections(10011001); +myFirstBox[262].setConections(01101001); +myFirstBox[263].setConections(01010010); +myFirstBox[264].setConections(10101010); +myFirstBox[265].setConections(01101001); +myFirstBox[266].setConections(01101001); +myFirstBox[267].setConections(01101001); +myFirstBox[268].setConections(10010110); +myFirstBox[269].setConections(10011001); +myFirstBox[270].setConections(01101010); +myFirstBox[271].setConections(10000110); +myFirstBox[272].setConections(10010101); +myFirstBox[273].setConections(00010101); +myFirstBox[274].setConections(10101010); +myFirstBox[275].setConections(01010110); +myFirstBox[276].setConections(01100100); +myFirstBox[277].setConections(01010101); +myFirstBox[278].setConections(10010101); +myFirstBox[279].setConections(01010101); +myFirstBox[280].setConections(01011010); +myFirstBox[281].setConections(10011010); +myFirstBox[282].setConections(00010101); +myFirstBox[283].setConections(10010110); +myFirstBox[284].setConections(10100101); +myFirstBox[285].setConections(10010101); +myFirstBox[286].setConections(01101001); +myFirstBox[287].setConections(10100101); +myFirstBox[288].setConections(01101001); +myFirstBox[289].setConections(10011001); +myFirstBox[290].setConections(01011001); +myFirstBox[291].setConections(10010110); +myFirstBox[292].setConections(01010101); +myFirstBox[293].setConections(10100110); +myFirstBox[294].setConections(10101001); +myFirstBox[295].setConections(10101001); +myFirstBox[296].setConections(01011010); +myFirstBox[297].setConections(10100101); +myFirstBox[298].setConections(01011010); +myFirstBox[299].setConections(01100110); +myFirstBox[300].setConections(10010101); +myFirstBox[301].setConections(10101001); +myFirstBox[302].setConections(10011001); +myFirstBox[303].setConections(01010101); +myFirstBox[304].setConections(01010101); +myFirstBox[305].setConections(10101001); +myFirstBox[306].setConections(01100101); +myFirstBox[307].setConections(01101000); +myFirstBox[308].setConections(01010101); +myFirstBox[309].setConections(10010110); +myFirstBox[310].setConections(10010110); +myFirstBox[311].setConections(01011010); +myFirstBox[312].setConections(10010110); +myFirstBox[313].setConections(01011001); +myFirstBox[314].setConections(01010110); +myFirstBox[315].setConections(01101001); +myFirstBox[316].setConections(10100101); +myFirstBox[317].setConections(10101010); +myFirstBox[318].setConections(10011001); +myFirstBox[319].setConections(01010110); +myFirstBox[320].setConections(10100000); +myFirstBox[321].setConections(10100101); +myFirstBox[322].setConections(00010101); +myFirstBox[323].setConections(01010110); +myFirstBox[324].setConections(01101010); +myFirstBox[325].setConections(10010110); +myFirstBox[326].setConections(00001001); +myFirstBox[327].setConections(10011010); +myFirstBox[328].setConections(10101010); +myFirstBox[329].setConections(01100101); +myFirstBox[330].setConections(01011010); +myFirstBox[331].setConections(01101010); +myFirstBox[332].setConections(10100101); +myFirstBox[333].setConections(10100101); +myFirstBox[334].setConections(01011000); +myFirstBox[335].setConections(01010110); +myFirstBox[336].setConections(00100110); +myFirstBox[337].setConections(01101010); +myFirstBox[338].setConections(01101010); +myFirstBox[339].setConections(10010110); +myFirstBox[340].setConections(10101010); +myFirstBox[341].setConections(01100110); +myFirstBox[342].setConections(10011000); +myFirstBox[343].setConections(10101010); +myFirstBox[344].setConections(01011001); +myFirstBox[345].setConections(01101001); +myFirstBox[346].setConections(10010101); +myFirstBox[347].setConections(10101010); +myFirstBox[348].setConections(10011001); +myFirstBox[349].setConections(01101001); +myFirstBox[350].setConections(01010110); +myFirstBox[351].setConections(10000110); +myFirstBox[352].setConections(10010110); +myFirstBox[353].setConections(10011010); +myFirstBox[354].setConections(01010110); +myFirstBox[355].setConections(10010010); +myFirstBox[356].setConections(10100110); +myFirstBox[357].setConections(10101001); +myFirstBox[358].setConections(01011001); +myFirstBox[359].setConections(01010000); +myFirstBox[360].setConections(10011001); +myFirstBox[361].setConections(01101001); +myFirstBox[362].setConections(01100001); +myFirstBox[363].setConections(10100110); +myFirstBox[364].setConections(10100101); +myFirstBox[365].setConections(01100101); +myFirstBox[366].setConections(01001010); +myFirstBox[367].setConections(10010110); +myFirstBox[368].setConections(10010101); +myFirstBox[369].setConections(10010100); +myFirstBox[370].setConections(01010101); +myFirstBox[371].setConections(01011000); +myFirstBox[372].setConections(01100010); +myFirstBox[373].setConections(10011001); +myFirstBox[374].setConections(01100110); +myFirstBox[375].setConections(10100101); +myFirstBox[376].setConections(01000110); +myFirstBox[377].setConections(01010101); +myFirstBox[378].setConections(01100110); +myFirstBox[379].setConections(10100110); +myFirstBox[380].setConections(00100110); +myFirstBox[381].setConections(01101001); +myFirstBox[382].setConections(01100101); +myFirstBox[383].setConections(10010101); +myFirstBox[384].setConections(01101001); +myFirstBox[385].setConections(10010110); +myFirstBox[386].setConections(10010101); +myFirstBox[387].setConections(10101001); +myFirstBox[388].setConections(10011001); +myFirstBox[389].setConections(01010110); +myFirstBox[390].setConections(10100010); +myFirstBox[391].setConections(10101001); +myFirstBox[392].setConections(01101010); +myFirstBox[393].setConections(10101010); +myFirstBox[394].setConections(01100110); +myFirstBox[395].setConections(01010101); +myFirstBox[396].setConections(01101001); +myFirstBox[397].setConections(10010101); +myFirstBox[398].setConections(10100110); +myFirstBox[399].setConections(01101010);