added 2016/day11

Author: anight

2016/day11/answers.txt

@@ -0,0 +1,2 @@
+47
+71

2016/day11/input.txt

@@ -0,0 +1,4 @@
+The first floor contains a polonium generator, a thulium generator, a thulium-compatible microchip, a promethium generator, a ruthenium generator, a ruthenium-compatible microchip, a cobalt generator, and a cobalt-compatible microchip.
+The second floor contains a polonium-compatible microchip and a promethium-compatible microchip.
+The third floor contains nothing relevant.
+The fourth floor contains nothing relevant.

2016/day11/run.py

@@ -0,0 +1,148 @@
+#! /usr/bin/env python3
+
+def load_data(filename):
+	with open(filename, 'r') as f:
+		for line in f:
+			match = re.findall(r' a (?:(\w+)(?:-compatible)? (microchip|generator))(?:\.|,| and)', line)
+			yield match
+
+import re
+from typing import Callable
+from collections import namedtuple
+from collections.abc import Iterator
+from itertools import combinations
+import networkx as nx
+
+type FS = frozenset[str]
+
+FloorNT = namedtuple('FloorNT', ('generators', 'microchips'))
+
+class Floor(FloorNT):
+	generators: FS
+	microships: FS
+
+	@classmethod
+	def empty(cls) -> 'Floor':
+		return cls(frozenset(), frozenset())
+
+	@classmethod
+	def from_input(cls, items: list[tuple[str, str]]) -> 'Floor':
+		microchips = set()
+		generators = set()
+		for element, type in items:
+			if type == 'microchip':
+				microchips.add(element)
+			elif type == 'generator':
+				generators.add(element)
+		return cls(frozenset(generators), frozenset(microchips))
+
+	def is_valid(self) -> bool:
+		return not self.generators or not (self.microchips - self.generators)
+
+	def to_input(self) -> list[tuple[str, str]]:
+		return [ (element, 'generator') for element in self.generators ] + \
+			[ (element, 'microchip') for element in self.microchips ]
+
+	def set_op(self, op: Callable[[FS, FS], FS], other: 'Floor') -> 'Floor':
+		return Floor(op(self.generators, other.generators), op(self.microchips, other.microchips))
+
+	def __sub__(self, other: 'Floor') -> 'Floor':
+		return self.set_op(frozenset.difference, other)
+
+	def __add__(self, other: 'Floor') -> 'Floor':
+		return self.set_op(frozenset.union, other)
+
+StateNT = namedtuple('StateNT', ('elevator_floor', 'floors'))
+
+class State(StateNT):
+
+	elevator_floor: int
+	floors: tuple['Floor']
+
+	@classmethod
+	def from_input(cls, data: list) -> 'State':
+		return cls(0, tuple( Floor.from_input(items) for items in data ) )
+
+	@classmethod
+	def end(cls, s: 'State') -> 'State':
+		full_floor = Floor.empty()
+		for floor in s.floors:
+			full_floor = full_floor + floor
+		assert full_floor.generators == full_floor.microchips
+		last_floor = len(s.floors)-1
+		return cls(last_floor, tuple( Floor.empty() if i < last_floor else full_floor for i in range(last_floor+1) ))
+
+	def next_states(self) -> Iterator['State']:
+		if self.elevator_floor > 0:
+			# The elevator can go one floor down
+			yield from self.next_states_floor(self.elevator_floor-1)
+		if self.elevator_floor < len(self.floors)-1:
+			# The elevator can go one floor up
+			yield from self.next_states_floor(self.elevator_floor+1)
+
+	def next_states_floor(self, next_floor_n: int) -> Iterator['State']:
+		this_floor = self.floors[self.elevator_floor]
+		next_floor = self.floors[next_floor_n]
+
+		def try_next_state(next_floor_n, elevator):
+			new_this_floor = this_floor - elevator
+			new_next_floor = next_floor + elevator
+			if new_this_floor.is_valid() and new_next_floor.is_valid():
+				# So what
+				yield State(next_floor_n, tuple( new_this_floor if floor is this_floor else new_next_floor if floor is next_floor else floor for floor in self.floors ))
+
+		items = this_floor.to_input()
+
+		# Try to pick one item
+		for item in items:
+			elevator = Floor.from_input([item])
+			# Heuristic 1: don't take down microchips
+			if next_floor_n < self.elevator_floor and item[1] == 'microchip':
+				continue
+			yield from try_next_state(next_floor_n, elevator)
+
+		# Heuristic 2: don't take down any pairs
+		if next_floor_n < self.elevator_floor:
+			return
+
+		# Try all possible pairs
+		for item1, item2 in combinations(items, 2):
+			elevator = Floor.from_input([item1, item2])
+			yield from try_next_state(next_floor_n, elevator)
+
+# Part One
+
+def steps(input):
+
+	start_state = State.from_input(input)
+	end_state = State.end(start_state)
+
+	G = nx.Graph()
+
+	to_check = [start_state]
+	while to_check:
+		state = to_check.pop(-1)
+		for new_state in state.next_states():
+			if new_state not in G.nodes:
+				to_check.append(new_state)
+			G.add_edge(state, new_state)
+
+	p = nx.shortest_path(G, start_state, end_state)
+
+	return len(p)-1
+
+input = list(load_data("input.txt"))
+
+print(steps(input))
+
+# Part Two
+
+input[0].extend([
+	('elerium', 'generator'),
+	('elerium', 'microchip'),
+	('dilithium', 'generator'),
+	('dilithium', 'microchip'),
+])
+
+print(steps(input))
+

README.md

@@ -1,7 +1,7 @@
 ```
       1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 2015 ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ -- -- -- -- -- -- -- -- -- -- -- -- -- +
-2016 ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
+2016 ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ -- -- -- -- -- -- -- -- -- -- -- -- -- -
 2017 ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
 2018 ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ -- -- -- -- -- -- -- -- -- -- -- -- -- -- +
 2019 ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ -- ++ ++ -- +- ++ +- -