def test_cube_neq(self): c = Cube(debug_cube_str) c.L() self.assertNotEqual(c, self.debug_cube) self.assertNotEqual(self.debug_cube, c) self.assertFalse(c == self.debug_cube) self.assertTrue(c != self.debug_cube)
def test_full_cube_rotation_optimization(self): for cw, cc in (('X', 'Xi'), ('Y', 'Yi'), ('Z', 'Zi')): for moves in ([cc, cw], [cw, cc]): rubik.optimize.apply_no_full_cube_rotation_optimization(moves) self.assertEqual([], moves) for cw, cc in (('Z', 'Zi'), ): moves = [cw, 'U', 'L', 'D', 'R', 'E', 'M', cc] expected = ['L', 'D', 'R', 'U', 'Mi', 'E'] actual = list(moves) rubik.optimize.apply_no_full_cube_rotation_optimization(actual) self.assertEqual(expected, actual) c, d = Cube(solved_cube_str), Cube(solved_cube_str) c.sequence(" ".join(moves)) d.sequence(" ".join(actual)) self.assertEqual(str(c), str(d)) moves = [cw, cw, 'U', 'L', 'D', 'R', 'E', 'M', cc, cc] expected = ['D', 'R', 'U', 'L', 'Ei', 'Mi'] actual = list(moves) rubik.optimize.apply_no_full_cube_rotation_optimization(actual) self.assertEqual(expected, actual) c, d = Cube(solved_cube_str), Cube(solved_cube_str) c.sequence(" ".join(moves)) d.sequence(" ".join(actual)) self.assertEqual(str(c), str(d))
def _check_can_solve_cube(self, orig): c = Cube(orig) solver = Solver(c) try: solver.solve() self.assertTrue(c.is_solved(), msg="Failed to solve cube: " + orig) except Exception as e: self.fail(traceback.format_exc() + "original cube: " + orig)
def _check_can_solve_cube(self, orig): c = Cube(orig) solver = Solver(c) try: solver.solve() self.assertTrue(c.is_solved(), msg="Failed to solve cube: " + orig) except Exception as e: self.fail(traceback.format_exc() + "original cube: " + orig)
def random_cube(): """ :return: A new scrambled Cube """ scramble_moves = " ".join(random.choices(MOVES, k=200)) a = Cube(SOLVED_CUBE_STR) a.sequence(scramble_moves) return a
def test(self): if not (self.fwd and self.rev): return False c = Cube(self.initial) c.sequence(self.fwd) c.sequence(self.rev) return (c.flat_str() == self.initial)
def data_generator(): c = Cube(SOLVED_STATE) print_cube(c) for x in np.random.randint(0, 12, 100): getattr(c, actions[x])() #scramble cube print(f"action={actions[x]}") print_cube(c) str = c.flat_str() print("12 children") for a in actions: c_working = Cube(str) getattr(c_working, a)() print_cube(c_working) print("--------------------")
def test_dict(): c = Cube(SOLVED_STATE) edges = [ ''.join(filter(None, x.colors)) for x in c.pieces if x.type == 'edge' ] edges = [[x, x[1:] + x[:1]] for x in edges] edges = [x for sublist in edges for x in sublist] edges = {edges[i]: i for i in range(len(edges))} corners = [''.join(x.colors) for x in c.pieces if x.type == 'corner'] corners = [(x, x[0] + x[2] + x[1], x[2] + x[1] + x[0]) for x in corners] corners = [x for sublist in corners for x in sublist] corners = {corners[i]: i for i in range(len(corners))} for x in np.random.randint(0, 12, 100): getattr(c, actions[x])() #scramble cube print([ edges[m] for m in [ ''.join(filter(None, x.colors)) for x in c.pieces if x.type == 'edge' ] ]) print([ corners[m] for m in [ ''.join(filter(None, x.colors)) for x in c.pieces if x.type == 'corner' ] ])
def test_full_cube_rotation_optimization(self): for cw, cc in (('X', 'Xi'), ('Y', 'Yi'), ('Z', 'Zi')): for moves in ([cc, cw], [cw, cc]): rubik.optimize.apply_no_full_cube_rotation_optimization(moves) self.assertEquals([], moves) for cw, cc in (('Z', 'Zi'),): moves = [cw, 'U', 'L', 'D', 'R','E', 'M', cc] expected = ['L', 'D', 'R', 'U', 'Mi', 'E'] actual = list(moves) rubik.optimize.apply_no_full_cube_rotation_optimization(actual) self.assertEquals(expected, actual) c, d = Cube(solved_cube_str), Cube(solved_cube_str) c.sequence(" ".join(moves)) d.sequence(" ".join(actual)) self.assertEquals(str(c), str(d)) moves = [cw, cw, 'U', 'L', 'D', 'R','E', 'M', cc, cc] expected = ['D', 'R', 'U', 'L', 'Ei', 'Mi'] actual = list(moves) rubik.optimize.apply_no_full_cube_rotation_optimization(actual) self.assertEquals(expected, actual) c, d = Cube(solved_cube_str), Cube(solved_cube_str) c.sequence(" ".join(moves)) d.sequence(" ".join(actual)) self.assertEquals(str(c), str(d))
def gen_diff(cls, pattern): # Generate a diff string for each direction and store it SOLVED_CUBE_STR = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01" cube = Cube(SOLVED_CUBE_STR) s1 = cube.flat_str() cube.sequence(pattern) s2 = cube.flat_str() return [s1.index(s2[i]) for i in range(len(s1))]
def test_cube_constructor_no_whitespace(self): cube = Cube("".join(x for x in debug_cube_str if x not in string.whitespace)) self.assertEqual(debug_cube_str, str(cube))
def test_cube_eq(self): c = Cube(debug_cube_str) self.assertEqual(c, self.debug_cube) self.assertEqual(self.debug_cube, c)
yield x + y else: for y in case_permutations(str[1:]): yield x.lower() + y yield x.upper() + y if __name__ == "__main__": model = build_model() print(model.summary()) #state = np.random.randint(0, 24, (10,20)) #state = tf.keras.utils.to_categorical(state, 24) #actions, value = model.predict(state) #print(model) c = Cube(SOLVED_STATE) lookup = init_lookup(c) corners = [''.join(p.colors) for p in c.pieces if p.type == 'corner'] corner_dict = {k: v for v, k in enumerate(corners)} for x in np.random.randint(0, 12, 200): getattr(c, actions[x])() #scramble cube corners = [ x[1] if x[0] > 0 else x[1].lower() for p in c.pieces if p.type == 'corner' for x in zip(p.pos, p.colors) ] corners = [ ''.join(x) for x in zip(corners[0::3], corners[1::3], corners[2::3]) ]
def test_cube_constructor_additional_whitespace(self): cube = Cube(" ".join(x for x in debug_cube_str)) self.assertEqual(debug_cube_str, str(cube))
def test_cube_copy_constructor(self): c = Cube(self.debug_cube) self.assertEqual(debug_cube_str, str(c)) self.assertEqual(self.debug_cube, c)
def setUp(self): self.solved_cube = Cube(solved_cube_str) self.debug_cube = Cube(debug_cube_str)
class TestCube(unittest.TestCase): def setUp(self): self.solved_cube = Cube(solved_cube_str) self.debug_cube = Cube(debug_cube_str) def test_cube_constructor_solved_cube(self): self.assertEqual(solved_cube_str, str(self.solved_cube)) def test_cube_constructor_unique_stickers(self): self.assertEqual(debug_cube_str, str(self.debug_cube)) def test_cube_constructor_additional_whitespace(self): cube = Cube(" ".join(x for x in debug_cube_str)) self.assertEqual(debug_cube_str, str(cube)) def test_cube_copy_constructor(self): c = Cube(self.debug_cube) self.assertEqual(debug_cube_str, str(c)) self.assertEqual(self.debug_cube, c) def test_cube_eq(self): c = Cube(debug_cube_str) self.assertEqual(c, self.debug_cube) self.assertEqual(self.debug_cube, c) def test_cube_neq(self): c = Cube(debug_cube_str) c.L() self.assertNotEqual(c, self.debug_cube) self.assertNotEqual(self.debug_cube, c) self.assertFalse(c == self.debug_cube) self.assertTrue(c != self.debug_cube) def test_cube_constructor_no_whitespace(self): cube = Cube("".join(x for x in debug_cube_str if x not in string.whitespace)) self.assertEqual(debug_cube_str, str(cube)) def test_cube_L(self): self.debug_cube.L() self.assertEqual( " I12\n" " w45\n" " k78\n" "xl9 0de fgh ijP\n" "yma 3pq rst uvM\n" "znb 6BC DEF GHJ\n" " cKL\n" " oNO\n" " AQR", str(self.debug_cube)) def test_cube_Li(self): self.debug_cube.Li() self.assertEqual( " c12\n" " o45\n" " A78\n" "bnz Jde fgh ij6\n" "amy Mpq rst uv3\n" "9lx PBC DEF GH0\n" " IKL\n" " wNO\n" " kQR", str(self.debug_cube)) def test_cube_R(self): self.debug_cube.R() self.assertEqual( " 01e\n" " 34q\n" " 67C\n" "9ab cdL Drf 8jk\n" "lmn opO Esg 5vw\n" "xyz ABR Fth 2HI\n" " JKG\n" " MNu\n" " PQi", str(self.debug_cube)) def test_cube_Ri(self): self.debug_cube.Ri() self.assertEqual( " 01G\n" " 34u\n" " 67i\n" "9ab cd2 htF Rjk\n" "lmn op5 gsE Ovw\n" "xyz AB8 frD LHI\n" " JKe\n" " MNq\n" " PQC", str(self.debug_cube)) def test_cube_U(self): self.debug_cube.U() self.assertEqual( " 630\n" " 741\n" " 852\n" "cde fgh ijk 9ab\n" "lmn opq rst uvw\n" "xyz ABC DEF GHI\n" " JKL\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_Ui(self): self.debug_cube.Ui() self.assertEqual( " 258\n" " 147\n" " 036\n" "ijk 9ab cde fgh\n" "lmn opq rst uvw\n" "xyz ABC DEF GHI\n" " JKL\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_D(self): self.debug_cube.D() self.assertEqual( " 012\n" " 345\n" " 678\n" "9ab cde fgh ijk\n" "lmn opq rst uvw\n" "GHI xyz ABC DEF\n" " PMJ\n" " QNK\n" " ROL", str(self.debug_cube)) def test_cube_Di(self): self.debug_cube.Di() self.assertEqual( " 012\n" " 345\n" " 678\n" "9ab cde fgh ijk\n" "lmn opq rst uvw\n" "ABC DEF GHI xyz\n" " LOR\n" " KNQ\n" " JMP", str(self.debug_cube)) def test_cube_F(self): self.debug_cube.F() self.assertEqual( " 012\n" " 345\n" " znb\n" "9aJ Aoc 6gh ijk\n" "lmK Bpd 7st uvw\n" "xyL Cqe 8EF GHI\n" " Drf\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_Fi(self): self.debug_cube.Fi() self.assertEqual( " 012\n" " 345\n" " frD\n" "9a8 eqC Lgh ijk\n" "lm7 dpB Kst uvw\n" "xy6 coA JEF GHI\n" " bnz\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_B(self): self.debug_cube.B() self.assertEqual( " htF\n" " 345\n" " 678\n" "2ab cde fgR Gui\n" "1mn opq rsQ Hvj\n" "0yz ABC DEP Iwk\n" " JKL\n" " MNO\n" " 9lx", str(self.debug_cube)) def test_cube_Bi(self): self.debug_cube.Bi() self.assertEqual( " xl9\n" " 345\n" " 678\n" "Pab cde fg0 kwI\n" "Qmn opq rs1 jvH\n" "Ryz ABC DE2 iuG\n" " JKL\n" " MNO\n" " Fth", str(self.debug_cube)) def test_cube_M(self): self.debug_cube.M() self.assertEqual( " 0H2\n" " 3v5\n" " 6j8\n" "9ab c1e fgh iQk\n" "lmn o4q rst uNw\n" "xyz A7C DEF GKI\n" " JdL\n" " MpO\n" " PBR", str(self.debug_cube)) def test_cube_Mi(self): self.debug_cube.Mi() self.assertEqual( " 0d2\n" " 3p5\n" " 6B8\n" "9ab cKe fgh i7k\n" "lmn oNq rst u4w\n" "xyz AQC DEF G1I\n" " JHL\n" " MvO\n" " PjR", str(self.debug_cube)) def test_cube_E(self): self.debug_cube.E() self.assertEqual( " 012\n" " 345\n" " 678\n" "9ab cde fgh ijk\n" "uvw lmn opq rst\n" "xyz ABC DEF GHI\n" " JKL\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_Ei(self): self.debug_cube.Ei() self.assertEqual( " 012\n" " 345\n" " 678\n" "9ab cde fgh ijk\n" "opq rst uvw lmn\n" "xyz ABC DEF GHI\n" " JKL\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_S(self): self.debug_cube.S() self.assertEqual( " 012\n" " yma\n" " 678\n" "9Mb cde f3h ijk\n" "lNn opq r4t uvw\n" "xOz ABC D5F GHI\n" " JKL\n" " Esg\n" " PQR", str(self.debug_cube)) def test_cube_Si(self): self.debug_cube.Si() self.assertEqual( " 012\n" " gsE\n" " 678\n" "95b cde fOh ijk\n" "l4n opq rNt uvw\n" "x3z ABC DMF GHI\n" " JKL\n" " amy\n" " PQR", str(self.debug_cube)) def test_cube_X(self): self.debug_cube.X() self.assertEqual( " cde\n" " opq\n" " ABC\n" "bnz JKL Drf 876\n" "amy MNO Esg 543\n" "9lx PQR Fth 210\n" " IHG\n" " wvu\n" " kji", str(self.debug_cube)) def test_cube_Xi(self): self.debug_cube.Xi() self.assertEqual( " IHG\n" " wvu\n" " kji\n" "xl9 012 htF RQP\n" "yma 345 gsE ONM\n" "znb 678 frD LKJ\n" " cde\n" " opq\n" " ABC", str(self.debug_cube)) def test_cube_Y(self): self.debug_cube.Y() self.assertEqual( " 630\n" " 741\n" " 852\n" "cde fgh ijk 9ab\n" "opq rst uvw lmn\n" "ABC DEF GHI xyz\n" " LOR\n" " KNQ\n" " JMP", str(self.debug_cube)) def test_cube_Yi(self): self.debug_cube.Yi() self.assertEqual( " 258\n" " 147\n" " 036\n" "ijk 9ab cde fgh\n" "uvw lmn opq rst\n" "GHI xyz ABC DEF\n" " PMJ\n" " QNK\n" " ROL", str(self.debug_cube)) def test_cube_Z(self): self.debug_cube.Z() self.assertEqual( " xl9\n" " yma\n" " znb\n" "PMJ Aoc 630 kwI\n" "QNK Bpd 741 jvH\n" "ROL Cqe 852 iuG\n" " Drf\n" " Esg\n" " Fth", str(self.debug_cube)) def test_cube_Zi(self): self.debug_cube.Zi() self.assertEqual( " htF\n" " gsE\n" " frD\n" "258 eqC LOR Gui\n" "147 dpB KNQ Hvj\n" "036 coA JMP Iwk\n" " bnz\n" " amy\n" " 9lx", str(self.debug_cube)) def test_cube_find_face_piece(self): piece = self.debug_cube.find_piece('p') self.assertEqual(cube.FACE, piece.type) self.assertEqual(cube.FRONT, piece.pos) self.assertEqual([None, None, 'p'], piece.colors) def test_cube_find_edge_piece(self): def _check_piece(piece): self.assertEqual(cube.EDGE, piece.type) self.assertEqual(cube.FRONT + cube.UP, piece.pos) self.assertEqual([None, '7', 'd'], piece.colors) _check_piece(self.debug_cube.find_piece('d', '7')) _check_piece(self.debug_cube.find_piece('7', 'd')) def test_cube_find_corner_piece(self): def _check_piece(piece): self.assertEqual(cube.CORNER, piece.type) self.assertEqual(cube.FRONT + cube.UP + cube.LEFT, piece.pos) self.assertEqual(['b', '6', 'c'], piece.colors) for colors in itertools.permutations(('b', '6', 'c')): _check_piece(self.debug_cube.find_piece(*colors)) def test_cube_find_face_piece_negative(self): self.assertIsNone(self.debug_cube.find_piece('7')) def test_cube_find_edge_piece_negative(self): self.assertIsNone(self.debug_cube.find_piece('o', 'q')) def test_cube_find_corner_piece_negative(self): self.assertIsNone(self.debug_cube.find_piece('c', '6', '9')) def test_cube_is_solved(self): self.assertTrue(self.solved_cube.is_solved()) def test_cube_is_solved_negative(self): self.solved_cube.L() self.assertFalse(self.solved_cube.is_solved()) self.assertFalse(self.debug_cube.is_solved()) def test_cube_sequence(self): self.solved_cube.sequence("L U M Ri X E Xi Ri D D F F Bi") self.assertEqual( " DLU\n" " RRD\n" " FFU\n" "BBL DDR BRB LDL\n" "RBF RUU LFB DDU\n" "FBR BBR FUD FLU\n" " DLU\n" " ULF\n" " LFR", str(self.solved_cube)) def test_cube_colors(self): self.assertEqual({'U', 'D', 'F', 'B', 'L', 'R'}, self.solved_cube.colors()) debug_colors = set() debug_colors.update(c for c in debug_cube_str if c not in string.whitespace) self.assertEqual(debug_colors, self.debug_cube.colors()) def test_cube_get_piece(self): piece = self.debug_cube.get_piece(0, 0, 1) self.assertEqual(cube.FACE, piece.type) self.assertEqual(cube.FRONT, piece.pos) def test_cube_getitem(self): piece = self.debug_cube[0, 0, 1] self.assertEqual(cube.FACE, piece.type) self.assertEqual(cube.FRONT, piece.pos) def test_cube_getitem_from_tuple(self): piece = self.debug_cube[(0, 0, 1)] self.assertEqual(cube.FACE, piece.type) self.assertEqual(cube.FRONT, piece.pos) def test_move_and_inverse(self): for name in ('R', 'L', 'U', 'D', 'F', 'B', 'M', 'E', 'S', 'X', 'Y', 'Z'): move, unmove = getattr(Cube, name), getattr(Cube, name + 'i') self._check_move_and_inverse(move, unmove, self.debug_cube) def _check_move_and_inverse(self, move, inverse, cube): check_str = str(cube) move(cube) self.assertNotEqual(check_str, str(cube)) inverse(cube) self.assertEqual(check_str, str(cube)) inverse(cube) self.assertNotEqual(check_str, str(cube)) move(cube) self.assertEqual(check_str, str(cube))
class TestCube(unittest.TestCase): def setUp(self): self.solved_cube = Cube(solved_cube_str) self.debug_cube = Cube(debug_cube_str) def test_cube_constructor_solved_cube(self): self.assertEqual(solved_cube_str, str(self.solved_cube)) def test_cube_constructor_unique_stickers(self): self.assertEqual(debug_cube_str, str(self.debug_cube)) def test_cube_constructor_additional_whitespace(self): cube = Cube(" ".join(x for x in debug_cube_str)) self.assertEqual(debug_cube_str, str(cube)) def test_cube_copy_constructor(self): c = Cube(self.debug_cube) self.assertEqual(debug_cube_str, str(c)) self.assertEqual(self.debug_cube, c) def test_cube_eq(self): c = Cube(debug_cube_str) self.assertEqual(c, self.debug_cube) self.assertEqual(self.debug_cube, c) def test_cube_neq(self): c = Cube(debug_cube_str) c.L() self.assertNotEqual(c, self.debug_cube) self.assertNotEqual(self.debug_cube, c) self.assertFalse(c == self.debug_cube) self.assertTrue(c != self.debug_cube) def test_cube_constructor_no_whitespace(self): cube = Cube("".join(x for x in debug_cube_str if x not in string.whitespace)) self.assertEqual(debug_cube_str, str(cube)) def test_cube_L(self): self.debug_cube.L() self.assertEqual(" I12\n" " w45\n" " k78\n" "xl9 0de fgh ijP\n" "yma 3pq rst uvM\n" "znb 6BC DEF GHJ\n" " cKL\n" " oNO\n" " AQR", str(self.debug_cube)) def test_cube_Li(self): self.debug_cube.Li() self.assertEqual(" c12\n" " o45\n" " A78\n" "bnz Jde fgh ij6\n" "amy Mpq rst uv3\n" "9lx PBC DEF GH0\n" " IKL\n" " wNO\n" " kQR", str(self.debug_cube)) def test_cube_R(self): self.debug_cube.R() self.assertEqual(" 01e\n" " 34q\n" " 67C\n" "9ab cdL Drf 8jk\n" "lmn opO Esg 5vw\n" "xyz ABR Fth 2HI\n" " JKG\n" " MNu\n" " PQi", str(self.debug_cube)) def test_cube_Ri(self): self.debug_cube.Ri() self.assertEqual(" 01G\n" " 34u\n" " 67i\n" "9ab cd2 htF Rjk\n" "lmn op5 gsE Ovw\n" "xyz AB8 frD LHI\n" " JKe\n" " MNq\n" " PQC", str(self.debug_cube)) def test_cube_U(self): self.debug_cube.U() self.assertEqual(" 630\n" " 741\n" " 852\n" "cde fgh ijk 9ab\n" "lmn opq rst uvw\n" "xyz ABC DEF GHI\n" " JKL\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_Ui(self): self.debug_cube.Ui() self.assertEqual(" 258\n" " 147\n" " 036\n" "ijk 9ab cde fgh\n" "lmn opq rst uvw\n" "xyz ABC DEF GHI\n" " JKL\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_D(self): self.debug_cube.D() self.assertEqual(" 012\n" " 345\n" " 678\n" "9ab cde fgh ijk\n" "lmn opq rst uvw\n" "GHI xyz ABC DEF\n" " PMJ\n" " QNK\n" " ROL", str(self.debug_cube)) def test_cube_Di(self): self.debug_cube.Di() self.assertEqual(" 012\n" " 345\n" " 678\n" "9ab cde fgh ijk\n" "lmn opq rst uvw\n" "ABC DEF GHI xyz\n" " LOR\n" " KNQ\n" " JMP", str(self.debug_cube)) def test_cube_F(self): self.debug_cube.F() self.assertEqual(" 012\n" " 345\n" " znb\n" "9aJ Aoc 6gh ijk\n" "lmK Bpd 7st uvw\n" "xyL Cqe 8EF GHI\n" " Drf\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_Fi(self): self.debug_cube.Fi() self.assertEqual(" 012\n" " 345\n" " frD\n" "9a8 eqC Lgh ijk\n" "lm7 dpB Kst uvw\n" "xy6 coA JEF GHI\n" " bnz\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_B(self): self.debug_cube.B() self.assertEqual(" htF\n" " 345\n" " 678\n" "2ab cde fgR Gui\n" "1mn opq rsQ Hvj\n" "0yz ABC DEP Iwk\n" " JKL\n" " MNO\n" " 9lx", str(self.debug_cube)) def test_cube_Bi(self): self.debug_cube.Bi() self.assertEqual(" xl9\n" " 345\n" " 678\n" "Pab cde fg0 kwI\n" "Qmn opq rs1 jvH\n" "Ryz ABC DE2 iuG\n" " JKL\n" " MNO\n" " Fth", str(self.debug_cube)) def test_cube_M(self): self.debug_cube.M() self.assertEqual(" 0H2\n" " 3v5\n" " 6j8\n" "9ab c1e fgh iQk\n" "lmn o4q rst uNw\n" "xyz A7C DEF GKI\n" " JdL\n" " MpO\n" " PBR", str(self.debug_cube)) def test_cube_Mi(self): self.debug_cube.Mi() self.assertEqual(" 0d2\n" " 3p5\n" " 6B8\n" "9ab cKe fgh i7k\n" "lmn oNq rst u4w\n" "xyz AQC DEF G1I\n" " JHL\n" " MvO\n" " PjR", str(self.debug_cube)) def test_cube_E(self): self.debug_cube.E() self.assertEqual(" 012\n" " 345\n" " 678\n" "9ab cde fgh ijk\n" "uvw lmn opq rst\n" "xyz ABC DEF GHI\n" " JKL\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_Ei(self): self.debug_cube.Ei() self.assertEqual(" 012\n" " 345\n" " 678\n" "9ab cde fgh ijk\n" "opq rst uvw lmn\n" "xyz ABC DEF GHI\n" " JKL\n" " MNO\n" " PQR", str(self.debug_cube)) def test_cube_S(self): self.debug_cube.S() self.assertEqual(" 012\n" " yma\n" " 678\n" "9Mb cde f3h ijk\n" "lNn opq r4t uvw\n" "xOz ABC D5F GHI\n" " JKL\n" " Esg\n" " PQR", str(self.debug_cube)) def test_cube_Si(self): self.debug_cube.Si() self.assertEqual(" 012\n" " gsE\n" " 678\n" "95b cde fOh ijk\n" "l4n opq rNt uvw\n" "x3z ABC DMF GHI\n" " JKL\n" " amy\n" " PQR", str(self.debug_cube)) def test_cube_X(self): self.debug_cube.X() self.assertEqual(" cde\n" " opq\n" " ABC\n" "bnz JKL Drf 876\n" "amy MNO Esg 543\n" "9lx PQR Fth 210\n" " IHG\n" " wvu\n" " kji", str(self.debug_cube)) def test_cube_Xi(self): self.debug_cube.Xi() self.assertEqual(" IHG\n" " wvu\n" " kji\n" "xl9 012 htF RQP\n" "yma 345 gsE ONM\n" "znb 678 frD LKJ\n" " cde\n" " opq\n" " ABC", str(self.debug_cube)) def test_cube_Y(self): self.debug_cube.Y() self.assertEqual(" 630\n" " 741\n" " 852\n" "cde fgh ijk 9ab\n" "opq rst uvw lmn\n" "ABC DEF GHI xyz\n" " LOR\n" " KNQ\n" " JMP", str(self.debug_cube)) def test_cube_Yi(self): self.debug_cube.Yi() self.assertEqual(" 258\n" " 147\n" " 036\n" "ijk 9ab cde fgh\n" "uvw lmn opq rst\n" "GHI xyz ABC DEF\n" " PMJ\n" " QNK\n" " ROL", str(self.debug_cube)) def test_cube_Z(self): self.debug_cube.Z() self.assertEqual(" xl9\n" " yma\n" " znb\n" "PMJ Aoc 630 kwI\n" "QNK Bpd 741 jvH\n" "ROL Cqe 852 iuG\n" " Drf\n" " Esg\n" " Fth", str(self.debug_cube)) def test_cube_Zi(self): self.debug_cube.Zi() self.assertEqual(" htF\n" " gsE\n" " frD\n" "258 eqC LOR Gui\n" "147 dpB KNQ Hvj\n" "036 coA JMP Iwk\n" " bnz\n" " amy\n" " 9lx", str(self.debug_cube)) def test_cube_find_face_piece(self): piece = self.debug_cube.find_piece('p') self.assertEqual(cube.FACE, piece.type) self.assertEqual(cube.FRONT, piece.pos) self.assertEqual([None, None, 'p'], piece.colors) def test_cube_find_edge_piece(self): def _check_piece(piece): self.assertEqual(cube.EDGE, piece.type) self.assertEqual(cube.FRONT + cube.UP, piece.pos) self.assertEqual([None, '7', 'd'], piece.colors) _check_piece(self.debug_cube.find_piece('d', '7')) _check_piece(self.debug_cube.find_piece('7', 'd')) def test_cube_find_corner_piece(self): def _check_piece(piece): self.assertEqual(cube.CORNER, piece.type) self.assertEqual(cube.FRONT + cube.UP + cube.LEFT, piece.pos) self.assertEqual(['b', '6', 'c'], piece.colors) for colors in itertools.permutations(('b', '6', 'c')): _check_piece(self.debug_cube.find_piece(*colors)) def test_cube_find_face_piece_negative(self): self.assertIsNone(self.debug_cube.find_piece('7')) def test_cube_find_edge_piece_negative(self): self.assertIsNone(self.debug_cube.find_piece('o', 'q')) def test_cube_find_corner_piece_negative(self): self.assertIsNone(self.debug_cube.find_piece('c', '6', '9')) def test_cube_is_solved(self): self.assertTrue(self.solved_cube.is_solved()) def test_cube_is_solved_negative(self): self.solved_cube.L() self.assertFalse(self.solved_cube.is_solved()) self.assertFalse(self.debug_cube.is_solved()) def test_cube_sequence(self): self.solved_cube.sequence("L U M Ri X E Xi Ri D D F F Bi") self.assertEqual(" DLU\n" " RRD\n" " FFU\n" "BBL DDR BRB LDL\n" "RBF RUU LFB DDU\n" "FBR BBR FUD FLU\n" " DLU\n" " ULF\n" " LFR", str(self.solved_cube)) def test_cube_colors(self): self.assertEqual({'U', 'D', 'F', 'B', 'L', 'R'}, self.solved_cube.colors()) debug_colors = set() debug_colors.update(c for c in debug_cube_str if c not in string.whitespace) self.assertEqual(debug_colors, self.debug_cube.colors()) def test_cube_get_piece(self): piece = self.debug_cube.get_piece(0, 0, 1) self.assertEqual(cube.FACE, piece.type) self.assertEqual(cube.FRONT, piece.pos) def test_cube_getitem(self): piece = self.debug_cube[0, 0, 1] self.assertEqual(cube.FACE, piece.type) self.assertEqual(cube.FRONT, piece.pos) def test_cube_getitem_from_tuple(self): piece = self.debug_cube[(0, 0, 1)] self.assertEqual(cube.FACE, piece.type) self.assertEqual(cube.FRONT, piece.pos) def test_move_and_inverse(self): for name in ('R', 'L', 'U', 'D', 'F', 'B', 'M', 'E', 'S', 'X', 'Y', 'Z'): move, unmove = getattr(Cube, name), getattr(Cube, name + 'i') self._check_move_and_inverse(move, unmove, self.debug_cube) def _check_move_and_inverse(self, move, inverse, cube): check_str = str(cube) move(cube) self.assertNotEqual(check_str, str(cube)) inverse(cube) self.assertEqual(check_str, str(cube)) inverse(cube) self.assertNotEqual(check_str, str(cube)) move(cube) self.assertEqual(check_str, str(cube))
cube_string = str(cube) lines = list(map(lambda s: s.replace(" ", ""), cube_string.splitlines())) top = lines[0] + lines[1] + lines[2] left = lines[3][0:3] + lines[4][0:3] + lines[5][0:3] middle = lines[3][3:6] + lines[4][3:6] + lines[5][3:6] right = lines[3][6:9] + lines[4][6:9] + lines[5][6:9] rightmost = lines[3][9:12] + lines[4][9:12] + lines[5][9:12] bottom = lines[6] + lines[7] + lines[8] parts = [top, left, middle, right, rightmost, bottom] for a, b, c, d, e, f in permutations(parts): flag = a + b + c + d + e + f if flag.startswith("HV20{") and flag.endswith("}"): with open('flag.txt', 'a+') as out_file: if flag_regex.match(flag): print(flag) out_file.write(flag + "\n") number_of_moves = 6 moves = "L Li R Ri U Ui D Di F Fi B Bi".split(' ') for sequence in product(moves, repeat=number_of_moves): c = Cube("6_ei{aes3HV7_weo@sislh_e0k__t_nsooa_cda4r52c__nsllt}ph") move = " ".join(sequence) c.sequence(move) get_flag_from_qube(c) # HV20{no_sle3p_since_4wks_lead5_to_@_hi6hscore_a7_last}
def setUp(self): self.solved_cube = Cube(solved_cube_str) self.debug_cube = Cube(debug_cube_str)
def main(): global log # Parse arguments and initialize logging parser = ArgumentParser( __name__, "Find permutations of PLL algorithms " + "that return the cube to a solved state. If " + "neither '--anki' or '--trainer' is specified, " + "print all identified sequences and their " + "patterns' respective steps.") parser.add_argument(action="store", nargs="*", dest="algorithms", help="Override the list of algorithms that will be " + "tested. If not specified, use all algorithms found " + " in ./pll.json") parser.add_argument("-d", "--max-depth", default=4, help="Set maximum " + "recursion depth (default: 4)") parser.add_argument("-a", "--anki", action="store_true", default=False, help="Print all identified patterns in Anki's flash " + "card format") parser.add_argument("-s", "--search", action="store", nargs="+", help="Only include sequences that use at least one " + "of the specified patterns") parser.add_argument("-t", "--trainer", action="store_true", default=False, help="Pick a random sequence and present the steps " + "one by one. Calculate time to solve each step, as " + "well as total time and average time per step. " + "Advance from one step to the next by pressing any " + "key") parser.add_argument("-v", nargs="?", action=VAction, dest="verbosity", help="Set log level. Accepted up to 3 times (e.g. " + "-vvv)") args = parser.parse_args() log = init_logging(args) # Read available algorithms from './pll.json' and parse them into Sequence # objects. # # TODO: Make the file path user-controllable pll = {} with open('./pll.json') as f: _pll = json.load(f) for j in _pll["algorithms"]: pll[j["name"]] = Sequence(j["name"], j["fwd"], j["rev"], j["fmt"]) if "variants" in j: for variant in j["variants"]: v_fwd = variant if len(v_fwd) == 1: v_rev = f"{v_fwd}i" v_fmt = v_fwd elif len(v_fwd) == 2 and v_fwd[1] == "i": v_rev = v_fwd[:-1] v_fmt = f"{v_rev}'" else: continue v = (v_fwd, v_rev, v_fmt) pll[f"{v[2]}+{j['name']}"] = Sequence( f"{v[2]}+{j['name']}", f"{v[0]} {j['fwd']}", f"{j['rev']} {v[1]}", f"{v[2]} {j['fmt']}") log.debug(f"Parsed sequence {j['name']:<2}: {j['fmt']}") ## TODO: # "Na": "Z D Ri U R R Di R D Ui Ri U R R Di R Ui R", # "Nb": "Z Ui R Di R R U Ri D Ui R Di R R U Ri D Ri", # "Gc": "Ri Ri Ui E R Ui R U Ri U Ei R R Fi S Ri Si F", # "V": "Ri U Ri Di Ei Ri Fi R R Ui Ri U Ri F R F", # Test all sequences for name, seq in pll.items(): if not seq.test(): log.error(f"Sequence {name} did not return cube to solved state") # Create a cube object and place it in the solved state cube = Cube(Sequence.initial) if args.algorithms: # If a list of algorithms was provided, drop any invalid entries sequences = list(set(args.algorithms).intersection(set(pll.keys()))) else: # Otherwise, use the full set sequences = list(pll.keys()) starting_sequences = set(sequences) limit_one = args.trainer patterns = find_pattern(cube.flat_str(), pll, sequences, int(args.max_depth), limit_one=limit_one) used_sequences = set() for p in patterns: pattern = p.split() # If a whitelist was provided, use it to filter the pattern list if (not args.search) or len( set(args.search).intersection(set(pattern))) > 0: if args.anki: # Print the raw list of matched sequences in Anki's flashcard # format ([front],[back],[tags]) out = f"{' -> '.join(pattern[:-1])} -> _," tags = [] # Print each pattern wrapped in a <div> for a in pattern: out = f"{out}<div>{str(pll[a])}</div>" tags.append(a) out = f"{out},{' '.join(tags)}" print(out) elif not args.trainer: # Default case (not Anki or trainer mode): Print each sequence, # including both the list of patterns and their respective # steps. print(f"{' -> '.join(pattern)}") for a in pattern: print(f"{a:<2} - {str(pll[a])}") print() used_sequences = used_sequences.union(set(pattern)) # Print a list of all sequences that were not used at least once not_used = starting_sequences - used_sequences if len(not_used): log.debug(f"Not used: {', '.join(list(not_used))}") ## # Whenever a key is pressed, add it to the queue to be handled inside the # timer loop. ## def read_input(_queue): # Source: https://stackoverflow.com/questions/510357/21659588#21659588 fd = sys.stdin.fileno() old_settings = termios.tcgetattr(fd) try: tty.setraw(sys.stdin.fileno()) ch = sys.stdin.read(1) # Handle arrow keys, which consist of 3-character ANSI escape # sequences. Source: https://stackoverflow.com/questions/22397289 if ord(ch) == 27: ch = sys.stdin.read(2) _queue.put(' ') else: _queue.put(ch) finally: termios.tcsetattr(fd, termios.TCSADRAIN, old_settings) ## # Create a separate thread to listen for (blocking) keyboard input events ## def spawn_thread(_queue): thread = threading.Thread(target=read_input, args=(_queue, )) thread.start() # 'Trainer' mode: select a random sequence from the identified list and step # through it. Each step is timed; advance steps by pressing any key. Press # ESC, Ctrl+C, or Ctrl+D to terminate, or advance through the last step. if args.trainer: if not len(patterns): log.critical("No patterns found; cannot continue") return 1 pattern = random.choice(list(patterns)).split(" ") interval = 0.01 elapsed = 0 spacer = "" out = "" _queue = queue.Queue() spawn_thread(_queue) if len(pattern): last = False cont = True total = 0 count = len(pattern) out = f"\x1bc{pattern.pop(0)}" while cont: try: val = _queue.get(False) if val: if ord(val) in [3, 4, 27]: total += elapsed print(f"\nTotal: {total:.2f}s") sys.exit(0) try: total += elapsed out = f"{out} [{elapsed:.2f}s]" # If the next step is the last one, mask it while # the timer is running. if len(pattern) == 1: last_pattern = pattern.pop(0) out = f"{out} -> _" else: out = f"{out} -> {pattern.pop(0)}" elapsed = 0 except IndexError: pass if last: cont = False else: # Spawn a new listener thread if there are more # queued steps. spawn_thread(_queue) if not len(pattern): last = True except queue.Empty: pass sys.stdout.write("\r") sys.stdout.write(f"{out} [{elapsed:.2f}s]") sys.stdout.flush() time.sleep(interval) elapsed += interval sys.stdout.write("\r") sys.stdout.flush() print(out.replace(" -> _", f" -> {last_pattern}")) print(f"Total: {total:.2f}s") print(f"Avg: {total/count:.2f}s")
""" scramble_moves = " ".join(random.choices(MOVES, k=200)) a = Cube(SOLVED_CUBE_STR) a.X() a.sequence(scramble_moves) return a a=random_cube() #Imprime el cubo en forma canonica #print(a) #print("") def removeNonAscii(s): return "".join(i for i in s if ord(i)<126 and ord(i)>32) #imprime el scramble aleatorio en colores del cubo scramble=removeNonAscii(str(a)).lower() print(scramble) print(Cube(scramble)) def organizar_scramble(scramble): string=scramble[:9] for i in range(1,5): for j in range (1,4): #i=1,j=1 k=9 #i=1,j=2 k=21 = k+12 #i=1,j=3 k=33 = k+12= k+2*12 #i=2, j=1 k=12 #i=2,j=2 k=24 =k+12 k=9+3*(i-1)+12*(j-1) string+=scramble[k:k+3] string+=scramble[45:] return string scramble=organizar_scramble(scramble) M = {'b':'g', 'g':'b'}