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'}
