Tell us what’s happening:
I have already implemented all the logic and it works: all the tests pass except the return str one. I checked why it says that it’s not a string, but I found no solution, why is that?
Your code so far
from copy import deepcopy
def create_start(disks: int) -> dict:
tower_1 = [x for x in range(disks + 1) if x > 0]
tower_1.reverse()
towers = [tower_1,[],[]]
return {"0:0" : towers}
def create_solution(disks: int) -> list:
tower_1 = [x for x in range(disks + 1) if x > 0]
tower_1.reverse()
return [[],[],tower_1]
class Towers:
def __init__(self, disks: int) -> None:
self.disks = disks
self.arrangements = create_start(disks)
self.solution = create_solution(disks)
self.current_child = 0
self.next_child = 1
self.parents = {
0: 0
}
self.visited = set()
self.visited.add(
self.state_to_tuple(self.arrangements["0:0"])
)
@property
def disks(self):
return self._disks
@disks.setter
def disks(self, new_disks):
self._disks = new_disks
@property
def arrangements(self):
return self._arrangements
@arrangements.setter
def arrangements(self, new_arrangements):
self._arrangements = new_arrangements
def state_to_tuple(self, arrangement):
return tuple(tuple(rod) for rod in arrangement)
def read_keys(self, key: str) -> tuple:
return tuple(key.split(":"))
def search_child(self, child: int) -> str:
for key in self.arrangements:
current_key = self.read_keys(key)
if current_key[1] == str(child):
return key
raise KeyError(
f"Key with child {child} not found!"
)
def create_key(self, parent: int, child: int) -> str:
return str(parent) + ":" + str(child)
def last_child(self):
return self.next_child - 1
def add_arrangement(self, new_arrangement, parent):
child = self.next_child
key = self.create_key(parent, child)
self.arrangements[key] = new_arrangement
self.parents[child] = parent
self.visited.add(
self.state_to_tuple(new_arrangement)
)
self.next_child += 1
def create_arrangements(self):
solution = self.state_to_tuple(self.solution)
while solution not in self.visited:
curr_child = self.current_child
parent = self.parents[curr_child]
curr_key = self.create_key(
parent,
curr_child
)
arrangement = self.arrangements[curr_key]
for rod_n, rod in enumerate(arrangement):
if not rod:
continue
disk = rod[-1]
for other_rod_n, other_rod in enumerate(arrangement):
if rod_n == other_rod_n:
continue
if other_rod and other_rod[-1] < disk:
continue
new_arrangement = deepcopy(arrangement)
new_arrangement[rod_n].pop()
new_arrangement[other_rod_n].append(disk)
state = self.state_to_tuple(
new_arrangement
)
if state not in self.visited:
self.add_arrangement(
new_arrangement,
curr_child
)
self.current_child += 1
def hanoi_solver(disks: int) -> str:
towers = Towers(disks)
towers.create_arrangements()
solution_key = ""
for key in towers.arrangements:
if towers.arrangements[key] == towers.solution:
solution_key = key
break
path = []
current_key = solution_key
while True:
path.append(current_key)
parent, child = towers.read_keys(current_key)
if parent == child:
break
current_key = towers.search_child(int(parent))
path.reverse()
result = ""
for key in path:
arrangement = towers.arrangements[key]
result += str(arrangement[0])
result += " "
result += str(arrangement[1])
result += " "
result += str(arrangement[2])
if key != path[-1]:
result += "\n"
return result
try:
print(hanoi_solver(3))
except KeyError as e:
print(f"KeyError: {e}")
Your browser information:
User Agent is: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:153.0) Gecko/20100101 Firefox/153.0
Challenge Information:
Implement the Tower of Hanoi Algorithm - Implement the Tower of Hanoi Algorithm