Can we write a computer program to solve a Rubik's cube?
Profile photo for Unnikrishnan Menon
Unnikrishnan Menon
Top Writer 2018 · Updated 6y ·

Well yeah. We actually can do this.

Note- This is a big answer. You have been warned.

I have made a basic C++ computer program that actually implements the Layer-Wise method to solve a [math]3\times3\times3[/math] Rubik’s Cube in under 800 lines of code.

I gotta admit this was a pretty fun thing to try out in code.

Now before coming to the Code, let me tell you something important…

I was initially planning to make a proper Rubik’s Cube Solver Machine that would actually solve a tangible Rubik’s cube. And the way I had planned to rotate the various faces of the cube was by using [math]6[/math] Stepper Motors (one for each side). Now as it turns out, stepper motors are too damn expensive :P

So, to make the machine, I was thinking of using an ordinary Arduino UNO Microcontroller. Now that means my code would have to be in Arduino’s code language for this to work. I don’t know arduino coding very well yet so I have made a very rudimentary code using the most basic commands in C++. I have done it this way so that in future, if I am ever able to afford [math]6[/math] stepper motors, I will be able to easily convert this C++ code to arduino code.

First of all, if you have ever broken a [math]3\times3\times3[/math] rubik’s cube (even out of frustration), you would definitely notice this central piece…

What I want you to realize is the fact that however badly you scramble a Rubik’s Cube, the center pieces don’t move at all relative to each other.

So that means if a side has a white center piece, all the other pieces on that side should become white by the time you completely solve the rubik’s cube. Similarly if the central piece of another side is say red, then all the other 8 pieces on that side should become red after the cube is solved. It’s a rudimentary idea.

Now the big problem is how to manipulate all the six sides of the rubik’s cube. To do that, I spent quite a bit of time. I first tried using 2-D Arrays in C++ but it was a bit challenging to manipulate how the various sides would change as I rotate the various sides of the cube.

So, I came up with a really simple idea…

Yup! I simply open up the cube on paper.

I created six linear arrays in my code having size [math]9[/math] .

In C++, whenever you create an array of size [math]n[/math], the indexing goes from [math]0[/math] to [math]n-1[/math]

So for each of our six arrays having size [math]9[/math], the indexing would be from [math]0[/math] to [math]8[/math]. And that’s why on each side in the above image you’ll see numbers arranged from [math]0[/math] to [math]8[/math].

Now you might be wondering why I’ve arranged these numbers in same order for green, red, blue and orange side and in a different order for white and yellow side. Well as it turns out, this arrangement just happened to help me see some patterns while coding :P

Phew. So now I’ve got the rubik’s cube opened up and spread out on a piece of paper.

This is my new perspective of looking at the rubik’s cube now :D

Now imagine I rotate the red side of the cube by [math]90[/math] degrees. What will really happen is that the sides adjacent to red (that is green, white, blue and yellow) will also get affected. So I spent some time just thinking how all this would look like from our perspective.

And once this was figured out, all I really did for next few days is just code and code and code the algorithm. That was the real task. The rest is history :P

Okay now I’ll scramble my rubik’s cube and show you exactly how to give input. So here’s my scrambled cube…

So now what I'll do is compare all the sides on white, blue and red side with respect to my numbering system…

Now just look at the white side (the side on top whose center piece is white). If you follow the colours in order on white side from index [math]0[/math] to [math]8[/math] you'll get the colours as…

0- blue (b)

1-blue (b)

2-blue (b)

3-blue (b)

4-yellow (y)

5-yellow (y)

6-yellow (y)

7-green (g)

8-white (w)

You just have to just enter the first character of each colour in space separated format in one line.

So for white side, the input will be…

White : b b b y y y g w

Similarly using this same logic, for red side the input will be…

Red : y g g o r w r r r

Similarly for blue side,

Blue : w b o g w w o o b

And so on. Follow the same logic for all 6 sides.

So I’ll show you the input as well as the output for this same scrambled cube…

Few Important things…

  • All you gotta do is give the input state correctly and press enter. You’ll see a sequence of colours appear line by line. You need to just follow the sequence from the first colour to the last colour in the exact order and rotate those sides of your scrambled cube in the CLOCKWISE direction by [math]90[/math] degree each time.
  • Clockwise direction because I’m a lazy coder and I have made the function to turn any side in the clockwise direction only. If the situation requires that the side must be turned in anti-clockwise direction, my code will simply give the command to rotate that side in clockwise direction [math]3[/math] times. Just think about it. It is essentially the same thing. Moreover my aim was to code this up in under [math]1000[/math] lines :P
  • If you give a wrong input, there would be infinite steps. I haven’t used any exception handling in the code because my ultimate aim is to use stepper motors and an arduino. For avoiding wrong inputs, I have a plan to learn some image processing so that a I can simply show all the sides of the cube to a colour sensor and it will detect the colour of each piece and then autmatically substitute the [math]9[/math] elements of my six colour arrays.
  • Sometimes the steps may tell you to turn the same side more than [math]4[/math] times. Don’t worry. Just turn those side whatever number to times it says to turn. That happens when the code is searching for some specific combinations.

Before I forget, here’s the C++ code for my little Rubik’s Cube Solver…

  1. #include<iostream> 
  2. using namespace std; 
  3. //----------------------------------------------- 
  4. char white[9]; 
  5. char red[9]; 
  6. char orange[9]; 
  7. char blue[9]; 
  8. char green[9]; 
  9. char yellow[9]; 
  10. //---------------------------------- 
  11. void display(char face[9]) 
  12. { 
  13.   for(int i=0;i<9;i++) 
  14.   { 
  15.     cout<<face[i]<<" "; 
  16.   } 
  17.   cout<<endl<<endl; 
  18. } 
  19. void swap(char &a,char &b) 
  20. { 
  21.     char t=a; 
  22.     a=b; 
  23.     b=t; 
  24. } 
  25. void rotate_clock(char choice) 
  26. { 
  27.   if (choice=='w') 
  28.   { 
  29.     cout<<"White"<<endl; 
  30.     swap(white[7],white[3]); 
  31.     swap(white[6],white[4]); 
  32.     swap(white[0],white[2]); 
  33.     swap(white[7],white[5]); 
  34.     swap(white[0],white[4]); 
  35.     swap(white[1],white[3]); 
  36.     //------------------------- 
  37.     swap(blue[0],orange[0]); 
  38.     swap(blue[7],orange[7]); 
  39.     swap(blue[6],orange[6]); 
  40.     swap(orange[6],green[6]); 
  41.     swap(orange[7],green[7]); 
  42.     swap(orange[0],green[0]); 
  43.     swap(green[6],red[6]); 
  44.     swap(green[7],red[7]); 
  45.     swap(green[0],red[0]); 
  46.   } 
  47.   //------------------------- 
  48.   else if(choice=='r') 
  49.   { 
  50.     cout<<"Red"<<endl; 
  51.     swap(red[0],red[4]); 
  52.     swap(red[7],red[5]); 
  53.     swap(red[1],red[3]); 
  54.     swap(red[0],red[6]); 
  55.     swap(red[1],red[5]); 
  56.     swap(red[2],red[4]); 
  57.     //------------------------- 
  58.     swap(blue[6],white[3]); 
  59.     swap(blue[5],white[2]); 
  60.     swap(blue[4],white[1]); 
  61.     swap(white[1],green[0]); 
  62.     swap(white[2],green[1]); 
  63.     swap(white[3],green[2]); 
  64.     swap(green[0],yellow[3]); 
  65.     swap(green[1],yellow[2]); 
  66.     swap(green[2],yellow[1]); 
  67.     //-------------------------- 
  68.   } 
  69.   //----------------------------------- 
  70.   else if(choice=='y') 
  71.   { 
  72.     cout<<"Yellow"<<endl; 
  73.     swap(yellow[1],yellow[5]); 
  74.     swap(yellow[2],yellow[4]); 
  75.     swap(yellow[0],yellow[6]); 
  76.     swap(yellow[1],yellow[3]); 
  77.     swap(yellow[0],yellow[4]); 
  78.     swap(yellow[7],yellow[5]); 
  79.     //-------------------------- 
  80.     swap(blue[4],red[4]); 
  81.     swap(blue[3],red[3]); 
  82.     swap(blue[2],red[2]); 
  83.     swap(red[2],green[2]); 
  84.     swap(red[3],green[3]); 
  85.     swap(red[4],green[4]); 
  86.     swap(green[4],orange[4]); 
  87.     swap(green[3],orange[3]); 
  88.     swap(green[2],orange[2]); 
  89.     //-------------------------- 
  90.   } 
  91.   //------------------------------------- 
  92.   else if(choice=='o') 
  93.   { 
  94.     cout<<"Orange"<<endl; 
  95.     swap(orange[4],orange[0]); 
  96.     swap(orange[3],orange[1]); 
  97.     swap(orange[5],orange[7]); 
  98.     swap(orange[4],orange[2]); 
  99.     swap(orange[5],orange[1]); 
  100.     swap(orange[6],orange[0]); 
  101.     //-------------------------- 
  102.     swap(blue[2],yellow[5]); 
  103.     swap(blue[1],yellow[6]); 
  104.     swap(blue[0],yellow[7]); 
  105.     swap(yellow[5],green[6]); 
  106.     swap(yellow[6],green[5]); 
  107.     swap(yellow[7],green[4]); 
  108.     swap(green[6],white[7]); 
  109.     swap(green[5],white[6]); 
  110.     swap(green[4],white[5]); 
  111.     //-------------------------- 
  112.   } 
  113.   //------------------------------------- 
  114.   else if(choice=='g') 
  115.   { 
  116.     cout<<"Green"<<endl; 
  117.     swap(green[6],green[2]); 
  118.     swap(green[5],green[3]); 
  119.     swap(green[7],green[1]); 
  120.     swap(green[4],green[6]); 
  121.     swap(green[7],green[3]); 
  122.     swap(green[0],green[2]); 
  123.     //-------------------------- 
  124.     swap(white[5],orange[2]); 
  125.     swap(white[4],orange[1]); 
  126.     swap(white[3],orange[0]); 
  127.     swap(yellow[3],orange[2]); 
  128.     swap(yellow[4],orange[1]); 
  129.     swap(yellow[5],orange[0]); 
  130.     swap(yellow[3],red[6]); 
  131.     swap(yellow[4],red[5]); 
  132.     swap(yellow[5],red[4]); 
  133.     //-------------------------- 
  134.   } 
  135.   //------------------------------------------- 
  136.   else if(choice=='b') 
  137.   { 
  138.     cout<<"Blue"; 
  139.     swap(blue[1],blue[7]); 
  140.     swap(blue[2],blue[6]); 
  141.     swap(blue[5],blue[3]); 
  142.     swap(blue[2],blue[0]); 
  143.     swap(blue[7],blue[3]); 
  144.     swap(blue[6],blue[4]); 
  145.     //-------------------------- 
  146.     swap(yellow[1],orange[4]); 
  147.     swap(yellow[0],orange[5]); 
  148.     swap(yellow[7],orange[6]); 
  149.     swap(white[7],orange[4]); 
  150.     swap(white[0],orange[5]); 
  151.     swap(white[1],orange[6]); 
  152.     swap(white[7],red[0]); 
  153.     swap(white[0],red[1]); 
  154.     swap(white[1],red[2]); 
  155.     //-------------------------- 
  156.   } 
  157. } 
  158.  
  159. void white_bottom(char q) 
  160. { 
  161.     if((yellow[0]=='w' && blue[3]==q) || (yellow[2]=='w' && red[3]==q) || (yellow[4]=='w' && green[3]==q) || (yellow[6]=='w' && orange[3]==q)) 
  162.     { 
  163.         if(q=='b') 
  164.         { 
  165.             while(blue[3]!=q || yellow[0]!='w') 
  166.             {rotate_clock('y');} 
  167.         } 
  168.         if(q=='r') 
  169.         { 
  170.             while(red[3]!=q || yellow[2]!='w') 
  171.             {rotate_clock('y');} 
  172.             if(q!='b') 
  173.             { 
  174.                 while(white[0]!='w' && blue[7]!='b') 
  175.                 {rotate_clock('w');} 
  176.             } 
  177.         } 
  178.         if(q=='g') 
  179.         { 
  180.             while(green[3]!=q || yellow[4]!='w') 
  181.             {rotate_clock('y');} 
  182.             if(q!='b') 
  183.             { 
  184.                 while(white[0]!='w' && blue[7]!='b') 
  185.                 {rotate_clock('w');} 
  186.             } 
  187.         } 
  188.         if(q=='o') 
  189.         { 
  190.             while(orange[3]!=q || yellow[6]!='w') 
  191.             {rotate_clock('y');} 
  192.             if(q!='b') 
  193.             { 
  194.                 while(white[0]!='w' && blue[7]!='b') 
  195.                 {rotate_clock('w');} 
  196.             } 
  197.         } 
  198.         rotate_clock(q);rotate_clock(q); 
  199.     } 
  200. } 
  201. void right_alg(char a,char c) 
  202. { 
  203.     rotate_clock(a);rotate_clock(a);rotate_clock(a); 
  204.     rotate_clock('y');rotate_clock(a);white_bottom(c); 
  205. } 
  206. void white_right(char q) 
  207. { 
  208.     if(blue[1]=='w' || red[1]=='w' || green[1]=='w' ||orange[1]=='w') 
  209.     { 
  210.         if(blue[5]==q && red[1]=='w') 
  211.         {right_alg('b',q);} 
  212.         if(red[5]==q && green[1]=='w') 
  213.         {right_alg('r',q);} 
  214.         if(green[5]==q && orange[1]=='w') 
  215.         {right_alg('g',q);} 
  216.         if(orange[5]==q && blue[1]=='w') 
  217.         {right_alg('o',q);} 
  218.     } 
  219. } 
  220. void left_alg(char a,char c) 
  221. { 
  222.     rotate_clock(a);rotate_clock('y');rotate_clock(a); 
  223.     rotate_clock(a);rotate_clock(a);white_bottom(c); 
  224. } 
  225. void white_left(char q) 
  226. { 
  227.     if(blue[5]=='w' || red[5]=='w' || green[5]=='w' ||orange[5]=='w') 
  228.     { 
  229.         if(blue[5]=='w' && red[1]==q) 
  230.         {left_alg('r',q);} 
  231.         if(red[5]=='w' && green[1]==q) 
  232.         {left_alg('g',q);} 
  233.         if(green[5]=='w' && orange[1]==q) 
  234.         {left_alg('o',q);} 
  235.         if(orange[5]=='w' && blue[1]==q) 
  236.         {left_alg('b',q);} 
  237.     } 
  238. } 
  239. void top_alg(char a,char b,char c) 
  240. { 
  241.     rotate_clock(a);rotate_clock(a);rotate_clock(a); 
  242.     rotate_clock('w');rotate_clock(b);rotate_clock('w'); 
  243.     rotate_clock('w');rotate_clock('w');white_bottom(c); 
  244. } 
  245. void white_top(char q) 
  246. { 
  247.     if(blue[7]=='w' && white[0]==q) 
  248.     {top_alg('b','r',q);} 
  249.     if(red[7]=='w' && white[2]==q) 
  250.     {top_alg('r','g',q);} 
  251.     if(green[7]=='w' && white[4]==q) 
  252.     {top_alg('g','o',q);} 
  253.     if(orange[7]=='w' && white[6]==q) 
  254.     {top_alg('o','b',q);} 
  255. } 
  256. void inv_alg(char a,char b,char c) 
  257. { 
  258.     rotate_clock(a);rotate_clock(b);rotate_clock('y'); 
  259.     rotate_clock('y');rotate_clock('y');rotate_clock(b); 
  260.     rotate_clock(b);rotate_clock(b);rotate_clock(a); 
  261.     rotate_clock(a);rotate_clock(a);white_bottom(c); 
  262. } 
  263. void white_bottom_inverted(char q) 
  264. { 
  265.     if(blue[3]=='w' || red[3]=='w' || green[3]=='w' || orange[3]=='w') 
  266.     { 
  267.         if(blue[3]=='w' && yellow[0]==q) 
  268.         {inv_alg('b','r',q);} 
  269.         if(red[3]=='w' && yellow[2]==q) 
  270.         {inv_alg('r','g',q);} 
  271.         if(green[3]=='w' && yellow[4]==q) 
  272.         {inv_alg('g','o',q);} 
  273.         if(orange[3]=='w' && yellow[6]==q) 
  274.         {inv_alg('o','b',q);} 
  275.     } 
  276. } 
  277.  
  278. void solve_white_cross() 
  279. { 
  280.     char prefer[4]={'b','r','g','o'}; 
  281.     for(int i=0;i<4;i++) 
  282.     { 
  283.         if(white[0]=='w' && blue[7]==prefer[i]){rotate_clock('b');} 
  284.         if(white[2]=='w' && red[7]==prefer[i]){rotate_clock('r');} 
  285.         if(white[4]=='w' && green[7]==prefer[i]){rotate_clock('g');} 
  286.         if(white[6]=='w' && orange[7]==prefer[i]){rotate_clock('o');} 
  287.         white_bottom(prefer[i]);white_bottom_inverted(prefer[i]);white_left(prefer[i]);white_right(prefer[i]);white_top(prefer[i]); 
  288.         if(i!=0) 
  289.         {while(blue[7]!='b'){rotate_clock('w');}} 
  290.         if(white[0]=='w' && white[2]=='w' && white[4]=='w' && white[6]=='w' &&blue[7]=='b' && red[7]=='r' && green[7]=='g' && orange[7]=='o') 
  291.         {break;} 
  292.     } 
  293. } 
  294.  
  295. void white_corners_alg_left() 
  296. { 
  297.     rotate_clock('b');rotate_clock('b');rotate_clock('b'); 
  298.     rotate_clock('y');rotate_clock('y');rotate_clock('y'); 
  299.     rotate_clock('b'); 
  300. } 
  301. void white_corners_alg_right() 
  302. { 
  303.     rotate_clock('r'); 
  304.     rotate_clock('y'); 
  305.     rotate_clock('r');rotate_clock('r');rotate_clock('r'); 
  306. } 
  307. void solve_white_corners() 
  308. { 
  309.     while(red[0]!='r' || red[6]!='r' || blue[0]!='b' || blue[6]!='b' || orange[0]!='o' || orange[6]!='o' || green[0]!='g' || green[6]!='g') 
  310.     { 
  311.         while(red[7]!='r') 
  312.         { 
  313.             rotate_clock('w'); 
  314.         } 
  315.     if(blue[4]=='w' || red[4]=='w' || green[4]=='w' || orange[4]=='w') 
  316.     { 
  317.         while(blue[4]!='w') 
  318.         { 
  319.             rotate_clock('y'); 
  320.         } 
  321.         while(red[2]!=red[7]) 
  322.         { 
  323.             rotate_clock('w'); 
  324.         } 
  325.         white_corners_alg_left(); 
  326.         while(red[7]!='r') 
  327.         { 
  328.             rotate_clock('w'); 
  329.         } 
  330.     } 
  331.     else if(blue[2]=='w' || red[2]=='w' || green[2]=='w' || orange[2]=='w') 
  332.     { 
  333.         while(red[2]!='w') 
  334.         { 
  335.             rotate_clock('y'); 
  336.         } 
  337.         while(red[7]!=yellow[1]) 
  338.         { 
  339.             rotate_clock('w'); 
  340.         } 
  341.         white_corners_alg_right(); 
  342.         while(red[7]!='r') 
  343.         { 
  344.             rotate_clock('w'); 
  345.         } 
  346.     } 
  347.     else if(yellow[1]=='w' || yellow[3]=='w' || yellow[5]=='w' || yellow[7]=='w') 
  348.     { 
  349.         while(yellow[1]!='w') 
  350.         { 
  351.             rotate_clock('y'); 
  352.         } 
  353.         while(red[2]!=blue[7]) 
  354.         { 
  355.             rotate_clock('w'); 
  356.         } 
  357.         rotate_clock('b');rotate_clock('b');rotate_clock('b'); 
  358.         rotate_clock('y');rotate_clock('y'); 
  359.         rotate_clock('b'); 
  360.         while(blue[4]!='w') 
  361.         { 
  362.             rotate_clock('y'); 
  363.         } 
  364.         while(red[2]!=red[7]) 
  365.         { 
  366.             rotate_clock('w'); 
  367.         } 
  368.         white_corners_alg_left(); 
  369.         while(red[7]!='r') 
  370.         { 
  371.             rotate_clock('w'); 
  372.         } 
  373.     } 
  374.     else 
  375.     { 
  376.         while(red[7]==red[0]) 
  377.         { 
  378.             rotate_clock('w'); 
  379.         } 
  380.         white_corners_alg_left(); 
  381.         while(red[7]!='r') 
  382.         { 
  383.             rotate_clock('w'); 
  384.         } 
  385.     } 
  386.     } 
  387. } 
  388. void middle_place_left_alg(char left,char center) 
  389. { 
  390.     rotate_clock('y');rotate_clock('y');rotate_clock('y'); 
  391.     rotate_clock(left);rotate_clock(left);rotate_clock(left); 
  392.     rotate_clock('y'); 
  393.     rotate_clock(left); 
  394.     rotate_clock('y'); 
  395.     rotate_clock(center); 
  396.     rotate_clock('y');rotate_clock('y');rotate_clock('y'); 
  397.     rotate_clock(center);rotate_clock(center);rotate_clock(center); 
  398.  
  399. } 
  400. void middle_place_right_alg(char center,char right) 
  401. { 
  402.     rotate_clock('y'); 
  403.     rotate_clock(right); 
  404.     rotate_clock('y');rotate_clock('y');rotate_clock('y'); 
  405.     rotate_clock(right);rotate_clock(right);rotate_clock(right); 
  406.     rotate_clock('y');rotate_clock('y');rotate_clock('y'); 
  407.     rotate_clock(center);rotate_clock(center);rotate_clock(center); 
  408.     rotate_clock('y'); 
  409.     rotate_clock(center); 
  410. } 
  411. void solve_middle_layer() 
  412. { 
  413.     while(red[5]!='r' || red[1]!='r' || blue[1]!='b' || blue[5]!='b' || orange[1]!='o' || orange[5]!='o' || green[1]!='g' || green[5]!='g') 
  414.     { 
  415.  
  416.         if((orange[1]!='o' && green[5]!='g') && (orange[1]!='y' || green[5]!='y')) 
  417.         { 
  418.             while(green[3]!='y' && yellow[4]!='y') 
  419.             { 
  420.                 rotate_clock('y'); 
  421.             } 
  422.             middle_place_right_alg('g','o'); 
  423.         } 
  424.  
  425.         else if((orange[5]!='o' && blue[1]!='b') && (orange[5]!='y' || blue[1]!='y')) 
  426.         { 
  427.             while(orange[3]!='y' && yellow[6]!='y') 
  428.             { 
  429.                 rotate_clock('y'); 
  430.             } 
  431.             middle_place_right_alg('o','b'); 
  432.         } 
  433.  
  434.         else if((blue[5]!='b' && red[1]!='r') && (blue[5]!='y' || red[1]!='y')) 
  435.         { 
  436.             while(blue[3]!='y' && yellow[0]!='y') 
  437.             { 
  438.                 rotate_clock('y'); 
  439.             } 
  440.             middle_place_right_alg('b','r'); 
  441.         } 
  442.  
  443.         else if((red[5]!='r' && green[1]!='g') && (red[5]!='y' || green[1]!='y')) 
  444.         { 
  445.             while(red[3]!='y' && yellow[2]!='y') 
  446.             { 
  447.                 rotate_clock('y'); 
  448.             } 
  449.             middle_place_right_alg('r','g'); 
  450.         } 
  451.  
  452.         while(red[3]=='y' || yellow[2]=='y') 
  453.         { 
  454.             rotate_clock('y'); 
  455.         } 
  456.  
  457.         if(red[3]=='r' && yellow[2]!='y') 
  458.         { 
  459.             if(yellow[2]=='g') 
  460.             { 
  461.                 middle_place_right_alg('r','g'); 
  462.             } 
  463.             else if(yellow[2]='b') 
  464.             { 
  465.                 middle_place_left_alg('b','r'); 
  466.             } 
  467.         } 
  468.         else if(red[3]=='b' && yellow[2]!='y') 
  469.         { 
  470.             rotate_clock('y'); 
  471.             if(yellow[0]=='r') 
  472.             { 
  473.                 middle_place_right_alg('b','r'); 
  474.             } 
  475.             else if(yellow[0]='o') 
  476.             { 
  477.                 middle_place_left_alg('o','b'); 
  478.             } 
  479.         } 
  480.         else if(red[3]=='o' && yellow[2]!='y') 
  481.         { 
  482.             rotate_clock('y');rotate_clock('y'); 
  483.             if(yellow[6]=='b') 
  484.             { 
  485.                 middle_place_right_alg('o','b'); 
  486.             } 
  487.             else if(yellow[6]='g') 
  488.             { 
  489.                 middle_place_left_alg('g','o'); 
  490.             } 
  491.         } 
  492.         else if(red[3]=='g' && yellow[2]!='y') 
  493.         { 
  494.             rotate_clock('y');rotate_clock('y');rotate_clock('y'); 
  495.             if(yellow[4]=='o') 
  496.             { 
  497.                 middle_place_right_alg('g','o'); 
  498.             } 
  499.             else if(yellow[4]='r') 
  500.             { 
  501.                 middle_place_left_alg('r','g'); 
  502.             } 
  503.         } 
  504.     } 
  505. } 
  506. void yellow_cross_algorithm() 
  507. { 
  508.         rotate_clock('r'); 
  509.         rotate_clock('y'); 
  510.         rotate_clock('g'); 
  511.         rotate_clock('y');rotate_clock('y');rotate_clock('y'); 
  512.         rotate_clock('g');rotate_clock('g');rotate_clock('g'); 
  513.         rotate_clock('r');rotate_clock('r');rotate_clock('r'); 
  514. } 
  515. void solve_yellow_cross() 
  516. { 
  517.     while(yellow[0]!='y' || yellow[2]!='y' || yellow[4]!='y' || yellow[6]!='y') 
  518.     { 
  519.         if((yellow[0]=='y' && yellow[6]=='y') || (yellow[4]=='y' && yellow[6]=='y') 
  520.                 || (yellow[2]=='y' && yellow[4]=='y') || (yellow[0]=='y' && yellow[2]=='y')) 
  521.         { 
  522.             while(yellow[0]!='y' && yellow[6]!='y') 
  523.             { 
  524.                 rotate_clock('y'); 
  525.             } 
  526.             yellow_cross_algorithm(); 
  527.         } 
  528.         if((yellow[2]=='y' && yellow[6]=='y') || (yellow[0]=='y' && yellow[4]=='y')) 
  529.         { 
  530.             while(yellow[0]!='y' && yellow[4]!='y') 
  531.             { 
  532.                 rotate_clock('y'); 
  533.             } 
  534.             yellow_cross_algorithm(); 
  535.             yellow_cross_algorithm(); 
  536.         } 
  537.         else if(yellow[8]=='y') 
  538.         { 
  539.             yellow_cross_algorithm(); 
  540.             rotate_clock('y'); 
  541.             yellow_cross_algorithm(); 
  542.             yellow_cross_algorithm(); 
  543.         } 
  544.     } 
  545. } 
  546. void yellow_corners_algorithm() 
  547. { 
  548.     rotate_clock('g'); 
  549.     rotate_clock('y'); 
  550.     rotate_clock('g');rotate_clock('g');rotate_clock('g'); 
  551.     rotate_clock('y'); 
  552.     rotate_clock('g'); 
  553.     rotate_clock('y');rotate_clock('y'); 
  554.     rotate_clock('g');rotate_clock('g');rotate_clock('g'); 
  555. } 
  556. void solve_yellow_corners() 
  557. { 
  558.     while(yellow[1]!='y' || yellow[3]!='y'  || yellow[5]!='y' || yellow[7]!='y') 
  559.     { 
  560.         if((yellow[1]=='y' && yellow[3]!='y' && yellow[5]!='y' && yellow[7]!='y') 
  561.            || (yellow[3]=='y' && yellow[1]!='y' && yellow[5]!='y' && yellow[7]!='y') 
  562.            || (yellow[5]=='y' && yellow[1]!='y' && yellow[3]!='y' && yellow[7]!='y') 
  563.            || (yellow[7]=='y' && yellow[1]!='y' && yellow[3]!='y' && yellow[5]!='y')) 
  564.         { 
  565.             while(yellow[1]!='y') 
  566.             { 
  567.                 rotate_clock('y'); 
  568.             } 
  569.             yellow_corners_algorithm(); 
  570.         } 
  571.         else if((green[2]=='y' && green[4]=='y' && yellow[1]=='y' && yellow[7]=='y') 
  572.                 || (orange[2]=='y' && orange[4]=='y' && yellow[1]=='y' && yellow[3]=='y') 
  573.                 || (blue[2]=='y' && blue[4]=='y' && yellow[3]=='y' && yellow[5]=='y') 
  574.                 || (red[2]=='y' && red[4]=='y' && yellow[5]=='y' && yellow[7]=='y')) 
  575.         { 
  576.             while(red[2]!='y' && red[4]!='y' && yellow[5]!='y' && yellow[7]!='y') 
  577.             { 
  578.                 rotate_clock('y'); 
  579.             } 
  580.             yellow_corners_algorithm(); 
  581.         } 
  582.         else if((red[4]=='y' && orange[2]=='y' && yellow[1]=='y' && yellow[7]=='y') 
  583.                 || (blue[2]=='y' && green[4]=='y' && yellow[1]=='y' && yellow[3]=='y') 
  584.                 || (red[2]=='y' && orange[4]=='y' && yellow[3]=='y' && yellow[5]=='y') 
  585.                 || (blue[4]=='y' && green[2]=='y' && yellow[5]=='y' && yellow[7]=='y')) 
  586.         { 
  587.             while(red[2]!='y' && orange[4]!='y' && yellow[3]!='y' && yellow[5]!='y') 
  588.             { 
  589.                 rotate_clock('y'); 
  590.             } 
  591.             yellow_corners_algorithm(); 
  592.         } 
  593.         else if((green[2]=='y' && green[4]=='y' && blue[2]=='y' && blue[4]=='y') 
  594.             || (red[2]=='y' && red[4]=='y' && orange[2]=='y' && orange[4]=='y')) 
  595.         { 
  596.             while(green[2]!='y' && green[4]!='y' && blue[2]!='y' && blue[4]!='y') 
  597.             { 
  598.                 rotate_clock('y'); 
  599.             } 
  600.             yellow_corners_algorithm(); 
  601.         } 
  602.         else if((green[2]=='y' && orange[2]=='y' && orange[4]=='y' && blue[4]=='y') 
  603.             || (red[4]=='y' && orange[2]=='y' && blue[2]=='y' && blue[4]=='y') 
  604.             || (red[2]=='y' && red[4]=='y' && green[4]=='y' && blue[2]=='y') 
  605.             || (green[2]=='y' && green[4]=='y' && orange[4]=='y' && red[2]=='y')) 
  606.         { 
  607.             while(green[2]!='y' && orange[2]!='y' && orange[4]!='y' && blue[4]!='y') 
  608.             { 
  609.                 rotate_clock('y'); 
  610.             } 
  611.             yellow_corners_algorithm(); 
  612.         } 
  613.         else if((yellow[1]=='y' && yellow[5]=='y' && yellow[3]!='y' && yellow[7]!='y') 
  614.             || (yellow[3]=='y' && yellow[7]=='y' && yellow[1]!='y' && yellow[5]!='y')) 
  615.         { 
  616.             while(red[2]!='y' && green[4]!='y') 
  617.             { 
  618.                 rotate_clock('y'); 
  619.             } 
  620.             yellow_corners_algorithm(); 
  621.         } 
  622.     } 
  623. } 
  624. void yellow_corner_orientation_algorithm() 
  625. { 
  626.     rotate_clock('g');rotate_clock('g');rotate_clock('g'); 
  627.     rotate_clock('r'); 
  628.     rotate_clock('g');rotate_clock('g');rotate_clock('g'); 
  629.     rotate_clock('o');rotate_clock('o'); 
  630.     rotate_clock('g'); 
  631.     rotate_clock('r');rotate_clock('r');rotate_clock('r'); 
  632.     rotate_clock('g');rotate_clock('g');rotate_clock('g'); 
  633.     rotate_clock('o');rotate_clock('o'); 
  634.     rotate_clock('g');rotate_clock('g'); 
  635.     rotate_clock('y');rotate_clock('y');rotate_clock('y'); 
  636. } 
  637. void yellow_corner_orientation() 
  638. { 
  639.     while(red[2]!='r' || red[4]!='r' || green[2]!='g' || green[4]!='g' 
  640.           || orange[2]!='o' || orange[4]!='o' || blue[2]!='b' || blue[4]!='b') 
  641.     { 
  642.     if((red[2]==red[4]) || (green[2]==green[4]) || (orange[2]==orange[4]) || (blue[2]==blue[4])) 
  643.     { 
  644.         while(orange[2]!=orange[4]) 
  645.         { 
  646.             rotate_clock('y'); 
  647.         } 
  648.         yellow_corner_orientation_algorithm(); 
  649.         while(blue[2]!='b') 
  650.         { 
  651.             rotate_clock('y'); 
  652.         } 
  653.     } 
  654.     else 
  655.     { 
  656.         while(orange[4]!='o' && red[4]!='r') 
  657.         { 
  658.             rotate_clock('y'); 
  659.         } 
  660.         yellow_corner_orientation_algorithm(); 
  661.         while(orange[2]!=orange[4]) 
  662.         { 
  663.             rotate_clock('y'); 
  664.         } 
  665.         yellow_corner_orientation_algorithm(); 
  666.         while(blue[2]!='b') 
  667.         { 
  668.             rotate_clock('y'); 
  669.         } 
  670.     } 
  671.     } 
  672. } 
  673. void yellow_edges_colour_arrangement_right() 
  674. { 
  675.     rotate_clock('r');rotate_clock('r'); 
  676.     rotate_clock('y');rotate_clock('y');rotate_clock('y'); 
  677.     rotate_clock('g');rotate_clock('g');rotate_clock('g'); 
  678.     rotate_clock('b'); 
  679.     rotate_clock('r');rotate_clock('r'); 
  680.     rotate_clock('b');rotate_clock('b');rotate_clock('b'); 
  681.     rotate_clock('g'); 
  682.     rotate_clock('y');rotate_clock('y');rotate_clock('y'); 
  683.     rotate_clock('r');rotate_clock('r'); 
  684. } 
  685. void yellow_edges_colour_arrangement_left() 
  686. { 
  687.     rotate_clock('r');rotate_clock('r'); 
  688.     rotate_clock('y'); 
  689.     rotate_clock('b'); 
  690.     rotate_clock('g');rotate_clock('g');rotate_clock('g'); 
  691.     rotate_clock('r');rotate_clock('r'); 
  692.     rotate_clock('b');rotate_clock('b');rotate_clock('b'); 
  693.     rotate_clock('g'); 
  694.     rotate_clock('y'); 
  695.     rotate_clock('r');rotate_clock('r'); 
  696. } 
  697. void yellow_edges_colour_arrangement() 
  698. { 
  699.     while(red[2]!='r') 
  700.     { 
  701.         rotate_clock('r'); 
  702.     } 
  703.     if(red[3]=='o' && orange[3]=='r' && blue[3]=='g' && green[3]=='b') 
  704.     { 
  705.         yellow_edges_colour_arrangement_left(); 
  706.     } 
  707.     else if(red[3]=='b' && blue[3]=='r') 
  708.     { 
  709.         yellow_edges_colour_arrangement_left(); 
  710.     } 
  711.     else if(red[3]=='g' && green[3]=='r') 
  712.     { 
  713.         yellow_edges_colour_arrangement_left(); 
  714.     } 
  715.     while(orange[2]!=orange[3]) 
  716.     { 
  717.         rotate_clock('y'); 
  718.     } 
  719.     if(red[3]==green[2]) 
  720.     { 
  721.         yellow_edges_colour_arrangement_right(); 
  722.     } 
  723.     else if(red[3]==blue[2]) 
  724.     { 
  725.         yellow_edges_colour_arrangement_left(); 
  726.     } 
  727.     while(red[3]!='r') 
  728.     { 
  729.         rotate_clock('y'); 
  730.     } 
  731. } 
  732. int main() 
  733. { 
  734.   cout<<"________________________| RUBIK'S CUBE SOLVER |________________________"<<endl<<endl; 
  735.   cout<<"Input :"<<endl<<endl; 
  736.   cout<<"White Side : "; 
  737.   for(int i=0;i<9;++i) 
  738.   {cin>>white[i];} 
  739.   cout<<"Red Side : "; 
  740.   for(int i=0;i<9;++i) 
  741.   {cin>>red[i];} 
  742.   cout<<"Orange Side : "; 
  743.   for(int i=0;i<9;++i) 
  744.   {cin>>orange[i];} 
  745.   cout<<"Blue Side : "; 
  746.   for(int i=0;i<9;++i) 
  747.   {cin>>blue[i];} 
  748.   cout<<"Green Side : "; 
  749.   for(int i=0;i<9;++i) 
  750.   {cin>>green[i];} 
  751.   cout<<"Yellow Side : "; 
  752.   for(int i=0;i<9;++i) 
  753.   {cin>>yellow[i];} 
  754.   //----------------------------------- 
  755.   cout<<"\n-------------------------------------------------\n"<<endl; 
  756.   cout<<"Turn these sides of the Cube in Clockwise Direction by 90 degrees in this exact order..."<<endl<<endl; 
  757.   solve_white_cross(); 
  758.   solve_white_corners(); 
  759.   solve_middle_layer(); 
  760.   solve_yellow_cross(); 
  761.   solve_yellow_corners(); 
  762.   yellow_corner_orientation(); 
  763.   yellow_edges_colour_arrangement(); 
  764.   //------------------------------------ 
  765.   cout<<"\n\n-------------------------------------------------"<<endl<<endl; 
  766.   cout<<"Your Rubik's Cube is now SOLVED!\n\nOutput : "<<endl<<endl; 
  767.   cout<<"White Side : "; 
  768.   display(white); 
  769.   cout<<"Red Side : "; 
  770.   display(red); 
  771.   cout<<"Orange Side : "; 
  772.   display(orange); 
  773.   cout<<"Blue Side : "; 
  774.   display(blue); 
  775.   cout<<"Green Side : "; 
  776.   display(green); 
  777.   cout<<"Yellow Side : "; 
  778.   display(yellow); 
  779.   return 0; 
  780. } 

Another Scrambled Rubik’s Cube Solved (scrambled by my friend) :D

On following all the steps correctly…

Voilà!

And that’s my little Rubik’s Cube Solver :)

Edit: Here’s the link to my GitHub Repository- 7enTropy7/Rubiks_Cube_Solver_Algorithm

226K views ·
View upvotes
 ·
View 78 shares
 ·
1 of 11 answers
View 10 other answers to this question
About · Careers · Privacy · Terms · Contact · Languages · Your Ad Choices · Press ·
© Quora, Inc. 2025