def main():
p = EightPuzzle()
p.shuffle(20)
print(p)
path, count = p.solve(h_manhattan)
path.reverse()
for i in path:
print(i)
def __init__(self):
#
super().__init__()
#
self.layouts = []
self.tiles = []
self.buttons = []
self.puzzle = EightPuzzle()
#
self.display_window()
self.display_content()
self.shuffle_tiles()
self.set_button_actions()
def main():
global default_problem
global goal
global goal2
puzzle = EightPuzzle(default_problem, goal)
startTime = time.time()
result = depth_limited_search(puzzle, 30)
#result = breadth_first_tree_search(puzzle)
endTime = time.time()
print('solution is ', Node.solution(result))
print('path is', Node.path(result))
print('걸린 시간 :', endTime - startTime)
8: "D2-8675"
}
return mapping.get(robot_num)
commands = []
robot_nums = set()
robots = []
while True:
commands = []
robot_nums = set()
robots = [None for i in range(9)]
board = [[1, 2, 3], [4, 5, 6], [7, 8, 0]]
game = EightPuzzle(board)
game.scramble(100)
commands = game.find_soln()
for command in commands:
robot_nums.add(command[0])
print(game.get_board())
print("# of robots that need to be connected: " + str(len(robot_nums)))
print("# of moves required: " + str(len(commands)))
print("Enter s to start or any other key to re-scramble:")
choice = input()
if choice == "s":
break
print("Started")
class EightPuzzleQt(QWidget):
def __init__(self):
#
super().__init__()
#
self.layouts = []
self.tiles = []
self.buttons = []
self.puzzle = EightPuzzle()
#
self.display_window()
self.display_content()
self.shuffle_tiles()
self.set_button_actions()
def display_window(self):
#
self.setGeometry(0, 0, 500, 500)
resolution = QDesktopWidget().screenGeometry()
self.move((resolution.width() / 2) - (self.frameSize().width() / 2),
(resolution.height() / 2) - (self.frameSize().height() / 2))
self.setWindowTitle('Eight Puzzle')
self.setWindowIcon(QIcon('Images/eight_puzzle.ico'))
self.setStyleSheet('background-color: #363B57;')
self.show()
def display_content(self):
#
layout_main = QVBoxLayout()
layout_main.setAlignment(Qt.AlignCenter)
self.setLayout(layout_main)
self.layouts.append(layout_main)
#
fonts = QFontDatabase()
fonts.addApplicationFont('Fonts/Raleway/Raleway-ExtraLight.ttf')
fonts.addApplicationFont('Fonts/OpenSans/OpenSans-Light.ttf')
#
title = QLabel("Eight Puzzle")
title.setStyleSheet('font-size: 52px; color: #CECFD4;')
title.setFont(QFont('Raleway'))
layout_main.addWidget(title)
layout_main.addSpacerItem(QSpacerItem(0, 12))
#
layout_tiles = QGridLayout()
layout_tiles.setAlignment(Qt.AlignCenter)
layout_main.addLayout(layout_tiles)
for index in range(9):
tile = QPushButton(str(self.puzzle.state[index]))
tile.setStyleSheet('background-color: #879AA4;'
'color: #CECFD4; font-size: 32px;')
tile.setFont(QFont('Open Sans'))
tile.setFixedSize(75, 75)
tile.setEnabled(False)
tile.setFocusPolicy(Qt.NoFocus)
layout_tiles.addWidget(tile, index / 3, index % 3)
if self.puzzle.state[index] is '0':
tile.setVisible(False)
self.tiles.append(tile)
self.layouts.append(layout_tiles)
layout_main.addSpacerItem(QSpacerItem(0, 25))
#
layout_buttons = QGridLayout()
layout_buttons.setAlignment(Qt.AlignCenter)
layout_main.addLayout(layout_buttons)
for index in range(3):
button = QPushButton(['Shuffle', 'Solve', 'Quit'][index])
button.setStyleSheet('background-color: #CECFD4;'
'color: #363B57; font-size: 18px;')
button.setFont(QFont('Raleway'))
button.setFixedSize(90, 40)
button.setFocusPolicy(Qt.NoFocus)
layout_buttons.addWidget(button, 0, index)
self.buttons.append(button)
self.layouts.append(layout_buttons)
layout_main.addSpacerItem(QSpacerItem(0, 10))
def set_button_actions(self):
#
for key in self.puzzle.neighbors.keys():
button = self.tiles[self.puzzle.neighbors[key].index('0')]
button.setEnabled(True)
button.clicked.connect(self.button_actions)
#
self.buttons[0].clicked.connect(self.button_actions)
self.buttons[1].clicked.connect(self.button_actions)
self.buttons[2].clicked.connect(self.button_actions)
def button_actions(self):
#
if self.sender() in self.tiles:
for key in self.puzzle.neighbors:
if self.puzzle.neighbors[key][self.tiles.index(self.sender())] is '0':
self.puzzle.move(key)
self.update_tiles()
#
elif self.sender() is self.buttons[0]:
self.shuffle_tiles()
#
elif self.sender() is self.buttons[1]:
path = self.puzzle.shortest_path
for move in path:
self.puzzle.move(move)
QApplication.processEvents()
sleep(0.5)
self.update_tiles()
#
else:
exit()
def update_tiles(self):
#
tiles = list((self.layouts[1].itemAt(index).widget()
for index in range(self.layouts[1].count())))
for tile in tiles:
try:
tile.clicked.disconnect()
except TypeError:
pass
tile.setEnabled(False)
tile.setVisible(True)
tile.setText(str(self.puzzle.state[tiles.index(tile)]))
if self.puzzle.state[tiles.index(tile)] is '0':
tile.setVisible(False)
#
for key in self.puzzle.neighbors.keys():
button = self.tiles[self.puzzle.neighbors[key].index('0')]
button.setEnabled(True)
button.clicked.connect(self.button_actions)
def shuffle_tiles(self):
#
opposites = {'Up': 'Down', 'Down': 'Up',
'Left': 'Right', 'Right': 'Left'}
previous_move = None
for i in range(50):
moves = self.puzzle.moves
if previous_move:
moves.pop(moves.index(opposites[previous_move]))
move = moves[randrange(0, len(moves), 1)]
previous_move = move
self.puzzle.move(move)
QApplication.processEvents()
self.update_tiles()
sleep(0.1)
def __init__(self):
self.eight_puzzle = EightPuzzle()
def generate(self, current):
#TODO replace these meaningless numbers by Moves
next_steps = []
puzzle = current.state
if puzzle.can_move(puzzle.Moves.up):
next_puzzle = EightPuzzle(puzzle=puzzle)
next_puzzle.move_up()
next_steps.append(AStarState(self.distance(next_puzzle), current.g + 1, next_puzzle, current))
if puzzle.can_move(puzzle.Moves.right):
next_puzzle = EightPuzzle(puzzle=puzzle)
next_puzzle.move_right()
next_steps.append(AStarState(self.distance(next_puzzle), current.g + 1, next_puzzle, current))
if puzzle.can_move(puzzle.Moves.left):
next_puzzle = EightPuzzle(puzzle=puzzle)
next_puzzle.move_left()
next_steps.append(AStarState(self.distance(next_puzzle), current.g + 1, next_puzzle, current))
if puzzle.can_move(puzzle.Moves.down):
next_puzzle = EightPuzzle(puzzle=puzzle)
next_puzzle.move_down()
next_steps.append(AStarState(self.distance(next_puzzle), current.g + 1, next_puzzle, current))
return next_steps
next_puzzle.move_down()
next_steps.append(AStarState(self.distance(next_puzzle), current.g + 1, next_puzzle, current))
return next_steps
def is_final_state(self, state):
return self.desired == state
def distance(self, instance):
"""
Manhattan distance
"""
value = 0
dimension = instance.dimension
for i in range(len(instance)):
if instance[i] == 0:
continue
current_i = self.desired.index(instance[i])
value += abs(current_i % dimension - i % dimension) + abs(current_i // dimension - i // dimension)
return value
if __name__ == '__main__':
eightp = EightPuzzle(4)
eightp.shuffle(80)
solver = EightPuzzleSolver(eightp, list(range(1, len(eightp))) + [0])
print(eightp)
solution = solver.solve()
for step in solution:
print("\n", step, sep="")
print(len(solution))
def main():
problem2 = EightPuzzle((1, 2, 3, 4, 5, 6, 7, 8, 0),
(1, 2, 3, 4, 7, 6, 8, 5, 0))
path = breadth_first_graph_search(problem2).solution()
print(path, '\n')
