import java.util.Map; import java.util.HashMap; import java.util.Vector; import java.util.Random; public class Cube { // here is declared the 8 letters that each cube contains at each vertex private char[] letters = new char[8]; // 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. private Map right = new HashMap(); private Map left = new HashMap(); private Map up = new HashMap(); private Map down = new HashMap(); // this is where I store the rotation sequence for each cube. It is initiallized with random rotations in the constructor below // private Vector rotationSequence = new Vector(); private Vector rotationSequence = new Vector(); // show the cube public void show() { System.out.println(" " + letters[5] + "----" + letters[6]); System.out.println(" /| /|"); System.out.println(letters[1] + "----" + letters[2] + " |"); System.out.println("| " + letters[4] + " | " + letters[7]); System.out.println("|/ |/ "); System.out.println(letters[0] + "----" + letters[3] + " "); } // display the actual string public void asString() { for (int i = 0; i < 8; ++i) { if (letters[i] != '*') { System.out.print(letters[i]); } } } // encrypt uses the rotate function below public void encrypt() { // just looping through the rotation sequence and rotating in the directions set in rotationSequence int l = rotationSequence.size(); for (int i = 0; i < l; ++i) { rotate(rotationSequence.elementAt(i)); } } // this shows the rotation sequence public void showDirections() { // this function loops through the rotation sequence and outputs readable letters U D L R as the assignment requested int l = rotationSequence.size(); for (int i = 0; i < l; ++i) { if (i != 0) System.out.print(":"); switch (rotationSequence.elementAt(i)) { case 0: System.out.print("R"); break; case 1: System.out.print("L"); break; case 2: System.out.print("U"); break; case 3: System.out.print("D"); break; } } } // decrypt calls rotate like encrypt public void decrypt() { // as you can see, this loop goes through the rotation sequence backwards. When rotation is right, it rotates left, etc. for (int i = rotationSequence.size() - 1; i >= 0; --i) { switch (rotationSequence.elementAt(i)) { case 0: rotate(1); break; case 1: rotate(0); break; case 2: rotate(3); break; case 3: rotate(2); break; } } } // rotate the cube in the direction given private void rotate(Integer direction) { // create new 8 char array, copied from letters array. This is what letters will become when we've swapped around the letters char[] newArr = letters.clone(); // 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.get(i)] = letters[i]; } break; case 1: for (int i = 0; i < 8; ++i) { newArr[left.get(i)] = letters[i]; } break; case 2: for (int i = 0; i < 8; ++i) { newArr[up.get(i)] = letters[i]; } break; case 3: for (int i = 0; i < 8; ++i) { newArr[down.get(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.clone(); } // construct each cube with its 8 letters given to it in the CubeHandler class below 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.charAt(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.put(0, 3); right.put(1, 2); right.put(2, 6); right.put(3, 7); right.put(4, 0); right.put(5, 1); right.put(6, 5); right.put(7, 4); left.put(0, 4); left.put(1, 5); left.put(2, 1); left.put(3, 0); left.put(4, 7); left.put(5, 6); left.put(6, 2); left.put(7, 3); up.put(0, 1); up.put(1, 5); up.put(2, 6); up.put(3, 2); up.put(4, 0); up.put(5, 4); up.put(6, 7); up.put(7, 3); down.put(0, 4); down.put(1, 0); down.put(2, 3); down.put(3, 7); down.put(4, 5); down.put(5, 1); down.put(6, 2); down.put(7, 6); // pick a random number of rotations Random r = new Random(); int nRotations = r.nextInt(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 = r.nextInt(4);// 0 - 3 // push them back into the rotationSequence vector in order rotationSequence.add(direction); } } } public class CubeHandler { // keeps track of how many cubes a string has, the total input length, and a vector of Cube pointers private int nCubes; private int inputWordLength; private Vector cubes = new Vector(); // these just loop through each cube and call the cube's own show or encrypt function public void show() { int l = cubes.size(); // show each cube for (int i = 0; i < l; ++i) { cubes.elementAt(i).show(); } // then show the string as an appendage of each cube's string for (int i = 0; i < l; ++i) { cubes.elementAt(i).asString(); } System.out.println("\n"); } public void encryptCubes() { System.out.println("Encrypting..."); // call encrypt for each cube for (int i = 0; i < nCubes; ++i) { cubes.elementAt(i).encrypt(); } } public void showDirectionSequence() { // show each cube's rotation sequence for (int i = 0; i < cubes.size(); ++i) { if (i != 0) System.out.print(","); System.out.print(i); cubes.elementAt(i).showDirections(); } System.out.print("\n"); } public void decrypt() { // decrpyt each cube System.out.println("Decrypting..."); for (int i = 0; i < nCubes; ++i) { cubes.elementAt(i).decrypt(); } } // constructor and destructor. Defined my own destructor to delete the vector of Cube pointers CubeHandler(String 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 inputWordLength = inputWord.length(); nCubes = (int)Math.ceil(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.add(new Cube(inputWord.substring(8 * mult, 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.add(new Cube(inputWord.substring(8 * mult))); break; // break here, since there is no more string to separate into chunks } mult++; // increment } while (true); } }; public class Program { public static void main(String[] args) { CubeHandler ch = new CubeHandler("Input string goes HERE"); ch.show(); ch.encryptCubes(); // encrypt them ch.showDirectionSequence(); // show how they were encrypted ch.show(); // show them after encryptiono ch.decrypt(); // decrypt and show ch.show(); } }

Java Crypto-Cube