{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Rubik's Cube" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Making the cube" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First, we'll define the Faces and Pieces." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "from matplotlib.colors import ListedColormap,BoundaryNorm\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "class Face:\n", " RED = 0#'RED'\n", " BLUE = 1#'BLUE'\n", " WHITE = 2#'WHITE'\n", " ORANGE = 3#'ORANGE'\n", " GREEN = 4#'GREEN'\n", " YELLOW = 5#'YELLOW'\n", "class Piece:\n", " mod = 1\n", " def __init__(self, faces):\n", " self.f = faces\n", " self.o = 0\n", " def add_orient(self, num):\n", " self.o = (self.o + num) % self.mod\n", " def ori(self):\n", " return self.o\n", " def faces(self):\n", " return self.f\n", "class Corner(Piece):\n", " mod = 3\n", "class Edge(Piece):\n", " mod = 2\n", "class Middle(Piece):\n", " mod = 1\n", " \n", "position = []\n", "def reset_cube():\n", " try:\n", " Move.count = 0\n", " except:\n", " pass\n", " position = [Piece([])]\n", " position.append(Corner([Face.RED, Face.BLUE, Face.YELLOW]))\n", " position.append(Edge([Face.RED, Face.BLUE]))\n", " position.append(Corner([Face.RED, Face.WHITE, Face.BLUE]))\n", " position.append(Edge([Face.RED, Face.YELLOW]))\n", " position.append(Middle([Face.RED]))\n", " position.append(Edge([Face.RED, Face.WHITE]))\n", " position.append(Corner([Face.RED, Face.YELLOW, Face.GREEN]))\n", " position.append(Edge([Face.RED, Face.GREEN]))\n", " position.append(Corner([Face.RED, Face.GREEN, Face.WHITE]))\n", " position.append(Edge([Face.BLUE, Face.YELLOW]))\n", " position.append(Middle([Face.BLUE]))\n", " position.append(Edge([Face.BLUE, Face.WHITE]))\n", " position.append(Middle([Face.YELLOW]))\n", " position.append(Piece([]))\n", " position.append(Middle([Face.WHITE]))\n", " position.append(Edge([Face.GREEN, Face.YELLOW]))\n", " position.append(Middle([Face.GREEN]))\n", " position.append(Edge([Face.GREEN, Face.WHITE]))\n", " position.append(Corner([Face.ORANGE, Face.YELLOW, Face.BLUE]))\n", " position.append(Edge([Face.ORANGE, Face.BLUE]))\n", " position.append(Corner([Face.ORANGE, Face.BLUE, Face.WHITE]))\n", " position.append(Edge([Face.ORANGE, Face.YELLOW]))\n", " position.append(Middle([Face.ORANGE]))\n", " position.append(Edge([Face.ORANGE, Face.WHITE]))\n", " position.append(Corner([Face.ORANGE, Face.GREEN, Face.YELLOW]))\n", " position.append(Edge([Face.ORANGE, Face.GREEN]))\n", " position.append(Corner([Face.ORANGE, Face.WHITE, Face.GREEN]))\n", " return position\n", "position = reset_cube()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next up, the different Sides and how they interact with Pieces." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "class Side:\n", " pieces = []\n", " side = []\n", " cmap = ListedColormap(['red', 'blue', 'white', 'orange', 'green', 'yellow'])\n", " norm = BoundaryNorm([0,1,2,3,4,5,6], cmap.N)\n", " fig_num = 0\n", " @classmethod\n", " def view_side(self):\n", " output = []\n", " for i in range(len(self.pieces)):\n", " x = position[self.pieces[i]]\n", " output.append(x.faces()[(x.ori() + self.side[i]) % x.mod])\n", " return output\n", " @classmethod\n", " def viz(self):\n", " Side.fig_num+=1\n", " fig = plt.figure(Side.fig_num)\n", " plt.title(self.__name__)\n", " plt.xticks([-0.5,0.5,1.5,2.5], ['','','','']);\n", " plt.yticks([-0.5,0.5,1.5,2.5], ['','','','']);\n", " plt.imshow(np.reshape(self.view_side(), (3,3)),origin='upper',interpolation='nearest',cmap=self.cmap, norm=self.norm)\n", " plt.grid(which='major',color='black', linestyle='-', linewidth=2)\n", "class TopSide(Side):\n", " pieces = [7,8,9,4,5,6,1,2,3]\n", " side = [0,0,0,0,0,0,0,0,0]\n", "class BottomSide(Side):\n", " pieces = [19,20,21,22,23,24,25,26,27]\n", " side = [0,0,0,0,0,0,0,0,0]\n", "class FrontSide(Side):\n", " pieces = [1,2,3,10,11,12,19,20,21]\n", " side = [1,1,2,0,0,0,2,1,1]\n", "class BackSide(Side):\n", " pieces = [9,8,7,18,17,16,27,26,25]\n", " side = [1,1,2,0,0,0,2,1,1]\n", "class LeftSide(Side):\n", " pieces = [7,4,1,16,13,10,25,22,19]\n", " side = [1,1,2,1,0,1,2,1,1]\n", "class RightSide(Side):\n", " pieces = [3,6,9,12,15,18,21,24,27]\n", " side = [1,1,2,1,0,1,2,1,1]\n", "\n", "def view_cube():\n", " TopSide.viz()\n", " FrontSide.viz()\n", " RightSide.viz()\n", " BackSide.viz()\n", " LeftSide.viz()\n", " BottomSide.viz()\n", "def validate():\n", " a = TopSide.view_side()\n", " b = FrontSide.view_side()\n", " c = RightSide.view_side()\n", " d = BackSide.view_side()\n", " e = LeftSide.view_side()\n", " f = BottomSide.view_side()\n", " return a.count(a[0]) == len(a) and b.count(b[0]) == len(b) and c.count(c[0]) == len(c) \\\n", " and d.count(d[0]) == len(d) and e.count(e[0]) == len(e) and f.count(f[0]) == len(f)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then, we define the Moves of a Rubik's Cube." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "class Move:\n", " pos_list = [0,0,0,0,0,0,0,0]\n", " orient_adjust = [0,0,0,0,0,0,0,0]\n", " count = 0\n", " @classmethod\n", " def run(self, num=1):\n", " for i in range(num%4):\n", " self.reorient()\n", " self.swap()\n", " Move.count += 1\n", " @classmethod\n", " def reorient(self):\n", " for i in range(len(self.pos_list)):\n", " position[self.pos_list[i]].add_orient(self.orient_adjust[i])\n", " @classmethod\n", " def swap(self):\n", " a6 = position[self.pos_list[6]]\n", " a7 = position[self.pos_list[7]]\n", " for i in range(len(self.pos_list)-2):\n", " position[self.pos_list[7-i]] = position[self.pos_list[5-i]]\n", " position[self.pos_list[0]] = a6\n", " position[self.pos_list[1]] = a7\n", "class LU_Move(Move):\n", " pos_list = [1,4,7,16,25,22,19,10]\n", " orient_adjust = [1,0,-1,0,1,0,-1,0]\n", "class MU_Move(Move):\n", " pos_list = [2,5,8,17,26,23,20,11]\n", " orient_adjust = [1,0,1,0,1,0,1,0]\n", "class RU_Move(Move):\n", " pos_list = [3,6,9,18,27,24,21,12]\n", " orient_adjust = [-1,0,1,0,-1,0,1,0]\n", "class TL_Move(Move):\n", " pos_list = [1,4,7,8,9,6,3,2]\n", " orient_adjust = [0,0,0,0,0,0,0,0]\n", "class ML_Move(Move):\n", " pos_list = [10,13,16,17,18,15,12,11]\n", " orient_adjust = [1,0,1,0,1,0,1,0]\n", "class BL_Move(Move):\n", " pos_list = [19,22,25,26,27,24,21,20]\n", " orient_adjust = [0,0,0,0,0,0,0,0]\n", "class RLU_Move(Move):\n", " pos_list = [1,10,19,20,21,12,3,2]\n", " orient_adjust = [-1,1,1,1,-1,1,1,1]\n", "class RMU_Move(Move):\n", " pos_list = [4,13,22,23,24,15,6,5]\n", " orient_adjust = [1,0,1,0,1,0,1,0]\n", "class RRU_Move(Move):\n", " pos_list = [7,16,25,26,27,18,9,8]\n", " orient_adjust = [1,1,-1,1,1,1,-1,1]\n", "def RotateDown(num=1):\n", " for i in range(num%4):\n", " LU_Move.run();MU_Move.run();RU_Move.run()\n", "def RotateRight(num=1):\n", " for i in range(num%4):\n", " TL_Move.run();ML_Move.run();BL_Move.run()\n", "def RotateCC(num=1): #counter-clockwise\n", " for i in range(num%4):\n", " RLU_Move.run();RMU_Move.run();RRU_Move.run()\n", "\n", "def mixup(n=100):\n", " moves = [LU_Move,MU_Move,RU_Move,TL_Move,ML_Move,BL_Move,RLU_Move,RMU_Move,RRU_Move]\n", " for i in range(n):\n", " moves[np.random.randint(9)].run()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Solving the cube" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is the algorithm I use to solve a Rubik's Cube. " ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "scrolled": true }, "outputs": [], "source": [ "def find_piece(faces):\n", " for i in range(len(position)):\n", " if set(position[i].faces()) == set(faces):\n", " return i\n", "def solve():\n", " while (not validate()):\n", " print(\"Checking...\")\n", " for i in range(4):\n", " RotateRight()\n", " solve_topcross()\n", " for i in range(4):\n", " RotateRight()\n", " solve_topcorners() \n", " for i in range(4):\n", " RotateRight()\n", " solve_middle()\n", " solve_bottomcornerswap()\n", " solve_bottomcornerorient()\n", " solve_bottomcross()\n", " RotateDown()\n", " print(\"Solved! Total number of moves: \" + str(Move.count))\n", " return 'Solved!'\n", "def solve_topcross():\n", " topface = TopSide.view_side()\n", " frontface = FrontSide.view_side()\n", " topcolor = topface[4]\n", " frontcolor = frontface[4]\n", " if (topface[7] != topcolor or frontface[1] != frontcolor):\n", " piece_index = find_piece([topcolor,frontcolor]) \n", " if piece_index in [2,6,8,4]:\n", " on_top = [2,6,8,4].index(piece_index)\n", " RotateRight(on_top)\n", " run_topcross_algorithm(False)\n", " RotateRight(4-on_top)\n", " piece_index = find_piece([topcolor,frontcolor]) \n", " if piece_index in [12,10,16,18]:\n", " in_middle = [12,10,16,18].index(piece_index)\n", " RotateRight(4-in_middle)\n", " run_middle_algorithm(False)\n", " RotateRight(in_middle)\n", " piece_index = find_piece([topcolor,frontcolor]) \n", " alt = (position[piece_index].faces()[position[piece_index].ori()] == frontcolor) #alt is not double-flip\n", " num_bl_moves = [20,24,26,22].index(piece_index)\n", " BL_Move.run(num_bl_moves)\n", " run_topcross_algorithm(alt)\n", " assert (TopSide.view_side()[7] == topcolor and FrontSide.view_side()[1] == frontcolor), 'topcross solver didnt work' \n", "def run_topcross_algorithm(alt=False):\n", " if alt:\n", " RLU_Move.run(3)\n", " ML_Move.run(3)\n", " RLU_Move.run()\n", " ML_Move.run()\n", " else:\n", " RLU_Move.run(2)\n", "def solve_topcorners():\n", " for i in range(4):\n", " topface = TopSide.view_side()\n", " frontface = FrontSide.view_side()\n", " rightface = RightSide.view_side()\n", " topcolor = topface[4]\n", " frontcolor = frontface[4]\n", " rightcolor = rightface[4]\n", " if (topface[8] != topcolor or frontface[2] != frontcolor or rightface[0] != rightcolor):\n", " piece_index = find_piece([frontcolor,rightcolor,topcolor])\n", " if piece_index in [3,1,7,9]:\n", " on_top = [3,1,7,9].index(piece_index)\n", " RotateRight(4-on_top)\n", " run_topcorners_algorithm(False)\n", " RotateRight(on_top)\n", " piece_index = find_piece([frontcolor,rightcolor,topcolor])\n", " alt = (position[piece_index].faces()[position[piece_index].ori()] == rightcolor) #alt is right face to top\n", " num_bl_moves = [21,27,25,19].index(piece_index)\n", " BL_Move.run(num_bl_moves)\n", " run_topcorners_algorithm(alt)\n", " topface = TopSide.view_side()\n", " frontface = FrontSide.view_side()\n", " rightface = RightSide.view_side()\n", " assert (topface[8] == topcolor and frontface[2] == frontcolor and rightface[0] == rightcolor), \\\n", " 'topcorners solver didnt work' \n", "def run_topcorners_algorithm(alt=False):\n", " if alt:\n", " BL_Move.run(1)\n", " RU_Move.run(3)\n", " BL_Move.run(3)\n", " RU_Move.run(1)\n", " else:\n", " RLU_Move.run(3)\n", " BL_Move.run(3)\n", " RLU_Move.run(1) \n", "def solve_middle():\n", " frontface = FrontSide.view_side()\n", " rightface = RightSide.view_side()\n", " frontcolor = frontface[4]\n", " rightcolor = rightface[4]\n", " if (frontface[5] != frontcolor or rightface[3] != rightcolor):\n", " piece_index = find_piece([frontcolor,rightcolor]) \n", " if piece_index in [12,10,16,18]:\n", " in_middle = [12,10,16,18].index(piece_index)\n", " RotateRight(4-in_middle)\n", " run_middle_algorithm(False)\n", " RotateRight(in_middle)\n", " piece_index = find_piece([frontcolor,rightcolor]) \n", " alt = (position[piece_index].faces()[position[piece_index].ori()] == rightcolor) #alt is right face to front middle\n", " num_bl_moves = ([20,24,26,22].index(piece_index) - int(alt))\n", " BL_Move.run(num_bl_moves)\n", " run_middle_algorithm(alt)\n", " frontface = FrontSide.view_side()\n", " rightface = RightSide.view_side()\n", " assert (frontface[5] == frontcolor and rightface[3] == rightcolor), 'middle solver didnt work'+str(alt) \n", "def run_middle_algorithm(alt=False):\n", " if alt:\n", " BL_Move.run(2)\n", " RU_Move.run(3)\n", " BL_Move.run(1)\n", " RU_Move.run(1)\n", " BL_Move.run(3)\n", " RLU_Move.run(3)\n", " BL_Move.run(3)\n", " RLU_Move.run(1)\n", " else:\n", " BL_Move.run(2)\n", " RLU_Move.run(3)\n", " BL_Move.run(1)\n", " RLU_Move.run(1)\n", " BL_Move.run(1)\n", " RU_Move.run(3)\n", " BL_Move.run(3)\n", " RU_Move.run(1) \n", "def solve_bottomcornerswap(): #swap corners\n", " bottomcolor = BottomSide.view_side()[4]\n", " frontcolor = FrontSide.view_side()[4]\n", " backcolor = BackSide.view_side()[4]\n", " rightcolor = RightSide.view_side()[4]\n", " leftcolor = LeftSide.view_side()[4]\n", " corners = [find_piece([frontcolor,bottomcolor,rightcolor]),find_piece([backcolor,bottomcolor,rightcolor]), \\\n", " find_piece([backcolor,bottomcolor,leftcolor]),find_piece([frontcolor,bottomcolor,leftcolor])] #[21,27,25,19]\n", " num_bl_moves = ([21,27,25,19].index(corners[0]))\n", " BL_Move.run(num_bl_moves) #first element lines up\n", " corners = [find_piece([frontcolor,bottomcolor,rightcolor]),find_piece([backcolor,bottomcolor,rightcolor]), \\\n", " find_piece([backcolor,bottomcolor,leftcolor]),find_piece([frontcolor,bottomcolor,leftcolor])] #[21,27,25,19]\n", " if (corners[1] == 19):\n", " RotateRight(3)\n", " run_bottomcornerswap_algorithm()\n", " RotateRight(1)\n", " x = corners.index(25)\n", " corners[x],corners[1] = corners[1],corners[x]\n", " if (corners[1] == 25):\n", " RotateRight(2)\n", " run_bottomcornerswap_algorithm()\n", " RotateRight(2)\n", " x = corners.index(27)\n", " corners[x],corners[1] = corners[1],corners[x] #second element lines up\n", " if (corners[2] == 19):\n", " RotateRight(3)\n", " run_bottomcornerswap_algorithm()\n", " RotateRight(1)\n", " x = corners.index(25)\n", " corners[x],corners[2] = corners[2],corners[x] #third element lines up\n", " assert corners == [21,27,25,19], 'something went wrong with my logic, bottomcornerswap' + str(corners)\n", " corners = [find_piece([frontcolor,bottomcolor,rightcolor]),find_piece([backcolor,bottomcolor,rightcolor]), \\\n", " find_piece([backcolor,bottomcolor,leftcolor]),find_piece([frontcolor,bottomcolor,leftcolor])] #[21,27,25,19]\n", " assert corners == [21,27,25,19], 'bottomcornerswap solver not working' + str(corners)\n", "def run_bottomcornerswap_algorithm():\n", " RU_Move.run(3)\n", " BL_Move.run(1)\n", " RU_Move.run(1)\n", " RLU_Move.run(3)\n", " BL_Move.run(3)\n", " RLU_Move.run(1)\n", " RU_Move.run(3)\n", " BL_Move.run(3)\n", " RU_Move.run(1)\n", " BL_Move.run(2)\n", "def solve_bottomcornerorient():\n", " bottomcolor = BottomSide.view_side()[4]\n", " frontcolor = FrontSide.view_side()[4]\n", " backcolor = BackSide.view_side()[4]\n", " rightcolor = RightSide.view_side()[4]\n", " leftcolor = LeftSide.view_side()[4]\n", " \n", " corners = [find_piece([frontcolor,bottomcolor,rightcolor]),find_piece([backcolor,bottomcolor,rightcolor]), \\\n", " find_piece([backcolor,bottomcolor,leftcolor]),find_piece([frontcolor,bottomcolor,leftcolor])] #[21,27,25,19]\n", " orients = [(position[i].faces()[position[i].ori()] == bottomcolor) for i in corners]\n", " if orients.count(True) == 4:\n", " return True\n", " while orients.count(True) != 1:\n", " if orients.count(True) > 1:\n", " while ((FrontSide.view_side()[8]) == FrontSide.view_side()[4]):\n", " RotateRight()\n", " run_bottomcornerorient_algorithm()\n", " orients = [(position[i].faces()[position[i].ori()] == bottomcolor) for i in corners]\n", " RotateRight(orients.index(True))\n", " for a in range(2):\n", " if orients.count(True) != 4: \n", " run_bottomcornerorient_algorithm()\n", " orients = [(position[i].faces()[position[i].ori()] == bottomcolor) for i in corners]\n", " assert(orients.count(True) == 4), 'bottomcornerorient solver not working'\n", "def run_bottomcornerorient_algorithm():\n", " RRU_Move.run(3)\n", " BL_Move.run(1)\n", " RRU_Move.run(1)\n", " BL_Move.run(1) \n", " RRU_Move.run(3)\n", " BL_Move.run(2)\n", " RRU_Move.run(1)\n", " BL_Move.run(2)\n", "def solve_bottomcross():\n", " bottomface = BottomSide.view_side()\n", " frontface = FrontSide.view_side()\n", " backface = BackSide.view_side()\n", " rightface = RightSide.view_side()\n", " leftface = LeftSide.view_side()\n", " bottomcolor = bottomface[4]\n", " frontcolor = frontface[4]\n", " backcolor = backface[4]\n", " rightcolor = rightface[4]\n", " leftcolor = leftface[4]\n", " num_done = int(frontface.count(frontcolor) == len(frontface)) + \\\n", " int(backface.count(backcolor) == len(backface)) + \\\n", " int(rightface.count(rightcolor) == len(rightface)) + \\\n", " int(leftface.count(leftcolor) == len(leftface))\n", " cross = [find_piece([frontcolor,bottomcolor]),find_piece([bottomcolor,rightcolor]), \\\n", " find_piece([backcolor,bottomcolor]),find_piece([bottomcolor,leftcolor])] #[20,24,26,22]\n", " orients = [(position[i].faces()[position[i].ori()] == bottomcolor) for i in cross]\n", " if num_done == 4:\n", " return True #done!\n", " if num_done == 0: #beginning of stage\n", " if (cross[0] == 24 and not orients[0]) or (cross[0] == 26 and orients[0]):\n", " RotateRight(3)\n", " elif (cross[1] == 26 and not orients[1]) or (cross[1] == 22 and orients[1]):\n", " pass\n", " elif (cross[2] == 22 and not orients[2]) or (cross[2] == 20 and orients[2]):\n", " RotateRight(1)\n", " elif (cross[3] == 20 and not orients[3]) or (cross[3] == 24 and orients[3]):\n", " RotateRight(2)\n", " else:\n", " if (cross[0] == 26):\n", " pass\n", " elif (cross[1] == 22):\n", " RotateRight(1)\n", " elif (cross[2] == 20):\n", " RotateRight(2)\n", " elif (cross[3] == 24):\n", " RotateRight(3)\n", " RotateDown()\n", " RLU_Move.run(3)\n", " ML_Move.run(3)\n", " RLU_Move.run(1)\n", " ML_Move.run(1)\n", " RotateDown(3)\n", " return False #needs middle swap. if logic error, print these: str(num_done)+str(orients)+str(cross)\n", " else:\n", " while (FrontSide.view_side().count(FrontSide.view_side()[0]) != 9):\n", " RotateRight()\n", " if num_done == 1 and orients.count(True) != 4:\n", " return False\n", " run_bottomcross_algorithm()\n", " solve_bottomcross()\n", " \n", "def run_bottomcross_algorithm():\n", " LU_Move.run()\n", " RU_Move.run()\n", " RLU_Move.run()\n", " LU_Move.run(3)\n", " RU_Move.run(3)\n", " BL_Move.run(2)\n", " LU_Move.run()\n", " RU_Move.run()\n", " RLU_Move.run()\n", " LU_Move.run(3)\n", " RU_Move.run(3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Now let's play!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Viewing the Cube" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can play with the cube by executing moves, and view it by running ```view_cube()```." ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "position=reset_cube()\n", "view_cube()\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "RU_Move.run(2)\n", "view_cube()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Mixing up the Cube \n", "```mixup(n)``` runs _n_ random moves on the cube. It's like mixing the cube up!" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "position=reset_cube()\n", "mixup(100)\n", "view_cube()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Solving the Cube" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "```solve()``` will run an algorithm to finish the cube." ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Solved! Total number of moves: 556\n", "CPU times: user 350 µs, sys: 134 µs, total: 484 µs\n", "Wall time: 384 µs\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAO4AAAD7CAYAAABt9agKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAB0dJREFUeJzt21uopXUZx/HfU6NZGkmTURMd7DBlSASTBN0URAcxQ4gsqMgKNgRGQV10U3iTEARBURdzkXWRkR2Q7HBhREFEhBCEhkaIZg1Gg42n7GA+Xey1YTW199rbmT2zn/HzgQVrrff/rve///Dd77vWYlV3B5jlSad7AsDOCRcGEi4MJFwYSLgwkHBhIOGSJKmqh6rqxZtsu6qqfn6q58TmhHuKVdVdVfXIIpSN24GTfIw3VNUfj3vu/Kr6SlXdW1UPVtXvquqTG9u7+7zuvvNkzoPds+90T+AJ6vLu/vFmG6tqX3c/epKP+fkk5ya5KMn9SQ4mufgkH4NTxBl3D6iqF1VVV9WHquoPSX6yeP7tVXVbVR2rqp9W1UVL+9xVVZ+oqt9U1f1V9c2qOqeqzk3yoyQHjjujX5Lk+u7+a3c/1t23d/e3l16vq+qli/v7q+p7VfVAVf0qyUuOm+8rqurmqrqvqu6oqit3f5VYJty95fVZPyO+paoOJvlGko8luSDJD5PcVFVnL42/Mslbk1yY5FVJruruh5NcmuTI4vL3vO4+kuSXST5TVR+oqpetmMeXkvw9yXOTfHBxS5Is/jHcnOT6JM9O8u4kX66qV57Yn85OCPf0uHFxFj1WVTcuPX9Ndz/c3Y8keVeSH3T3zd39rySfS/LUJK9bGv+F7j7S3fcluSnJq7c45keSfD3J1Ul+W1W/r6pLjx9UVU9O8o4kn17M5dYkX1sa8rYkd3X3dd39aHf/Osl3krxzp4vA4yfc0+OK7j5/cbti6fl7lu4fSHL3xoPufmyx/XlLY+5duv+3JOdtdsDufqS7r+3uQ0n2J7khybeq6pnHDb0g6599LM/l7qX7L0zy2qV/PMeSvCfJczY7NiefcPeW5Z9qHcl6JEmSqqokz0/ypx2+zv9u7H4gybVZ/7DqwuM2/yXJo4tjbXjB0v17kvxs6R/P+YvL8Q9vY16cJMLdu25IcllVvbGqzkry8ST/SPKLbez75yT7q+oZG09U1aeq6pKqOruqzkny0STHktyxvGN3/zvJd5NcU1VPW7x3ff/SkO8nOVhV76uqsxa3S5Y/OGP3CXeP6u47krw3yReTHE1yeda/RvrnNva9PesfbN25uJw9kPWz8HWL1zqS5E1JLuvuh/7PS1yd9cvue5N8dbHfxms/mOTNWf9Q6shizGeTPOVx/aE8LuWH9DCPMy4MJFwYSLgwkHBhIOHCQCt/HVRVa0nWFg8P7e504Ilt//7k6NGuVeN29HVQlW+PNlOLpbY+m7NGW6tKDh1KbrlldbgulWEg4cJAwoWBhAsDCRcGEi4MJFwYSLgwkHBhIOHCQMKFgYQLAwkXBhIuDCRcGEi4MJBwYSDhwkDChYGECwMJFwYSLgwkXBhIuDCQcGEg4cJAwoWBhAsDCRcGEi4MJFwYSLgwkHBhIOHCQMKFgYQLAwkXBhIuDCRcGEi4MJBwYSDhwkDChYGECwMJFwYSLgwkXBhIuDCQcGEg4cJAwoWBhAsDCRcGEi4MJFwYSLgwkHBhIOHCQMKFgYQLAwkXBhIuDCRcGEi4MJBwYSDhwkDChYGECwMJFwbat9MdqnZjGmcO67OaNTpxK8OtqrUka6dgLsA2rQy3uw8nOZwkVdXduz6nkTbOItZnc9Zoazu5EvEeFwYSLgwkXBhIuDCQcGEg4cJAwoWBhAsDCRcGEi4MJFwYSLgwkHBhIOHCQMKFgYQLAwkXBhIuDCRcGEi4MJBwYSDhwkDChYGECwMJFwYSLgwkXBhIuDCQcGEg4cJAwoWBhAsDCRcGEi4MJFwYSLgwkHBhIOHCQMKFgYQLAwkXBhIuDCRcGEi4MJBwYSDhwkDChYGECwMJFwYSLgwkXBhIuDCQcGEg4cJAwoWBhAsDCRcGEi4MJFwYSLgwkHBhIOHCQMKFgYQLAwkXBhIuDCRcGEi4MJBwYSDhwkD7drpD1W5M48xhfVazRiduZbhVtZZk7RTMBdimleF29+Ekh5Okqrp71+c00sZZxPpszhptbSdXIt7jwkDChYGECwMJFwYSLgwkXBhIuDCQcGEg4cJAwoWBhAsDCRcGEi4MJFwYSLgwkHBhIOHCQMKFgYQLAwkXBhIuDCRcGEi4MJBwYSDhwkDChYGECwMJFwYSLgwkXBhIuDCQcGEg4cJAwoWBhAsDCRcGEi4MJFwYSLgwkHBhIOHCQMKFgYQLAwkXBhIuDCRcGEi4MJBwYSDhwkDChYGECwMJFwYSLgwkXBhIuDCQcGEg4cJAwoWBhAsDCRcGEi4MJFwYSLgwkHBhIOHCQMKFgYQLAwkXBhIuDLRvpztU7cY0zhzWZzVrdOKqu7ceULWWZG3x8OIkt+72pAZ7VpKjp3sSe5w12trLu/vpqwatDPe/Blfd0t2vOaFpncGsz2rWaGvbXR/vcWEg4cJAOw338K7M4sxhfVazRlvb1vrs6D0usDe4VIaBhAsDCRcGEi4MJFwY6D94WVmQ6uQ4RgAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%time solve() #magic %time command to time the function\n", "view_cube()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's mix it up and try again." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "position = reset_cube()\n", "mixup(1000)\n", "view_cube()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Checking...\n", "Checking...\n", "Solved! Total number of moves: 1503\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAO4AAAD7CAYAAABt9agKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAABuFJREFUeJzt20uI7nUdx/HPt0wSoywtPBVlYBeDgtBdBFkULqMbhEUEdWjXqjZdHKFFVNSmFoUUgtAiCmlREbYJWhQVERUkYvdjFwmli93w12KeA4+jnpnJOc589PWC4Znn/H78/r/nz3mf//8/nJm1VoAuTzjuDQCHJ1woJFwoJFwoJFwoJFwoJNzHoZl50czcc47xj83MTY/mnjgc4R6jmfnb1tf9M3Pf1vvrH+HaV8zMrTNz98zcOzM/ObvmWuv2tdYlR/MpOA4XHPcGHs/WWk85+/3M/CrJu9datx3R8l9K8p0kb0vy3yQvT3LpEa3NMXPFPcFm5qKZ+ezM3DUzv5uZT8zMkzZj183MHTNz48z8ZWZ+OTNv2YxNkmuSfHGtdd9a6z9rrR+utb61GX/JzPx36zhXzsx3Z+avM/ONJE/fs49Xzcz3ZuaemfnRzLzyUTsJPCThnmw3ZvdK+bIkVyd5dZIPbI1fkeTCJJcneU+Sm2fmBWv3/7F+L8nnZuatM/PchzvAJvIvZ/fqfGmSTyZ5x9b4FUluTfLBJM9I8qEkt87M0/euxaNHuCfb9UluWGvdvdb6Y5KPZiuq7N4C37jW+vfmFvu2JG/ejL0hyfezG/9vZuYHM/OKhzjGC5NctbXOt5N8c2v8nUm+uta6ba11/1rr60l+nuT1R/g5OSThnlCbK+HlSX699ce/TvKcrfd/Xmv9c8/4s5NkE/v711pXbda5PclXH+JQz36Ydc56fpK3b26T79n8NPqas8fheAj3hNrc7v4hu+Gc9bwkv996f9nMPHnP+JmHWOtPST6V5IqZuXjP8F0Ps85Zv01y01rrkq2vi9danz78p+KoCPdk+1KSG2bm0pl5VnafM2/ZGn9Skg/PzIUz85okr0vylSSZmU/OzEtn5okz87Qk703y07XW3/cc4/Ykv9ha59ok122N35zkLTPz2s1aF22+v/y8fGIORLgn20ey+zz5syQ/TvLdJB/fGv9Vdp9z/5DkC0netda6czP21CRfS3JvkjuSPDPJG/ceYHNlf2uSa5P8Jbs//Lpla/zOJG/K7rPy3dm9jX5f/N05VuMX6TvNzHVJPrPWuvK498Kjz7+aUEi4UMitMhRyxYVCwoVC+/520MycTnJ68/bq87sdeJy7KFn/WLPftEM9487Mys4j2dVj2M6eVx5sZ88rD7ST5FSyzuwfrltlKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKDRrrYNPnjn4ZODwTiXrzJr9pl2w34SZOZ3k9JFsCjgSh7/i7py/zVTb2fPKg+3seeWBdnLgK65nXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCgkXCg0a62DT545+GTg8E4l68ya/aZdsN+EmTmd5PSRbAo4Eoe/4u6cv81U29nzyoPt7HnlgXZy4CuuZ1woJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoNGutg0+eOfhk4PBOJevMmv2mXbDfhJk5neT05u2/kvz0EW7tseyyJHcf9yZOOOfoXO7Kiw8y7bBX3B+sta75vzf1GOf87M85OreDnh/PuFBIuFDosOF+/rzs4rHD+dmfc3RuBzo/h3rGBU4Gt8pQSLhQSLhQSLhQSLhQ6H99BEW32QTD5gAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "solve()\n", "view_cube()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Try your own" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now you try! Have fun :)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAO4AAAD7CAYAAABt9agKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAB4NJREFUeJzt21+InFcdh/Hn10YLktSGRIsSNdiKlhZqabxVL6I1VkFBUm+sCunaghYR/FdQK1ZEqVi80hWxir2wigoitYJoi0IrKlSqV62owabGoMHGQrHy82LehTHO7syyM5n9bp8PBGb2PTPn5GSefd/ZzVR3IynLectegKTNM1wpkOFKgQxXCmS4UiDDlQIZ7jZSVV+qqo/NOPbOqrptjnPfU1XvXOfYwarqqto1r/m0Nf5DnGNV9UfgYuA/wBngR8B7u/tMd984x3kaeFl3PzL2tVuAG4DnAaeBX3T3dQDdfWRec2vxPOMux5u7ezfwSuAq4KOLnnA4m74DODzMfQj4yaLn1WIY7hJ19+PAvYwC/r/L36r6UFWdqKrHqurYcLl66dhT7K2qH1bVE1X1YFVdMjzu/uH4Q1V1pqquA14F3Nvdj67N3d2rY3P9rKqODbfPr6rbq+pUVf0BuHZ83VX13Kr66rC2v1TVbVV1/tw3SOsy3CWqqgPAEeCRCcfeAHwAOAxcCrx2wlO8HfgksHd4jk8DdPerh+NXdvfu7v4W8ABwfVV9sKoOTQntBuBNjK4GDgFvO+v4ncDTw7quAl4PHJvy19UcGe5yfL+qngCOAyeBT0wYcxT4Wnf/rrufBG6dMOZ73f3L7n4auIvhzD1Jd38TeB9wDXAfcLKqPrzO8KPAHd19vLv/Dnxm7UBVXQy8EXh/d/+ru08CX2D0TUTniOEux1u6ew+js+grgP0TxryQUdhrjk8Y8/jY7SeB3RtN2t13dfdh4CLgRuBTVXXNDHP/aez2S4BnASeq6nRVnQa+DDx/o7k1X4a7RN19H6PLztsnHD4BHBi7/6I5zvvv7v428FvginXmHp/vxWO3jwNPAfu7+6Lhz4Xdffm81qfpDHf57gBeV1VXnvX1u4F3V9VlVfUcYKbf7475K/DStTtV9a6quraq9lTVeVV1BLgceHDCY+8Gbq6qA1W1F/jI2oHuPgH8GPh8VV04PNclVfWaTa5PW2C4S9bdfwO+AXz8rK/fA3wR+CmjHzw9MBx6asanvhX4+nA5exT4J3AL8GdGv8P9HHBTd/98wmO/wuin3Q8BvwG+e9bx64FnA78H/gF8B3jBjOvSHJQfpM9QVZcBDwMXDD+M0jOYZ9xtrKreWlUXDJernwV+YLQCw93u3sPo10WPMvovkjctdznaLrxUlgJ5xpUCGa4UaOrH+qpqBVgZ7l692OVIz2z79u3j1KlTNW3c1HCHT5Cswugznr4nnqxqtNduz/qGLcLX0GRVxcGDB2ca66WyFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBdm32AVW1iHXsGG7PdL6Gtm5quFW1Aqycg7VI4tczjZoabnevAqsAVdXdW1vWTrV2EnGD1rd2pnWLJtvMhYjvcaVAhisFMlwpkOFKgQxXCmS4UiDDlQIZrhTIcKVAhisFMlwpkOFKgQxXCmS4UiDDlQIZrhTIcKVAhisFMlwpkOFKgQxXCmS4UiDDlQIZrhTIcKVAhisFMlwpkOFKgQxXCmS4UiDDlQIZrhTIcKVAhisFMlwpkOFKgQxXCmS4UiDDlQIZrhTIcKVAhisFMlwpkOFKgQxXCmS4UiDDlQIZrhTIcKVAhisFMlwpkOFKgQxXCmS4UiDDlQIZrhTIcKVAhisFMlwpkOFKgQxXCmS4UiDDlQIZrhTIcKVAhisFMlwpkOFKgQxXCmS4UqBdm31A1SKWsXOUGzSVW7SRq2caNTXcqloBVra6HEnzMzXc7l4FVgGqqrt74YtKtHamdXvWt3am9TU02Wau1nyPKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSIMOVAhmuFMhwpUCGKwUyXCmQ4UqBDFcKZLhSoF2bfUBVLWIdO4bbM52voa2r7t54QNUKsDLcvQJ4eNGLCrYfOLXsRWxz7tHGXt7de6YNmhru/wyu+lV3H9rSsnYw92c692hjs+6P73GlQIYrBdpsuKsLWcXO4f5M5x5tbKb92dR7XEnbg5fKUiDDlQIZrhTIcKVAhisF+i95MlYgG5MpkAAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAO4AAAD7CAYAAABt9agKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAABvNJREFUeJzt20mIZlcdxuH3Ly2OcUpESZSA4IAJorSioBtFBScUIQvJJohWspBsAgHFjeC8cshCW5S4kLgQFScwCxU0YiCCSEQRBSELFdskJkoQDcdFfw1l01XVZXV119s+D9Ti1r3n+8491K/v+aiuWWsF6PKYiz0BYP+EC4WEC4WEC4WEC4WEC4WEW2hmXjgzv5iZh2fm5v9h/PUzc+cu5380M+852Cw5TMK9yGbmDzPz+n0OuzXJD9dal621PjMzt8/Mh8943dfMzE9n5m8zc//M3DUzr0iStdZX1lpvPF/3wIUn3E5XJ/nVTidn5ilJvpPks0mekeSqJB9K8s8LMjsOnXCPqJl562Y7/ODmyfmSzfd/kOS1SW6bmb/PzFaS65Pcujn+dpIXJMla64611qNrrUfWWneutX65eY0bZuYn297rDTPzm83T+bYkc8Zc3j0zv56ZB2bm+zNz9YVZBXYi3CNoZl6W5EtJbkxyeZLPJ/nWzDxurfW6JD9O8r611pPXWieSfCXJJzfHb0vy2ySPzsyXZ+ZNM/P0Xd7riiRfT/LBJFck+X2SV287//YkH0jyziTP3Lz3Hef9ptkX4R5NW0k+v9a6e/PE/HJObXNfdS6D11oPJXlNkpXkC0n+MjPfmplnneXyNyf51Vrra2utfyX5VJI/bTt/U5KPrbV+vdb6d5KPJnmpp+7FJdyj6eokt2y2yQ/OzINJnpvkynN9gU1oN6y1npPk2s3YT53l0iuT3Ldt3Np+vJnLp7fN4/6c2kpftd+b4vwR7tF0X5KPrLWetu3riWutnbaou/6J11rrN0luz6mAz/THnPpHIUkyM7P9eDOXG8+YyxPWWj/dzw1xfgn3aHjszDz+9FdObW9vmplXzilPmpm3zMxlO4z/c5LnnT6YmRfNzC0z85zN8XOTvCvJz84y9rtJrpmZd87MsSQ3J3n2tvOfS/L+mblm81pPnZnrDnrDHIxwj4bvJXlk29c7krw3yW1JHkjyuyQ37DL+i0levNnOfjPJw0lemeTumflHTgV7b5Jbzhy41jqZ5LokH0/y1yTPT3LXtvPfSPKJJF+dmYc2r/OmA9wr58H4Q3ro44kLhYQLhYQLhYQLhYQLhY7tdcHmP7FvbQ6PH+504P/b5ZcnJ0+u2eu6ff06aMZvj3Yym6W2QDubzSJZorObSY4fT+65Z+9wbZWhkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHChkHCh0LH9Dpg5jGlcOsYC7ckSHdye4c7MVpKtCzAXIMfP6ao9w11rnUhyIklmZq21DjavS9TpJ63l2dnpJ62fobPbz27NZ1woJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwoJFwodGy/A2bmMOZxybA8e/MztJufn9NVe4Y7M1tJtg46HeD82TPctdaJJCeSZGbWWoc+p0qnHyIWaGenn7SW6Oz2sxHxGRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKCRcKHdvvgJnDmMalYyzQnizRwc1aa/cLZraSbG0Or01y72FPqtgVSU5e7EkccdZody9ca12210V7hvtfF8/cs9Z6+YGmdQmzPnuzRrs71/XxGRcKCRcK7TfcE4cyi0uH9dmbNdrdOa3Pvj7jAkeDrTIUEi4UEi4UEi4UEi4U+g8LAERrOCUGHwAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "position = reset_cube()\n", "MU_Move.run(2)\n", "ML_Move.run(2)\n", "RMU_Move.run(2)\n", "view_cube()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 2", "language": "python", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.15" } }, "nbformat": 4, "nbformat_minor": 1 }