day24.py

@@ -1,259 +0,0 @@
-from __future__ import annotations
-
-import itertools
-
-from tools.aoc import AOCDay
-from typing import Any
-
-OPS = {
-    "AND": lambda a, b: a & b,
-    "OR": lambda a, b: a | b,
-    "XOR": lambda a, b: a ^ b,
-}
-
-
-def padded_bin(number: int, pad: int = 45):
-    b = bin(number)[2:]
-    return "0" * (pad - len(b)) + b
-
-
-class Gate:
-    def __init__(self, input_1: Wire, input_2: Wire, op: str, out: Wire = None) -> None:
-        self.input_1 = input_1
-        self.input_2 = input_2
-        self.op_name = op
-        self.op = OPS[op]
-        self.out = out
-
-    def get_state(self) -> int:
-        return self.op(self.input_1.get_state(), self.input_2.get_state())
-
-
-class Wire:
-    def __init__(self, name: str, gate: Gate | None = None, state: int = 0) -> None:
-        self.name = name
-        self.gate = gate
-        self.state = state
-
-    def get_state(self) -> int:
-        if self.gate is not None:
-            self.state = self.gate.get_state()
-        return self.state
-
-    def print(self, depth: int = 0) -> None:
-        pad = " " * depth
-        if self.gate is not None:
-            print(f"{pad} {self.name} <- {self.gate.input_1.name} {self.gate.op_name} {self.gate.input_2.name}")
-            self.gate.input_1.print(depth + 2)
-            self.gate.input_2.print(depth + 2)
-
-
-class Wires(list):
-    def __init__(self):
-        super().__init__()
-        self.wires = {}
-        self.lines = {"x": [], "y": [], "z": []}
-        self.wire_count = {"x": 0, "y": 0, "z": 0}
-
-    def get_number(self, line: str = "z") -> int:
-        return int("".join(str(x.get_state()) for x in self.lines[line][::-1]), 2)
-
-    def set_number(self, line: str, number: int) -> None:
-        wires = self.lines[line][::-1]
-        for i, c in enumerate(padded_bin(number, len(wires))):
-            wires[i].state = int(c)
-
-    def swap_gates(self, wire_1: Wire | str, wire_2: Wire | str) -> None:
-        if isinstance(wire_1, str):
-            wire_1 = self.wires[wire_1]
-        if isinstance(wire_2, str):
-            wire_2 = self.wires[wire_2]
-
-        wire_1.gate, wire_2.gate = wire_2.gate, wire_1.gate
-
-    def get_bit_diff(self, number: int) -> list[int]:
-        my_z = self.get_number()
-        if my_z == number:
-            return []
-        number_bin = padded_bin(number, self.wire_count["z"])
-        my_bin_z = padded_bin(my_z, self.wire_count["z"])
-        return [i for i, c in enumerate(number_bin) if c != my_bin_z[i]]
-
-    def append(self, wire: Wire) -> None:
-        self.wires[wire.name] = wire
-        if wire.name[0] in self.wire_count:
-            self.wire_count[wire.name[0]] += 1
-        if wire.name[0] in self.lines:
-            self.lines[wire.name[0]] = list(sorted(self.lines[wire.name[0]] + [wire], key=lambda w: w.name))
-        super().append(wire)
-
-    def __getitem__(self, item: int | str) -> Wire:
-        if isinstance(item, int):
-            return super()[item]
-        else:
-            return self.wires[item]
-
-    def __contains__(self, item: Wire | str) -> bool:
-        if isinstance(item, str):
-            return item in self.wires
-        else:
-            return super().__contains__(item)
-
-
-class Day(AOCDay):
-    inputs = [
-        [
-            (4, "input24_test"),
-            (2024, "input24_test2"),
-            (42883464055378, "input24"),
-        ],
-        [
-            (None, "input24"),
-        ],
-    ]
-
-    def parse_input(self) -> tuple[Wires, list[Gate]]:
-        init_state, init_gates = self.getMultiLineInputAsArray()
-
-        wires = Wires()
-        for wire in init_state:
-            wire, wire_state = wire.split(": ")
-            wires.append(Wire(name=wire, state=int(wire_state)))
-
-        gates = []
-        done = set()
-        while len(gates) < len(init_gates):
-            for gate in init_gates:
-                if gate in done:
-                    continue
-                input_1, op, input_2, _, output = gate.split()
-                if input_1 not in wires or input_2 not in wires:
-                    continue
-                done.add(gate)
-
-                gate = Gate(wires[input_1], wires[input_2], op)
-                gates.append(gate)
-                wires.append(Wire(name=output, gate=gate))
-                gate.out = wires[output]
-
-        return wires, gates
-
-    def part1(self) -> Any:
-        return self.parse_input()[0].get_number()
-
-    def part2(self) -> Any:
-        wires, gates = self.parse_input()
-
-        # deduced by manually debugging the output from below
-        # need to find some automated solution in the future
-        wires.swap_gates("dtk", "vgs")
-        wires.swap_gates("z39", "pfw")
-        wires.swap_gates("z21", "shh")
-        wires.swap_gates("z33", "dqr")
-        wires["z21"].print()
-
-        fishy_wires = []
-        for w in wires:
-            if w.gate is None:
-                continue
-            if w.name.startswith("z") and w.gate.op_name != "XOR":
-                fishy_wires.append(w)
-            if w.gate.op_name == "OR":
-                if w.gate.input_1.gate is None or w.gate.input_1.gate.op_name != "AND":
-                    fishy_wires.append(w)
-                if w.gate.input_2.gate is None or w.gate.input_2.gate.op_name != "AND":
-                    fishy_wires.append(w)
-            else:
-                if w.gate.input_1.gate is not None and w.gate.input_1.gate.op_name not in ["XOR", "OR"]:
-                    fishy_wires.append(w)
-                if w.gate.input_2.gate is not None and w.gate.input_2.gate.op_name not in ["XOR", "OR"]:
-                    fishy_wires.append(w)
-
-        for w in fishy_wires:
-            print(
-                f"{w.name} -> Input Gate: {w.gate.op_name} from {w.gate.input_1.name} ({w.gate.input_1.gate.op_name if w.gate.input_1.gate is not None else 'None'}) and {w.gate.input_2.name} ({w.gate.input_2.gate.op_name if w.gate.input_2.gate is not None else 'None'})"
-            )
-
-        # z21 -> Input Gate: AND from jsq (XOR) and vcj (OR)
-        # z33 -> Input Gate: OR from mtw (AND) and fdv (AND)
-        # z39 -> Input Gate: AND from x39 (None) and y39 (None)
-        # sjk -> Input Gate: OR from shh (XOR) and kcq (AND)
-        # z26 -> Input Gate: XOR from skh (OR) and vgs (AND)
-        # bmg -> Input Gate: AND from vgs (AND) and skh (OR)
-        # qcr -> Input Gate: OR from bmg (AND) and dtk (XOR)
-        # jqk -> Input Gate: OR from pfw (XOR) and kdd (AND)
-
-        return ""
-
-        old_x = wires.get_number("x")
-        old_y = wires.get_number("y")
-        old_real_z = wires.get_number("x") + wires.get_number("y")
-
-        wires.set_number("x", int("101010101010101010101010101010101010101010101", 2))
-        wires.set_number("y", int("010101010101010101010101010101010101010101010", 2))
-        real_z = wires.get_number("x") + wires.get_number("y")
-
-        # z-lines have to finish on an XOR gate, except for the most significant bit, which should have an OR gate
-        wrong_gates = []
-        for i in range(46):
-            z_0 = [w for w in wires if w.name == "z%02d" % i][0]
-            if i < 45 and z_0.gate.op_name != "XOR":
-                wrong_gates.append(z_0)
-            elif i == 45 and z_0.gate.op_name != "OR":
-                wrong_gates.append(z_0)
-
-        xor_gates = [xor.out for xor in gates if xor.op_name == "XOR" and not xor.out.name.startswith("z")]
-
-        best = 10e9
-        best_pairs = None
-        for comp in itertools.combinations(xor_gates, len(wrong_gates)):
-            for mesh in [list(zip(x, wrong_gates)) for x in itertools.permutations(comp, len(wrong_gates))]:
-                for wire_1, wire_2 in mesh:
-                    wires.swap_gates(wire_1, wire_2)
-                try:
-                    bit_rot = len(wires.get_bit_diff(real_z))
-                except RecursionError:
-                    bit_rot = 10e9
-                if bit_rot < best:
-                    best = bit_rot
-                    best_pairs = mesh
-                for wire_1, wire_2 in mesh:
-                    wires.swap_gates(wire_1, wire_2)
-
-        print(best)
-        swapped = []
-        for wire_1, wire_2 in best_pairs:
-            wires.swap_gates(wire_1, wire_2)
-            swapped.append(wire_1)
-            swapped.append(wire_2)
-
-        wrong_wire = wires["z%02d" % (wires.wire_count["z"] - 1 - wires.get_bit_diff(real_z)[0])]
-        swapped.append(wrong_wire)
-        for x_wire in xor_gates:
-            if x_wire in swapped:
-                continue
-            wires.swap_gates(x_wire, wrong_wire)
-            try:
-                if len(wires.get_bit_diff(real_z)) == 0:
-                    swapped.append(x_wire)
-                    break
-            except RecursionError:
-                pass
-            wires.swap_gates(x_wire, wrong_wire)
-
-        print(real_z)
-        print(wires.get_number())
-
-        wires.set_number("x", old_x)
-        wires.set_number("y", old_y)
-        print(old_real_z)
-        print(wires.get_number())
-
-        print(",".join(sorted(w.name for w in swapped)))
-
-        return ""
-
-
-if __name__ == "__main__":
-    day = Day(2024, 24)
-    day.run(verbose=True)

day25.py

@@ -1,50 +0,0 @@
-from tools.aoc import AOCDay
-from typing import Any
-
-
-class Day(AOCDay):
-    inputs = [
-        [
-            (3, "input25_test"),
-            (3114, "input25"),
-        ],
-        [
-            (None, "input25"),
-        ],
-    ]
-
-    def parse_input(self) -> tuple[list[list[int]], list[list[int]]]:
-        keys, locks = [], []
-        for key_lock in self.getMultiLineInputAsArray():
-            lens = []
-            for x in range(len(key_lock[0])):
-                lens.append(len([key_lock[y][x] for y in range(len(key_lock)) if key_lock[y][x] == "#"]) - 1)
-            if key_lock[0] == "#####":
-                locks.append(lens)
-            else:
-                keys.append(lens)
-
-        return keys, locks
-
-    def part1(self) -> Any:
-        ans = 0
-        keys, locks = self.parse_input()
-        for lock in locks:
-            for key in keys:
-                fits = True
-                for i, k in enumerate(key):
-                    if k + lock[i] > 5:
-                        fits = False
-                        break
-                if fits:
-                    ans += 1
-
-        return ans
-
-    def part2(self) -> Any:
-        return ""
-
-
-if __name__ == "__main__":
-    day = Day(2024, 25)
-    day.run(verbose=True)

inputs/input24

@@ -1,313 +0,0 @@
-x00: 1
-x01: 0
-x02: 0
-x03: 1
-x04: 1
-x05: 0
-x06: 0
-x07: 0
-x08: 0
-x09: 0
-x10: 0
-x11: 1
-x12: 0
-x13: 1
-x14: 1
-x15: 0
-x16: 1
-x17: 1
-x18: 1
-x19: 1
-x20: 0
-x21: 0
-x22: 1
-x23: 0
-x24: 1
-x25: 1
-x26: 1
-x27: 1
-x28: 1
-x29: 0
-x30: 0
-x31: 1
-x32: 0
-x33: 0
-x34: 1
-x35: 1
-x36: 0
-x37: 0
-x38: 0
-x39: 0
-x40: 0
-x41: 0
-x42: 1
-x43: 0
-x44: 1
-y00: 1
-y01: 0
-y02: 0
-y03: 1
-y04: 1
-y05: 1
-y06: 0
-y07: 0
-y08: 0
-y09: 1
-y10: 0
-y11: 0
-y12: 0
-y13: 1
-y14: 1
-y15: 1
-y16: 0
-y17: 0
-y18: 1
-y19: 0
-y20: 1
-y21: 1
-y22: 1
-y23: 0
-y24: 0
-y25: 1
-y26: 0
-y27: 0
-y28: 1
-y29: 1
-y30: 1
-y31: 1
-y32: 1
-y33: 0
-y34: 0
-y35: 0
-y36: 1
-y37: 1
-y38: 1
-y39: 0
-y40: 0
-y41: 1
-y42: 0
-y43: 0
-y44: 1
-
-mvq XOR chf -> z05
-chf AND mvq -> pnn
-nqp OR gqt -> ddt
-pnn OR ntm -> ttr
-kvq XOR ttr -> z06
-jqk XOR vnc -> z40
-kjf OR ftk -> sqn
-mwb XOR sbr -> z09
-x42 XOR y42 -> vvg
-x09 XOR y09 -> mwb
-x19 AND y19 -> scf
-x16 AND y16 -> gqt
-pgd AND wjd -> dqf
-fjc OR wdj -> jnh
-x37 XOR y37 -> fpb
-dqr XOR wnt -> z34
-x11 XOR y11 -> thj
-shh OR kcq -> sjk
-jwp OR dvc -> qhc
-sjr OR jrk -> tfq
-x20 AND y20 -> ssw
-jqp AND vkp -> fdv
-thj AND fgd -> ngq
-ccb OR kfg -> tqd
-x07 XOR y07 -> dgg
-nmt OR jrg -> sjq
-y40 AND x40 -> tcf
-x02 AND y02 -> rgb
-x15 AND y15 -> chh
-gqn XOR sjq -> pfw
-bhc AND fqq -> jvk
-hsk OR kwq -> kdv
-chh OR mqf -> pht
-x00 AND y00 -> mcg
-hhp AND hhg -> kbm
-cph OR qjc -> nff
-jnh XOR bdw -> z28
-y06 AND x06 -> qjc
-y30 AND x30 -> kfg
-y21 AND x21 -> kcq
-vgs AND skh -> bmg
-qgg AND bmw -> jwp
-chn XOR jjk -> z25
-y34 XOR x34 -> wnt
-sjk XOR dpc -> z22
-y11 AND x11 -> hqj
-kbg XOR tcv -> z30
-pww AND pvw -> mvv
-hqj OR ngq -> qgg
-x23 AND y23 -> cpq
-jnh AND bdw -> qhb
-y04 AND x04 -> ggg
-x25 AND y25 -> thm
-x34 AND y34 -> fbd
-pqk XOR srh -> z02
-y43 AND x43 -> gvv
-kkk OR rgb -> gkk
-jvk OR drq -> smj
-pww XOR pvw -> z24
-tcv AND kbg -> ccb
-wtw OR scf -> vcp
-x03 AND y03 -> ngs
-dqr AND wnt -> cgq
-tsf AND kpk -> tjr
-y18 AND x18 -> hsk
-y26 XOR x26 -> dtk
-y44 XOR x44 -> hhg
-x10 XOR y10 -> wjp
-kvq AND ttr -> cph
-y35 XOR x35 -> bhc
-wsw OR dqf -> pvj
-jsq XOR vcj -> shh
-pdf OR npr -> vkp
-y12 AND x12 -> dvc
-fsg XOR fdh -> z14
-dwf XOR rbf -> z32
-y24 XOR x24 -> pww
-sqn AND fmd -> mqf
-x35 AND y35 -> drq
-wjp AND dvh -> bdf
-smj AND tww -> ddk
-hrm AND jhc -> kwq
-jvv AND jww -> kff
-pvt AND gkk -> pwn
-hhg XOR hhp -> z44
-kdv XOR ntj -> z19
-y23 XOR x23 -> jww
-sdg OR trv -> dvh
-fdh AND fsg -> ftk
-x01 XOR y01 -> vcn
-y29 AND x29 -> ghw
-hsg XOR dct -> z08
-kff OR cpq -> pvw
-ddt AND nhg -> vft
-ggv OR thm -> skh
-mcg XOR vcn -> z01
-y41 AND x41 -> wsw
-x14 XOR y14 -> fsg
-y13 AND x13 -> rgp
-rgp OR crm -> fdh
-srh AND pqk -> kkk
-tcf OR cpp -> pgd
-y03 XOR x03 -> pvt
-x33 AND y33 -> mtw
-dgg AND nff -> gqk
-y30 XOR x30 -> kbg
-y07 AND x07 -> dvs
-x44 AND y44 -> spc
-y38 AND x38 -> nmt
-hkv AND tqd -> ckb
-y31 XOR x31 -> hkv
-y02 XOR x02 -> srh
-y17 AND x17 -> fjk
-vcp AND khd -> dsj
-qcr AND jgd -> wdj
-y19 XOR x19 -> ntj
-fpb XOR dds -> z37
-x16 XOR y16 -> rqv
-y17 XOR x17 -> nhg
-ssw OR dsj -> vcj
-fpb AND dds -> fqd
-pdr OR ggg -> mvq
-x38 XOR y38 -> tdj
-rqv XOR pht -> z16
-pfw OR kdd -> jqk
-x36 AND y36 -> sbn
-x33 XOR y33 -> jqp
-bns OR gvv -> hhp
-y32 XOR x32 -> rbf
-y36 XOR x36 -> tww
-pgd XOR wjd -> z41
-khd XOR vcp -> z20
-ckb OR sqr -> dwf
-x39 XOR y39 -> gqn
-wfj XOR vfk -> z04
-qhb OR kjs -> tsf
-kdv AND ntj -> wtw
-ksd OR hqw -> jvv
-x13 XOR y13 -> kdm
-y00 XOR x00 -> z00
-jvv XOR jww -> z23
-y12 XOR x12 -> bmw
-y22 AND x22 -> ksd
-x21 XOR y21 -> jsq
-x43 XOR y43 -> qtr
-bmg OR dtk -> qcr
-gqk OR dvs -> dct
-qgg XOR bmw -> z12
-mwb AND sbr -> sdg
-mcg AND vcn -> ndb
-kkg OR bdf -> fgd
-x04 XOR y04 -> wfj
-y22 XOR x22 -> dpc
-skh XOR vgs -> z26
-ddt XOR nhg -> z17
-bhc XOR fqq -> z35
-tdj XOR pnh -> z38
-kdm XOR qhc -> z13
-y31 AND x31 -> sqr
-vvg AND pvj -> sjr
-rbf AND dwf -> npr
-qtr AND tfq -> bns
-y18 XOR x18 -> hrm
-chn AND jjk -> ggv
-y28 AND x28 -> kjs
-mtw OR fdv -> z33
-nff XOR dgg -> z07
-y10 AND x10 -> kkg
-jsq AND vcj -> z21
-vft OR fjk -> jhc
-qtr XOR tfq -> z43
-gqn AND sjq -> kdd
-y15 XOR x15 -> fmd
-wfj AND vfk -> pdr
-y27 XOR x27 -> jgd
-y09 AND x09 -> trv
-x14 AND y14 -> kjf
-tww XOR smj -> z36
-jqk AND vnc -> cpp
-nkq OR fqd -> pnh
-x06 XOR y06 -> kvq
-y01 AND x01 -> gbh
-x37 AND y37 -> nkq
-x05 XOR y05 -> chf
-vdk OR cdm -> sbr
-y08 AND x08 -> vdk
-sqn XOR fmd -> z15
-x24 AND y24 -> dcj
-y25 XOR x25 -> jjk
-kbm OR spc -> z45
-hrm XOR jhc -> z18
-pvj XOR vvg -> z42
-wjp XOR dvh -> z10
-mvv OR dcj -> chn
-y42 AND x42 -> jrk
-tsf XOR kpk -> z29
-vkp XOR jqp -> dqr
-y41 XOR x41 -> wjd
-y32 AND x32 -> pdf
-y26 AND x26 -> vgs
-jgd XOR qcr -> z27
-y29 XOR x29 -> kpk
-ngs OR pwn -> vfk
-dpc AND sjk -> hqw
-qhc AND kdm -> crm
-rqv AND pht -> nqp
-x39 AND y39 -> z39
-thj XOR fgd -> z11
-tjr OR ghw -> tcv
-gkk XOR pvt -> z03
-y27 AND x27 -> fjc
-y28 XOR x28 -> bdw
-gbh OR ndb -> pqk
-tqd XOR hkv -> z31
-dct AND hsg -> cdm
-fbd OR cgq -> fqq
-x05 AND y05 -> ntm
-sbn OR ddk -> dds
-y40 XOR x40 -> vnc
-y20 XOR x20 -> khd
-x08 XOR y08 -> hsg
-tdj AND pnh -> jrg

inputs/input24_test

@@ -1,10 +0,0 @@
-x00: 1
-x01: 1
-x02: 1
-y00: 0
-y01: 1
-y02: 0
-
-x00 AND y00 -> z00
-x01 XOR y01 -> z01
-x02 OR y02 -> z02

inputs/input24_test2

@@ -1,47 +0,0 @@
-x00: 1
-x01: 0
-x02: 1
-x03: 1
-x04: 0
-y00: 1
-y01: 1
-y02: 1
-y03: 1
-y04: 1
-
-ntg XOR fgs -> mjb
-y02 OR x01 -> tnw
-kwq OR kpj -> z05
-x00 OR x03 -> fst
-tgd XOR rvg -> z01
-vdt OR tnw -> bfw
-bfw AND frj -> z10
-ffh OR nrd -> bqk
-y00 AND y03 -> djm
-y03 OR y00 -> psh
-bqk OR frj -> z08
-tnw OR fst -> frj
-gnj AND tgd -> z11
-bfw XOR mjb -> z00
-x03 OR x00 -> vdt
-gnj AND wpb -> z02
-x04 AND y00 -> kjc
-djm OR pbm -> qhw
-nrd AND vdt -> hwm
-kjc AND fst -> rvg
-y04 OR y02 -> fgs
-y01 AND x02 -> pbm
-ntg OR kjc -> kwq
-psh XOR fgs -> tgd
-qhw XOR tgd -> z09
-pbm OR djm -> kpj
-x03 XOR y03 -> ffh
-x00 XOR y04 -> ntg
-bfw OR bqk -> z06
-nrd XOR fgs -> wpb
-frj XOR qhw -> z04
-bqk OR frj -> z07
-y03 OR x01 -> nrd
-hwm AND bqk -> z03
-tgd XOR rvg -> z12
-tnw OR pbm -> gnj

inputs/input25_test

@@ -1,39 +0,0 @@
-#####
-.####
-.####
-.####
-.#.#.
-.#...
-.....
-
-#####
-##.##
-.#.##
-...##
-...#.
-...#.
-.....
-
-.....
-#....
-#....
-#...#
-#.#.#
-#.###
-#####
-
-.....
-.....
-#.#..
-###..
-###.#
-###.#
-#####
-
-.....
-.....
-.....
-#....
-#.#..
-#.#.#
-#####