def get_fake_555(self): if self.fake_555 is None: self.fake_555 = RubiksCube555(solved_555, 'URFDLB') self.fake_555.lt_init() self.fake_555.enable_print_cube = False else: self.fake_555.re_init() return self.fake_555
def lr_centers_555() -> None: filename_nn = "cube.csv" cube = RubiksCube555(solved_555, "URFDLB") cube.cpu_mode = "normal" cube.lt_init() cube.re_init() pt_count = len(cube.lt_LR_centers_stage.prune_tables) BATCH_SIZE = 10 to_write = [] to_write_count = 0 original_state = cube.state[:] with open(filename_nn, "w") as fh_nn: fh_nn.write(",".join([f"PT{x}" for x in range(pt_count)])) fh_nn.write(",COST\n") # solve 10000 random cubes for x in range(10000): cube.state = original_state[:] cube.randomize() cube.solution = [] cube.lt_LR_centers_stage.solve_via_c() logger.info(cube.solve_via_c_output) in_table = False for line in cube.solve_via_c_output.splitlines(): if line.startswith(" === === === === ==="): in_table = True elif in_table: if line: line = line.strip().split() cost_to_goal = line[-2] if cost_to_goal != "0": nn_line = line[1:pt_count + 1] nn_line.append(cost_to_goal) to_write.append(",".join(nn_line)) to_write_count += 1 else: in_table = False break if to_write_count >= BATCH_SIZE: fh_nn.write("\n".join(to_write) + "\n") fh_nn.flush() to_write = [] to_write_count = 0 if to_write_count: fh_nn.write("\n".join(to_write) + "\n") fh_nn.flush() to_write = [] to_write_count = 0
def group_centers_guts(self): self.lt_init() self.group_centers_stage_UD() self.lt_LR_inner_x_centers_stage.solve() log.info("LR inner x-center staged, %d steps in" % self.get_solution_len_minus_rotates(self.solution)) self.lt_LR_oblique_edge_pairing.solve() log.info("LR oblique edges paired, %d steps in" % self.get_solution_len_minus_rotates(self.solution)) log.info("") log.info("") log.info("") log.info("") log.info("") # Reduce the centers to 5x5x5 centers # - solve the UD inner x-centers and pair the UD oblique edges # - solve the LR inner x-centers and pair the LR oblique edges # - solve the FB inner x-centers and pair the FB oblique edges self.lt_UD_solve_inner_x_centers_and_oblique_edges.solve() log.info("UD inner x-center solved, %d steps in" % self.get_solution_len_minus_rotates(self.solution)) self.lt_LR_solve_inner_x_centers_and_oblique_edges.solve() # speed up IDA log.info("LR inner x-center and oblique edges prune table solved, %d steps in" % self.get_solution_len_minus_rotates(self.solution)) self.lt_LFRB_solve_inner_x_centers_and_oblique_edges.solve() log.info("LFRB inner x-center and oblique edges paired, %d steps in" % self.get_solution_len_minus_rotates(self.solution)) self.print_cube() log.info("") log.info("") log.info("") log.info("") log.info("") # At this point the 6x6x6 centers have been reduced to 5x5x5 centers fake_555 = RubiksCube555(solved_5x5x5, 'URFDLB') fake_555.lt_init() self.populate_fake_555_for_ULFRBD(fake_555) fake_555.group_centers_guts() for step in fake_555.solution: self.rotate(step) log.info("Took %d steps to solve centers" % self.get_solution_len_minus_rotates(self.solution))
def get_fake_555(self): if self.fake_555 is None: if self.fake_777 and self.fake_777.fake_555: self.fake_555 = self.fake_777.fake_555 self.fake_555.cpu_mode = self.cpu_mode self.fake_555.re_init() self.fake_555.enable_print_cube = False else: # Because our centers are already solved we get very little benefit # from using the more advanced 555 edge pairing code path...and it # takes much longer to run. For now use the old L4E way it is only # about 1 move longer if the centers are solved but runs 3x faster. self.fake_555 = RubiksCube555(solved_555, "URFDLB") self.fake_555.cpu_mode = self.cpu_mode self.fake_555.lt_init() self.fake_555.enable_print_cube = False else: self.fake_555.re_init() return self.fake_555
def stage_centers_555(cube_count: int, move_count: int, batch_size: int, filename: str) -> None: cube = RubiksCube555(solved_555, "URFDLB") cube.cpu_mode = "normal" cube.lt_init() cube.re_init() original_state = cube.state[:] with open(filename, "w") as fh_nn: # noqa: F841 # fh_nn.write(",".join([f"PT{x}" for x in range(pt_count)])) # fh_nn.write(",COST\n") # scramble CUBE_COUNT cubes up to MOVE_COUNT random moves for x in range(cube_count): cube.state = original_state[:] for y in range(move_count): cube.randomize(count=1) cube.print_cube()
def print_symmetry_swaps(size): order = 'ULFRBD' if size == 2: cube = RubiksCube222(solved_222, 'URFDLB') rotate_xxx = rotate_222 elif size == 3: cube = RubiksCube333(solved_333, 'URFDLB') rotate_xxx = rotate_333 elif size == 4: cube = RubiksCube444(solved_444, 'URFDLB') rotate_xxx = rotate_444 elif size == 5: cube = RubiksCube555(solved_555, 'URFDLB') rotate_xxx = rotate_555 elif size == 6: cube = RubiksCube666(solved_666, 'URFDLB') rotate_xxx = rotate_666 elif size == 7: cube = RubiksCube777(solved_777, 'URFDLB') rotate_xxx = rotate_777 else: assert False for (index, _) in enumerate(cube.state): cube.state[index] = str(index) orig_state = cube.state[:] cube.print_cube() for seq in symmetry_48: cube.state = orig_state[:] seq_str = ' '.join(seq) if seq_str in ("", "x", "x'", "y", "y'", "z", "z'"): continue for step in seq: cube.state = rotate_xxx(cube.state[:], step) print(' "%s" : (%s),' % (' '.join(seq), ', '.join(cube.state)))
from rubikscubennnsolver.RubiksCube444 import RubiksCube444, solved_444 cube = RubiksCube444(args.state, args.order, args.colormap, avoid_pll=True, debug=args.debug) elif size == 5: from rubikscubennnsolver.RubiksCube555 import solved_555 if cpu_mode == "fast": from rubikscubennnsolver.RubiksCube555ForNNN import RubiksCube555ForNNN cube = RubiksCube555ForNNN(args.state, args.order, args.colormap, args.debug) else: from rubikscubennnsolver.RubiksCube555 import RubiksCube555 cube = RubiksCube555(args.state, args.order, args.colormap, args.debug) elif size == 6: from rubikscubennnsolver.RubiksCube666 import RubiksCube666 cube = RubiksCube666(args.state, args.order, args.colormap, args.debug) elif size == 7: from rubikscubennnsolver.RubiksCube777 import RubiksCube777 cube = RubiksCube777(args.state, args.order, args.colormap, args.debug) elif size % 2 == 0: from rubikscubennnsolver.RubiksCubeNNNEven import RubiksCubeNNNEven cube = RubiksCubeNNNEven(args.state, args.order, args.colormap, args.debug) else: from rubikscubennnsolver.RubiksCubeNNNOdd import RubiksCubeNNNOdd cube = RubiksCubeNNNOdd(args.state, args.order, args.colormap, args.debug)
level=logging.INFO, format="%(asctime)s %(filename)20s %(levelname)8s: %(message)s") log = logging.getLogger(__name__) filename = sys.argv[1] with open(filename, "r") as fh: if "2x2x2" in filename: cube = RubiksCube222(solved_222, "URFDLB") elif "3x3x3" in filename: cube = RubiksCube333(solved_333, "URFDLB") elif "4x4x4" in filename: cube = RubiksCube444(solved_444, "URFDLB") elif "5x5x5" in filename: cube = RubiksCube555(solved_555, "URFDLB") elif "6x6x6" in filename: cube = RubiksCube666(solved_666, "URFDLB") elif "7x7x7" in filename: cube = RubiksCube777(solved_777, "URFDLB") else: raise Exception("What size cube?") for line in fh: (state, steps_to_solve) = line.strip().split(":") cube.re_init() cube.nuke_corners() # cube.nuke_edges() # cube.nuke_centers() steps_to_solve = steps_to_solve.split() steps_to_scramble = reverse_steps(steps_to_solve)
def pair_edge_orbit_via_555(self, orbit): log.info("%s: pair_edge_orbit_via_555 for %d" % (self, orbit)) fake_555 = RubiksCube555(solved_555, 'URFDLB') fake_555.lt_init() # Fill in the corners so we can avoid certain types of parity start_555 = 0 start_nnn = 0 for x in range(6): fake_555.state[start_555 + 1] = self.state[start_nnn + 1] fake_555.state[start_555 + 5] = self.state[start_nnn + self.size] fake_555.state[start_555 + 21] = self.state[start_nnn + (self.size * self.size) - self.size + 1] fake_555.state[start_555 + 25] = self.state[start_nnn + (self.size * self.size)] start_nnn += self.size * self.size start_555 += 25 # Fill in the edges start_555 = 0 start_nnn = 0 half_size = int(self.size / 2) max_orbit = int((self.size - 2) / 2) - 1 for x in range(6): row1_col2 = start_nnn + half_size row1_col1 = row1_col2 - (max_orbit - orbit) row1_col3 = row1_col2 + (max_orbit - orbit) + 1 row2_col1 = start_nnn + ((orbit + 1) * self.size) + 1 row2_col3 = row2_col1 + self.size - 1 row3_col1 = start_nnn + (self.size * (half_size - 1)) + 1 row3_col3 = row3_col1 + self.size - 1 row4_col1 = start_nnn + (self.size * self.size) - ( (orbit + 2) * self.size) + 1 row4_col3 = row4_col1 + self.size - 1 row5_col1 = row1_col1 + ((self.size - 1) * self.size) row5_col2 = row1_col2 + ((self.size - 1) * self.size) row5_col3 = row1_col3 + ((self.size - 1) * self.size) log.info("%d row1: %s, %s, %s" % (x, row1_col1, row1_col2, row1_col3)) log.info("%d row2: %s, %s" % (x, row2_col1, row2_col3)) log.info("%d row3: %s, %s" % (x, row3_col1, row3_col3)) log.info("%d row4: %s, %s" % (x, row4_col1, row4_col3)) log.info("%d row5: %s, %s, %s" % (x, row5_col1, row5_col2, row5_col3)) # row1 fake_555.state[start_555 + 2] = self.state[row1_col1] fake_555.state[start_555 + 3] = self.state[row1_col2] fake_555.state[start_555 + 4] = self.state[row1_col3] # row2 fake_555.state[start_555 + 6] = self.state[row2_col1] fake_555.state[start_555 + 10] = self.state[row2_col3] # row3 - The middle of the edge so orbit doesn't matter fake_555.state[start_555 + 11] = self.state[row3_col1] fake_555.state[start_555 + 15] = self.state[row3_col3] # row4 fake_555.state[start_555 + 16] = self.state[row4_col1] fake_555.state[start_555 + 20] = self.state[row4_col3] # row5 fake_555.state[start_555 + 22] = self.state[row5_col1] fake_555.state[start_555 + 23] = self.state[row5_col2] fake_555.state[start_555 + 24] = self.state[row5_col3] start_nnn += self.size * self.size start_555 += 25 fake_555.sanity_check() self.print_cube() fake_555.print_cube() fake_555.avoid_pll = False fake_555.group_edges() wide_str = str(orbit + 2) for step in fake_555.solution: if step == 'EDGES_GROUPED': continue # Rotate the entire cube if step.startswith('5'): step = str(self.size) + step[1:] elif step in ("Uw", "Uw'", "Uw2", "Lw", "Lw'", "Lw2", "Fw", "Fw'", "Fw2", "Rw", "Rw'", "Rw2", "Bw", "Bw'", "Bw2", "Dw", "Dw'", "Dw2"): step = wide_str + step self.rotate(step)
if args.size != 'all' and size != args.size: continue # solve the cube if size == '2x2x2': cube = RubiksCube222(solved_222, order) elif size == '3x3x3': cube = RubiksCube333(solved_333, order) elif size == '4x4x4': cube = RubiksCube444(solved_444, order) elif size == '5x5x5': cube = RubiksCube555(solved_555, order) elif size == '6x6x6': cube = RubiksCube666(solved_666, order) elif size == '7x7x7': cube = RubiksCube777(solved_777, order) elif size == '8x8x8': cube = RubiksCubeNNNEven(solved_888, order) elif size == '9x9x9': cube = RubiksCubeNNNOdd(solved_999, order) elif size == '10x10x10': cube = RubiksCubeNNNEven(solved_101010, order)
logging.basicConfig( level=logging.INFO, format='%(asctime)s %(filename)20s %(levelname)8s: %(message)s') log = logging.getLogger(__name__) # Color the errors and warnings in red logging.addLevelName( logging.ERROR, "\033[91m %s\033[0m" % logging.getLevelName(logging.ERROR)) logging.addLevelName( logging.WARNING, "\033[91m %s\033[0m" % logging.getLevelName(logging.WARNING)) filename = sys.argv[1] with open(filename, "r") as fh: cube = RubiksCube555(solved_555, 'URFDLB') for line in fh: (state, steps_to_solve) = line.strip().split(":") cube.re_init() cube.nuke_corners() #cube.nuke_edges() cube.nuke_centers() steps_to_solve = steps_to_solve.split() steps_to_scramble = reverse_steps(steps_to_solve) for step in steps_to_scramble: cube.rotate(step) cube.print_cube() log.info("steps_to_scramble %s" % " ".join(steps_to_scramble)) log.info("steps_to_solve %s\n\n" % " ".join(steps_to_solve))
def pair_edge_orbit_via_555(self, orbit): log.warning("pair_edge_orbit_via_555 for %d" % orbit) fake_555 = RubiksCube555(solved_5x5x5, 'URFDLB') fake_555.lt_init() # The corners don't matter but it does make troubleshooting easier if they match start_index = 0 fake_555.state[1] = self.state[start_index+1] fake_555.state[5] = self.state[start_index + self.size] fake_555.state[21] = self.state[start_index + (self.size * self.size) - self.size + 1] fake_555.state[25] = self.state[start_index + (self.size * self.size)] start_index += self.size * self.size fake_555.state[26] = self.state[start_index+1] fake_555.state[30] = self.state[start_index + self.size] fake_555.state[46] = self.state[start_index + (self.size * self.size) - self.size + 1] fake_555.state[50] = self.state[start_index + (self.size * self.size)] start_index += self.size * self.size fake_555.state[51] = self.state[start_index+1] fake_555.state[55] = self.state[start_index + self.size] fake_555.state[71] = self.state[start_index + (self.size * self.size) - self.size + 1] fake_555.state[75] = self.state[start_index + (self.size * self.size)] start_index += self.size * self.size fake_555.state[76] = self.state[start_index+1] fake_555.state[80] = self.state[start_index + self.size] fake_555.state[96] = self.state[start_index + (self.size * self.size) - self.size + 1] fake_555.state[100] = self.state[start_index + (self.size * self.size)] start_index += self.size * self.size fake_555.state[101] = self.state[start_index+1] fake_555.state[105] = self.state[start_index + self.size] fake_555.state[121] = self.state[start_index + (self.size * self.size) - self.size + 1] fake_555.state[125] = self.state[start_index + (self.size * self.size)] start_index += self.size * self.size fake_555.state[126] = self.state[start_index+1] fake_555.state[130] = self.state[start_index + self.size] fake_555.state[146] = self.state[start_index + (self.size * self.size) - self.size + 1] fake_555.state[150] = self.state[start_index + (self.size * self.size)] start_index += self.size * self.size half_size = int(self.size/2) # Upper start_index = 0 fake_555.state[2] = self.state[start_index + orbit + 1] fake_555.state[3] = self.state[start_index + half_size] fake_555.state[4] = self.state[start_index + self.size - orbit] fake_555.state[6] = self.state[start_index + (orbit * self.size) + 1] fake_555.state[10] = self.state[start_index + (orbit * self.size) + self.size] # The middle of the edge so orbit doesn't matter fake_555.state[11] = self.state[start_index + (self.size * (half_size - 1)) + 1] fake_555.state[15] = self.state[start_index + (self.size * half_size)] fake_555.state[16] = self.state[start_index + (self.size * self.size) - (orbit * self.size) - self.size + 1] fake_555.state[20] = self.state[start_index + (self.size * self.size) - (orbit * self.size)] fake_555.state[22] = self.state[start_index + (self.size * self.size) - self.size + 1 + orbit] fake_555.state[23] = self.state[start_index + (self.size * self.size) - half_size] fake_555.state[24] = self.state[start_index + (self.size * self.size) - orbit] start_index += self.size * self.size # Left fake_555.state[27] = self.state[start_index + orbit + 1] fake_555.state[28] = self.state[start_index + half_size] fake_555.state[29] = self.state[start_index + self.size - orbit] fake_555.state[31] = self.state[start_index + (orbit * self.size) + 1] fake_555.state[35] = self.state[start_index + (orbit * self.size) + self.size] # The middle of the edge so orbit doesn't matter fake_555.state[36] = self.state[start_index + (self.size * (half_size - 1)) + 1] fake_555.state[40] = self.state[start_index + (self.size * half_size)] fake_555.state[41] = self.state[start_index + (self.size * self.size) - (orbit * self.size) - self.size + 1] fake_555.state[45] = self.state[start_index + (self.size * self.size) - (orbit * self.size)] fake_555.state[47] = self.state[start_index + (self.size * self.size) - self.size + 1 + orbit] fake_555.state[48] = self.state[start_index + (self.size * self.size) - half_size] fake_555.state[49] = self.state[start_index + (self.size * self.size) - orbit] start_index += self.size * self.size # Front fake_555.state[52] = self.state[start_index + orbit + 1] fake_555.state[53] = self.state[start_index + half_size] fake_555.state[54] = self.state[start_index + self.size - orbit] fake_555.state[56] = self.state[start_index + (orbit * self.size) + 1] fake_555.state[60] = self.state[start_index + (orbit * self.size) + self.size] # The middle of the edge so orbit doesn't matter fake_555.state[61] = self.state[start_index + (self.size * (half_size - 1)) + 1] fake_555.state[65] = self.state[start_index + (self.size * half_size)] fake_555.state[66] = self.state[start_index + (self.size * self.size) - (orbit * self.size) - self.size + 1] fake_555.state[70] = self.state[start_index + (self.size * self.size) - (orbit * self.size)] fake_555.state[72] = self.state[start_index + (self.size * self.size) - self.size + 1 + orbit] fake_555.state[73] = self.state[start_index + (self.size * self.size) - half_size] fake_555.state[74] = self.state[start_index + (self.size * self.size) - orbit] start_index += self.size * self.size # Right fake_555.state[77] = self.state[start_index + orbit + 1] fake_555.state[78] = self.state[start_index + half_size] fake_555.state[79] = self.state[start_index + self.size - orbit] fake_555.state[81] = self.state[start_index + (orbit * self.size) + 1] fake_555.state[85] = self.state[start_index + (orbit * self.size) + self.size] # The middle of the edge so orbit doesn't matter fake_555.state[86] = self.state[start_index + (self.size * (half_size - 1)) + 1] fake_555.state[90] = self.state[start_index + (self.size * half_size)] fake_555.state[91] = self.state[start_index + (self.size * self.size) - (orbit * self.size) - self.size + 1] fake_555.state[95] = self.state[start_index + (self.size * self.size) - (orbit * self.size)] fake_555.state[97] = self.state[start_index + (self.size * self.size) - self.size + 1 + orbit] fake_555.state[98] = self.state[start_index + (self.size * self.size) - half_size] fake_555.state[99] = self.state[start_index + (self.size * self.size) - orbit] start_index += self.size * self.size # Back fake_555.state[102] = self.state[start_index + orbit + 1] fake_555.state[103] = self.state[start_index + half_size] fake_555.state[104] = self.state[start_index + self.size - orbit] fake_555.state[106] = self.state[start_index + (orbit * self.size) + 1] fake_555.state[110] = self.state[start_index + (orbit * self.size) + self.size] # The middle of the edge so orbit doesn't matter fake_555.state[111] = self.state[start_index + (self.size * (half_size - 1)) + 1] fake_555.state[115] = self.state[start_index + (self.size * half_size)] fake_555.state[116] = self.state[start_index + (self.size * self.size) - (orbit * self.size) - self.size + 1] fake_555.state[120] = self.state[start_index + (self.size * self.size) - (orbit * self.size)] fake_555.state[122] = self.state[start_index + (self.size * self.size) - self.size + 1 + orbit] fake_555.state[123] = self.state[start_index + (self.size * self.size) - half_size] fake_555.state[124] = self.state[start_index + (self.size * self.size) - orbit] start_index += self.size * self.size # Down fake_555.state[127] = self.state[start_index + orbit + 1] fake_555.state[128] = self.state[start_index + half_size] fake_555.state[129] = self.state[start_index + self.size - orbit] fake_555.state[131] = self.state[start_index + (orbit * self.size) + 1] fake_555.state[135] = self.state[start_index + (orbit * self.size) + self.size] # The middle of the edge so orbit doesn't matter fake_555.state[136] = self.state[start_index + (self.size * (half_size - 1)) + 1] fake_555.state[140] = self.state[start_index + (self.size * half_size)] fake_555.state[141] = self.state[start_index + (self.size * self.size) - (orbit * self.size) - self.size + 1] fake_555.state[145] = self.state[start_index + (self.size * self.size) - (orbit * self.size)] fake_555.state[147] = self.state[start_index + (self.size * self.size) - self.size + 1 + orbit] fake_555.state[148] = self.state[start_index + (self.size * self.size) - half_size] fake_555.state[149] = self.state[start_index + (self.size * self.size) - orbit] start_index += self.size * self.size self.print_cube() fake_555.print_cube() fake_555.avoid_pll = False fake_555.group_edges() # dwalton wide_str = str(orbit + 1) for step in fake_555.solution: if step == 'EDGES_GROUPED': continue # Rotate the entire cube if step.startswith('5'): step = str(self.size) + step[1:] elif step in ("Uw", "Uw'", "Uw2", "Lw", "Lw'", "Lw2", "Fw", "Fw'", "Fw2", "Rw", "Rw'", "Rw2", "Bw", "Bw'", "Bw2", "Dw", "Dw'", "Dw2"): step = wide_str + step #log.warning("fake_555 step %s" % step) self.rotate(step)
def pair_outside_edges_via_555(self): fake_555 = RubiksCube555(solved_5x5x5, 'URFDLB') fake_555.lt_init() # The corners matter for avoiding PLL fake_555.state[1] = self.state[1] fake_555.state[5] = self.state[6] fake_555.state[21] = self.state[31] fake_555.state[25] = self.state[36] fake_555.state[26] = self.state[37] fake_555.state[30] = self.state[42] fake_555.state[46] = self.state[67] fake_555.state[50] = self.state[72] fake_555.state[51] = self.state[73] fake_555.state[55] = self.state[78] fake_555.state[71] = self.state[103] fake_555.state[75] = self.state[108] fake_555.state[76] = self.state[109] fake_555.state[80] = self.state[114] fake_555.state[96] = self.state[139] fake_555.state[100] = self.state[144] fake_555.state[101] = self.state[145] fake_555.state[105] = self.state[150] fake_555.state[121] = self.state[175] fake_555.state[125] = self.state[180] fake_555.state[126] = self.state[181] fake_555.state[130] = self.state[186] fake_555.state[146] = self.state[211] fake_555.state[150] = self.state[216] # Upper fake_555.state[2] = self.state[2] fake_555.state[3] = self.state[3] fake_555.state[4] = self.state[5] fake_555.state[6] = self.state[7] fake_555.state[10] = self.state[12] fake_555.state[11] = self.state[13] fake_555.state[15] = self.state[18] fake_555.state[16] = self.state[25] fake_555.state[20] = self.state[30] fake_555.state[22] = self.state[32] fake_555.state[23] = self.state[33] fake_555.state[24] = self.state[35] # Left fake_555.state[27] = self.state[38] fake_555.state[28] = self.state[39] fake_555.state[29] = self.state[41] fake_555.state[31] = self.state[43] fake_555.state[35] = self.state[48] fake_555.state[36] = self.state[49] fake_555.state[40] = self.state[54] fake_555.state[41] = self.state[61] fake_555.state[45] = self.state[66] fake_555.state[47] = self.state[68] fake_555.state[48] = self.state[69] fake_555.state[49] = self.state[71] # Front fake_555.state[52] = self.state[74] fake_555.state[53] = self.state[75] fake_555.state[54] = self.state[77] fake_555.state[56] = self.state[79] fake_555.state[60] = self.state[84] fake_555.state[61] = self.state[85] fake_555.state[65] = self.state[90] fake_555.state[66] = self.state[97] fake_555.state[70] = self.state[102] fake_555.state[72] = self.state[104] fake_555.state[73] = self.state[105] fake_555.state[74] = self.state[107] # Right fake_555.state[77] = self.state[110] fake_555.state[78] = self.state[111] fake_555.state[79] = self.state[113] fake_555.state[81] = self.state[115] fake_555.state[85] = self.state[120] fake_555.state[86] = self.state[121] fake_555.state[90] = self.state[126] fake_555.state[91] = self.state[133] fake_555.state[95] = self.state[138] fake_555.state[97] = self.state[140] fake_555.state[98] = self.state[141] fake_555.state[99] = self.state[143] # Back fake_555.state[102] = self.state[146] fake_555.state[103] = self.state[147] fake_555.state[104] = self.state[149] fake_555.state[106] = self.state[151] fake_555.state[110] = self.state[156] fake_555.state[111] = self.state[157] fake_555.state[115] = self.state[162] fake_555.state[116] = self.state[169] fake_555.state[120] = self.state[174] fake_555.state[122] = self.state[176] fake_555.state[123] = self.state[177] fake_555.state[124] = self.state[179] # Down fake_555.state[127] = self.state[182] fake_555.state[128] = self.state[183] fake_555.state[129] = self.state[185] fake_555.state[131] = self.state[187] fake_555.state[135] = self.state[192] fake_555.state[136] = self.state[193] fake_555.state[140] = self.state[198] fake_555.state[141] = self.state[205] fake_555.state[145] = self.state[210] fake_555.state[147] = self.state[212] fake_555.state[148] = self.state[213] fake_555.state[149] = self.state[215] #self.print_cube() #fake_555.print_cube() fake_555.avoid_pll = True fake_555.group_edges() for step in fake_555.solution: if step == 'EDGES_GROUPED': continue if step.startswith('5'): step = '6' + step[1:] elif step.startswith('3'): step = '4' + step[1:] self.rotate(step) log.info("Outside edges are paired, %d steps in" % self.get_solution_len_minus_rotates(self.solution))
def getResults(state): if sys.version_info < (3, 4): raise SystemError("Must be using Python 3.4 or higher") logging.basicConfig( level=logging.INFO, format="%(asctime)s %(filename)22s %(levelname)8s: %(message)s") log = logging.getLogger(__name__) log.info("rubiks-cube-solver.py begin") start_time = dt.datetime.now() parser = argparse.ArgumentParser() parser.add_argument("--print-steps", default=False, action="store_true", help="Display animated step-by-step solution") parser.add_argument("--debug", default=False, action="store_true", help="set loglevel to DEBUG") parser.add_argument("--no-comments", default=False, action="store_true", help="No comments in alg.cubing.net url") # CPU mode parser.add_argument( "--min-memory", default=False, action="store_true", help="Load smaller tables to use less memory...takes longer to run", ) parser.add_argument("--fast", default=True, action="store_true", help="Find a solution quickly") parser.add_argument("--normal", default=False, action="store_true", help="Find a shorter solution but takes longer") parser.add_argument("--slow", default=False, action="store_true", help="Find shortest solution we can, takes a while") action = parser.add_mutually_exclusive_group(required=False) parser.add_argument("--openwith", default=None, type=str, help="Colors for sides U, L, etc") parser.add_argument("--colormap", default=None, type=str, help="Colors for sides U, L, etc") parser.add_argument( "--order", type=str, default="URFDLB", help="order of sides in --state, default kociemba URFDLB") parser.add_argument("--solution333", type=str, default=None, help="cube explorer optimal steps for solving 3x3x3") parser.add_argument( "--state", type=str, help="Cube state", # no longer used # parser.add_argument('--test', default=False, action='store_true') # 2x2x2 # default='DLRRFULLDUBFDURDBFBRBLFU') # default='UUUURRRRFFFFDDDDLLLLBBBB') # 3x3x3 # default='RRBBUFBFBRLRRRFRDDURUBFBBRFLUDUDFLLFFLLLLDFBDDDUUBDLUU') # default='UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB') # solved # 4x4x4 # default='DRFDFRUFDURDDLLUFLDLLBLULFBUUFRBLBFLLUDDUFRBURBBRBDLLDURFFBBRUFUFDRFURBUDLDBDUFFBUDRRLDRBLFBRRLB') # xyzzy test cube # default='FLDFDLBDFBLFFRRBDRFRRURBRDUBBDLURUDRRBFFBDLUBLUULUFRRFBLDDUULBDBDFLDBLUBFRFUFBDDUBFLLRFLURDULLRU') # TPR cube # default="BRBLLLBRDLBBDDRRFUDFUDUDFUDDDRURBBBUUDRLFRDLLFBRFLRFLFFFBRULDRUBUBBLDBFRDLLUBUDDULFLRRFLFUBFUFUR", ) # default='UUUUUUUUUUUUUUUURRRRRRRRRRRRRRRRFFFFFFFFFFFFFFFFDDDDDDDDDDDDDDDDLLLLLLLLLLLLLLLLBBBBBBBBBBBBBBBB') # solved # 5x5x5 # default='RFFFUDUDURBFULULFDBLRLDUFDBLUBBBDDURLRDRFRUDDBFUFLFURRLDFRRRUBFUUDUFLLBLBBULDDRRUFUUUBUDFFDRFLRBBLRFDLLUUBBRFRFRLLBFRLBRRFRBDLLDDFBLRDLFBBBLBLBDUUFDDD') # https://www.speedsolving.com/forum/threads/arnauds-5x5x5-edge-pairing-method-examples.1447/ # default='LDFRDDUUUUFUUUBLUUUFLDFDRFDDFBBRRRULRRRBFRRRURFRFDUBDRUBFFFUBFFFUUFFFRLDLRFDLBDDLDDDRDDDDUDDDDUULDLFBFLFFULLLRFLLLRLLLLRRBLBBRBULULBBBRUBBBRBBBBULBRFB') # default='UDLFDLDDLUFDUBRLBDLFLRBFRBLBBFUDURDULRRBRLFUURBUFLUBDUDRURRRBUFUFFFRUFFLDUURURFFULFFRLFDBRRFRDDBRFBBLBRDFBBBBUDDLLLDBUULUDULDLDDLBRRLRLUBBFFBDLFBDDLFR') # default='UUUUUUUUUUUUUUUUUUUUUUUUURRRRRRRRRRRRRRRRRRRRRRRRRFFFFFFFFFFFFFFFFFFFFFFFFFDDDDDDDDDDDDDDDDDDDDDDDDDLLLLLLLLLLLLLLLLLLLLLLLLLBBBBBBBBBBBBBBBBBBBBBBBBB') # solved # default='DFFURRULDLDLURLBDDRRBFRURFBFBFRBDLBBFRBLRFBRBBFLULDLBLULLFRUBUFLDFFLDULDDLUURRDRFBRLULUDRBDUUUBBRFFDBDFURDBBDDRULBUDRDLLLBDRFDLRDLLFDBBUFBRURFFUFFUUFU') # step10 takes 2s # default='URUBFUUFRDFFUUFLRDBLLBDDDLUULRDLDUBDLRBBLFLBRBFUUBBRBFFUDLFLLBFUFUDRLBFUBBURRLLRUFRDUFFDFRFUBRBBDRFRFLLFURLLFBRBLUDRDDRRDRRFDUDLFLDLUUDUDBRBBBRBDDLDFL') # step10 takes 9s # default='RFUBLFUBRULLUDDRLRLLFFFLUBDBLBFFUFLFURBFFLDDLFFBBRLUUDRRDLLLRDFFLBBLFURUBULBRLBDRUURDRRDFURDBUUBBFBUDRUBURBRBDLFLBDFBDULLDBBDDDRRFURLDUDUBRDFRFFDFDRLU') # step10 takes 6s, centers take 37 steps :( # 6x6x6 # default='FBDDDFFUDRFBBLFLLURLDLLUFBLRFDUFLBLLFBFLRRBBFDRRDUBUFRBUBRDLUBFDRLBBRLRUFLBRBDUDFFFDBLUDBBLRDFUUDLBBBRRDRUDLBLDFRUDLLFFUUBFBUUFDLRUDUDBRRBBUFFDRRRDBULRRURULFDBRRULDDRUUULBLLFDFRRFDURFFLDUUBRUFDRFUBLDFULFBFDDUDLBLLRBL') # default='UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUURRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB') # solved # defult='xxxxxxxDRRLxxLDDBxxLUUDxxFRDUxxxxxxxxxxxxxxBBLBxxURFUxxDRBDxxDFDLxxxxxxxxxxxxxxULLRxxUFLLxxBLFRxxBBRDxxxxxxxxxxxxxxLFBRxxBUUFxxFDDFxxURUFxxxxxxxxxxxxxxRFDLxxURFUxxUBBFxxRULDxxxxxxxxxxxxxxBBLFxxFLLRxxDRBBxxFDRUxxxxxxx') # good step20 IDA test # 7x7x7 # default='DBDBDDFBDDLUBDLFRFRBRLLDUFFDUFRBRDFDRUFDFDRDBDBULDBDBDBUFBUFFFULLFLDURRBBRRBRLFUUUDUURBRDUUURFFFLRFLRLDLBUFRLDLDFLLFBDFUFRFFUUUFURDRFULBRFURRBUDDRBDLLRLDLLDLUURFRFBUBURBRUDBDDLRBULBULUBDBBUDRBLFFBLRBURRUFULBRLFDUFDDBULBRLBUFULUDDLLDFRDRDBBFBUBBFLFFRRUFFRLRRDRULLLFRLFULBLLBBBLDFDBRBFDULLULRFDBR') # 8x8x8 # default='DRRRURBDDBFBRBDDBRRDUFLLURFBFLFURLFLFRBRFUBDRFDFUUBLFFFUULBBFDBDFBUBBFRFLRDLFDRBBLLFRLDFDRBURULDDRFFBFUUBLLFBRUUFDUBRDBBRDFLURUUFFUDLBRRFDUBFLRUUFFRLBFRFLRULUDFRUBBDBFFLBBDFDFLDBFRRRDDLFLBRBFBBRULDDUUBLBBURULLDDLDRUDRBUDRLUULDURLRDFLFULUFLFULRDDDUBBULRBRDFBBLFURRLULUBDDULRFBRFURBRLBRUBULBDDFBUFFBBRLRUUUFRULLBFFRFDDFFDULLDLBUDLLLLUUBBLDLLBBULULBDUDDFUBFLLDLDLFRDUDDBRRFRURRFRRLDDDDRD') # 9x9x9 # default='RFBLRUFLLFFLRRBDUDDBBBDUDFRUDUFFFBBFRBRDURBULFUDDFLLLDLFLRDLDBBBUUBRDBBBDFUFRUURULURBURDLFDUBFFDRDFRUBDUBRFLRRLUDLRLFBLBRRLLRDRBRBLURBLLRFRLDDFFFRBFUFURDFRRUDUFDDRRRLFLLUBBLBFDRRDLBRLUUBRDBBUBFLUUFBLLDBFFFBUFBFDBRDDDFLRFFBFFFLFRRDUUDDBUBLUUDURRBDBFFLFURDDLUBULUULULBFBRUBLLDDFLRBDBRFDUUDFURLLUBUFBLULLURDLLLBLFFRLLBLUDRLRDBLDDBRBUDRBLLRDUUUBRRFBFBBULUDUDLDRFUDDDFULRFRBDUDULBRRDBDFFRUUFRRFBDBLFBBDFURLRFDUUFRLUBURFURDDFLDFUBDFRRURRDLUDRBRBDLBFLBBRDLRDBFDUBDFFUBLFLUULLBUDLLLURDBLFFFDFLF' # 10x10x10 # default='ULBDLDBUFRBBBBBLBFFFDFRFBBDDFDFRFFLDLDLURRBUDRRBFLUDFRLBDURULRUUDBBBUBRURRRLDLRFFUFFFURRFBLLRRFLFUDBDRRDFULLLURFBFUUBDBBDBFLFDFUUFDUBRLUFDBLRFLUDUFBFDULDFRUBLBBBUBRRDBDDDDFURFLRDBRRLLRFUFLRDFDUULRRDULFDUDRFLBFRLDUDBDFLDBDUFULULLLBUUFDFFDBBBRBRLFLUFLFUFFRLLLFLBUDRRFDDUDLFLBRDULFLBLLULFLDLUULBUDRDFLUDDLLRBLUBBRFRRLDRDUUFLDDFUFLBDBBLBURBBRRRFUBLBRBRUBFFDBBBBLBUFBLURBLDRFLFBUDDFFRFFRLBDBDUURBUFBDFFFLFBDLDUFFBRDLBRLRLBFRUUUULRRBDBRRFDLLRRUUBDBDBFDLRDDBRUUUUUBLLURBDFUFLLRDBLRRBBLBDDBBFUDUDLDLUFDDDUURBFUFRRBLLURDDRURRURLBLDRFRUFBDRULUFFDUDLBBUURFDUDBLRRUDFRLLDULFUBFDLURFBFULFLRRRRRFDDDLFDDRUFRRLBLUBU') # 14x14x14 # default='FBDRLBLRRURRLDRBDLBURDFDDDRBLBBFBRDLLFDUBLFRLDFUUBFRDBFBBBULFRLBUFLBDDDLLDRBFLLBBLFBFFDFBFDDFRRRBDRRBRBDUFDRLRUDLDFDDURFLBUBBUUDLBRRDUDRDBBBLDBRBBBUFLBLRUURBDDLDRLUFFBLFRLDFBRFLDLBULFFBRLDBDDFLLRFLUBFDFBRLRLFDBLBURLBLFRFBLLDULUDURLBUUULLRRLUBDDLURLLRFURFRFRBDDUBLDFBLUDRLRDRRBLFUFRDUFFRULBLRBBRUFDBUBBBBLDBRBLDDRRFDDBFFUUBRBLFUBBRFUURBFDRLURLRBFUUFUBRUDRBDFBBFURFLFFDRDFUFFULFLUBDFUFFDLRRFRUDUDLBBBDLLLDUFUDRFDBLRRFFLRUFDRFURDLRRDRDLFBRLRLULRFBDLFDRLFRDDFLLDBFBUBBRLLDLFURFRFULUBLUBFLFFBFDFBDUUBURUUUBFUBDLLFLUUUFDUDLUUULDLLUDDBUFRDRULRLLULRULFBLUDFURFLFUBDLLFLFUBUUBBUFLUDUBRDBLFFUUUFDRLRULUDDRLRBLRUUFBRRRRULBDLFBFLDLRDFUBLUBRDDFUULFLDLUBFURRURUBDFFFDLRFFLBRFRDRUDUULURULLDFRBUDRDLFUFULDBLUBFRFBURDLLUUFDURLRDBLFFRFDBFURLFUBLUUUFFRULUBURRURFDDBFUFRBURBBDRFUDDFDLRUURFBBDBDRLUBRRBFDFRDFDLRDUFFUBRRBDBBLDLFDUDDRLFRRRBUUUBRFUFBUFFBRRDRDDBBDRUULDRFRFBUFLFFBLRBFLLLRUDFDRUDLDRLFRLUFLUBRDUFDDLLUDDRBUBBBDRDBBFRBDDRRLRRUUBBUDUDBLDBDFLFRFUBFLFDBBLRLULDBRFBRRLUUURDFFFDBLDUDBRFDDFFUBLUUURBBULFUFUDFBRDLLFURBULULBUDLUFFBDRBRRDBUUULFDURRDFDDLUDBDRBFBUFLULURUFDRFRFBBFBBBDRLBLUDLDRDLLDRRLLDLFBRBRLDUFBDDUDBLDFRFBBBDRDRDDLDRULFFLLFLBLDFLURLBUDFBDLRBLFDFLUDDFUBUBLURBBBLFRLFLBDDBURFFBFRRL') # 15x15x15 # default='RLURLURBDDULFUUURFLRBLURUBFDBULFLUBBFLDUFBDRFRBRUDFULFRUFLUDFRLFDFLLFDBULURRLBFBUURDULFDFBLRRRLFULLFFFDUULRRRUUUUFDBLDDFFLRDLLUURUBBULUFFURBRRLBBUUBBFDRRBRBRLUDLUDRBFBFULLRRBBFBFRDDDLDDDFRFUFLURUFLBDLUBRLDFRRDBDBFLFUDFLDFFURLFULLDDRURRDLRFLDFLULUUDDRFDRBLRBRBFUFDBDUUDBRRBDFBLBLRBBLBFLLDUBFFFFBDDRLBBBRFDFFUBBDURFLUUDDDRDDLDBRLBULLFLFBRBRBLUDDLRDRDUDFLFRUFLDLBLURDDDRUFDLBRDRLFBDBLDRFBFFBURULUDRRBRDFRFFLULLUBRDRRRDUFRBLFULUBBUFFBRBBFRLFDRRDBLDFRDRDDRLRUULBDURDURFDDLFDUUDBFLBDUFBULFRRDUDUBFBUDBBFUDFUUDLUDDRFDDDFRRRBUDRBFBBULLUFBLRLFLLBRRRRUBDRFLFDFDBLRFLURULULFFBUUUUFDBBLDLUBBRUBBBRBFLULLBLUUULLUBFFDULDFFBFFFUFFDUDRFBUFLDDLURFLRFLRFBUUBLRFDDRULUUUFFRDDBLRDULFURUDDBDLBBUUBFURFRFBRLBUULBLDDDBUBRFFULLUDFFDLDFUBLLBLDFFDDLBDUFUFFLBBBUBULDDFBRRFFLDUDDFRBLRRDDUDLBDBLURBUDBRRLUBBDRFBUFRDRDRBBDULBUFFDRBBDFBUULFFRLLDURRRDFFUUFULDULURLDLUUUDLBBUDLDRFBDBBDLUFBRRFDFLLDLFDBRBBRFUDDDBURDRBUBRUBDUBLDLLDLURLDFDBRUBDLDFRRRBRLULFRFLDRLBUBRUBLFBFDFFLFRFDFLBRULLRBLDRBBFURRRDUUULLULLDLBLBBDFBUUUBRRUFFBRUDBFRDFDLFLFFRFFFFRULDFFDFRUBBBRURBUFLBDFBBBBBRRRLFLFBDRRUFLURDDLRRBRLLFURRURBRFLLLFFURBFULFRFFBLDUUUUBDDUFFDRBRLDDFRBULDDDFFRURUFLDRFLDFBLRUFFUBBDFFDBLLDBDUBDLDLUDFBFLRULRRBDBLRBLDLUURRLLRULDBLBLLRRFDDRBBRBUBDDULDRFBFBBFLUFBLUULDDFDBRLLUBUBBDFBBLBBUBLULDRUDBLRULDUDLUFRRDLLUDDBUFLFLBUFUURFDRDLBURLLRRRULRBFFRRBRFBUBRBUUFRLRDRDLBBRFLLLDDBRFUFRBULFLFDRDDRRDBF') args = parser.parse_args() args.state = state if "G" in args.state: args.state = args.state.replace("G", "F") args.state = args.state.replace("Y", "D") args.state = args.state.replace("O", "L") args.state = args.state.replace("W", "U") if args.debug: log.setLevel(logging.DEBUG) try: size = int(sqrt((len(args.state) / 6))) if args.slow: cpu_mode = "slow" elif args.normal: cpu_mode = "normal" elif args.fast: cpu_mode = "fast" else: raise Exception("What CPU mode to use?") if size == 2: # rubiks cube libraries from rubikscubennnsolver.RubiksCube222 import RubiksCube222 cube = RubiksCube222(args.state, args.order, args.colormap, args.debug) elif size == 3: # rubiks cube libraries from rubikscubennnsolver.RubiksCube333 import RubiksCube333 cube = RubiksCube333(args.state, args.order, args.colormap, args.debug) elif size == 4: # rubiks cube libraries from rubikscubennnsolver.RubiksCube444 import RubiksCube444 cube = RubiksCube444(args.state, args.order, args.colormap, avoid_pll=True, debug=args.debug) elif size == 5: # rubiks cube libraries from rubikscubennnsolver.RubiksCube555 import RubiksCube555 cube = RubiksCube555(args.state, args.order, args.colormap, args.debug) elif size == 6: # rubiks cube libraries from rubikscubennnsolver.RubiksCube666 import RubiksCube666 cube = RubiksCube666(args.state, args.order, args.colormap, args.debug) elif size == 7: # rubiks cube libraries from rubikscubennnsolver.RubiksCube777 import RubiksCube777 cube = RubiksCube777(args.state, args.order, args.colormap, args.debug) elif size % 2 == 0: # rubiks cube libraries from rubikscubennnsolver.RubiksCubeNNNEven import RubiksCubeNNNEven cube = RubiksCubeNNNEven(args.state, args.order, args.colormap, args.debug) else: # rubiks cube libraries from rubikscubennnsolver.RubiksCubeNNNOdd import RubiksCubeNNNOdd cube = RubiksCubeNNNOdd(args.state, args.order, args.colormap, args.debug) if args.openwith: cube.print_cube() for step in args.openwith.split(): cube.rotate(step) cube.cpu_mode = cpu_mode log.info("CPU mode %s" % cube.cpu_mode) cube.sanity_check() cube.print_cube() cube.www_header() cube.www_write_cube("Initial Cube") try: if args.solution333: solution333 = reverse_steps(args.solution333.split()) else: solution333 = [] cube.solve(solution333) except NotSolving: if cube.heuristic_stats: log.info("%s: heuristic_stats raw\n%s\n\n" % (cube, pformat(cube.heuristic_stats))) for (key, value) in cube.heuristic_stats.items(): cube.heuristic_stats[key] = int(median(value)) log.info("%s: heuristic_stats median\n%s\n\n" % (cube, pformat(cube.heuristic_stats))) sys.exit(0) else: raise end_time = dt.datetime.now() log.info("Final Cube") cube.print_cube() res = cube.print_solution(not args.no_comments) log.info( "*********************************************************************************" ) log.info( "See /tmp/rubiks-cube-NxNxN-solver/index.html for more detailed solve instructions" ) log.info( "*********************************************************************************\n" ) # Now put the cube back in its initial state and verify the solution solves it solution = cube.solution cube.re_init() len_steps = len(solution) for (i, step) in enumerate(solution): if args.print_steps: print(("Phase : %s" % cube.phase())) print(("Move %d/%d: %s" % (i + 1, len_steps, step))) cube.rotate(step) www_desc = "Phase: %s<br>\nCube After Move %d/%d: %s<br>\n" % ( cube.phase(), i + 1, len_steps, step) cube.www_write_cube(www_desc) if args.print_steps: cube.print_cube() print("\n\n\n\n") cube.www_footer() if args.print_steps: cube.print_cube() if args.min_memory: print("\n\n****************************************") print("--min-memory has been replaced by --fast") print("****************************************\n\n") log.info("rubiks-cube-solver.py end") log.info("Memory : {:,} bytes".format( resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)) log.info("Time : %s" % (end_time - start_time)) log.info("") success = True if not cube.solved(): kociemba_string = cube.get_kociemba_string(False) # edge_swap_count = cube.get_edge_swap_count(edges_paired=True, orbit=None, debug=True) # corner_swap_count = cube.get_corner_swap_count(debug=True) # raise SolveError("cube should be solved but is not, edge parity %d, corner parity %d, kociemba %s" % # (edge_swap_count, corner_swap_count, kociemba_string)) raise SolveError("cube should be solved but is not") except (ImplementThis, SolveError, StuckInALoop, NoSteps, KeyError, NoPruneTableState, InvalidCubeReduction): cube.enable_print_cube = True cube.print_cube_layout() cube.print_cube() res = cube.print_solution(False) success = True print((cube.get_kociemba_string(True))) log.info("rubiks-cube-solver.py end") raise return res, success
logging.basicConfig( level=logging.INFO, format='%(asctime)s %(filename)17s %(levelname)8s: %(message)s') log = logging.getLogger(__name__) # Color the errors and warnings in red logging.addLevelName( logging.ERROR, "\033[91m %s\033[0m" % logging.getLevelName(logging.ERROR)) logging.addLevelName( logging.WARNING, "\033[91m %s\033[0m" % logging.getLevelName(logging.WARNING)) cube = RubiksCube555( 'DFFURRULDLDLURLBDDRRBFRURFBFBFRBDLBBFRBLRFBRBBFLULDLBLULLFRUBUFLDFFLDULDDLUURRDRFBRLULUDRBDUUUBBRFFDBDFURDBBDDRULBUDRDLLLBDRFDLRDLLFDBBUFBRURFFUFFUUFU' ) lt = LookupTable(cube, 'lookup-table-5x5x5-step10-UD-centers-stage.txt', 'UD-centers-stage', '3fe000000001ff', True, moves_5x5x5) # should not find this one with open(lt.filename, 'r') as fh: print(lt.file_binary_search(fh, '0206f462228611')) # should find this one with open(lt.filename, 'r') as fh: print(lt.file_binary_search(fh, '3ffec000100012')) states_to_find = [] with open('states-to-find-lookup-table-5x5x5-step10-UD-centers-stage.txt',
def print_cubes(filename): state = [] with open(filename, 'r') as fh: for line in fh: if line.strip(): state.append(line) state = ''.join(state) order = 'ULFRBD' len_state = len(state.replace('\n', '').replace(' ', '')) if len_state == 24: state = parse_ascii_222(state) cube = RubiksCube222(state, order) rotate_xxx = rotate_222 elif len_state == 54: state = parse_ascii_333(state) cube = RubiksCube333(state, order) rotate_xxx = rotate_333 elif len_state == 96: state = parse_ascii_444(state) cube = RubiksCube444(state, order) rotate_xxx = rotate_444 elif len_state == 150: state = parse_ascii_555(state) cube = RubiksCube555(state, order) rotate_xxx = rotate_555 elif len_state == 216: state = parse_ascii_666(state) cube = RubiksCube666(state, order) rotate_xxx = rotate_666 elif len_state == 294: state = parse_ascii_777(state) cube = RubiksCube777(state, order) rotate_xxx = rotate_777 else: raise Exception("cube has %d entries, what size is this?" % len_state) #cube.print_cube() tmp_state = cube.state[:] keepers = [] for seq in symmetry_48: cube.state = tmp_state[:] for step in seq: cube.state = rotate_xxx(cube.state[:], step) if cube.state == tmp_state: log.info("================") log.info(' '.join(seq)) log.info("================") cube.print_cube() log.info("\n\n\n\n\n") keepers.append(' '.join(seq)) print("foo = (\n \"" + '",\n "'.join(keepers) + '"\n)')
with open(lt_centers_filename, "r") as fh: for line in fh: (state, steps) = line.strip().split(':') lt_centers[state] = len(steps.split()) log.info("end loading %s" % lt_centers_filename) # Init the workq workq = deque() for step in moves_555: if "w" in step: workq.append((1, step)) # Init misc variables cube = RubiksCube555(solved_555, order='URFDLB') depth = 1 kept = 0 total_processed = 0 processed = 0 pruned = 0 max_depth = args.depth min_wide_turns = args.min_wide_turns keepers = [] keepers_count = 0 keepers_filename = "keepers_555.txt" workq_filename = "workq.txt" next_workq = [] next_workq_count = 0