Possibilities of optimising the Rubik s Cube solver

Transcription

1 Possibilities of optimising the Rubik s Cube solver Matura paper Kantonsschule Sargans Kevin Jörg, 4bNPW Supervisor Thomas Büsser Submitted at: 6th January 2014

2 Index II Index 1 Introduction Motivation and topic choice Questions and target of the matura paper Structure of the matura paper Rubik s Cube About God s number Solving Methods Two-Phase-Algorithm About The robot Analysis Hardware Software Building the own robot The solving algorithm The program The robot Conclusion Bibliography... V 7 List of figures... VI Appendices Source code of the program Declaration of authenticity... 14

3 Introduction 1 1 Introduction 1.1 Motivation and topic choice In the beginning of 2013 I got a Rubik s Cube into my hands. I tried to solve it, but it didn t take a long time until I gave up. Because I really like physics I was always thinking about doing my matura paper in the field of it. But then because I was unable to solve the Rubik s Cube I had the idea to build a robot that could do it. I was always interested in robots so it would be a quiet interesting matura paper. I decided to ask Mr Büsser who teaches informatics to be my supervisor. He also found the idea interesting and gave me the ok. After I knew my topic for this matura paper I started researching. It didn t take a long time until I found Hans Andersson s homepage and the model Tilted Twister 2.0. I started straight away rebuilding this robot according to the manual I found on this page. When I ended building it I gave it a twisted Rubik s Cube and started the robot. It started reading in the first face, turned the cube around and read in the second face. But when it tried to turn it the second time it failed. I started again, but again it failed to turn the cube properly. Furthermore in version 1 of the Tilted Twister robot only a light sensor is used and in version 2.0 a colour sensor. According to Hans Andersson it s possible to read in the colours with a light sensor by changing some of the stickers. Is it possible to read in the colours with the light sensor without changing the stickers of the cube? Because my Rubik s Cube was still unsolved I decided to optimise the Rubik s Cube solver. 1.2 Questions and target of the matura paper In the beginning of the matura paper I had the following questions: Is it possible to program a Lego Mindstorms robot in Java and have a fluent interaction with a Java program running on a computer? Is it possible to identify colours correctly with only a brightness sensor? Is it possible to optimise the construction of the Rubik s cube solver? The target of this matura paper was: A Lego Mindstorms robot that is able to solve a standard Rubik s cube should be generated. The algorithm to solve the cube should be written by myself in Java. The robot should read in the cube automated, calculate the solution and solve it. Parts of the robot should be optimised.

4 Introduction Structure of the matura paper Rubik's Cube Two-Phase- Algorithm Analysis Software Hardware Building the own robot The algorithm The program The hardware

5 Rubik s Cube 3 2 Rubik s Cube 2.1 About The Rubik s Cube was invented in 1974 by Professor Ernö Rubik. It s a three dimensional puzzle made out of plastic and sometimes also just called cube. Like its name says it s a cube consisting of six faces. Each face consists of nine so called facelets and can be twisted independently, which mixes up the colours. The cube is considered as solved when each face has a solid colour. The cube appears to consist of 27 smaller cubes called cubies. One cubie is invisible because it s in the middle. The other cubies have one, two or three visible sides, the facelets. There are 54 visible facelets. With twisting one side, the facelets get rearranged. All six sides can be turned 90, 180 or minus 90 degrees. The notifications for the twist of the sides are: U, L, F, R, B and D and stand for up, left, front, right, back and down. Just the capital letter stands for a 90 degrees clockwise twist. For 180 and minus 90 degree twists there are modifiers. A 2 after the capital letter stands for a 180 degree twist. For example U2 means twist the upper side by 180 degrees. The modifier for minus 90 degree is a (apostrophe). For example R means twist the right side 90 degree counter clockwise. (Ullah, 2012, S. 45/46) 2.2 God s number It doesn t matter how a Rubik s Cube is twisted, in any case it can be solved with maximum 20 manoeuvres. This was only proven in July 2010, 36 years after the cube was introduced. Because it took so long to proof what the maximum number of manoeuvres really is, it s called God s number. It was proven by calculating the solution to all positions of the cube with about 35 CPU years. (Kociemba, 2013) 2.3 Solving Methods There are a lot of different methods to solve a Rubik s Cube, versions for human and for computers. Let s start with the ones for human. Basically the faster Figure 1: Solved Rubik's Cube Figure 2: Average number of faceturns to solve the Rubik's Cube they are the more algorithms have to be learned by heart. Most of the professionals use the so called Fridrich method. There are about 78 algorithms which have to be learned

6 Rubik s Cube 4 by heart. (König, 2013) The methods used by computers are completely different. One aspect is the length of the solution. The Two-Phase-Algorithm finds usually a solution that is only one to two moves longer than the optimal solution (Kociemba, 2013). Other algorithms like Corners First Method give a solution that is two to three times as long (Andersson, 2011). The other aspect is the required computation power. While it s possible to run a simple algorithm such as the Corners First Method on a Lego Mindstorms, it s impossible to run the Two-Phase algorithm on it. (Andersson, 2011)

7 Two-Phase-Algorithm 5 3 Two-Phase-Algorithm 3.1 About It was introduced by Herbert Kociemba in 1992 and is the algorithm that gives the shortest solution so far. It solves the cube in two steps. If you only apply the moves U, D, R2, L2, F2 and B2 the orientation of the corners and edges cannot be changed. Step one of the algorithm is to search for manoeuvres so that they can be solved by only applying U, D, R2, L2 and F2 in step two. It s done by iterating through all possible manoeuvres with increasing length. In phase two the same is done by only iterating through the moves U, D, R2, L2, F2 and B2. (Kociemba, 2013)

8 The robot 6 4 The robot 4.1 Analysis Before I started optimising my robot, I analysed what could be optimised. I split it up into soft- and hardware Hardware What does a robot need to solve a Rubik s Cube? First it should be able to recognise how the cube is twisted. Therefore it has to know the colour of every single facelet. To find the colour of a facelet a sensor is needed. One option is a colour sensor, there are two different ones available. One from Lego itself and one from a company called Hitechnic. Another option is a light sensor, which gives you the level of brightness. After knowing how the cube is twisted, it s possible to calculate a solution. When the solution is known, the sides have to be turned accordingly. And that s the difficult part. A Lego Mindstorms robot has only three motors and there are six sides that have to be turned. This leads to only Figure 3: Hitechnic Colour Sensor limited possibilities to build the robot. The colour sensor has also to be moved over the different facelets of one face, therefore one motor is already used for this. So the cube has to be moved and twisted by only two motors Software An important part of the software is the solving algorithm. There are a few possibilities that you can choose. Either you take one that gives a pretty long solution like an implementation of Corners First Method, but is able to calculate the solution on the Mindstorms itself or you take an algorithm like the Two-Phase-Algorithm which requires a better processor and more memory and therefore has to run on a normal computer. Another part of the software is controlling the robot. There are different programming languages the software can be written in. The graphical ones are not really suitable for bigger programs because they get not even remotely comprehensible. There is one called NXC, which stands for not exactly c, and there is Java.

9 The robot Building the own robot The solving algorithm I first wanted to write my own solving algorithm. After I did a lot of research on this topic I found out that the Two-Phase-Algorithm is the one that gives by far the best result. I tried to understand the mathematics behind it, but I soon had to give up, because it was just too difficult. Then I found that Herbert Kociemba provided a Java package with just a simple implementation of the Two-Phase- Algorithm on his homepage for download. I decided to use it. The way the cube is twisted has to be entered in a defined way. The faces have to be read in in the order U, R, F, D, L and B and the facelets according to figure 4. Also not the colour of a facelet is important, but the side it belongs to. Usually the algorithm keeps searching a solution that is shorter than a clearly defined number which is usually 21. If the cube is now twisted only a little and solvable with only for example 12 moves, the algorithm will still stop searching if he has a solution that is 21 moves long. So I put the method to search the solution into a loop to let the algorithm keep searching a shorter solution until there is no shorter solution possible or until a maximum time for which he is already searching is reached The program After I had built the Tilted Twister 2.0 and it didn t really work, I knew I had to change the arm that turns the cube and therefore would have to write my own program. When I had the Java package from Herbert Kociemba it was clear that I would have to write my program in Java. I took the option to just let the program run on the computer and control the robot via USB or Bluetooth. It works well and so one of the questions is answered. In the end the writing of the program was the biggest part of my matura paper. I decided to split up my program into three different parts. First the reading in of the cube, then calculation the solution and finally solve it. Figure 4: The facelets have to be read in according to this scheme I began to write very simple methods to move the cube. There are methods to rotate the cube on the turntable 90, 180 and minus 90 degrees and there is a method to turn the cube with the arm. With those procedures it s already possible to move the cube in every possible position. The next step was to read in the cube. I started with reading in one facelet. First I tried using only the standard light sensor. To distinguish between blue, red and green worked quiet well, but the difference between white, yellow and orange was just not big enough. Also if there is just one facelet read in wrong, the mistake is fatal, it s impossible to calculate a solution and the robot has to start from

10 The robot 8 the beginning again. If the chance to read in a simple facelet wrong is only 1 per cent, with 54 facelets the chance to have an error rises to 54 per cent. So I took the decision to use a colour sensor. My choice fell on the colour sensor from Hitechnic and not the one from lego because it has much more possibilities. The only negative aspect is that it needs more time until a colour is detected, so the cube always has to be stopped and it s not possible to just keep it rotating. The sensor is able to give out a number between one and 16, which represent different colours. This works well with the colours of the Rubik s Cube. The only problem was with red and orange, there was the same number for both of them. But also this could be fixed easily. The sensor has the possibility to give out the red, green and blue values separately. There is a significant difference in the green value between the red and orange facelet. So if the sensor gives out the colour number of red and orange, it checks the green value to decide what it is. The next method is to read in one face of the cube. The motor of the sensor and the motor of the turntable line up the cube with the faclets. Important to mind is in which order the facelets are read. After the face is read in, the sides of the facelets are added to a string. A string is a kind of variable which is able to store any characters and not just numbers. The next step is to read in the whole cube. The Two-Phase-Algorithm needs the sides of the facelets in a clearly defined order. First the top face is read in, then the right, front, bottom, left and finally the back. After the cube is turned, the next face might be read in from the wrong side and not according to the scheme. The way I turn the cube, one face is read in from the right side and two from a wrong side. So there are three different cases. I programed the robot to read in all the faces the same way but then the sides of the facelets are added to the string in a different order for the three different cases through three different methods. After all the sides of the facelets are known they are handed over to the solving method from Herbert Kociembas Two-Phase-Algorithm. The Two-Phase-Algorithm returns the solution in a string. I split up the solving of the cube into the moves that are applied on the cube. To solve the cube it s important to know how the cube is standing. Therefore I made a variable for every side and gave them a number from 1 to 6. When the cube is rotated or turned, the variables get the value of the variable where this side was before. When a move gets applied, first the move itself is checked on modifiers. Then it s checked where the face, which has to get twisted, is located right now. If the right side has to get twisted and is located in the front, the robot just acts like it would twist the front. With this the cube doesn t has to be moved unnecessarily always back to a standard position after a face was twisted. This procedure is repeated until the cube is solved.

11 The robot The robot I found out in the analysis that there are only limited possibilities to build a Rubik s Cube solver due to the limitations of Lego Mindstorms. After I had built the Tilted Twister 2.0 and it didn t manage to turn the cube, I tried different angles how the robot was standing. Also I noticed differences with different battery voltage. I never got it to work well, so I decided to change the arm. I had already seen pictures of a robot called Mindcuber and found a manual how to build it. Its basic concept was the same like the concept of the Tilted Twister 2.0. There is a turntable, the colour sensor and the arm. But this arm is different than the arm of the Tilted Twister 2.0. I build just the arm according to the manual and mounted it on my robot. It was difficult to find the correct position, but after I found it, it worked well. I added a hook in front of the arm to always catch the cube when trying to turn it, reduced the play when twisting the cube with two half Lego unit wide parts and added two posts outside the arm to have a better side guidance. This minimises mistakes. Also now the robot doesn t need to be tilted anymore, therefore I could remove the legs and replace the brick. Now the robot consist of parts of the Tilted Twister 2.0 and the Mindcuber, but there are also parts I added to optimise the robot. Figure 5: A part to reduce play by half a Lego unit

12 Conclusion 10 5 Conclusion I managed to optimise the Rubik s Cube solver. From the hardware side my robot is a mixture between the Tilted Twister 2.0 and the Mindcuber. The important part, the arm, is like the one from the Mindcuber just with some additional parts to decrease play and minimise mistakes. From the software side my robot is different. My program runs fully on a computer and just controls the robot. I use the Two-Phase-Algorithm. The Tilted Twister 2.0 has the possibility to hand over the calculation to a computer and also use the Two-Phase-Algorithm, the Mindcuber doesn t have this option and calculates a longer solution on the brick. So my robot has parts in common with the Tilted Twister 2.0 and the Mindcuber, but there are also new parts. The result is a robot that is able to solve the Rubik s Cube with an only minimal rate of errors.

13 Bibliography V 6 Bibliography Andersson, H. (2011, Oktober 12). Tilted Twister. Retrieved from Kociemba, H. (2013, April 28). Kociemba. Retrieved from König, F. (2013, August 24). Speedcube.de. Retrieved from Ullah, S. A. (2012). Consequence of Schreier-Sims Algorithm in Solving Rubik's Cube. Saarbrücken: LAP LAMBERT Academic Publishing GmbH & Co. KG.

14 List of figures VI 7 List of figures Figure 1: Solved Rubik's Cube... 3 Figure 2: Average number of faceturns to solve the Rubik's Cube... 3 Figure 3: Hitechnic Colour Sensor... 6 Figure 4: The facelets have to be read in according to this scheme... 7 Figure 5: A part to reduce play by half a Lego unit All the figures have been created by myself.

15 Appendices 1 Appendices 1 Source code of the program ///// Rubik's Cube Solver \\\\\ // Matura paper Kantonschule Sargans // Author: Kevin Jörg // Supervisor: Thomas Büsser package com.mydomain; // Required from Lejos import org.kociemba.twophase.*; Herbert Kociemba, kociemba.org import lejos.nxt.motor; import lejos.nxt.sensorport; import lejos.util.*; import lejos.nxt.addon.colorhtsensor; public class RCS //// Defining Variables \\\\ int maxdepth = 22; // Sets the maximum amount of manoeuvre to start with. long timetosearch = 15; // Sets the maximum time to find a solution in seconds. // Variables for sides. They are used to know in which position the Cube is. int U = 1; int R = 2; int F = 3; int D = 4; int L = 5; int B = 6; int X = 0; // X is used to store the value of a side when it's reassigned. // Variables for facelets. They are used to save the colors of the facelets. String f1 = ""; String f2 = ""; String f3 = ""; String f4 = ""; String f5 = ""; String f6 = ""; String f7 = ""; String f8 = ""; String f9 = ""; /* * The first digit equals the color on top, the second digit equals the color in right. Used to assign the side which has to be turned to the proper cube position. * 1 = white U * 2 = red R * 3 = green F * 4 = yellow D * 5 = orange L * 6 = blue B

16 Source code of the program 2 */ String side = ""; // other Variables String side1 = ""; String cubestring = ""; String result = ""; String fresult = ""; String move = ""; String movemodifier = ""; boolean useseparator = false; long timesearching = 0; long timestart = 0; long timeend = 0; int maxtime = 15; int substringstart = 0; int substringend = 1; int substringstart2 = substringstart +1; int substringend2 = substringend +1; int lightvalue = 0; int red = 0; int blue = 0; int green = 0; //// Constructor \\\\ RCS() ReadInCube();// First the cube is read in. Calculate();// The solution is calculated with Herbert Kociembas two phase algorithm. SolveCube();// The cube is getting solved. //// Basic movements of the robot \\\\ void Rotate5() // Rotates the turntable by 5 degrees. Used to twist the Cube. Motor.A.setPower(30); Motor.A.rotate(-5); void Rotateb5() // Rotates the turntable by minus 5 degrees. Used to twist the Cube. The b in the name stands for back. Motor.A.setPower(30); Motor.A.rotate(5); void Rotate90() // Rotates the turntable by 90 degrees. X = F; // Reassigning the variables of the position of the cube. X is used to store the value of F. F = R; R = B; B = L; L = X; Motor.A.setPower(40); Motor.A.rotate(-90);

17 Source code of the program 3 void Rotateb90() // Rotates the turntable by minus 90 degrees. The b in the name stands for back. X = F; // Reassigning the variables of the position of the cube. X is used to store the value of F. F = L; L = B; B = R; R = X; Motor.A.setPower(40); Motor.A.rotate(90); void Rotate180() // Rotates the turntable by 180 degrees by applying twice Rotate90(). Rotate90(); Rotate90(); void Rotateb180() // Rotates the turntable by minus 180 degrees by applying twice Rotateb90(). Rotateb90(); Rotateb90(); void Rotate270() Rotate90(); Rotate90(); Rotate90(); void Rotateb270() Rotateb90(); Rotateb90(); Rotateb90(); void Turn() // Turns the cube with the arm. X = F; // Reassigning the variables. X is used to store the value of F. F = D; D = B; B = U; U = X; Motor.C.setPower(30); Motor.C.rotate(-245); // Rotates the arm from standard position to the opposite. The cube is half turned through this. Delay.msDelay(200); // Wait 200 ms to make sure the cube is settled. Motor.C.rotate(165); // Rotates the arm about 2/3 back. The cube is pushed back in the turntable and completely turned. Delay.msDelay(100); // Wait 100 ms to make sure the cube is settled. Motor.C.rotate(-68); // Pushes the cube on the front side of the cube down into the turntable. Delay.msDelay(200);

18 Source code of the program 4 Motor.C.rotate(148); // Rotates the arm back to standard position. Delay.msDelay(100); void Twist90() // Turns the turntable minus 95 degrees and then 5 degrees back. Does not change cube position variables. 95 degrees because of play in the arm. Motor.A.setPower(30); Motor.A.rotate(95); Rotate5(); void Twistb90() // Turns the turntable 95 degrees and then 5 degrees back. Does not change cube position variables. 95 degrees because of play in the arm. Motor.A.setPower(30); Motor.A.rotate(-95); Rotateb5(); void Hold() // Rotates the arm from standard position to the position to hold the cube in top and middle layer. Motor.C.setPower(30); Motor.C.rotateTo(-135); Motor.C.stop(); void Release() // Rotates the arm from standard position to the position to hold the cube in top and middle layer. Motor.C.setPower(30); Motor.C.rotateTo(0); //// Method to assign a color to a side public String LighttoSide() // Returns the side which the facelet belongs to in a string. Delay.msDelay(600); // Wait 500 ms to make sure that the sensor is not moving. ColorHTSensor color = new ColorHTSensor(SensorPort.S1); lightvalue = color.getcolorid(); // The method getcolortid() returns a number between 0 and 16 for different colors. green = color.getrgbcomponent(color.green); // The green value is used to distinguish between orange and red, because it's not possible to differentiate red and orange with getcolorid(). String side = ""; // Assign the color sensor values to the according side. if (lightvalue == 6) //Up, white side = "U"; if (lightvalue == 1) //Front, green side = "F";

19 Source code of the program 5 if (lightvalue == 4) //Back, blue "magenta" side = "B"; if (lightvalue == 3) //Down, yellow side = "D"; if (lightvalue == 0) if(green <= 45) side = "R"; // Because getcolorid() returns the same number for red and orange, the green value is checked to distinguish between them. else side = "L"; return side; // Returns the side. //// Method to read in one face \\\\ void ReadInFace() String testface = ""; // Variable to check if every facelet was detected. while (testface.length()!= 9) // Loop to check if every facelet was detected. testface = ""; /* The facelet variables have the following order on a face: f1*f2*f3 f4*f5*f6 f7*f8*f9 */ Motor.B.setPower(40); Motor.A.setPower(40); Motor.B.rotateTo(68); // Rotate to the middle facelet and get it's according side. f5 = LighttoSide(); Motor.A.rotateTo(-23); // Rotate the cube and the light sensor to the top right faclet and get it's according side. Motor.B.rotateTo(42); f3 = LighttoSide(); Motor.A.rotateTo(-113); // Rotate the cube degrees to get side of top left facelet. f1 = LighttoSide(); Motor.A.rotateTo(-200); // Rotate the cube degrees to get side of bottom left facelet. f7 = LighttoSide(); Motor.A.rotateTo(-62); // Rotate the cube and the light sensor to the bottom right faclet and get it's according side. Motor.B.rotateTo(98); f9 = LighttoSide(); Motor.A.rotateTo(-19); // Rotate the cube and the light sensor to the bottom middle faclet and get it's according side. Motor.B.rotateTo(88); f8 = LighttoSide(); Motor.A.rotateTo(-105); // Rotate the cube degrees to get side of middle right facelet. f6 = LighttoSide();

20 Source code of the program 6 Motor.A.rotateTo(-195); // Rotate the cube degrees to get side of top middle facelet. f2 = LighttoSide(); Motor.A.rotateTo(-157); // Rotate the cube and the light sensor to middle left faclet and get it's according side. Motor.B.rotateTo(51); f4 = LighttoSide(); Motor.A.rotateTo(0); // Rotate cube and light sensor back to standard position. Motor.B.rotateTo(0); testface += f5; testface += f3; testface += f1; testface += f7; testface += f9; testface += f8; testface += f6; testface += f2; testface += f4; System.out.println(testface); //// The following three methods add the facelet variables properly to cubestring. \\\\ void CubeStringC1() // Case 1. Used for side U. cubestring += f1; cubestring += f2; cubestring += f3; cubestring += f4; cubestring += "U"; // For the facelet with the Rubik's Cube Logo. cubestring += f6; cubestring += f7; cubestring += f8; cubestring += f9; void CubeStringC2() // Case 2. Used for side R, F and D. cubestring += f7; cubestring += f4; cubestring += f1; cubestring += f8; cubestring += f5; cubestring += f2; cubestring += f9; cubestring += f6; cubestring += f3; void CubeStringC3() // Case 3. Used for side L and B. cubestring += f9; cubestring += f8; cubestring += f7; cubestring += f6; cubestring += f5; cubestring += f4; cubestring += f3;

21 Source code of the program 7 cubestring += f2; cubestring += f1; //// Method to read in the whole cube. \\\\ void ReadInCube() ReadInFace();// Read in side U. CubeStringC1();// Add the read in facelets to cubestring. Rotate90();// Move the cube to get side R on top. Rotateb90(); ReadInFace();// Read in side R. CubeStringC2();// Add the read in facelets to cubestring. // Move the cube to get side F on top. ReadInFace();// Read in side F. CubeStringC2();// Add the read in facelets to cubestring. Rotate90();// Move the cube to get side D on top. Rotateb90(); ReadInFace();// Read in side D. CubeStringC2();// Add the read in facelets to cubestring. // Move the cube to get side L on top. ReadInFace();// Read in side L. CubeStringC3();// Add the read in facelets to cubestring. Rotate90();// Move the cube to get side B on top. Rotateb90(); ReadInFace();// Read in side B. CubeStringC3();// Add the read in facelets to cubestring. //// Calculate the Solution with Kociembas Two Phase Algorithm. \\\\ void Calculate() timestart = System.currentTimeMillis(); // Get the time when calculation is started. while (timesearching < timetosearch*1000) // The program will keep searching for a shorter solution after a solution is found for 30 seconds. fresult = result; //fresult is the final solution result = Search.solution(cubeString, maxdepth, maxtime, useseparator); // Get the solution by handing over the calculation to Herbert Kociebas Two Phase Algorithm. timeend = System.currentTimeMillis(); // Get the current time. timesearching = timeend - timestart; // Calculate for how long the solution is already beeing searched. if (result == "Error 7") // Stops the loop if the program runs into a Error 7. Error 7 means there is no better solution than already found. timesearching = timetosearch*1000; // Jump out of the while loop. if (result == "Error 8") // Stops the loop if the program runs into Error 8. Error 8 means timeout, no better solution found within the maximum time to search.

22 Source code of the program 8 while loop. timesearching =timetosearch*1000; // Jump out of the maxdepth = maxdepth -1; // Decrease search depth by one. //// Read out the next move from fresult. \\\\ String Getmove() move = fresult.substring(substringstart, substringend); // Read out one character from fresult. // Check if it's just a 90 degree clockwise turn or if there is a modifier that belongs to the move. if (fresult.substring(substringstart2, substringend2).equals("2")) // Checks if the next character is a two and therefore belongs to the same move. move += "2"; // The two is added to move. substringstart++; // All variables are increased by one. substringend++; substringstart2++; substringend2++; else if (fresult.substring(substringstart2, substringend2).equals("'")) // Checks if the next character is a dash and therefore belongs to the same move. move += "'"; // The dash is added to move. substringstart++; // All variables are increased by one. substringend++; substringstart2++; substringend2++; substringstart++; // All variables are increased by one. substringend++; substringstart2++; substringend2++; return move; // Returns move. //// Apply one move on the cube. \\\\ String Solve() int side2 = 0; // Local variable side2. Used to get assign a number to the side which has to be turned. int i = 0; // Local variable to check if there was not jet a move applied. Necessary because after a move is applied the side could equal the value of a new face variable. String m = Getmove(); // String m is a string for the move. Get the move with Getmove().

23 Source code of the program 9 if (m.length() == 1) // If the length of the move is one, the according side has to get twisted 90 degrees. // Assign the string of the sides to a number to be able to check it easily. if (m.equals("u")) side2 = 1; if (m.equals("f")) side2 = 3; if (m.equals("r")) side2 = 2; if (m.equals("b")) side2 = 6; if (m.equals("l")) side2 = 5; if (m.equals("d")) side2 = 4; if (side2 == F && i == 0) // Checks if the side which has to be turned is now positioned in the front. Rotate180(); // Turn the cube to have the side in the bottom. Twist90(); // Twist the side by 90 degrees. if (side2 == U && i == 0) // Checks if the side which has to be turned is now positioned on top. // Turn the cube to have the side in the bottom. Twist90(); // Twist the side by 90 degrees. if (side2 == D && i == 0) // Checks if the side which has to be turned is now positioned on the bottom. Twist90(); // Twist the side by 90 degrees. if (side2 == R && i == 0) // Checks if the side which has to be turned is now positioned in the right. Rotateb90(); // Turn the cube to have the side in the bottom. Twist90(); // Twist the side by 90 degrees. if (side2 == B && i == 0) // Checks if the side which has to be turned is now positioned in the back. // Turn the cube to have the side in the bottom.

24 Source code of the program 10 Twist90(); // Twist the side by 90 degrees. if (side2 == L && i == 0) // Checks if the side which has to be turned is now positioned in the left. Rotate90(); // Turn the cube to have the side in the bottom. Twist90(); // Twist the side by 90 degrees. else // If the length of m was not one. // Check if the modifier is two. If the modifier is two, the according side has to get twisted 180 degrees. if (m.substring(1, 2).equals("2")) // Assign the string of the sides to a number to be able to check it easily. if (m.equals("u2")) side2 = 1; if (m.equals("f2")) side2 = 3; if (m.equals("r2")) side2 = 2; if (m.equals("b2")) side2 = 6; if (m.equals("l2")) side2 = 5; if (m.equals("d2")) side2 = 4; if (side2 == F && i == 0) // Checks if the side which has to be turned is now positioned in the front. Rotate180(); // Turn the cube to have the side in the bottom. Twist90(); // Twist the side by 180 degrees. Twist90(); if (side2 == U && i == 0) // Checks if the side which has to be turned is now positioned on top. // Turn the cube to have the side in the bottom. Twist90(); // Twist the side by 180 degrees. Twist90(); if (side2 == D && i == 0) // Checks if the side which has to be turned is now positioned on bottom.

25 Source code of the program 11 Twist90(); // Twist the side by 180 degrees. Twist90(); if (side2 == R && i == 0) // Checks if the side which has to be turned is now positioned on the right. Rotateb90(); // Turn the cube to have the side in the bottom. Twist90(); // Twist the side by 180 degrees. Twist90(); if (side2 == B && i == 0) // Checks if the side which has to be turned is now positioned in the back. // Turn the cube to have the side in the bottom. Twist90(); // Twist the side by 180 degrees. Twist90(); if (side2 == L && i == 0) // Checks if the side which has to be turned is now positioned on the left. Rotate90(); // Turn the cube to have the side in the bottom. Twist90(); // Twist the side by 180 degrees. Twist90(); // Check if the modifier is a dash. If the modifier is a dash, the according side has to get twisted minus 90 degrees. if (m.substring(1, 2).equals("'")) // Assign the string of the sides to a number to be able to check it easily. if (m.equals("u'")) side2 = 1; if (m.equals("f'")) side2 = 3; if (m.equals("r'")) side2 = 2; if (m.equals("b'")) side2 = 6; if (m.equals("l'")) side2 = 5; if (m.equals("d'")) side2 = 4; if (side2 == F && i == 0) // Checks if the side which has to be turned is now positioned in front. Rotate180(); // Turn the cube to have the side in the bottom.

26 Source code of the program 12 Twistb90(); // Twist the side by minus 90 degrees. if (side2 == U && i == 0) // Checks if the side which has to be turned is now positioned on top. // Turn the cube to have the side in the bottom. Twistb90(); // Twist the side by minus 90 degrees. if (side2 == D && i == 0) // Checks if the side which has to be turned is now positioned on the bottom. Twistb90(); // Twist the side by minus 90 degrees. if (side2 == R && i == 0) // Checks if the side which has to be turned is now positioned on the right. Rotateb90(); // Turn the cube to have the side in the bottom. Twistb90(); // Twist the side by minus 90 degrees. if (side2 == B && i == 0) // Checks if the side which has to be turned is now positioned in the back. // Turn the cube to have the side in the bottom. Twistb90(); // Twist the side by minus 90 degrees. if (side2 == L && i == 0) // Checks if the side which has to be turned is now positioned on the left. Rotate90(); // Turn the cube to have the side in the bottom. Twistb90(); // Twist the side by minus 90 degrees.

27 Source code of the program 13 return m; // Return m to be able to count how far the robot is in fresult. Used in SolveCube(). //// Method to finally solve the cube \\\\ void SolveCube() int s1 = 0; // Local variable to control while loop. int s2 = 1; fresult += " "; // Add a space to solution string in the end. while (fresult.substring(s1, s2)!= " ") // The method solve is applied until the space which was added is reached. if (Solve().length() == 2)// Checks the length of the variable m. If it's two the local variables have to be increased by another one. s1++; s2++; s1++; s2++; //// Main method \\\\ public static void main(string[] args) new RCS();

28 Declaration of authenticity 14 2 Declaration of authenticity I hereby declare that the work submitted is my own and that all passages and ideas that are not mine have been fully and properly acknowledged. Weesen,