#include #include #include #include #include #include #include using namespace std; /* Code By: Zeke Williams Date: June 26, 2018 CONTEST WIN ON June 29, 2018! THANK YOU SO MUCH. Comments for learners ;) Description: This code is for the SoloLearn challenge posted today, June 26, 2018. I'll post the full description when this is complete. Features: Takes an input, shows the cubes, and then encrypts the string. After encryption, it will display the rotated cubes and the string. After, it will decrypt. Removed warnings from new SL compiler */ class Cube { private: // here is declared the 8 letters that each cube contains at each vertex array letters; // these are the rotation codes. I decided to order them in the letters array above 0 - 7. In order to display them in that order, you // need to know where the positions of the verteces of the cube correspond to the positions in the array. Look below in the Cube constructor to learn how. map right; map left; map up; map down; // this is where I store the rotation sequence for each cube. It is initiallized with random rotations in the constructor below vector rotationSequence; public: // show the cube void show(); // display the actual string void asString(); // encrypt uses the rotate function below void encrypt(); // this shows the rotation sequence void showDirections(); // decrypt calls rotate like encrypt void decrypt(); private: // rotate the cube in the direction given void rotate(int direction); public: // construct each cube with its 8 letters given to it in the CubeHandler class below Cube(string wordSection); }; Cube::Cube(string wordSection) { // to save processing, I calculate the length of the word section once // while it is usually 8, some cases call for less than 8 int l = wordSection.length(); // loop 8 times to fill the letters array for (int i = 0; i < 8; ++i) { // if i exceeds or matches the wordSection length, the letter is a filler '*' // this means, if the section has fewer than 8 letters, it will fill in the rest // with this character. if (i >= l) { letters[i] = '*'; } else { // else, the letters array is set to that section's letters letters[i] = wordSection[i]; } } // as I mentioned above, these are the array positions that rotating a "cube" represents. // when a cube is rotated, the positions correspond to these array indeces. If you notice, // the opposites (right - left, up - down) are just the numbers swapping places. // right[4] = 0; left[0] = 4; I found these by using a white-board to draw the cubes :) right[0] = 3; right[1] = 2; right[2] = 6; right[3] = 7; right[4] = 0; right[5] = 1; right[6] = 5; right[7] = 4; left[0] = 4; left[1] = 5; left[2] = 1; left[3] = 0; left[4] = 7; left[5] = 6; left[6] = 2; left[7] = 3; up[0] = 1; up[1] = 5; up[2] = 6; up[3] = 2; up[4] = 0; up[5] = 4; up[6] = 7; up[7] = 3; down[0] = 4; down[1] = 0; down[2] = 3; down[3] = 7; down[4] = 5; down[5] = 1; down[6] = 2; down[7] = 6; // pick a random number of rotations int nRotations = rand() % 5 + 2;// 2 - 6 rotations // loop through this cube's number of rotations, picking a random rotation (0 - right, 1 - left, 2 - up, 3 - down) for (int i = 0; i < nRotations; ++i) { int direction = rand() % 4;// 0 - 3 // push them back into the rotationSequence vector in order rotationSequence.push_back(direction); } }// END of constructor void Cube::show() { // visual representation to help me type it out below /* cout << " 5----6"; cout << " /| /|"; cout << "1----2 |"; cout << "| 4 | 7"; cout << "|/ |/ "; cout << "0----3 "; */ // as was said in the problem description, the string is read from a cube in the order above. // when printing line-by-line, you have to know which order to do it in, It's 5 -> 6 -> 1 -> 2 -> 4 -> 7 -> 0 -> 3 cout << " " << letters[5] << "----" << letters[6] << endl; cout << " /| /|\n"; cout << letters[1] << "----" << letters[2] << " |\n"; cout << "| " << letters[4] << " | " << letters[7] << endl; cout << "|/ |/ \n"; cout << letters[0] << "----" << letters[3] << " \n"; cout << endl; } void Cube::asString() { // this just goes through the letters array and outputs them. there is no endl because when ALL cubes are printed, the outputs will be next to one another, // creating the string in a normal way for (int i = 0; i < (int)(letters.size()); ++i) { if (letters[i] != '*') { cout << letters[i]; } } } void Cube::rotate(int direction) { // create new 8 char array, copied from letters array. This is what letters will become when we've swapped around the letters array newArr(letters); // switch based on the direction number switch (direction) { case 0:// rotate right for (int i = 0; i < 8; ++i) { // this is a tricky way to write it, but it means this: // newArr position at the value of the right map's key of i, is equal to the char in letters at i // for example, when we rotate right, the bottom left (index 0) vertex goes to the bottom right (index 3). If you look above, map 'right[0]' is equal to 3 // so for i equal to zero, this is the same as newArr[3] = letters[0]; we made the letter at 0 move to index 3. newArr[right[i]] = letters[i]; } break; case 1: for (int i = 0; i < 8; ++i) { newArr[left[i]] = letters[i]; } break; case 2: for (int i = 0; i < 8; ++i) { newArr[up[i]] = letters[i]; } break; case 3: for (int i = 0; i < 8; ++i) { newArr[down[i]] = letters[i]; } break; } // once we've changed the newArr to equal a rotated cube of letters, we must set letters equal to the change letters = newArr; } void Cube::encrypt() { // just looping through the rotation sequence and rotating in the directions set in rotationSequence for (int i = 0; i < (int)(rotationSequence.size()); ++i) { rotate(rotationSequence[i]); } } void Cube::showDirections() { // this function loops through the rotation sequence and outputs readable letters U D L R as the assignment requested for (int i = 0; i < (int)(rotationSequence.size()); ++i) { if (i != 0) cout << ":"; switch (rotationSequence[i]) { case 0: cout << "R"; break; case 1: cout << "L"; break; case 2: cout << "U"; break; case 3: cout << "D"; break; } } } void Cube::decrypt() { // as you can see, this loop goes through the rotation sequence backwards. When rotation is right, it rotates left, etc. for (int i = (int)(rotationSequence.size()) - 1; i >= 0; --i) { switch (rotationSequence[i]) { case 0: rotate(1); break; case 1: rotate(0); break; case 2: rotate(3); break; case 3: rotate(2); break; } } } /****************************************** * Cube Handler Class * ***************************************/ class CubeHandler { private: // keeps track of how many cubes a string has, the total input length, and a vector of Cube pointers int nCubes; int inputWordLength; vector cubes; public: // these just loop through each cube and call the cube's own show or encrypt function void show(); void encryptCubes(); void showDirectionSequence(); void decrypt(); public: // constructor and destructor. Defined my own destructor to delete the vector of Cube pointers CubeHandler(string inputWord); ~CubeHandler(); }; CubeHandler::CubeHandler(string inputWord) : inputWordLength(inputWord.length()) // initialize inputWordLength to the length of inputWord { // this is some math wizardry. If inputWordLength divided by 8 has a remainder, the number of cubes is equal to input length divided by 8 plus 1. // for example, say the string was "SoloLearn". length = 9, so 9 % 8 = 1. The number of cubes is 9 / 8 = 1, plus 1, = 2 // if the string is evenly divisible by 8, the number of cubes is simply the input divided by 8. length = 16, nCubes = 2 nCubes = inputWordLength % 8 ? inputWordLength / 8 + 1 : inputWordLength / 8; // mult keeps track of the offset in the inputString, starting at position 0 and increments each loop int mult = 0; do { // this checks to see if the input length is greater than 8 times the offset plus 1. If this was the first time through the loop, and we inputted 'SoloLearn', // we would get true, because 9 is greater than 8 * 1 = 8. Basically, it's a check to see if we can fill a cube if (inputWordLength >= 8 * (mult + 1)) { // now we push back a new Cube, which returns a pointer. The argument passed uses a function of the string library, substr(), which takes the start position // of the stubstring you want to extract, and the length of the substring you want to extract. For "SoloLearn" on the first loop (mult = 0), // the substring starts at 8 * 0 = 0, and goes 8 characters from there, S1 o2 l3 o4 L5 e6 a7 r8 => "SoloLear". The first cube is initiallized with "Sololear" // for the second loop (mult = 1) see the else portion cubes.push_back(new Cube(inputWord.substr(8 * mult, 8))); // if the string length is a multiple of 8, we can break the loop here if (inputWordLength == 8 * (mult + 1)) break; } else { // diff will be used as the second argument in substr(). It is the remaining letters that don't fill a cube completely int diff; // check to see if the string was less than 8 in length. If so, diff is equal to the length if (inputWordLength < 8) diff = inputWordLength; else // else diff is the string length minus eight "SoloLearn" = 9. diff = 9 -8 = 1. One remaining character to put into a new Cube diff = inputWordLength - 8; // for the second loop of "SoloLearn" (mult = 1), substr(8 * 1, 1). starting at location 8 (not including 8) take 1 character // "SoloLearn" ... a7 r8 n9 => substr(8, 1) = new Cube("n"); cubes.push_back(new Cube(inputWord.substr(8 * mult, diff))); break; // break here, since there is no more string to separate into chunks } mult++; // increment } while (true); } CubeHandler::~CubeHandler() { // delete allocated Cubes in cubes vector for (int i = 0; i < (int)(cubes.size()); ++i) { delete cubes[i]; } } void CubeHandler::show() { int l = cubes.size(); // show each cube for (int i = 0; i < l; ++i) { cubes[i]->show(); } // then show the string as an appendage of each cube's string for (int i = 0; i < l; ++i) { cubes[i]->asString(); } cout << endl << endl; } void CubeHandler::encryptCubes() { cout << "Encrypting..." << endl; // call encrypt for each cube for (int i = 0; i < nCubes; ++i) { cubes[i]->encrypt(); } } void CubeHandler::showDirectionSequence() { // show each cube's rotation sequence for (int i = 0; i < (int)(cubes.size()); ++i) { if (i != 0) cout << ","; cout << i; cubes[i]->showDirections(); } cout << endl; } void CubeHandler::decrypt() { // decrpyt each cube cout << "Decrypting..." << endl; for (int i = 0; i < nCubes; ++i) { cubes[i]->decrypt(); } } int main() { srand(static_cast(time(nullptr))); cout << "Thank you so much SoloLearn for the\nwin! It was such a fun and challenging assigment.\nHappy coding to all, and congrats to the other codes" << endl << endl; // get the word from user string word = ""; getline(cin, word); if (word.length() == 0) // or if no input, make one word = "Enter your own String to Encrypt!"; // create a cube handler initiallized with the inputted word CubeHandler ch(word); ch.show(); // show before encryption ch.encryptCubes(); // encrypt them ch.showDirectionSequence(); // show how they were encrypted ch.show(); // show them after encryptiono ch.decrypt(); // decrypt and show ch.show(); return 0; }

CryptoCube (Visualized Now!)