advent_of_ruby 0.2.0 → 0.3.0

data/data/solutions/reddit/ruby/2023/20.yml

@@ -0,0 +1,90 @@
+---
+- :author: RelativeLead5
+  :url: https://www.reddit.com/r/adventofcode/comments/18mmfxb/2023_day_20_solutions/ke9prw0/
+  :body: |-
+    Parts 1 & 2
+
+    [Pastebin](https://pastebin.com/H1UBvwji)
+
+    Thanks to everyone for the hints on Part 2. I left part 2 running while I was gone for a couple of hours and when it wasn't done when I came back, the head scratching began.
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/18mmfxb/2023_day_20_solutions/ke7jig8/
+  :body: |-
+    Fun one today, lcm for the win (again)!!
+
+    [Github](https://github.com/careyi3/aoc_2023/tree/master/solutions/20)
+
+    [Video Walkthrough](https://youtu.be/yjPjLHpHbnk)
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/18mmfxb/2023_day_20_solutions/ke5i6ni/
+  :body: |-
+    I'm a SystemVerilog RTL designer who works with flip flops all day and I had a hell of a time parsing this description in part 1. For part 2, I just let a (0..).find loop run while I thought about it and deconstructed the circuit on paper. Saw that there was a conjunction on 'rx', so immediately started throwing in debug to see how how often the inputs to that conjunction were toggling. Thank Zeus for Ruby's built-in LCM. In the end, I'm really happy with how simple the code came out for this.
+
+    [github](https://github.com/globalreset/advent_of_code_2023/blob/main/2023/20/solution.rb)
+  :replies:
+  - :author: PillarsBliz
+    :url: https://www.reddit.com/r/adventofcode/comments/18mmfxb/2023_day_20_solutions/ke5vdbi/
+    :body: |-
+      I'm a computer engineer, have messed with NAND gates and flipflops through my life / school, and I feel like it made the problem harder for me.
+
+      The two things that really threw me off were 1, you could have 2 mismatched drivers pulsing the same target (unless this was just a bug, which was quite possible). I kept seeing 0 and 1 going to the same flipflop. It didn't help that the examples never had multiple drivers of a flipflop.
+
+      And 2, even if 4 pulses are simultaneously generated for a NAND gate, the output pulses 4 times, NOT once. I was just simulating the entire circuit at once and it took me forever to catch this.
+    :replies:
+    - :author: globalreset
+      :url: https://www.reddit.com/r/adventofcode/comments/18mmfxb/2023_day_20_solutions/ke6vbm3/
+      :body: I agree that having an understanding of how flops work probably did make this harder. I don’t think I had any multiple driver issues on my flops. But I did have that exact same problem of waiting on the “final” state of each flop after a button push. For part 1, my pulse counter was counting every pulse it processed in one of two buckets. So for part 2, I just modified my pulse counter to keep a record of high/low pulses received at each node, then waited for at least one low pulse on the flops that fed the last conjunction. I still wasn’t sure this was going to result in all the flops being the right state for the conjunction to change (what if the lcm got one of the 4 to an odd state and the rest of the 4 to an even state). I thought I was still going to have work to do, but nope.
+      :replies:
+      - :author: PillarsBliz
+        :url: https://www.reddit.com/r/adventofcode/comments/18mmfxb/2023_day_20_solutions/ke6zkrq/
+        :body: |-
+          I ended up making an input queue for every gate input, but that felt really dirty.
+
+          I saw someone else made a general FIFO pulse array, just processing one at a time, which was probably a cleaner idea.
+        :replies:
+        - :author: globalreset
+          :url: https://www.reddit.com/r/adventofcode/comments/18mmfxb/2023_day_20_solutions/ke71sl6/
+          :body: |-
+            The general fifo is what I did. I think the “button push” function could hardly be simpler than this:
+
+            ```ruby
+            def push_button(circuit, pulse_cnt)
+              queue = [[0, :broadcaster, :button] ]
+              until queue.empty?
+                op, dst, src = queue.shift
+                (pulse_cnt[dst] ||= [0,0])[op] += 1
+                next unless (circuit[dst])
+
+                pulse_out = case(circuit[dst][:type])
+                  when :broadcaster then 0
+                  when :%
+                    (circuit[dst][:state] ^= 1) if(op==0)
+                  when :&
+                    circuit[dst][:inputs][src] = op
+                    (circuit[dst][:inputs].values.all?{_1==1}) ? 0 : 1
+                  end
+
+                circuit[dst][:outputs].each { queue << [pulse_out, _1, dst] } if(pulse_out!=nil)
+              end
+              pulse_cnt
+            end
+            ```
+          :replies: []
+- :author: Symbroson
+  :url: https://www.reddit.com/r/adventofcode/comments/18mmfxb/2023_day_20_solutions/ke6jmc1/
+  :body: |-
+    Ugly, [but works](https://github.com/alex-Symbroson/Advent-of-Code/blob/master/2023%2F20.rb)
+
+    runs in about half a second, and.basically detects the first cycle and calculates the lcm. However the path to that solution was a bit rocky:
+
+    I was confused at first because the first cycle where all of the switches that trigger the node before rx was one lower than the rest of the looping cycles. Thats why I initially tried to use chinese reminder theorem to calculate lcm with offset but that wasn't the answer. Probably just a mistake caused by a wrong start offset so it detects the loop at the third cycle.
+  :replies: []
+- :author: JelloRough
+  :url: https://www.reddit.com/r/adventofcode/comments/18mmfxb/2023_day_20_solutions/ke5jsj9/
+  :body: |-
+    Because I don't see other Ruby solutions here is the [paste]([https://raw.githubusercontent.com/hugomosh/adventura-de-codigo/sandbox/2023/day20.rb](https://raw.githubusercontent.com/hugomosh/adventura-de-codigo/sandbox/2023/day20.rb))
+
+    Was stuck on part 2 but I got a hint to detect patterns and used it.
+  :replies: []

data/data/solutions/reddit/ruby/2023/21.yml

@@ -0,0 +1,71 @@
+---
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/18nevo3/2023_day_21_solutions/keh3elw/
+  :body: |-
+    Very slow second part, but works, the maths trick for part 2 threw me for a loop!
+
+    [Github](https://github.com/careyi3/aoc_2023/tree/master/solutions/21)
+
+    [Video Walkthrough](https://youtu.be/99Mjs1i0JxU)
+  :replies: []
+- :author: kateba72
+  :url: https://www.reddit.com/r/adventofcode/comments/18nevo3/2023_day_21_solutions/kebuguk/
+  :body: |-
+    [Source](https://github.com/Kateba72/advent_of_code/blob/main/aoc/y2023/d21.rb)
+
+    For part 2, I noticed that the direct paths from the start point to the edges as well as the edges themselves contain no rocks.
+
+    Furthermore, the input is nice and all gardens within are block that are reachable are also reachable within 260 steps (meaning that if the elf can get from one corner of a block to the opposite corner, then all gardens with the correct parity within that block are reachable)
+
+    So, we get a diamond that looks roughly like this:
+
+    ```ruby
+               ╎ ╎
+              ╌╆━━━╅╌
+               ┃/ \┃
+               ┃ O ┃
+           ╎ /┃ ┃\ ╎
+          ╌╆━━━╋━━━╋━━━╅╌
+           ┃/ ┃ ┃ \┃
+           ┃ O ┃ E ┃ O ┃
+       ╎ /┃ ┃ ┃ ┃\ ╎
+      ╌╆━━━╋━━━╋━━━╋━━━╋━━━╅╌
+       ┃/ ┃ ┃ ┃ ┃ \┃
+       ┃ O ┃ E ┃ S ┃ E ┃ O ┃
+       ┃\ ┃ ┃ O ┃ ┃ /┃
+      ╌╄━━━╋━━━╋━━━╋━━━╋━━━╃╌
+       ╎ \┃ ┃ ┃ ┃/ ╎
+           ┃ O ┃ E ┃ O ┃
+           ┃\ ┃ ┃ /┃
+          ╌╄━━━╋━━━╋━━━╃╌
+           ╎ \┃ ┃/ ╎
+               ┃ O ┃
+               ┃\ /┃
+              ╌╄━━━╃╌
+               ╎ ╎
+    ```
+
+    Then I counted how many odd/even cells are "mostly reachable" (i.e. they are at most missing one or two corners) and how many reachable gardens an odd/even cell has. I subtracted the corner cells that I can't reach and added the extra corners outside of the mostly reachable cells.
+
+    And after ~3 hours, I eliminated the last off-by-one error and got the correct solution
+  :replies:
+  - :author: Draco18s
+    :url: https://www.reddit.com/r/adventofcode/comments/18nevo3/2023_day_21_solutions/kec8yj3/
+    :body: I ended up with a very similar diagram in [my own doodly notes](https://github.com/Draco18s/Advent-of-Code-2023/blob/main/Day21.cs#L276).
+    :replies: []
+- :author: Symbroson
+  :url: https://www.reddit.com/r/adventofcode/comments/18nevo3/2023_day_21_solutions/kebeey6/
+  :body: |-
+    Executes in ~1.5 seconds. [link to solution](https://github.com/alex-Symbroson/Advent-of-Code/blob/master/2023/21.rb)
+
+    The input is diamond-shaped and thus forms a repetitive pattern that can be expressed as quadratic formula. To get an exact result we calculate three values that would map over to our target amount of steps using modulo.
+
+    Optimized the time by adding a cache, because each step with the same parity can be calculated from the previous step with the same parity, plus the new steps. So we only need to re-calculate the current unvisited positions.
+  :replies:
+  - :author: Symbroson
+    :url: https://www.reddit.com/r/adventofcode/comments/18nevo3/2023_day_21_solutions/keboy52/
+    :body: |-
+      I was able to optimize the quadratic formula by solving the quadratic formula equation system for `x = [-1, 0, 1]`, basically walking back in history. Halved execution time to about `650ms`
+
+      [detailed explanation posted here](https://www.reddit.com/r/adventofcode/comments/18nni6t/2023_21_part_2_optimization_hint/)
+    :replies: []

data/data/solutions/reddit/ruby/2023/22.yml

@@ -0,0 +1,30 @@
+---
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/18o7014/2023_day_22_solutions/kefyqao/
+  :body: |-
+    Nice straight-forward one after yesterday's. For part 1, I created a collection of all the brick coordinates and then populated a grid to help with collision detection. Falling was just iterating through all of the bricks (sorted by the lower z value) and checking if the next z coordinate down was empty and moving the brick if not. Then I made two hashes, one to store all bricks above and another for below. I was surprised how fast the part 2 ran, I was expecting that a bfs per brick would've been a time sink.
+
+    ```ruby
+    bricks.sum do |b|
+      felled = [b].to_set
+      q = above[b].to_a
+      until q.empty?
+        t = q.shift
+        next if felled.include?(t)
+        next unless (below[t].all? { felled.include?(_1) })
+        felled << t
+        q += above[t].to_a
+      end
+      felled.size - 1
+    end
+    ```
+
+    [github](https://github.com/globalreset/advent_of_code_2023/blob/main/2023/20/solution.rb)
+  :replies: []
+- :author: '0x623'
+  :url: https://www.reddit.com/r/adventofcode/comments/18o7014/2023_day_22_solutions/kefrpta/
+  :body: |-
+    Bit manipulation
+
+    [Carbon](https://carbon.now.sh/?bg=rgba%280%2C0%2C0%2C0%29&t=a11y-dark&wt=none&l=ruby&width=666&ds=false&dsyoff=20px&dsblur=68px&wc=false&wa=true&pv=0px&ph=0px&ln=true&fl=1&fm=JetBrains+Mono&fs=14px&lh=152%25&si=false&es=1x&wm=false&code=inp%2520%253D%2520DATA.read%250A%2560make%2560%253B%2520inp%2520%253D%2520IO.read%2520%27input22%27%250A%250AB%2520%253D%2520inp.each_line%28chomp%253A%2520true%29.map%2520%257B%2520%257Cln%257C%250A%2520%2520x0%252C%2520x1%2520%253D%2520ln.split%28%253F%7E%29.map%2520%257B%2520_1.split%28%253F%252C%29.map%2520%2526%253Ato_i%2520%257D%250A%2520%2520%255Bx0%252C%2520x1.zip%28x0%29.map%2520%257B%2520%257Cv1%252C%2520v0%257C%2520v1%2520%252B%25201%2520-%2520v0%2520%257D%255D%250A%257D%250A%250A%28OFFX%252C%2520_OFFY%252C%2520_OFFZ%29%252C%2520%28WX%252C%2520_WY%252C%2520_WZ%29%2520%253D%2520B.reduce%28%255B%255B0%255D*3%252C%2520%255B0%255D*3%255D%29%2520%257B%2520%257Cx%252C%2520b%257C%250A%2520%2520x.zip%28b%29.map%2520%257B%2520_1.zip%28_2%29.map%2520%2526%253Amax%2520%257D%250A%257D%250AMAX_X%2520%253D%2520OFFX%2520%252B%2520WX%250A%250Ato_bits%2520%253D%2520proc%2520%257B%2520%257C%28x0%252C%2520y0%252C%2520z0%29%252C%2520%28wx%252C%2520wy%252C%2520wz%29%257C%250A%2520%2520plane%2520%253D%25200%250A%2520%2520%280...wx%29.each%2520%257B%2520%257Cdx%257C%250A%2520%2520%2520%2520x%2520%253D%2520x0%2520%252B%2520dx%250A%2520%2520%2520%2520%280...wy%29.each%2520%257B%2520%257Cdy%257C%2520plane%2520%257C%253D%25201%2520%253C%253C%2520%28x%2520%252B%2520%28y0%252Bdy%29%2520*%2520MAX_X%29%2520%257D%250A%2520%2520%257D%250A%2520%2520%255Bz0%252C%2520plane%252C%2520wz%255D%250A%257D%250A%250AB.map%21%28%2526to_bits%29.sort%21%250A%250Atower%2520%253D%2520%255B-1%255D%250Afloor%2520%253D%2520-%253E%2520z%2520%257B%2520tower%255Bz%255D%2520%257C%257C%25200%2520%257D%250Abricks%2520%253D%2520%255B%255D%250AB.each%2520%257B%2520%257Cz%252C%2520layer%252C%2520wz%257C%250A%2520%2520z%2520-%253D%25201%2520while%2520floor%255Bz-1%255D%2520%2526%2520layer%2520%253D%253D%25200%250A%2520%2520%280...wz%29.each%2520%257B%2520%257Cdz%257C%2520tower%255Bz%252Bdz%255D%2520%253D%2520floor%255Bz%252Bdz%255D%2520%257C%2520layer%2520%257D%250A%2520%2520bricks%2520%253C%253C%2520%255Bz%252C%2520layer%252C%2520wz%255D%250A%257D%250A%250Apart_1%2520%253D%2520-%253E%2520%257B%250A%2520%2520p%2520bricks.each_with_index.count%2520%257B%2520%257C%28z%252C%2520layer%252C%2520wz%29%252C%2520i%257C%250A%2520%2520%2520%2520dis%2520%253D%2520tower.dup%250A%2520%2520%2520%2520%280...wz%29.each%2520%257B%2520%257Cdz%257C%2520dis%255Bz%252Bdz%255D%2520%255E%253D%2520layer%2520%257D%250A%2520%2520%2520%2520not%2520bricks%255Bi%252B1..%255D.any%253F%2520%257B%2520%257Cz_%252C%2520layer_%252C%2520_%257C%2520dis%255Bz_-1%255D%2520%2526%2520layer_%2520%253D%253D%25200%2520%257D%250A%2520%2520%257D%250A%257D%250A%250Apart_2%2520%253D%2520-%253E%2520%257B%250A%2520%2520p%2520bricks.each_with_index.sum%2520%257B%2520%257Cb0%252C%2520i%257C%250A%2520%2520%2520%2520dis%2520%253D%2520tower.dup%250A%2520%2520%2520%2520rm%2520%253D%2520proc%2520%257B%2520%257Cz%252C%2520layer%252C%2520wz%257C%250A%2520%2520%2520%2520%2520%2520%280...wz%29.each%2520%257B%2520%257Cdz%257C%2520dis%255Bz%252Bdz%255D%2520%255E%253D%2520layer%2520%257D%250A%2520%2520%2520%2520%257D%250A%2520%2520%2520%2520fallable%2520%253D%2520proc%2520%257B%2520%257Cz%252C%2520layer%252C%2520_wz%257C%2520dis%255Bz-1%255D%2520%2526%2520layer%2520%253D%253D%25200%2520%257D%250A%2520%2520%2520%2520fall%2520%253D%2520proc%2520%257B%2520%257Cz%252C%2520layer%252C%2520wz%257C%250A%2520%2520%2520%2520%2520%2520rm%255Bz%252C%2520layer%252C%2520wz%255D%250A%2520%2520%2520%2520%2520%2520z%2520-%253D%25201%2520while%2520fallable%255Bz%252C%2520layer%255D%250A%2520%2520%2520%2520%2520%2520%280...wz%29.each%2520%257B%2520%257Cdz%257C%2520dis%255Bz%252Bdz%255D%2520%257C%253D%2520layer%2520%257D%250A%2520%2520%2520%2520%257D%250A%250A%2520%2520%2520%2520rm%255Bb0%255D%250A%2520%2520%2520%2520bricks%255Bi%252B1..%255D.count%2520%257B%2520%257Cb%257C%2520fallable%255Bb%255D%2520and%2520fall%255Bb%255D%2520%257D%250A%2520%2520%257D%250A%257D%250A%250Apart_1%255B%255D%250Apart_2%255B%255D%250A%250A __END__ %250A1%252C0%252C1%7E1%252C2%252C1%250A0%252C0%252C2%7E2%252C0%252C2%250A0%252C2%252C3%7E2%252C2%252C3%250A0%252C0%252C4%7E0%252C2%252C4%250A2%252C0%252C5%7E2%252C2%252C5%250A0%252C1%252C6%7E2%252C1%252C6%250A1%252C1%252C8%7E1%252C1%252C9) (52 loc) (600 ms)
+  :replies: []

data/data/solutions/reddit/ruby/2023/23.yml

@@ -0,0 +1,56 @@
+---
+- :author: baseballlover723
+  :url: https://www.reddit.com/r/adventofcode/comments/18oy4pc/2023_day_23_solutions/kgdwvdw/
+  :body: |-
+    : [Github](https://github.com/baseballlover723/advent-of-code/blob/master/2023/ruby/).
+
+    [Language: Crystal]: [Github](https://github.com/baseballlover723/advent-of-code/blob/master/2023/crystal).
+
+    Didn't see any ruby here so I thought I'd share my own.
+
+    # Part [A](https://github.com/baseballlover723/advent-of-code/blob/master/2023/ruby/day22a.rb)
+
+    [I started](https://github.com/baseballlover723/advent-of-code/blob/master/2023/ruby/day22d.rb) with just my standard maze navigation (after converting the maze from characters into numbers from 0..5 to do some of the checks all at once) using a queue and a tuple of x,y, distance, and direction, with a minor optimization of setting the end at the first fork from the end (and remembering how long that section was to add afterwards), instead of the actual end (this only saved ~`12 ms`) to get to a runtime of ~`102 ms`. I also realized that the way I did my maze navigation, I didn't actually have to worry about visiting the same places twice, since it turned out that the slopes made it so that you could only go one way.
+
+    Then I realized that I could probably make it faster by [converting the maze to a graph with only a few nodes and just dealing with that instead](https://github.com/baseballlover723/advent-of-code/blob/master/2023/ruby/day22a.rb). So I did that and then just generated all the paths from the start to the end and found the largest one to get the runtime down to ~`14 ms`. I actually tried with [Dijkstra's algorithm](https://github.com/baseballlover723/advent-of-code/blob/master/2023/ruby/day22c.rb) (with negative edge values) to see if that was any faster, and it was actually slower by ~`0.5 ms`, which I think makes sense since you still have to generate all the paths anyways.
+
+    # Part [B](https://github.com/baseballlover723/advent-of-code/blob/master/2023/ruby/day22b.rb)
+
+    For Part B it wasn't too difficult for [my first version](https://github.com/baseballlover723/advent-of-code/blob/master/2023/ruby/day22e.rb), just do the same thing, but represent the maze using booleans instead of integers, since now there's only 2 possible values (wall and path) and using a set to check what nodes I'd already visited when generating all the paths (I even managed to shave off a copy of seen set by reusing the original seen set for the first copy), and it took ~`54 seconds`, yikes. I entered the answer to confirm it was actually correct (which it was) and then looked here for some inspiration for something faster.
+
+    I found it in https://www.reddit.com/r/adventofcode/comments/18oy4pc/2023_day_23\_solutions/kfyvp2g/, and [trimming down the perimeter nodes to be one way](https://github.com/baseballlover723/advent-of-code/blob/master/2023/ruby/day22g.rb) got my runtime down to ~`10.9 seconds`. Some further optimization of the cycle detection to use [an array of booleans by node id](https://github.com/baseballlover723/advent-of-code/blob/master/2023/ruby/day22h.rb) got down to ~`5.7 seconds` and then [using an integer with bit manipulation](https://github.com/baseballlover723/advent-of-code/blob/master/2023/ruby/day22b.rb) got it down to my final runtime of ~`2.6 seconds`.
+
+    [I tried my original algorithm without the perimeter node stuff but with the more efficient bitwise cycle detection](https://github.com/baseballlover723/advent-of-code/blob/master/2023/ruby/day22f.rb) and it was a decently reasonable ~`15.0 seconds`.
+
+    Overall I was really happy to get down to `2.6 seconds` in ruby, but as per usual I mirrored everything in Crystal lang as well and the relative runtimes matched up pretty similar to ruby, but ~20x faster.
+
+    Ruby runtimes (all times listed averaged over the 25 trials):
+
+    ```ruby
+    times: 25
+
+    day23a (ruby) : 14.193 ms => 2326
+    day23b (ruby) : 2 sec and 600.667 ms => 6574
+    day23c (ruby) : 14.572 ms => 2326
+    day23d (ruby) : 101.483 ms => 2326
+    day23e (ruby) : 53 sec and 886.581 ms => 6574
+    day23f (ruby) : 15 sec and 19.063 ms => 6854
+    day23g (ruby) : 10 sec and 879.43 ms => 6574
+    day23h (ruby) : 5 sec and 709.26 ms => 657
+    ```
+
+    Crystal runtimes (all times listed averaged over the 100 trials):
+
+    ```ruby
+    times: 100
+
+    day23a (release): 0.926 ms => 2326
+    day23b (release): 126.396 ms => 6574
+    day23c (release): 0.797 ms => 2326
+    day23d (release): 6.971 ms => 2326
+    day23e (release): 4.0 sec and 577.198 ms => 6574
+    day23f (release): 686.635 ms => 6854
+    day23g (release): 1.0 sec and 315.651 ms => 6574
+    day23h (release): 301.475 ms => 6574
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2023/24.yml

@@ -0,0 +1 @@
+--- []

data/data/solutions/reddit/ruby/2023/25.yml

@@ -0,0 +1,10 @@
+---
+- :author: kateba72
+  :url: https://www.reddit.com/r/adventofcode/comments/18qbsxs/2023_day_25_solutions/keucgrf/
+  :body: |-
+    I had a blast today. This summer, I had a lecture on flow algorithms, which included an algorithm for finding a minimum cut. So, I took this opportunity to revise my knowledge and implement a flow algorithm for the first time.
+
+    For those who know flow algorithms, I used a variation of the preflow-push algorithm to find a a-b cut, then a {a, b}-c cut, then a {a, b, c}-d cut etc. The minimum cut is then guaranteed to be the smallest of these cuts.
+
+    The code can be found [in my github](https://github.com/Kateba72/advent_of_code/blob/main/aoc/y2023/d25.rb), it should run in O(n² + nm) (where n is the number of vertices and m the number of edges). For the input, it runs in ~46ms on my machine
+  :replies: []

data/data/solutions/reddit/ruby/2024/01.yml

@@ -0,0 +1,203 @@
+---
+- :author: HAEC_EST_SPARTA
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/m0c0fmv/
+  :body: |-
+    [Solution on sourcehut](https://git.sr.ht/%7Eawsmith/advent-of-code/tree/2024-ruby/item/lib/day01.rb)
+
+    Using Ruby for this problem almost felt like cheating: between `Array#transpose` and `Enumerable#tally`, I barely had to write any code of my own :) My Ruby is definitely a bit rusty, so this was a nice opportunity to review those classes' interfaces in preparation for future days.
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzvccp8/
+  :body: |-
+    > This looks like a job for ... [Trans Pose](https://ruby-doc.org/3.3.6/Array.html#method-i-transpose)! :)
+
+    ```ruby
+    input = File
+      .readlines('input01.txt')
+      .map { |line| line.scan(/\d+/).map &:to_i }
+
+    # Part 1
+    p input.transpose.map(&:sort).transpose.sum { |a,b| (a - b).abs }
+
+    # Part 2
+    a,b = input.transpose
+    p a.sum { |i| i * b.count(i) }
+    ```
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lztxpm4/
+  :body: |-
+    7062/1094 I could have made it to the first 1k if I didn't have to help my wife with something between the two parts :D
+
+    ```ruby
+    # 1.rb
+    DAY = __FILE__.sub(".rb", ".input")
+    def parse(io)
+      _line_parts = io.readlines.map { |l| l.chomp.split.map(&:to_i) }
+    end
+    def daily_input
+      File.open(DAY) do |fd|
+        return parse(fd)
+      end
+    end
+
+    def solve_easy(pairs)
+      a, b = pairs.transpose.map(&:sort)
+      a.zip(b).sum { (_1 - _2).abs }
+    end
+
+    def solve_hard(pairs)
+      a, b = pairs.transpose
+      t = b.tally
+      a.sum { _1 * t.fetch(_1, 0) }
+    end
+    ```
+
+    edit: usual complaint, I hate that ruby's `Array#zip` with a block returns `nil`
+  :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzx6a3o/
+  :body: |-
+    ```ruby
+    lines = File.readlines('input1.txt', chomp: true)
+    list1 = []
+    list2 = []
+    freq = Hash.new(0)
+
+    lines.each do |line|
+      ids = line.split.map(&:to_i)
+      list1 << ids[0]
+      list2 << ids[1]
+      freq[ids[1]] += 1
+    end
+
+    list1.sort!
+    list2.sort!
+
+    distance = 0
+    similarity = 0
+    list1.zip(list2).each do |id1, id2|
+      distance += (id1 - id2).abs
+      similarity += id1 * freq[id1]
+    end
+
+    puts distance, similarity
+    ```
+
+    My very first Ruby script, critiques more than welcome!
+  :replies: []
+- :author: Sharparam
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lztwobe/
+  :body: |-
+    ```ruby
+    left, right = ARGF.readlines.map(&:split).map { _1.map(&:to_i) }.transpose
+    puts left.sort.zip(right.sort).map { (_1 - _2).abs }.sum
+    puts left.map { [_1, right.count(_1)] }.map { _1 * _2 }.sum
+    ```
+
+    Initially had a small bug in my part 2 with using `find` instead of `count`, I blame sleep deprivation!
+  :replies: []
+- :author: The_Jare
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzufxbj/
+  :body: |-
+    ```ruby
+    l1, l2 = ARGF.each.map(&:split).transpose.map {|x| x.map(&:to_i).sort }
+    puts l1.zip(l2).sum { |a, b| (a-b).abs }
+    puts l1.sum { |x| x*l2.count(x) }
+    ```
+  :replies: []
+- :author: glebm
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzunulz/
+  :body: |-
+    ```ruby
+    lists = $<.map { _1.scan(/\d+/).map(&:to_i) }.transpose
+    lists.each(&:sort!)
+    puts lists[0].zip(lists[1]).lazy.map { |(a, b)| (a - b).abs }.sum
+    puts lists[0].lazy.map { |a|
+      lo = lists[1].bsearch_index { |b| b >= a }
+      next 0 if lo.nil?
+      count = (lo...).lazy.take_while { _1 < lists[1].size && lists[1][_1] == a }.count
+      a * count
+    }.sum
+    ```
+  :replies:
+  - :author: stellar_opossum
+    :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzuqguv/
+    :body: "`left_element * right_list.count(left_element)`. Now that's `lazy`"
+    :replies:
+    - :author: glebm
+      :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzuzfy6/
+      :body: That's quadratic, you're making the computer do all the work, so inconsiderate!
+      :replies: []
+- :author: vinc686
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzusygn/
+  :body: |-
+    https://github.com/vinc/advent-of-code
+
+    Part 1
+
+    ```ruby
+    a, b = ARGF.read.split.map(&:to_i).each_slice(2).to_a.transpose.map(&:sort)
+    puts a.zip(b).map { |x, y| (x - y).abs }.sum
+    ```
+
+    Part 2
+
+    ```ruby
+    a, b = ARGF.read.split.map(&:to_i).each_slice(2).to_a.transpose
+    puts a.map { |x| x * b.count(x) }.sum
+    ```
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzut10v/
+  :body: "[https://github.com/careyi3/aoc\\_2024/tree/master/solutions/1](https://github.com/careyi3/aoc_2024/tree/master/solutions/1)"
+  :replies: []
+- :author: Cheswick32
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzw82qi/
+  :body: |-
+    The first day always feels like a test of "So how much thought we putting into running this thing?".
+
+    I was going to use [aoc\_rb](https://github.com/pacso/aoc_rb) but I can't bring myself to write spec tests this early in the month
+
+    [Paste](https://topaz.github.io/paste/#XQAAAQA1BQAAAAAAAAA5GUqKNoFH6SMqgz5/p0SQOJLmsq1ZB0a/1piD4YtOTl2yryMSPb8yt+HzPgs17kMK3qa5Pt4XB0i+P157YAYOjqPnnUayVBdNcP2YpHcA4r3Y+MR8fkwdqbk0WawDRDBeQKH/SQvLD4n5TgrbeiQ/D4eTIWxM62dZwygva6quKx2/9Uyy7AZBhywh5jp5z5L03KUMCcbXBCpAj7raYZaeBrU/ABVkIUOL4vo5b26uNY8YphcqbCWnmSktj3KUqxUFxqRzk1tnEawkklHFBTy9qP7wRZSC7ZAPqxZpAvJgqUWsz3nPJSNOmGSUj8xIst85XDJv1YojTeG6YIGzJCIsFTvmpE++CfYzEmsCjhct2EAixl3SPSOSJmpjNa1T7ojdJeZLsdzM19XbycmPJ1ndMUeJMsA0KZu7dZZZuW1M+jC4icyESt5m7D4lUJdHy4SPrzgI9C1SUxkM13YNcnGA8UPyqOXtespj1ltgM1AnHpKbkuEoETy/LRGGPuEH4K5dfGGFlb9jRS9NPe1ix5HeQdoEwYHbPFU/mH/odgPP6//lQ3jvSbqkxxTaKRvMvmEWWGmmBUSbmwvpTjtlnPr7YEar767MJoAONUBzHxY67Nu4zXlVVfnzfKQHT/CXvARSNBZJf8EkJStTB507isAwz9wFlZUxZ9uPXyS7BG6asaHjPmVHW+wmSTgnPFkGiZXeusyi44je3g0cEEZXA5kbKyBwN7Nip79YTaNDAcPrqUUeJzPY1L/gdZhIKi3vS6QK8+V2rx0g6xcR6uEO+82kf01Aw8hO3CdDAwr9pwqNBYgBGZYuoaraAD6DppkjnyOH/mo9RA==)
+  :replies: []
+- :author: zaniwoop
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzwfu9m/
+  :body: |-
+    ```ruby
+    # part 1
+    list_1 = values.map(&:first).sort
+    list_2 = values.map(&:last).sort
+
+    differences = list_1.map.with_index do |value, index|
+        difference = value - list_2[index]
+        difference = -difference if difference < 0
+        [value, list_2[index], difference]
+    end
+
+    puts differences.map{ |value| value[2] }.sum
+
+    # part 2
+    occurances = list_1.map.with_index do |value, index|
+        occurance = value * list_2.select{ |a| a == value }.count
+        [value, list_2[index], occurance]
+    end
+
+    puts occurances.map{ |value| value[2] }.sum
+    ```
+  :replies: []
+- :author: Robowiko123
+  :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzwhsbr/
+  :body: |-
+    ```ruby
+    # Part 1
+    p File.open("input").read.split("\n").map { |x| x.split.reject(&:empty?).map &:to_i }.transpose.map(&:sort).transpose.map { |x| (x[0]-x[1]).abs }.sum
+    # Part 2
+    left, right = File.open("input").read.split("\n").map { |x| x.split.reject(&:empty?).map &:to_i }.transpose
+    p left.map { |x| x * right.count(x) }.sum
+    ```
+  :replies:
+  - :author: vmaskmovps
+    :url: https://www.reddit.com/r/adventofcode/comments/1h3vp6n/2024_day_1_solutions/lzxkt83/
+    :body: Check your post, right now everything is a code block, including the Language header
+    :replies: []