You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

81 lines
3.1 KiB

#!/usr/bin/python
from collections import OrderedDict, defaultdict, namedtuple
from functools import total_ordering
from heapq import heappop, heappush
from itertools import chain
import re
Bot = namedtuple('Bot', 'x y z r')
with open('day23.txt') as puzzle_file:
pattern = re.compile(r'pos=<(-?\d+),(-?\d+),(-?\d+)>, r=(\d+)')
bots = [Bot(*map(int, pattern.match(line).groups())) for line in puzzle_file]
max_r = max(bot.r for bot in bots)
print(
max(
sum(abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z) <= a.r for b in bots) for a in bots
if a.r == max_r))
@total_ordering
class Octa_ordering(object):
def __lt__(self, other):
return self.min < other.min or self.min == other.min and other.max < self.max
class Octa(Octa_ordering, namedtuple('Octa', ('min', 'max'))):
def __new__(cls, *args, **kwargs):
if 'bot' in kwargs:
x, y, z, r = kwargs['bot']
t, u, v, w = x + y + z, x + y - z, x - y - z, x - y + z
return super(Octa, cls).__new__(cls, (t - r, u - r, v - r, w - r),
(t + r, u + r, v + r, w + r))
return super(Octa, cls).__new__(cls, *args, **kwargs)
def intersect(self, other):
c, d, e, f = self.min
g, h, i, j = other.min
k, l, m, n = self.max
o, p, q, r = other.max
s, t, u, v = max(c, g), max(d, h), max(e, i), max(f, j)
w, x, y, z = min(k, o), min(l, p), min(m, q), min(n, r)
return None if s > w or t > x or u > y or v > z else Octa((s, t, u, v), (w, x, y, z))
def distance_to_origin(self):
o, p, q, r = self.min
s, t, u, v = self.max
if o < s and p < t and q < u and r < v:
w = min(abs(o), abs(s)) if o * s >= 0 else 0
x = min(abs(p), abs(t)) if p * t >= 0 else 0
y = min(abs(q), abs(u)) if q * u >= 0 else 0
z = min(abs(r), abs(v)) if r * v >= 0 else 0
return max(w, x, y, z)
return min(
abs((x + z) // 2) + abs((y - z) // 2) + abs((x - y) // 2)
for x in range(o, s + 1) for y in range(p + ((p ^ x) & 1), t + 1, 2)
for z in range(q + ((q ^ x) & 1), u + 1, 2) if r <= x - y + z <= v)
best_count = 0
octs = defaultdict(set)
for i, bot in enumerate(bots):
octs[Octa(bot=bot)].add(i)
queue = [(0, (), OrderedDict((k, octs[k]) for k in sorted(octs)))]
while queue:
n, _, rest = heappop(queue)
if -n < best_count:
break
octa, n = rest.popitem()
sub = defaultdict(set)
for octa2, m in rest.items():
octa3 = octa.intersect(octa2)
if octa3 is not None:
(n if octa == octa3 else sub[octa3]).update(m)
if len(n) > best_count:
best_count, best_distance = len(n), [octa]
elif len(n) == best_count:
best_distance.append(octa)
m = frozenset(chain.from_iterable(rest.values()))
heappush(queue, (-len(m), m, rest))
rest = OrderedDict((k, sub[k].union(n)) for k in sorted(sub))
m = frozenset(chain.from_iterable(rest.values()))
heappush(queue, (-len(m), m, rest))
print(min(octa.distance_to_origin() for octa in best_distance))