You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
204 lines
5.6 KiB
Python
204 lines
5.6 KiB
Python
from pprint import pprint
|
|
from time import sleep
|
|
|
|
m = list()
|
|
hitpoints = dict()
|
|
|
|
|
|
with open('input.txt', 'r') as f:
|
|
for raw_line in f.readlines():
|
|
line = list()
|
|
for field in raw_line.strip():
|
|
line.append(field)
|
|
m.append(line)
|
|
|
|
for x in range(len(m)):
|
|
for y in range(len(m[x])):
|
|
if m[x][y] in ['G', 'E']:
|
|
hitpoints[(x, y)] = 200
|
|
|
|
def get_patch(pos):
|
|
x, y = pos
|
|
if x < 0 or x >= len(m):
|
|
return None
|
|
if y < 0 or y >= len(m[x]):
|
|
return None
|
|
return m[x][y]
|
|
|
|
def neighbors(pos):
|
|
return [
|
|
(pos[0], pos[1] + 1),
|
|
(pos[0], pos[1] - 1),
|
|
(pos[0] + 1, pos[1]),
|
|
(pos[0] - 1, pos[1])
|
|
]
|
|
|
|
def valid_neighbors(pos):
|
|
return [x for x in neighbors(pos) if get_patch(x) == '.']
|
|
|
|
|
|
def flood(pos):
|
|
patches = set([pos])
|
|
flood_map = {
|
|
pos: 0
|
|
}
|
|
new = set(valid_neighbors(pos))
|
|
i = 1
|
|
while new:
|
|
patches.update(new)
|
|
new_new = set()
|
|
for p in new:
|
|
flood_map[p] = i
|
|
new_new.update(valid_neighbors(p))
|
|
new = new_new - patches
|
|
i += 1
|
|
return flood_map
|
|
|
|
def get_units():
|
|
"""unit is a tuple (pos, symbol)"""
|
|
units = list()
|
|
for x in range(len(m)):
|
|
for y in range(len(m[x])):
|
|
if m[x][y] in ['G', 'E']:
|
|
units.append(((x, y), m[x][y]))
|
|
return units
|
|
|
|
def get_closest_target(flood_map, targets):
|
|
reachable_targets = {pos: dist for pos, dist in flood_map.items() if pos in targets}
|
|
if len(reachable_targets) == 0:
|
|
return None
|
|
# print('Reachable targets:', reachable_targets)
|
|
min_range = min(reachable_targets.values())
|
|
closest = [pos for pos, dist in reachable_targets.items() if dist == min_range]
|
|
# print('Closest targets:', closest)
|
|
closest.sort()
|
|
return closest[0]
|
|
|
|
def get_enemies(unit):
|
|
return [e for e in get_units() if e[1] != unit[1]]
|
|
|
|
def get_targets(unit):
|
|
targets = set()
|
|
for e in get_enemies(unit):
|
|
targets.update(valid_neighbors(e[0]))
|
|
return targets
|
|
|
|
def get_enemies_in_range(unit):
|
|
x, y = unit[0]
|
|
enemies = get_enemies(unit)
|
|
neighbors = [
|
|
(x + 1, y),
|
|
(x - 1, y),
|
|
(x, y + 1),
|
|
(x, y - 1)
|
|
]
|
|
return [e for e in enemies if e[0] in neighbors]
|
|
|
|
def move(unit, target):
|
|
move_to = dict()
|
|
neighbors = valid_neighbors(unit[0])
|
|
# print('neighbors', neighbors)
|
|
for n in neighbors:
|
|
flood_map = flood(n)
|
|
# print(n, target, flood_map.get('target'))
|
|
if target in flood_map:
|
|
move_to[n] = flood_map[target]
|
|
# print(move_to)
|
|
min_range = min(move_to.values())
|
|
closest = [pos for pos, dist in move_to.items() if dist == min_range]
|
|
closest.sort()
|
|
|
|
x1, y1 = unit[0]
|
|
x2, y2 = closest[0]
|
|
m[x1][y1] = '.'
|
|
m[x2][y2] = unit[1]
|
|
|
|
htp = hitpoints[unit[0]]
|
|
del hitpoints[unit[0]]
|
|
hitpoints[closest[0]] = htp
|
|
|
|
return (closest[0])
|
|
|
|
def count_dwarfes():
|
|
c = 0
|
|
for line in m:
|
|
for sym in line:
|
|
if sym == 'E':
|
|
c += 1
|
|
return c
|
|
|
|
def count_goblins():
|
|
c = 0
|
|
for line in m:
|
|
for sym in line:
|
|
if sym == 'G':
|
|
c += 1
|
|
return c
|
|
|
|
def print_map():
|
|
print(' ', ''.join([ str(y // 10) for y, _ in enumerate(m[0]) ]))
|
|
print(' ', ''.join([ str(y % 10) for y, _ in enumerate(m[0]) ]))
|
|
for i, line in enumerate(m):
|
|
htp_list = [(pos, htp) for pos, htp in hitpoints.items() if pos[0] == i]
|
|
htp_list.sort()
|
|
print(str(i).ljust(2), ''.join(line), [h[1] for h in htp_list])
|
|
print(' ', ''.join([ str(y % 10) for y, _ in enumerate(m[0]) ]))
|
|
print(' ', ''.join([ str(y // 10) for y, _ in enumerate(m[0]) ]))
|
|
|
|
|
|
def main(elf_atk=3):
|
|
i = 0
|
|
while 1:
|
|
# print()
|
|
# print(f'After {i} rounds:')
|
|
# print_map()
|
|
units = get_units()
|
|
units.sort()
|
|
for u in units:
|
|
if get_patch(u[0]) != u[1]:
|
|
continue
|
|
if count_dwarfes() == 0 or count_goblins() == 0:
|
|
return i
|
|
# print(f'UNIT: {u[1]} at {u[0]}')
|
|
e = get_enemies_in_range(u)
|
|
if len(e) == 0:
|
|
# move
|
|
targets = get_targets(u)
|
|
closest = get_closest_target(flood(u[0]), targets)
|
|
if closest is None:
|
|
# print('do nothing')
|
|
continue
|
|
d = move(u, closest)
|
|
u = (d, u[1])
|
|
# print(f'Moved towards {closest} via {d}')
|
|
e = get_enemies_in_range(u)
|
|
if len(e) != 0:
|
|
# attack
|
|
atk_pos = [en[0] for en in e]
|
|
htp_map = {pos: val for pos, val in hitpoints.items() if pos in atk_pos}
|
|
min_htp = min(htp_map.values())
|
|
atk_targets = [pos for pos, htp in htp_map.items() if htp == min_htp]
|
|
|
|
target = atk_targets[0]
|
|
# print(f'Unit {u} attacking {target}')
|
|
atk = elf_atk if u[1] == 'E' else 3
|
|
hitpoints[target] -= atk
|
|
if hitpoints[target] <= 0:
|
|
del hitpoints[target]
|
|
x, y = target
|
|
m[x][y] = '.'
|
|
|
|
i += 1
|
|
# pprint(hitpoints)
|
|
# sleep(.1)
|
|
|
|
print('Elves before:', count_dwarfes())
|
|
i = main(15)
|
|
print('Elves after:', count_dwarfes())
|
|
# print()
|
|
# print(f'After {i + 1} rounds:')
|
|
# print_map()
|
|
print()
|
|
print('Number of complete rounds:', i)
|
|
print('hitpoints:', sum(hitpoints.values()))
|
|
print('Result', i * sum(hitpoints.values())) |