Solve day 24

2024/24_logicgates.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+import sys
+from functools import reduce
+from itertools import takewhile
+from operator import and_, or_, xor
+
+def parse(f):
+    initial = {line[:3]: int(line[5])
+               for line in takewhile(lambda line: line != '\n', f)}
+    rules = {}
+    for line in f:
+        left, op, right, _, out = line.split()
+        rules[out] = {'AND': and_, 'OR': or_, 'XOR': xor}[op], left, right
+    return initial, rules
+
+def evaluate(initial, rules):
+    def value(name):
+        if name in initial:
+            return initial[name]
+        op, left, right = rules[name]
+        return op(value(left), value(right))
+    return reduce(or_, (value(z) << int(z[1:]) for z in rules if z[0] == 'z'))
+
+def construct_xy(op, i):
+    return op, 'x%02d' % i, 'y%02d' % i
+
+def construct_carry(i):
+    carry = construct_xy(and_, i)
+    if i == 0:
+        return carry
+    lhs = and_, construct_carry(i - 1), construct_xy(xor, i)
+    return or_, lhs, construct_xy(and_, i)
+
+def construct_z(i, initial):
+    adder = construct_xy(xor, i)
+    if i == 0:
+        return adder
+    carry = construct_carry(i - 1)
+    if 'x%02d' % i not in initial:
+        return carry
+    return xor, carry, adder
+
+def tostr(construct, rules):
+    match construct:
+        case op, left, right:
+            op_str = {and_: '&', or_: '|', xor: '^'}[op]
+            left, right = sorted((tostr(left, rules), tostr(right, rules)))
+            return f'({left} {op_str} {right})'
+        case str(node):
+            return tostr(rules[node], rules) if node in rules else node
+
+def find_incorrect(initial, rules):
+    def expect(name, expected):
+        if name in rules:
+            op, left, right = rules[name]
+            eop, eleft, eright = expected
+            if op != eop:
+                return {name}
+            (lstr, left), (rstr, right) = sorted(((tostr(left, rules), left),
+                                                  (tostr(right, rules), right)))
+            if left in rules and right in rules:
+                return expect(left, eleft) | expect(right, eright)
+            if lstr != tostr(eleft, rules):
+                return {left}
+            if rstr != tostr(eright, rules):
+                return {right}
+        return set()
+    return reduce(set.union, (expect(name, construct_z(int(name[1:]), initial))
+                              for name in rules if name[0] == 'z'))
+
+initial, rules = parse(sys.stdin)
+print(evaluate(initial, rules))
+print(','.join(sorted(find_incorrect(initial, rules))))

2024/input/24

@@ -0,0 +1,313 @@
+x00: 1
+x01: 1
+x02: 0
+x03: 0
+x04: 0
+x05: 1
+x06: 0
+x07: 1
+x08: 1
+x09: 0
+x10: 1
+x11: 0
+x12: 0
+x13: 0
+x14: 1
+x15: 0
+x16: 0
+x17: 1
+x18: 0
+x19: 1
+x20: 0
+x21: 1
+x22: 0
+x23: 1
+x24: 0
+x25: 0
+x26: 1
+x27: 0
+x28: 0
+x29: 0
+x30: 0
+x31: 1
+x32: 1
+x33: 1
+x34: 1
+x35: 1
+x36: 1
+x37: 1
+x38: 0
+x39: 1
+x40: 1
+x41: 0
+x42: 1
+x43: 1
+x44: 1
+y00: 1
+y01: 0
+y02: 1
+y03: 1
+y04: 0
+y05: 0
+y06: 1
+y07: 1
+y08: 0
+y09: 1
+y10: 1
+y11: 1
+y12: 1
+y13: 0
+y14: 1
+y15: 1
+y16: 0
+y17: 0
+y18: 0
+y19: 1
+y20: 1
+y21: 0
+y22: 0
+y23: 1
+y24: 1
+y25: 1
+y26: 0
+y27: 1
+y28: 0
+y29: 0
+y30: 0
+y31: 1
+y32: 1
+y33: 0
+y34: 1
+y35: 0
+y36: 0
+y37: 0
+y38: 1
+y39: 0
+y40: 1
+y41: 0
+y42: 1
+y43: 1
+y44: 1
+
+x21 XOR y21 -> hgv
+cpr OR tmw -> dhb
+cpq AND tkb -> jqs
+nbp AND tnq -> cpr
+scj AND btd -> tpk
+ffg OR tpj -> jrb
+pft AND qcp -> bcq
+djg OR djr -> nbf
+qdg AND fqp -> trd
+jkm AND wrg -> vsk
+x39 AND y39 -> rjk
+frt AND pgs -> vfq
+nqk OR mdk -> tbs
+y00 AND x00 -> ktt
+pks OR ptm -> dnd
+ntj AND fbk -> dps
+y44 AND x44 -> dgh
+wgw OR qqp -> rnc
+y33 AND x33 -> jpc
+x13 AND y13 -> ntm
+y38 XOR x38 -> spf
+fnq OR pcv -> scj
+hjs OR vwj -> hhp
+y38 AND x38 -> pgc
+ftg AND mhv -> njj
+wvw OR rdt -> trw
+gkk AND nrd -> smk
+jjc AND mpf -> gvt
+x14 AND y14 -> tmw
+mwp OR vsb -> jqc
+mks OR jqs -> jrr
+y40 XOR x40 -> cvb
+hjm AND jrr -> rpj
+x04 AND y04 -> csm
+kdm AND cgt -> sch
+jkm XOR wrg -> z33
+wjh XOR cpv -> z17
+bfn OR gwm -> smd
+x06 AND y06 -> kfb
+sqr XOR wpd -> z25
+dkq OR jsf -> frt
+x40 AND y40 -> wgw
+sqt OR wnv -> hww
+y12 AND x12 -> djr
+y18 XOR x18 -> qcp
+cpq XOR tkb -> z23
+bsr OR njd -> cpq
+rqp XOR hcd -> z10
+ckt XOR jwg -> z20
+x19 AND y19 -> z19
+y37 AND x37 -> gqf
+hqv XOR bcf -> z34
+x41 XOR y41 -> mfp
+x14 XOR y14 -> nbp
+x42 XOR y42 -> qsg
+y25 XOR x25 -> wpd
+x27 AND y27 -> jqg
+y05 AND x05 -> fjd
+y28 XOR x28 -> gkk
+x17 AND y17 -> bpg
+y26 XOR x26 -> tmk
+bgs OR rpc -> nqq
+x13 XOR y13 -> fnc
+x31 AND y31 -> jsf
+y34 XOR x34 -> bcf
+ftg XOR mhv -> z06
+y10 AND x10 -> wnv
+x00 XOR y00 -> z00
+y15 AND x15 -> ptm
+fnc AND nbf -> mwj
+qmj XOR jqc -> z36
+bcf AND hqv -> cwc
+gkk XOR nrd -> z28
+kbm AND dgv -> vsb
+y34 AND x34 -> gbk
+y33 XOR x33 -> jkm
+y08 AND x08 -> wvw
+y39 XOR x39 -> fkg
+hhp XOR tjm -> dsd
+cwc OR gbk -> dgv
+dnd XOR nqd -> z16
+dts XOR gpv -> z07
+njf XOR jsb -> djg
+y36 AND x36 -> hjs
+y31 XOR x31 -> qvw
+stm OR mgr -> cpv
+y02 AND x02 -> kwm
+x03 AND y03 -> jmr
+wcc OR jjp -> fqp
+btd XOR scj -> z43
+y24 AND x24 -> hjm
+y32 XOR x32 -> pgs
+y12 XOR x12 -> jsb
+y23 XOR x23 -> tkb
+kfb OR njj -> gpv
+y22 XOR x22 -> kvp
+x16 XOR y16 -> nqd
+dhr AND cvb -> qqp
+y25 AND x25 -> ffg
+fbk XOR ntj -> z03
+wqw AND mtm -> rdt
+qvw AND smd -> dkq
+kgm OR smk -> rmg
+hww XOR fkc -> z11
+dcc OR wkn -> njf
+x09 XOR y09 -> pmb
+fbf OR npg -> gtk
+y15 XOR x15 -> ktv
+nbp XOR tnq -> z14
+tbs AND kvp -> njd
+qcp XOR pft -> z18
+sqr AND wpd -> tpj
+jmr OR dps -> mpf
+y20 AND x20 -> rpc
+tmc OR tpk -> fjb
+fsc OR bcq -> qjc
+qdg XOR fqp -> z27
+x28 AND y28 -> kgm
+y32 AND x32 -> psb
+y17 XOR x17 -> wjh
+mcq OR rpj -> sqr
+dsd XOR spf -> z38
+mfp AND rnc -> fbf
+dgh OR vpj -> z45
+jsb AND njf -> z12
+kgp OR kmb -> rkn
+dmn XOR rkw -> z30
+csm OR gvt -> cgt
+y03 XOR x03 -> fbk
+y05 XOR x05 -> kdm
+hhp AND tjm -> spj
+qjc XOR kbs -> sbg
+rqp AND hcd -> sqt
+x01 XOR y01 -> rvb
+y30 XOR x30 -> rkw
+wqw XOR mtm -> z08
+y08 XOR x08 -> wqw
+mrf OR pgc -> kvh
+x24 XOR y24 -> mcq
+jpc OR vsk -> hqv
+hww AND fkc -> dcc
+dhb AND ktv -> pks
+tbs XOR kvp -> z22
+trd OR jqg -> nrd
+jfn AND fjb -> vpj
+trw AND pmb -> pvb
+cpv AND wjh -> jtp
+kbm XOR dgv -> z35
+hhm XOR rmg -> z29
+y07 XOR x07 -> dts
+whm OR qss -> mtm
+nqq AND hgv -> mdk
+dmn AND rkw -> gwm
+x43 AND y43 -> tmc
+rmg AND hhm -> ktc
+jjc XOR mpf -> z04
+y23 AND x23 -> mks
+frt XOR pgs -> z32
+x19 XOR y19 -> kbs
+kvh AND fkg -> qns
+bnh OR sbg -> jwg
+qsg AND gtk -> fnq
+y11 XOR x11 -> fkc
+vfq OR psb -> wrg
+bpg OR jtp -> pft
+x29 AND y29 -> rwk
+qsg XOR gtk -> z42
+x07 AND y07 -> qss
+x41 AND y41 -> npg
+kvh XOR fkg -> z39
+jrb AND tmk -> wcc
+y36 XOR x36 -> qmj
+ntm OR mwj -> tnq
+y11 AND x11 -> wkn
+fjb XOR jfn -> z44
+rwk OR ktc -> dmn
+ktt XOR rvb -> z01
+mfp XOR rnc -> z41
+hgv XOR nqq -> z21
+x35 XOR y35 -> kbm
+y35 AND x35 -> mwp
+x42 AND y42 -> pcv
+dsd AND spf -> mrf
+y02 XOR x02 -> ssq
+x18 AND y18 -> fsc
+y04 XOR x04 -> jjc
+rkn XOR ssq -> z02
+x43 XOR y43 -> btd
+dhb XOR ktv -> z15
+x20 XOR y20 -> ckt
+jqc AND qmj -> vwj
+y21 AND x21 -> nqk
+x01 AND y01 -> kgp
+qjc AND kbs -> bnh
+fhf OR pvb -> rqp
+fnc XOR nbf -> z13
+dts AND gpv -> whm
+smd XOR qvw -> z31
+fjd OR sch -> ftg
+y06 XOR x06 -> mhv
+tmk XOR jrb -> z26
+y27 XOR x27 -> qdg
+x44 XOR y44 -> jfn
+qns OR rjk -> dhr
+kdm XOR cgt -> z05
+kwm OR vsc -> ntj
+x22 AND y22 -> bsr
+cvb XOR dhr -> z40
+y37 XOR x37 -> tjm
+x16 AND y16 -> mgr
+rkn AND ssq -> vsc
+ktt AND rvb -> kmb
+x10 XOR y10 -> hcd
+pmb XOR trw -> z09
+spj OR gqf -> z37
+y30 AND x30 -> bfn
+x26 AND y26 -> jjp
+jrr XOR hjm -> z24
+jwg AND ckt -> bgs
+x29 XOR y29 -> hhm
+x09 AND y09 -> fhf
+dnd AND nqd -> stm