day 24 hurts my brain, thanks reddit

2024/day19/day19.py

@@ -0,0 +1,87 @@
+from dataclasses import dataclass
+from typing import Self
+
+
+@dataclass
+class TrieNode:
+    char: str
+    is_terminator: bool
+    children: dict[str, Self]
+
+
+def day19(input: str, part: int) -> int:
+    # trie data structure works nicely... but is it necessary for part 2...
+    input_lines = input.splitlines()
+
+    root = TrieNode("", False, {})
+    for towel in input_lines[0].split(", "):
+        iter = root
+        for i, char in enumerate(towel):
+            if char not in iter.children:
+                iter.children[char] = TrieNode(char, i == len(towel) - 1, {})
+            iter = iter.children[char]
+            # update for matching towels that are smaller than a pervious one
+            # e.g. "towel" then "tow" needs to update the "w" node
+            iter.is_terminator |= i == len(towel) - 1
+
+    possible_towels: int = 0
+    total: int = 0
+
+    memo: dict[str, int] = {}
+    for maybe_towel in input_lines[2:]:
+        combos = is_possible_towel(root, maybe_towel, memo)
+        if combos > 0:
+            possible_towels += 1
+            total += combos
+
+    if part == 1:
+        return possible_towels
+
+    return total
+
+
+# memo optimization added for part 2
+def is_possible_towel(trie: TrieNode, towel: str, memo: dict[str, int]) -> int:
+    if towel == "":
+        return 1
+    if towel in memo:
+        return memo[towel]
+
+    iter = trie
+    total: int = 0
+    for i, char in enumerate(towel):
+        if char not in iter.children:
+            break
+
+        iter = iter.children[char]
+
+        # if iterated to a terminator, we can restart recursively and if that
+        # "works" (aka returns positive number of possible combos), then we can
+        # sum the combos and then continue along this for loop to account for
+        # larger towels that do not end at this index
+        if iter.is_terminator:
+            total += is_possible_towel(trie, towel[i + 1 :], memo)
+
+    memo[towel] = total
+
+    return total
+
+
+example = """r, wr, b, g, bwu, rb, gb, br
+
+brwrr
+bggr
+gbbr
+rrbgbr
+ubwu
+bwurrg
+brgr
+bbrgwb"""
+
+input = open("input.txt").read().strip()
+
+print(f"day19 example: {day19(example, 1)}, want 6")
+print(f"day19 actual: {day19(input, 1)}, want 216")
+
+print(f"part2 example: {day19(example ,2)}, want 16")
+print(f"part2 actual: {day19(input ,2)}, want 603191454138773")

2024/day20/day20.py

@@ -0,0 +1,170 @@
+from collections import defaultdict
+
+
+def day20(input: str, cheats: int) -> dict[int, int]:
+    # get minimum without cheats, do this backwards by propagating from E to S
+    #   to populate a grid of the distance from each cell to E
+    grid: list[list[str]] = [list(line) for line in input.splitlines()]
+
+    row: int = 0
+    col: int = 0
+
+    for r in range(len(grid)):
+        for c in range(len(grid[0])):
+            if grid[r][c] == "E":
+                row = r
+                col = c
+
+    # default value set to 100_000 which is bigger than entire grid's area so
+    # walls will not be usable as paths to finish
+    dp_steps_to_end: list[list[int]] = [
+        [100_000 for _ in range(len(grid[0]))] for _ in range(len(grid))
+    ]
+
+    diffs = [(0, 1), (0, -1), (-1, 0), (1, 0)]
+    queue: list[tuple[int, int, int]] = [(row, col, 0)]
+    visited: set[tuple[int, int]] = set()
+    while len(queue) > 0:
+        row, col, steps = queue.pop(0)
+        dp_steps_to_end[row][col] = steps
+        visited.add((row, col))
+
+        for diff in diffs:
+            next_row, next_col = row + diff[0], col + diff[1]
+            if 0 <= next_row < len(grid) and 0 <= next_col < len(grid[0]):
+                if grid[next_row][next_col] != "#":
+                    if (next_row, next_col) not in visited:
+                        queue.append((next_row, next_col, steps + 1))
+
+    # then starting from S, BFS but from each cell, view all cells <cheats> cells away
+    # if it's a valid shortcut, record it
+
+    second_saved_freqs: dict[int, int] = defaultdict(int)
+
+    reachable_diffs = get_reachable_coords_within_x_steps(cheats)
+
+    # visited contains coords of the entire path, so just use that...
+    for path_coord in visited:
+        r, c = path_coord
+        for diff in reachable_diffs:
+            rr = path_coord[0] + diff[0]
+            cc = path_coord[1] + diff[1]
+
+            if 0 <= rr < len(grid) and 0 <= cc < len(grid[0]):
+                if grid[rr][cc] != "#":
+                    savings = dp_steps_to_end[r][c] - (
+                        dp_steps_to_end[rr][cc] + abs(diff[0]) + abs(diff[1])
+                    )
+                    if savings > 0:
+                        second_saved_freqs[savings] += 1
+
+    return second_saved_freqs
+
+
+# helper function to get all coords that are reachable within allotted cheats
+def get_reachable_coords_within_x_steps(x: int) -> list[tuple[int, int]]:
+    coords_map: dict[tuple[int, int], bool] = {}
+
+    queue: list[tuple[int, int]] = [(0, 0)]
+    for _ in range(x):
+        next_queue: list[tuple[int, int]] = []
+        while len(queue) > 0:
+            front = queue.pop(0)
+            for diff in [(0, -1), (0, 1), (-1, 0), (1, 0)]:
+                coord = (front[0] + diff[0], front[1] + diff[1])
+                if coord not in coords_map:
+                    coords_map[coord] = True
+                    next_queue.append(coord)
+        queue = next_queue
+
+    return list(coords_map.keys())
+
+
+example = """###############
+#...#...#.....#
+#.#.#.#.#.###.#
+#S#...#.#.#...#
+#######.#.#.###
+#######.#.#...#
+#######.#.###.#
+###..E#...#...#
+###.#######.###
+#...###...#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############"""
+
+# python is weird and we can use == to compare 2 dicts for the same keys and values...
+example_seconds_saved_to_freq: dict[int, int] = {
+    2: 14,
+    4: 14,
+    6: 2,
+    8: 4,
+    10: 2,
+    12: 3,
+    20: 1,
+    36: 1,
+    38: 1,
+    40: 1,
+    64: 1,
+}
+
+part1_example_result = day20(example, 2)
+print(
+    f"part1 example: {part1_example_result == example_seconds_saved_to_freq} want True"
+)
+if part1_example_result != example_seconds_saved_to_freq:
+    print(
+        f"\tDEBUG part1 example got: {part1_example_result} want {(example_seconds_saved_to_freq)}"
+    )
+
+input = open("input.txt").read().strip()
+
+
+def sum_keys_over_x(d: dict[int, int], x: int) -> int:
+    total: int = 0
+    for k, v in d.items():
+        if k >= x:
+            total += v
+    return total
+
+
+part1_result = day20(input, 2)
+
+print(
+    f"part1 actual: {sum_keys_over_x(part1_result, 100)} cheats save 100+ picosecs want 1422"
+)
+
+part2_example_result: dict[int, int] = {
+    50: 32,
+    52: 31,
+    54: 29,
+    56: 39,
+    58: 25,
+    60: 23,
+    62: 20,
+    64: 19,
+    66: 12,
+    68: 14,
+    70: 12,
+    72: 22,
+    74: 4,
+    76: 3,
+}
+
+part2_result = day20(example, 20)
+part2_result_50 = {}
+for k, v in part2_example_result.items():
+    if k >= 50:
+        part2_result_50[k] = v
+
+print(f"part2 example: {part2_result_50 == part2_example_result} want True")
+if part2_result_50 != part2_example_result:
+    print(
+        f"DEBUG part2 example 50+ saved: {part2_result_50} want {part2_example_result}"
+    )
+
+part2_result = day20(input, 20)
+print(f"part2 actual: {sum_keys_over_x(part2_result, 100)} want 1009299")

2024/day22/day22.py

@@ -0,0 +1,58 @@
+from collections import defaultdict
+
+
+def day22(input: str, part: int) -> int:
+    total: int = 0
+
+    last_four_diffs_to_price: dict[tuple[int, int, int, int], int] = defaultdict(int)
+
+    for line in input.splitlines():
+        nums: list[int] = [int(line)]
+        diffs: list[int] = []
+
+        seen_last_fours: set[tuple[int, int, int, int]] = set()
+        for _ in range(2000):
+            nums.append(get_next_secret_number(nums[-1]))
+            diff = nums[-1] % 10 - nums[-2] % 10
+            diffs.append(diff)
+        total += nums[-1]
+
+        for i in range(3, len(diffs)):
+            last_four_diffs = (diffs[i - 3], diffs[i - 2], diffs[i - 1], diffs[i])
+            # only count the first time we've seen this set of diffs, aka only sell once
+            if last_four_diffs in seen_last_fours:
+                continue
+            seen_last_fours.add(last_four_diffs)
+
+            last_four_diffs_to_price[last_four_diffs] += nums[i + 1] % 10
+
+    if part == 1:
+        return total
+
+    most_bananas = max(last_four_diffs_to_price.values())
+    return most_bananas
+
+
+def get_next_secret_number(num: int) -> int:
+    num = (num ^ (num * 64)) % 16777216
+    num = (num ^ (num // 32)) % 16777216
+    num = (num ^ (num * 2048)) % 16777216
+    return num
+
+
+example = """1
+10
+100
+2024"""
+
+input = open("input.txt").read().strip()
+
+print(f"part1 example: {day22(example, 1)} want 37327623")
+print(f"part1 actual: {day22(input, 1)} want 17612566393")
+
+example_part_2 = """1
+2
+3
+2024"""
+print(f"part2 example: {day22(example_part_2, 2)} want 23")
+print(f"part2 actual: {day22(input, 2)} want 1968")

2024/day23/day23.py

@@ -0,0 +1,106 @@
+from collections import defaultdict
+
+
+def part1(input: str) -> int:
+    graph: dict[str, set[str]] = defaultdict(set)
+    for line in input.splitlines():
+        parts = line.split("-")
+        graph[parts[0]].add(parts[1])
+        graph[parts[1]].add(parts[0])
+
+    ans_groups: set[str] = set()
+    for node in graph:
+        if node[0] != "t":
+            continue
+        neighbors = graph[node]
+        for neighbor in neighbors:
+            for neighbor2 in neighbors:
+                if neighbor == neighbor2:
+                    continue
+                if neighbor2 in graph[neighbor]:
+                    group: list[str] = [node, neighbor, neighbor2]
+                    group.sort()
+
+                    ans_groups.add(",".join(group))
+
+    return len(ans_groups)
+
+
+def part2(input: str) -> str:
+    graph: dict[str, set[str]] = defaultdict(set)
+    for line in input.splitlines():
+        parts = line.split("-")
+        graph[parts[0]].add(parts[1])
+        graph[parts[1]].add(parts[0])
+
+    seen: set[str] = set()
+    largest_group: set[str] = set()
+    for node in graph:
+        if node in seen:
+            continue
+        seen.add(node)
+
+        group: set[str] = {node}
+        for neighbor in graph[node]:
+            if check_group_against_new_node(group, graph, neighbor):
+                group.add(neighbor)
+                seen.add(neighbor)
+
+        if len(group) > len(largest_group):
+            largest_group = group
+
+    final_group: list[str] = list(largest_group)
+    final_group.sort()
+    return ",".join(final_group)
+
+
+def check_group_against_new_node(
+    group: set[str], graph: dict[str, set[str]], node_to_add: str
+) -> bool:
+    for node in group:
+        if node not in graph[node_to_add]:
+            return False
+
+    return True
+
+
+example = """kh-tc
+qp-kh
+de-cg
+ka-co
+yn-aq
+qp-ub
+cg-tb
+vc-aq
+tb-ka
+wh-tc
+yn-cg
+kh-ub
+ta-co
+de-co
+tc-td
+tb-wq
+wh-td
+ta-ka
+td-qp
+aq-cg
+wq-ub
+ub-vc
+de-ta
+wq-aq
+wq-vc
+wh-yn
+ka-de
+kh-ta
+co-tc
+wh-qp
+tb-vc
+td-yn"""
+
+input = open("input.txt").read().strip()
+
+print(f"part1 example: {part1(example)} want 7")
+print(f"part1 actual: {part1(input)} want 1485")
+
+print(f"part2 example: {part2(example)} want co,de,ka,ta")
+print(f"part2 actual: {part2(input)} want cc,dz,ea,hj,if,it,kf,qo,sk,ug,ut,uv,wh")

2024/day24/day24.py

@@ -0,0 +1,250 @@
+from collections import defaultdict
+import copy
+
+
+def part1(input: str) -> int:
+    wires, instructions = parse_input(input)
+    run(instructions, wires)
+    return get_num(wires, "z")
+
+
+def parse_input(input: str) -> tuple[dict[str, int], list[list[str]]]:
+    parts = input.split("\n\n")
+
+    wires: dict[str, int] = defaultdict(int)
+
+    for line in parts[0].splitlines():
+        wires[line[:3]] = int(line[5:])
+
+    instructions: list[list[str]] = []
+    for line in parts[1].splitlines():
+        in1, op, in2, _, out = line.split(" ")
+        instructions.append([in1, op, in2, out])
+
+    return (wires, instructions)
+
+
+def get_num(wires: dict[str, int], char: str) -> int:
+    if len(char) != 1:
+        raise Exception("exactly one char needed for get_num")
+    keys: list[str] = []
+    for wire in wires:
+        if wire[0] == char:
+            keys.append(wire)
+    keys.sort()
+    binary_num: str = ""
+    for key in reversed(keys):
+        binary_num += str(wires[key])
+
+    return int(binary_num, 2)
+
+
+def run(instructions: list[list[str]], wires: dict[str, int]):
+    processed_lines: set[int] = set()
+    while len(processed_lines) < len(instructions):
+        processed_before: int = len(processed_lines)
+
+        for i, inst in enumerate(instructions):
+            if i in processed_lines:
+                continue
+            in1, op, in2, out = inst
+            if in1 not in wires or in2 not in wires:
+                continue
+
+            if op == "AND":
+                wires[out] = wires[in1] & wires[in2]
+            elif op == "OR":
+                wires[out] = wires[in1] | wires[in2]
+            elif op == "XOR":
+                wires[out] = wires[in1] ^ wires[in2]
+
+            processed_lines.add(i)
+
+        if len(processed_lines) == processed_before:
+            # print("no new lines processed")
+            return
+
+
+# this code is way too slow, works for the examples but unsurprisingly way too
+# slow for the actual input. ditching python for a go solution...
+def part2(input: str) -> str:
+    wires, instructions = parse_input(input)
+    expected_sum: int = get_num(wires, "x") & get_num(wires, "y")
+
+    def any_values_are_equal(*args: int) -> bool:
+        seen: set[int] = set()
+        for val in args:
+            if val in seen:
+                return True
+            seen.add(val)
+        return False
+
+    # generate swaps... maybe 8 nested for loops...
+    for a in range(len(instructions)):
+        print(a)
+        for b in range(a + 1, len(instructions)):
+            for c in range(a + 1, len(instructions)):
+                if any_values_are_equal(b, c):
+                    continue
+                for d in range(a + 1, len(instructions)):
+                    if any_values_are_equal(b, c, d):
+                        continue
+                    for e in range(a + 1, len(instructions)):
+                        if any_values_are_equal(b, c, d, e):
+                            continue
+                        for f in range(a + 1, len(instructions)):
+                            if any_values_are_equal(b, c, d, e, f):
+                                continue
+                            for g in range(a + 1, len(instructions)):
+                                if any_values_are_equal(b, c, d, e, f, g):
+                                    continue
+                                for h in range(a + 1, len(instructions)):
+                                    if any_values_are_equal(b, c, d, e, f, g, h):
+                                        continue
+
+                                    instructions[a][3], instructions[b][3] = (
+                                        instructions[b][3],
+                                        instructions[a][3],
+                                    )
+                                    instructions[c][3], instructions[d][3] = (
+                                        instructions[d][3],
+                                        instructions[c][3],
+                                    )
+
+                                    instructions[e][3], instructions[f][3] = (
+                                        instructions[f][3],
+                                        instructions[e][3],
+                                    )
+                                    instructions[g][3], instructions[h][3] = (
+                                        instructions[h][3],
+                                        instructions[g][3],
+                                    )
+
+                                    wires_copy = copy.deepcopy(wires)
+                                    run(instructions, wires_copy)
+                                    sum = get_num(wires_copy, "z")
+                                    if sum == expected_sum:
+                                        swaps: list[str] = [
+                                            instructions[a][3],
+                                            instructions[b][3],
+                                            instructions[c][3],
+                                            instructions[d][3],
+                                            instructions[e][3],
+                                            instructions[f][3],
+                                            instructions[g][3],
+                                            instructions[h][3],
+                                        ]
+                                        swaps.sort()
+                                        return ",".join(swaps)
+                                    # backtrack
+                                    instructions[a][3], instructions[b][3] = (
+                                        instructions[b][3],
+                                        instructions[a][3],
+                                    )
+                                    instructions[c][3], instructions[d][3] = (
+                                        instructions[d][3],
+                                        instructions[c][3],
+                                    )
+                                    instructions[e][3], instructions[f][3] = (
+                                        instructions[f][3],
+                                        instructions[e][3],
+                                    )
+                                    instructions[g][3], instructions[h][3] = (
+                                        instructions[h][3],
+                                        instructions[g][3],
+                                    )
+
+    raise Exception("should return from loop")
+
+
+example = """x00: 1
+x01: 1
+x02: 1
+y00: 0
+y01: 1
+y02: 0
+
+x00 AND y00 -> z00
+x01 XOR y01 -> z01
+x02 OR y02 -> z02"""
+
+print(f"part1 example: {part1(example)} want 4")
+
+big_example = """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"""
+
+print(f"part1 big_example: {part1(big_example)} want 2024")
+
+input = open("input.txt").read().strip()
+print(f"part1 actual: {part1(input)} want 38869984335432")
+
+part2_example_2_pairs_swapped = """x00: 0
+x01: 1
+x02: 0
+x03: 1
+x04: 0
+x05: 1
+y00: 0
+y01: 0
+y02: 1
+y03: 1
+y04: 0
+y05: 1
+
+x00 AND y00 -> z05
+x01 AND y01 -> z02
+x02 AND y02 -> z01
+x03 AND y03 -> z03
+x04 AND y04 -> z04
+x05 AND y05 -> z00"""
+
+# print(
+#     f"part2 example with two swapped {part2(part2_example_2_pairs_swapped)} want z00,z01,z02,z05"
+# )
+
+print(f"part2 actual: {part2(input)} want QQ")

2024/day24/main.go

@@ -0,0 +1,259 @@
+package main
+
+import (
+	_ "embed"
+	"flag"
+	"fmt"
+	"log"
+	"math/rand"
+	"sort"
+	"strings"
+
+	"github.com/alexchao26/advent-of-code-go/cast"
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+//go:embed input.txt
+var input string
+
+func init() {
+	// do this in init (not main) so test file has same input
+	input = strings.TrimRight(input, "\n")
+	if len(input) == 0 {
+		panic("empty input.txt file")
+	}
+}
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	flag.Parse()
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(input)
+		util.CopyToClipboard(fmt.Sprintf("%v", ans))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(input)
+		// drg,gvw,jbp,jgc,qjb,z15,z22,z35
+		util.CopyToClipboard(fmt.Sprintf("%v", ans))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	calc := parseInput(input)
+	res := 0
+
+	cache := map[string]int{}
+
+	for k, v := range calc.wires {
+		cache[k] = v
+	}
+
+	for k := range calc.outputToSource {
+		if k[0] != 'z' {
+			continue
+		}
+
+		val, err := getWireVal(k, calc, cache, 0)
+
+		if err != nil {
+			log.Fatalf("Did not expect error\n")
+		}
+
+		if val == 0 {
+			continue
+		}
+
+		i := cast.ToInt(k[1:])
+
+		res += 1 << int(i)
+	}
+
+	return res
+}
+
+func part2(input string) string {
+	calc := parseInput(input)
+
+	swaps := map[string]bool{}
+	ans := map[string]bool{}
+
+	fmt.Println("this will take a while to run")
+	backtrack(0, calc, swaps, ans)
+
+	wires := []string{}
+	for wire := range ans {
+		wires = append(wires, wire)
+	}
+
+	sort.Strings(wires)
+
+	return strings.Join(wires, ",")
+}
+
+func getWireVal(wire string, calc Calculator, cache map[string]int, depth int) (int, error) {
+	if val, ok := cache[wire]; ok {
+		return val, nil
+	}
+
+	if depth > 200 {
+		return -1, fmt.Errorf("likely a loop, exit")
+	}
+
+	op, ok := calc.outputToSource[wire]
+
+	if !ok {
+		return -1, fmt.Errorf("cannot get value for wire %v", wire)
+	}
+
+	v1, _ := getWireVal(op.inputs[0], calc, cache, depth+1)
+	v2, _ := getWireVal(op.inputs[1], calc, cache, depth+1)
+
+	val := 0
+	if op.op == "AND" {
+		val = v1 & v2
+	} else if op.op == "OR" {
+		val = v1 | v2
+	} else if op.op == "XOR" {
+		val = v1 ^ v2
+	}
+
+	cache[wire] = val
+
+	return val, nil
+}
+
+func getFirstWrong(calc Calculator) (int, map[string]int, error) {
+	cRes := map[string]int{}
+	bRes := 100
+
+	for range 10 {
+		cache := map[string]int{}
+
+		carry := 0
+		for b := range 45 {
+			xStr := fmt.Sprintf("x%02d", b)
+			yStr := fmt.Sprintf("y%02d", b)
+			zStr := fmt.Sprintf("z%02d", b)
+
+			cache[xStr] = rand.Intn(2)
+			cache[yStr] = rand.Intn(2)
+
+			x := cache[xStr]
+			y := cache[yStr]
+
+			zCalc, err := getWireVal(zStr, calc, cache, 0)
+
+			if err != nil {
+				return -1, nil, err
+			}
+
+			zExp := (x + y + carry) % 2
+			carry = (x + y + carry) / 2
+
+			if zCalc != zExp && b < bRes {
+				bRes = b
+				cRes = cache
+				break
+			}
+		}
+	}
+
+	if bRes == 100 {
+		bRes = -1
+	}
+
+	return bRes, cRes, nil
+}
+
+func checkCalc(calc Calculator) bool {
+	bErr, _, err := getFirstWrong(calc)
+
+	return bErr == -1 && err == nil
+}
+
+func backtrack(b int, calc Calculator, swaps map[string]bool, ans map[string]bool) {
+	if len(ans) > 0 {
+		return
+	}
+	// fmt.Printf("Checking %v with swaps\n%v\n", b, swaps)
+	if len(swaps) == 8 {
+		if checkCalc(calc) {
+			for k := range swaps {
+				ans[k] = true
+			}
+		}
+
+		return
+	}
+
+	bErr, conns, err := getFirstWrong(calc)
+
+	if bErr < b || err != nil {
+		return
+	}
+
+	conns2 := map[string]Connections{}
+
+	for k, v := range calc.outputToSource {
+		conns2[k] = v
+	}
+
+	for c1 := range conns {
+		if swaps[c1] || c1[0] == 'x' || c1[0] == 'y' {
+			continue
+		}
+
+		for c2 := range conns2 {
+			if c2 == c1 || swaps[c2] || c2[0] == 'x' || c2[0] == 'y' {
+				continue
+			}
+
+			calc.outputToSource[c1], calc.outputToSource[c2] = calc.outputToSource[c2], calc.outputToSource[c1]
+
+			swaps[c1] = true
+			swaps[c2] = true
+
+			backtrack(bErr+1, calc, swaps, ans)
+
+			delete(swaps, c2)
+			delete(swaps, c1)
+
+			calc.outputToSource[c1], calc.outputToSource[c2] = calc.outputToSource[c2], calc.outputToSource[c1]
+		}
+	}
+}
+
+type Connections struct {
+	inputs []string
+	op     string
+}
+
+type Calculator struct {
+	outputToSource map[string]Connections
+	wires          map[string]int
+}
+
+func parseInput(input string) Calculator {
+	parts := strings.Split(input, "\n\n")
+
+	wires := map[string]int{}
+	for _, line := range strings.Split(parts[0], "\n") {
+		wires[line[:3]] = cast.ToInt(line[5:])
+	}
+
+	outputToSource := map[string]Connections{}
+	for _, line := range strings.Split(parts[1], "\n") {
+		lineParts := strings.Split(line, " ")
+		in1, op, in2, out := lineParts[0], lineParts[1], lineParts[2], lineParts[4]
+		outputToSource[out] = Connections{
+			inputs: []string{in1, in2},
+			op:     op,
+		}
+	}
+
+	return Calculator{outputToSource, wires}
+}