From 5bed995d0139a8e337b88e45e682f6679bf57a06 Mon Sep 17 00:00:00 2001 From: FrederikBaerentsen Date: Tue, 24 Dec 2024 09:30:21 +0100 Subject: [PATCH] Solved 2024/24 P1 --- 2017/10/10.md | 2 +- 2024/20/20.md | 158 +++++++++++++++++ 2024/20/solution.py | 77 +++++++++ 2024/23/23.md | 92 ++++++++++ 2024/23/solution.py | 49 ++++++ 2024/24/24.md | 282 +++++++++++++++++++++++++++++++ 2024/24/solution.py | 125 ++++++++++++++ __pycache__/fred.cpython-311.pyc | Bin 35672 -> 36662 bytes fred.py | 23 +++ 9 files changed, 807 insertions(+), 1 deletion(-) create mode 100644 2024/20/20.md create mode 100644 2024/20/solution.py create mode 100644 2024/23/23.md create mode 100644 2024/23/solution.py create mode 100644 2024/24/24.md create mode 100644 2024/24/solution.py diff --git a/2017/10/10.md b/2017/10/10.md index 4d00aa5..6b47bc0 100644 --- a/2017/10/10.md +++ b/2017/10/10.md @@ -123,7 +123,7 @@ Once the rounds are complete, you will be left with the numbers from `0` to `255` in some order, called the *sparse hash*. Your next task is to reduce these to a list of only `16` numbers called the *dense hash*. To do this, use numeric bitwise -[XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) to combine +[](https://en.wikipedia.org/wiki/Bitwise_operation#) to combine each consecutive block of `16` numbers in the sparse hash (there are `16` such blocks in a list of `256` numbers). So, the first element in the dense hash is the first sixteen elements of the sparse hash XOR\'d diff --git a/2024/20/20.md b/2024/20/20.md new file mode 100644 index 0000000..e56ed12 --- /dev/null +++ b/2024/20/20.md @@ -0,0 +1,158 @@ +## \-\-- Day 20: Race Condition \-\-- + +The Historians are quite pixelated again. This time, a massive, black +building looms over you - you\'re [right outside](/2017/day/24) the CPU! + +While The Historians get to work, a nearby program sees that you\'re +idle and challenges you to a *race*. Apparently, you\'ve arrived just in +time for the frequently-held *race condition* festival! + +The race takes place on a particularly long and twisting code path; +programs compete to see who can finish in the *fewest picoseconds*. The +winner +even gets their very own +[mutex](https://en.wikipedia.org/wiki/Lock_(computer_science))! + +They hand you a *map of the racetrack* (your puzzle input). For example: + + ############### + #...#...#.....# + #.#.#.#.#.###.# + #S#...#.#.#...# + #######.#.#.### + #######.#.#...# + #######.#.###.# + ###..E#...#...# + ###.#######.### + #...###...#...# + #.#####.#.###.# + #.#...#.#.#...# + #.#.#.#.#.#.### + #...#...#...### + ############### + +The map consists of track (`.`) - including the *start* (`S`) and *end* +(`E`) positions (both of which also count as track) - and *walls* (`#`). + +When a program runs through the racetrack, it starts at the start +position. Then, it is allowed to move up, down, left, or right; each +such move takes *1 picosecond*. The goal is to reach the end position as +quickly as possible. In this example racetrack, the fastest time is `84` +picoseconds. + +Because there is only a single path from the start to the end and the +programs all go the same speed, the races used to be pretty boring. To +make things more interesting, they introduced a new rule to the races: +programs are allowed to *cheat*. + +The rules for cheating are very strict. *Exactly once* during a race, a +program may *disable collision* for up to *2 picoseconds*. This allows +the program to *pass through walls* as if they were regular track. At +the end of the cheat, the program must be back on normal track again; +otherwise, it will receive a [segmentation +fault](https://en.wikipedia.org/wiki/Segmentation_fault) +and get disqualified. + +So, a program could complete the course in 72 picoseconds (saving *12 +picoseconds*) by cheating for the two moves marked `1` and `2`: + + ############### + #...#...12....# + #.#.#.#.#.###.# + #S#...#.#.#...# + #######.#.#.### + #######.#.#...# + #######.#.###.# + ###..E#...#...# + ###.#######.### + #...###...#...# + #.#####.#.###.# + #.#...#.#.#...# + #.#.#.#.#.#.### + #...#...#...### + ############### + +Or, a program could complete the course in 64 picoseconds (saving *20 +picoseconds*) by cheating for the two moves marked `1` and `2`: + + ############### + #...#...#.....# + #.#.#.#.#.###.# + #S#...#.#.#...# + #######.#.#.### + #######.#.#...# + #######.#.###.# + ###..E#...12..# + ###.#######.### + #...###...#...# + #.#####.#.###.# + #.#...#.#.#...# + #.#.#.#.#.#.### + #...#...#...### + ############### + +This cheat saves *38 picoseconds*: + + ############### + #...#...#.....# + #.#.#.#.#.###.# + #S#...#.#.#...# + #######.#.#.### + #######.#.#...# + #######.#.###.# + ###..E#...#...# + ###.####1##.### + #...###.2.#...# + #.#####.#.###.# + #.#...#.#.#...# + #.#.#.#.#.#.### + #...#...#...### + ############### + +This cheat saves *64 picoseconds* and takes the program directly to the +end: + + ############### + #...#...#.....# + #.#.#.#.#.###.# + #S#...#.#.#...# + #######.#.#.### + #######.#.#...# + #######.#.###.# + ###..21...#...# + ###.#######.### + #...###...#...# + #.#####.#.###.# + #.#...#.#.#...# + #.#.#.#.#.#.### + #...#...#...### + ############### + +Each cheat has a distinct *start position* (the position where the cheat +is activated, just before the first move that is allowed to go through +walls) and *end position*; cheats are uniquely identified by their start +position and end position. + +In this example, the total number of cheats (grouped by the amount of +time they save) are as follows: + +- There are 14 cheats that save 2 picoseconds. +- There are 14 cheats that save 4 picoseconds. +- There are 2 cheats that save 6 picoseconds. +- There are 4 cheats that save 8 picoseconds. +- There are 2 cheats that save 10 picoseconds. +- There are 3 cheats that save 12 picoseconds. +- There is one cheat that saves 20 picoseconds. +- There is one cheat that saves 36 picoseconds. +- There is one cheat that saves 38 picoseconds. +- There is one cheat that saves 40 picoseconds. +- There is one cheat that saves 64 picoseconds. + +You aren\'t sure what the conditions of the racetrack will be like, so +to give yourself as many options as possible, you\'ll need a list of the +best cheats. *How many cheats would save you at least 100 picoseconds?* + +To begin, [get your puzzle input](20/input). + +Answer: + diff --git a/2024/20/solution.py b/2024/20/solution.py new file mode 100644 index 0000000..f5b9e79 --- /dev/null +++ b/2024/20/solution.py @@ -0,0 +1,77 @@ +#!/bin/python3 +import sys,time,re,copy +from pprint import pprint +sys.path.insert(0, '../../') +from fred import list2int,get_re,nprint,lprint,loadFile,dijkstra,toGrid,findInGrid,create_graph_from_grid,get_value_in_direction,addTuples +start_time = time.time() + +input_f = 'input' + +######################################### +# # +# Part 1 # +# # +######################################### +def part1(): + grid = toGrid(input_f) + start = findInGrid(grid,'S') + end = findInGrid(grid,'E') + graph = create_graph_from_grid(grid,start,end,'#') + #nprint(grid) + grid[start[0]][start[1]] = '.' + grid[end[0]][end[1]] = '.' + + path, dist = dijkstra(graph,start,end) + + cheatWalls = [] + + for r,row in enumerate(grid): + for c,pos in enumerate(row): + if pos == '.': + if get_value_in_direction(grid,(r,c),'up') == '#' and get_value_in_direction(grid,(r,c),'down') == '#': + cheatWalls.append(addTuples((r,c),(-1,0))) + cheatWalls.append(addTuples((r,c),(1,0))) + elif get_value_in_direction(grid,(r,c),'left') == '#' and get_value_in_direction(grid,(r,c),'right') == '#': + cheatWalls.append(addTuples((r,c),(0,-1))) + cheatWalls.append(addTuples((r,c),(0,1))) + if pos == '#': + if get_value_in_direction(grid,(r,c),'up') == '.' and get_value_in_direction(grid,(r,c),'down') == '.': + cheatWalls.append((r,c)) + cheatWalls.append((r,c)) + elif get_value_in_direction(grid,(r,c),'left') == '.' and get_value_in_direction(grid,(r,c),'right') == '.': + cheatWalls.append((r,c)) + cheatWalls.append((r,c)) + + + #print(dist) + #nprint(grid,positions=path) + + results = {} + startDist = dist + #print(cheatWalls) + for c in cheatWalls: + newGrid = copy.deepcopy(grid) + newGrid[c[0]][c[1]] = '.' + graph = create_graph_from_grid(newGrid,start,end,'#') + path, dist = dijkstra(graph,start,end) + dist = startDist-dist + if dist not in results: + results[dist] = 0 + results[dist] += 1 + + pprint(results) + +start_time = time.time() +print('Part 1:',part1(), '\t\t', round((time.time() - start_time)*1000), 'ms') + + +######################################### +# # +# Part 2 # +# # +######################################### +def part2(): + return + +start_time = time.time() +print('Part 2:',part2(), '\t\t', round((time.time() - start_time)*1000), 'ms') \ No newline at end of file diff --git a/2024/23/23.md b/2024/23/23.md new file mode 100644 index 0000000..2c788be --- /dev/null +++ b/2024/23/23.md @@ -0,0 +1,92 @@ +## \-\-- Day 23: LAN Party \-\-- + +As The Historians wander around a secure area at Easter Bunny HQ, you +come across posters for a [LAN +party](https://en.wikipedia.org/wiki/LAN_party) +scheduled for today! Maybe you can find it; you connect to a nearby +[datalink port](/2016/day/9) and download a map of the local network +(your puzzle input). + +The network map provides a list of every *connection between two +computers*. For 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 + +Each line of text in the network map represents a single connection; the +line `kh-tc` represents a connection between the computer named `kh` and +the computer named `tc`. Connections aren\'t directional; `tc-kh` would +mean exactly the same thing. + +LAN parties typically involve multiplayer games, so maybe you can locate +it by finding groups of connected computers. Start by looking for *sets +of three computers* where each computer in the set is connected to the +other two computers. + +In this example, there are `12` such sets of three inter-connected +computers: + + aq,cg,yn + aq,vc,wq + co,de,ka + co,de,ta + co,ka,ta + de,ka,ta + kh,qp,ub + qp,td,wh + tb,vc,wq + tc,td,wh + td,wh,yn + ub,vc,wq + +If the Chief Historian is here, *and* he\'s at the LAN party, it would +be best to know that right away. You\'re pretty sure his computer\'s +name starts with `t`, so consider only sets of three computers where at +least one computer\'s name starts with `t`. That narrows the list down +to `7` sets of three inter-connected computers: + + co,de,ta + co,ka,ta + de,ka,ta + qp,td,wh + tb,vc,wq + tc,td,wh + td,wh,yn + +Find all the sets of three inter-connected computers. *How many contain +at least one computer with a name that starts with `t`?* + +To begin, [get your puzzle input](23/input). + +Answer: + diff --git a/2024/23/solution.py b/2024/23/solution.py new file mode 100644 index 0000000..cf93742 --- /dev/null +++ b/2024/23/solution.py @@ -0,0 +1,49 @@ +#!/bin/python3 +import sys,time,re +from pprint import pprint +sys.path.insert(0, '../../') +from fred import list2int,get_re,nprint,lprint,loadFile,dprint,TSP,dfs_graph +start_time = time.time() + +input_f = 'test' + +######################################### +# # +# Part 1 # +# # +######################################### +def part1(): + graph = {} + + file = loadFile(input_f) + for f in file: + f = f.split('-') + if f[0] not in graph: + graph[f[0]] = [] + if f[1] not in graph: + graph[f[1]] = [] + graph[f[0]].append(f[1]) + graph[f[1]].append(f[0]) + dprint(graph) + + + + for key,values in graph.items(): + print(key) + print(dfs_graph(graph,key)) + input() + +start_time = time.time() +print('Part 1:',part1(), '\t\t', round((time.time() - start_time)*1000), 'ms') + + +######################################### +# # +# Part 2 # +# # +######################################### +def part2(): + return + +start_time = time.time() +print('Part 2:',part2(), '\t\t', round((time.time() - start_time)*1000), 'ms') \ No newline at end of file diff --git a/2024/24/24.md b/2024/24/24.md new file mode 100644 index 0000000..13767ba --- /dev/null +++ b/2024/24/24.md @@ -0,0 +1,282 @@ +## \-\-- Day 24: Crossed Wires \-\-- + +You and The Historians arrive at the edge of a [large +grove](/2022/day/23) somewhere in the jungle. After the last incident, +the Elves installed a small device that monitors the fruit. While The +Historians search the grove, one of them asks if you can take a look at +the monitoring device; apparently, it\'s been malfunctioning recently. + +The device seems to be trying to produce a number through some boolean +logic gates. Each gate has two inputs and one output. The gates all +operate on values that are either *true* (`1`) or *false* (`0`). + +- `AND` gates output `1` if *both* inputs are `1`; if either input is + `0`, these gates output `0`. +- `OR` gates output `1` if *one or both* inputs is `1`; if both inputs + are `0`, these gates output `0`. +- `XOR` gates output `1` if the inputs are *different*; if the inputs + are the same, these gates output `0`. + +Gates wait until both inputs are received before producing output; wires +can carry `0`, `1` or no value at all. There are no loops; once a gate +has determined its output, the output will not change until the whole +system is reset. Each wire is connected to at most one gate output, but +can be connected to many gate inputs. + +Rather than risk getting shocked while tinkering with the live system, +you write down all of the gate connections and initial wire values (your +puzzle input) so you can consider them in relative safety. For 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 + +Because gates wait for input, some wires need to start with a value (as +inputs to the entire system). The first section specifies these values. +For example, `x00: 1` means that the wire named `x00` starts with the +value `1` (as if a gate is already outputting that value onto that +wire). + +The second section lists all of the gates and the wires connected to +them. For example, `x00 AND y00 -> z00` describes an instance of an +`AND` gate which has wires `x00` and `y00` connected to its inputs and +which will write its output to wire `z00`. + +In this example, simulating these gates eventually causes `0` to appear +on wire `z00`, `0` to appear on wire `z01`, and `1` to appear on wire +`z02`. + +Ultimately, the system is trying to produce a *number* by combining the +bits on all wires starting with `z`. `z00` is the least significant bit, +then `z01`, then `z02`, and so on. + +In this example, the three output bits form the binary number `100` +which is equal to the decimal number `4`. + +Here\'s a larger 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 + +After waiting for values on all wires starting with `z`, the wires in +this system have the following values: + + bfw: 1 + bqk: 1 + djm: 1 + ffh: 0 + fgs: 1 + frj: 1 + fst: 1 + gnj: 1 + hwm: 1 + kjc: 0 + kpj: 1 + kwq: 0 + mjb: 1 + nrd: 1 + ntg: 0 + pbm: 1 + psh: 1 + qhw: 1 + rvg: 0 + tgd: 0 + tnw: 1 + vdt: 1 + wpb: 0 + z00: 0 + z01: 0 + z02: 0 + z03: 1 + z04: 0 + z05: 1 + z06: 1 + z07: 1 + z08: 1 + z09: 1 + z10: 1 + z11: 0 + z12: 0 + +Combining the bits from all wires starting with `z` produces the binary +number `0011111101000`. Converting this number to decimal produces +`2024`. + +Simulate the system of gates and wires. *What decimal number does it +output on the wires starting with `z`?* + +Your puzzle answer was `51715173446832`. + +The first half of this puzzle is complete! It provides one gold star: \* + +## \-\-- Part Two \-\-- {#part2} + +After inspecting the monitoring device more closely, you determine that +the system you\'re simulating is trying to *add two binary numbers*. + +Specifically, it is treating the bits on wires starting with `x` as one +binary number, treating the bits on wires starting with `y` as a second +binary number, and then attempting to add those two numbers together. +The output of this operation is produced as a binary number on the wires +starting with `z`. (In all three cases, wire `00` is the least +significant bit, then `01`, then `02`, and so on.) + +The initial values for the wires in your puzzle input represent *just +one instance* of a pair of numbers that sum to the wrong value. +Ultimately, *any* two binary numbers provided as input should be handled +correctly. That is, for any combination of bits on wires starting with +`x` and wires starting with `y`, the sum of the two numbers those bits +represent should be produced as a binary number on the wires starting +with `z`. + +For example, if you have an addition system with four `x` wires, four +`y` wires, and five `z` wires, you should be able to supply any four-bit +number on the `x` wires, any four-bit number on the `y` numbers, and +eventually find the sum of those two numbers as a five-bit number on the +`z` wires. One of the many ways you could provide numbers to such a +system would be to pass `11` on the `x` wires (`1011` in binary) and +`13` on the `y` wires (`1101` in binary): + + x00: 1 + x01: 1 + x02: 0 + x03: 1 + y00: 1 + y01: 0 + y02: 1 + y03: 1 + +If the system were working correctly, then after all gates are finished +processing, you should find `24` (`11+13`) on the `z` wires as the +five-bit binary number `11000`: + + z00: 0 + z01: 0 + z02: 0 + z03: 1 + z04: 1 + +Unfortunately, your actual system needs to add numbers with many more +bits and therefore has many more wires. + +Based on forensic analysis of scuff marks and +scratches on the device, you can tell that there are exactly *four* +pairs of gates whose output wires have been *swapped*. (A gate can only +be in at most one such pair; no gate\'s output was swapped multiple +times.) + +For example, the system below is supposed to find the bitwise `AND` of +the six-bit number on `x00` through `x05` and the six-bit number on +`y00` through `y05` and then write the result as a six-bit number on +`z00` through `z05`: + + 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 + +However, in this example, two pairs of gates have had their output wires +swapped, causing the system to produce wrong answers. The first pair of +gates with swapped outputs is `x00 AND y00 -> z05` and +`x05 AND y05 -> z00`; the second pair of gates is `x01 AND y01 -> z02` +and `x02 AND y02 -> z01`. Correcting these two swaps results in this +system that works as intended for any set of initial values on wires +that start with `x` or `y`: + + x00 AND y00 -> z00 + x01 AND y01 -> z01 + x02 AND y02 -> z02 + x03 AND y03 -> z03 + x04 AND y04 -> z04 + x05 AND y05 -> z05 + +In this example, two pairs of gates have outputs that are involved in a +swap. By sorting their output wires\' names and joining them with +commas, the list of wires involved in swaps is `z00,z01,z02,z05`. + +Of course, your actual system is much more complex than this, and the +gates that need their outputs swapped could be *anywhere*, not just +attached to a wire starting with `z`. If you were to determine that you +need to swap output wires `aaa` with `eee`, `ooo` with `z99`, `bbb` with +`ccc`, and `aoc` with `z24`, your answer would be +`aaa,aoc,bbb,ccc,eee,ooo,z24,z99`. + +Your system of gates and wires has *four* pairs of gates which need +their output wires swapped - *eight* wires in total. Determine which +four pairs of gates need their outputs swapped so that your system +correctly performs addition; *what do you get if you sort the names of +the eight wires involved in a swap and then join those names with +commas?* + +Answer: + +Although it hasn\'t changed, you can still [get your puzzle +input](24/input). + diff --git a/2024/24/solution.py b/2024/24/solution.py new file mode 100644 index 0000000..677112a --- /dev/null +++ b/2024/24/solution.py @@ -0,0 +1,125 @@ +#!/bin/python3 +import sys,time,re +from pprint import pprint +sys.path.insert(0, '../../') +from fred import list2int,get_re,nprint,lprint,loadFile,dprint +start_time = time.time() + +input_f = 'input' + +def loadGates(input_f): + gates = {} + instructions = [] + with open(input_f) as file: + for line in file: + if ':' in line: + tmp = line.split(': ') + gates[tmp[0]] = int(tmp[1]) + if '->' in line: + tmp = line.replace('-> ','').rstrip().split(' ') + instructions.append(tmp) + return gates, instructions + +######################################### +# # +# Part 1 # +# # +######################################### +def part1(): + gates, instructions = loadGates(input_f) + + #print(gates) + #print(instructions) + wait_for = [] + for inst in instructions: + + x,logic,y,z = inst + + if x not in gates or y not in gates: + #print(inst) + wait_for.append(inst) + continue + + for wdx, w in enumerate(wait_for): + x,logic,y,z = w + if x in gates and y in gates: + #print(wait_for,w,wdx) + # `AND` gates output `1` if *both* inputs are `1`; if either input is `0`, these gates output `0`. + if logic == 'AND': + gates[z] = 1 if gates[x] and gates[y] else 0 + + # `OR` gates output `1` if *one or both* inputs is `1`; if both inputs are `0`, these gates output `0`. + if logic == 'OR': + gates[z] = 1 if gates[x] or gates[y] else 0 + + # `XOR` gates output `1` if the inputs are *different*; if the inputs are the same, these gates output `0`. + if logic == 'XOR': + gates[z] = 1 if gates[x] != gates[y] else 0 + wait_for.pop(wdx) + #input() + + x,logic,y,z = inst + + # `AND` gates output `1` if *both* inputs are `1`; if either input is `0`, these gates output `0`. + if logic == 'AND': + gates[z] = 1 if gates[x] and gates[y] else 0 + + # `OR` gates output `1` if *one or both* inputs is `1`; if both inputs are `0`, these gates output `0`. + if logic == 'OR': + gates[z] = 1 if gates[x] or gates[y] else 0 + + # `XOR` gates output `1` if the inputs are *different*; if the inputs are the same, these gates output `0`. + if logic == 'XOR': + gates[z] = 1 if gates[x] != gates[y] else 0 + + while len(wait_for) > 0: + for wdx, w in enumerate(wait_for): + x,logic,y,z = w + if x in gates and y in gates: + #print(wait_for,w,wdx) + # `AND` gates output `1` if *both* inputs are `1`; if either input is `0`, these gates output `0`. + if logic == 'AND': + gates[z] = 1 if gates[x] and gates[y] else 0 + + # `OR` gates output `1` if *one or both* inputs is `1`; if both inputs are `0`, these gates output `0`. + if logic == 'OR': + gates[z] = 1 if gates[x] or gates[y] else 0 + + # `XOR` gates output `1` if the inputs are *different*; if the inputs are the same, these gates output `0`. + if logic == 'XOR': + gates[z] = 1 if gates[x] != gates[y] else 0 + wait_for.pop(wdx) + + #dprint(gates) + result = '' + + countZ = 0 + + for g in gates.keys(): + if g[0] == 'z': + countZ += 1 + + for i in range(countZ-1,-1,-1): + #print(i) + #print(g,gates[g]) + if i < 10: + result += str(gates['z0'+str(i)]) + else: + result += str(gates['z'+str(i)]) + print(result) + return int(result, 2) + +start_time = time.time() +print('Part 1:',part1(), '\t\t', round((time.time() - start_time)*1000), 'ms') + + +######################################### +# # +# Part 2 # +# # +######################################### +def part2(): + return + +start_time = time.time() +print('Part 2:',part2(), '\t\t', round((time.time() - start_time)*1000), 'ms') \ No newline at end of file diff --git a/__pycache__/fred.cpython-311.pyc b/__pycache__/fred.cpython-311.pyc index 5eb4c884e4530724180081d5698a8d9729a9303c..1714e73ac193a4df983f81a17ace8baa22ed9c61 100644 GIT binary patch delta 1243 zcmaKre`s4(6vyv& zZe6eBBAcI&%XoCJ1g~rjP7fqUvdOd&Wyc7k8AeTNWRpgmWD}Ic z8Dx?11Z9+r(qkrxf?=d}YLcF8E|a2Wm_!Yoj73v9@QG+DX=Y85juC?<A-LWByvJmrSBKIxE4};ckur^wJ$ucoLVCG0dF&Wz#o3zez`fhz&zRSYltn#45s8 z*{ZNV2VBwgm^s|oGJ8TezXzBqfRKDX&s@TH4KUGhJ2CP|Dm@ZSnfoHQU8g~Y`8=f6 z^QdZfzwMlLmItQS?16QApkfbH{hc3Z?`g}S^U|8XcirDxLy{J1pm?C_-h67j;_ia0 z>Isy!Q$1^*;JPPR@dWEN^`AWEf$A3|c2Eck0m4dC@MYl;3Y*duuwEhk{h%B^pJqTr z%R=E{FzR*Cc*BR>n@V(^<{z&qiV9Nx7p+Kj#x)jDn*!uUFWajawWE$B1hfz$cVQGLk&NH1;q31VzcKxDD&0f)?og0&jk{$E;f}eLx9g(oi=cblaC#=3|b)7h`N_Wb<^2R02FT)}ixcPLhoj>_P zC;z0d7q|19g%z6*+^TF{eDgHM+xUT*Pq#E)YD1Ga1SZ5VQIq-j)?%ll9Za~8x!u}d aT$b+f;z0SC8iHxLIW_EmA;PcDvcCZLT4*r< delta 548 zcmdlskLkuVCcfpoyj%=GuykWm`iJC+d=iWq6V<~QjVIRSGn!0%r^{$MS%y)W(QL8< zqp~4ODtn4M2G*QX_>im_gHg^AbjX zMkYgx&0m>xGB%&j%VcJpzuB_LhmrB^WXUQS@ozwzs{~TgiuG)A@{<#DitY4(oJEs& z7EhCU36v}91`!}tMQ=ew7l?Q>IkQBX3oHmCCT#92*~`fK3&>ovIiPG66VUA66^e`p zC(BlzF?bKs@exR9au)psu|d8q;sFt#K*VPdaSTL2Yymlo4aBSxpHwNr0(8xh$-z}s z>Y7YNo*-2!Kthx47He{9PEK(V*o_d4Ajy9WliyaUure|-Fl^W?R^82__W>l#1SEbj zDi`ep>E*=gf-fL-Unifh4`qBfS+!vb6AR;Hhf0abmm6}KUNKE}YMjQ(4m9=r=DUq6 zSegDYO>S@Bz{bc7)WkK}wxfuVW%7oO)oemQCGVIvCw9(dWYnDezw3}F*lnPoDFQjF w2xLZ)(B#|Qvclp(CJ-?ca{*2Hz|6?Vcw@3)kL+am9=6STJta(&kMtD*0O*mTNB{r; diff --git a/fred.py b/fred.py index 27faa62..ce419a6 100644 --- a/fred.py +++ b/fred.py @@ -653,6 +653,29 @@ def bfs(start, is_goal, get_neighbors, max_depth=float('inf')): return goal_nodes, paths_to_goal +def dfs_graph(graph: dict, start) -> list: + """ + Perform a DFS starting from the given position in the graph. + + Args: + graph (dict): Dictionary representing the graph where keys are nodes (tuples) and values are lists of neighbors. + start: Starting node in the graph. + + Returns: + list: List of visited nodes. + """ + visited = set() + + def dfs_graph(node): + visited.add(node) + for neighbor in graph.get(node, []): + if neighbor not in visited: + dfs_graph(neighbor) + + dfs_graph(start) + return list(visited) + + def dfs(grid:list, pos:set) -> list: """ Perform a flood fill/dfs starting from the given position in the grid.