advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,432 @@
+---
+- :author: RazarTuk
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ynz5p/
+  :body: |-
+    These isn't enough Ruby on this subreddit, so I may as well start posting _my_ solutions. Also, this is very intentionally only part _1_, in case anyone reading wants to practice by extending it for part 2. And I know it would probably be easier to just tokenize each line as I'm reading them in, but I'm using that first line as boilerplate so I don't have to think about input.
+
+    ```ruby
+    file = IO.foreach(ARGV[0]).map &:strip
+
+    def check(equation)
+        stack = [[equation[0], equation.count - 1]]
+        until stack.empty?
+            target, idx = stack.pop
+            if idx == 1
+                return true if target == equation[1]
+            else
+                stack << [target - equation[idx], idx - 1] if target - equation[idx] >= equation[1]
+                stack << [target / equation[idx], idx - 1] if target % equation[idx] == 0
+            end
+        end
+        false
+    end
+
+    res = file.sum do |line|
+        equation = line.split(/:?\s+/).map(&:to_i)
+        check(equation) ? equation[0] : 0
+    end
+
+    puts res
+    ```
+
+    EDIT: Oh, and it executes in ~100ms
+  :replies: []
+- :author: SwagosaurusFlex
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0u8enb/
+  :body: |-
+    I'm having trouble figuring out why my solution isn't passing for Part 2. It works on Part 1 and the example case, but it's giving too high of an answer on Part 2. Any help appreciated, thanks
+
+    ```ruby
+    def calc(total, parts, runningTotal)
+      if Integer(runningTotal) == Integer(total)
+        return true
+      end
+
+      if (parts.size == 0)
+        return false
+      end
+
+      if (calc(total, parts[1..], Integer(runningTotal) + Integer(parts[0])) == true) or (calc(total, parts[1..], Integer(runningTotal) * Integer(parts[0])) == true) or (calc(total, parts[1..], String(runningTotal) + parts[0]) == true)
+        return true
+      end
+
+      return false
+    end
+
+    if __FILE__ == $0
+      sum = 0
+      totals = Array.new
+      parts = Array.new
+
+      File.open('day7input.txt', 'r') do |f|
+        f.each_line do |line|
+          line = line.split(': ')
+          line[1] = line[1].split(' ')
+          if calc(line[0], line[1][1..], line[1][0])
+            sum += Integer(line[0])
+          end
+        end
+      end
+
+      puts sum
+    end
+    ```
+  :replies:
+  - :author: thereal_peasant
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0uabou/
+    :body: 'What happens when your `runningTotal` is equal to the `total` but there are still numbers left in `parts`? For example, take the input `''100: 10 10 3''`. Does this return `true`? Should it?'
+    :replies:
+    - :author: SwagosaurusFlex
+      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ucr4t/
+      :body: Ah that makes sense, can't believe I missed that! Thanks, finally got the star
+      :replies: []
+    - :author: ASteelyDan
+      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0uf841/
+      :body: Ah, had the same problem, thank you!
+      :replies: []
+- :author: NullT3rminated
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tr6lg/
+  :body: |-
+    970/553
+
+    [paste](https://topaz.github.io/paste/#XQAAAQAIAgAAAAAAAAAynEqz7f26DE+jk7bC9aN1f+FpLIK77itzuRsxYRP1MQ4bdqwA34ZbJoTpXR/wY63etWrSody9lO7a4gi6YfU+SOjXiC7PPk5rhv+qHEKEa1khJlmL8NgOK2wdwJDD+ksQVvZL2kwrgrblfafJbCQlyrI41PYV9IGlKaxUDgtfPgYcd5+AN/Z7CJAdScc04ElST0Y7pUdBBvz0Ebw41ydBuqRWkg0X38H6bWyFOidxvpcodCiBpHK7x5Auy6z65bvNnP/dUWekMGxemfpw8L/Wm2FKiBgwhVBUHrRQNi23198Sd7gJKt+lS9iM4T+LpuaXMWD1M9NP23rDLtfldFZ22XVKmIwZ/9C4ji4=)
+
+    First time getting top 1000, which is exciting for me! Definitely not the fastest solution though.
+  :replies:
+  - :author: FCBStar-of-the-South
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ttgnx/
+    :body: |-
+      Oh and I was excited to be the first Ruby in the megathread haha
+
+      What is your runtime like? I only started learning ruby by doing AoC this year so I will really appreciate it if you can give me some feedback on my solution!
+    :replies:
+    - :author: NullT3rminated
+      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tuf38/
+      :body: I get about 3 seconds on my laptop. Just slow enough to make me start to worry and start thinking about optimizations before it completed. YJIT speeds it up by about 300ms.
+      :replies:
+      - :author: FCBStar-of-the-South
+        :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tv98q/
+        :body: I think the only difference between our implementation is how we do ||. You use string concatenation and I use the logarithm. Will have to benchmark your way tmr
+        :replies:
+        - :author: NullT3rminated
+          :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0u8m8s/
+          :body: |-
+            Ok I changed mine to use log10 instead of string concatenation, and I went from 2.781s with YJIT to 1.549s with YJIT, so log is definitely faster.
+
+            Here's the code if you're curious:[paste](https://topaz.github.io/paste/#XQAAAQAVAgAAAAAAAAAynEqz7f26DE+jk7bC9aN1f+FpLIK77itzuRsxYRP1MQ4bdqwA34ZbJoTpXR/wY63etWrSody9lO7a4gi6YfU+SOjXiC7PPk5rhv+qHEKEa1khJlmL8NgOK2wdwJDD+ksQVvZL2kwrgrblfafJbCQlyrI41PYV9IGlKaxUDgtfPgYcd5+AN/Z7CJAdScc04ElST0Y7pUdBBvz0Ebw41ydBuqRWkg0X38H6bWyFOidxvpcodCiBpHK7x5Auy64VPe+huB2Mjz45waTc684cF0A0/usGCi9BMiIKDe3u9iKVZRJs2hRVS8hX1rpnLQH1zpBt0NqDYoOKJ1dyR7diSIm+GCHaOB4AKZvD/QAxx81gCyIRRFb8zVj7)
+
+            here's some performance numbers from hyperfine:
+
+            ```ruby
+            Benchmark 1: ruby --yjit 7_fast.rb 7.txt
+              Time (mean ± σ): 1.629 s ± 0.121 s [User: 1.578 s, System: 0.041 s]
+              Range (min … max): 1.456 s … 1.815 s 10 runs
+
+            Benchmark 2: ruby --yjit 7.rb 7.txt
+              Time (mean ± σ): 2.816 s ± 0.119 s [User: 2.739 s, System: 0.063 s]
+              Range (min … max): 2.695 s … 2.995 s 10 runs
+
+            Summary
+              ruby --yjit 7_fast.rb 7.txt ran
+                1.73 ± 0.15 times faster than ruby --yjit 7.rb 7.txt
+            ```
+          :replies: []
+- :author: yourparadigm
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tyk8p/
+  :body: |-
+    [LANGUAGE: Go]
+
+    I must preferred the Ruby implementation's ability to pass a list of methods to call on integers and implementing the `concat` method on `Integer`, but it was fun playing around with custom types in Go.
+
+    Not sure why people thought keeping lists of results was a good idea -- I just accumulated the partial result and recursed along each operator path down until there were no more values to operate on, so compare with the result.
+
+    [Ruby Solution](https://github.com/phene/advent-of-code/blob/main/2024/07/7.rb) runs in about 2s and [Go Solution](https://github.com/phene/advent-of-code/blob/main/2024/07/7.go) runs in 1s.
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0uc4nt/
+  :body: |-
+    Part 1
+
+    ```ruby
+    p File.read("input.txt")
+          .scan(/(\d+): (.*)/)
+          .map{ |r,n| [r.to_i, n.split().map(&:to_i)]}
+          .filter{ |r,n| [:*, :+].repeated_permutation(n.size-1)
+                                 .any?{|p| n[1..].each_with_index.inject(n.first){|a,(z,i)| a.send(p[i], z)} == r}}
+          .sum(&:first)
+    ```
+
+    Part 2
+
+    Just the same like part 1, but with a concat-operator for the Integer-class.
+
+    ```ruby
+    class Integer
+        def |(other)
+            self.to_s.concat(other.to_s).to_i
+        end
+    end
+
+    p File.read("input.txt")
+          .scan(/(\d+): (.*)/)
+          .map{ |r,n| [r.to_i, n.split().map(&:to_i)]}
+          .filter{ |r,n| [:*, :+, :|].repeated_permutation(n.size-1)
+                                     .any?{|p| n[1..].each_with_index.inject(n.first){|a,(z,i)| a.send(p[i], z)} == r}}
+          .sum(&:first)
+    ```
+  :replies:
+  - :author: Ill_Information_9522
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m1b2e92/
+    :body: This is great... very idiomatic. Still learning-- hadn't though of adding a bar operator to Integer. Love the built-in permutation methods though, quite handy. Not sure if other languages have such powerful stdlibs.
+    :replies: []
+- :author: fredster231
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0vh0np/
+  :body: |-
+    10 seconds lol, fun anonymous recursive pattern tho
+
+    https://gist.github.com/scockram/3ce5efc10cad27bf08c78bca4bcffd5f
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0vm2bo/
+  :body: |-
+    Tight on time today, brute force did the job!
+
+    EDIT: Okay, the recursive solution is actually less code and way more efficient, so I rewrote it in about 5 mins and it works way faster.
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/7](https://github.com/careyi3/aoc_2024/tree/master/solutions/7)
+  :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tt4k6/
+  :body: |-
+    ```ruby
+    require_relative 'utils'
+    require 'set'
+
+    equations = File.readlines('input7.txt').map { |line| ints(line) }
+
+    def solve_part1(equation)
+      target = equation[0]
+      results = Set[equation[1]]
+
+      equation[2...equation.length].each do |num|
+        add = results.map { |result| result + num }
+        mul = results.map { |result| result * num }
+        results = (add + mul).to_set
+      end
+      results.include?(target) ? target : 0
+    end
+
+    def solve_part2(equation)
+      target = equation[0]
+      results = Set[equation[1]]
+
+      equation[2...equation.length].each do |num|
+        add = results.map { |result| result + num }
+        mul = results.map { |result| result * num }
+        combine = results.map { |result| result * 10**(Math.log10(num).floor + 1) + num }
+        results = (add + mul + combine).to_set
+      end
+      results.include?(target) ? target : 0
+    end
+
+    puts equations.map { |equation| solve_part1(equation) }.sum
+    puts equations.map { |equation| solve_part2(equation) }.sum
+    ```
+
+    Part 1 runs in half a second. Altogether takes about 8 seconds. Initially I had an early stopping condition that checks the minimum achieveable result is smaller than the target. This turns out to have no effect on the runtime.
+
+    Simply optimizing the data structures used can probably lower the runtime substantially without modification to the algorithm. But that is for tomorrow morning.
+
+    Edit: not using a set cuts this down to barely a second
+  :replies:
+  - :author: yourparadigm
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0u05oy/
+    :body: You'd save a lot of time and memory by not saving all the possible results.
+    :replies:
+    - :author: FCBStar-of-the-South
+      :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0xtael/
+      :body: Eh this morning I just said what if I don’t do any deduplication with sets. Cut it right down to barely over a second and that’s good enough for me
+      :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0ttkxm/
+  :body: |-
+    today was ... easy? I wasted some time on part 1 cause I tried to build the result down by subtracting and dividing instead of building it up, which didn't work. Also on part two I thought brute force would take a while, but turned out I was brute forcing \*the whole input as a single line\* which, well, didn't go anywhere.
+
+    Simple recursive solution with no memoization or TCO runs in 2s, so good enough.
+
+    ```ruby
+    def test_value(target, array, use_concat:)
+      do_test_value(target, 0, array, use_concat:)
+    end
+
+    def do_test_value(target, current, array, use_concat:)
+      if current > target
+        false
+      elsif array.empty?
+        current == target
+      else
+        top = array.first
+        rest = array[1..]
+        do_test_value(target, current + top, rest, use_concat:) ||
+          do_test_value(target, current * top, rest, use_concat:) ||
+          (use_concat && do_test_value(target, (current.to_s + top.to_s).to_i, rest, use_concat:))
+      end
+    end
+
+    def solve_easy(lines)
+      lines.sum { |result, *operands| test_value(result, operands, use_concat: false) ? result : 0 }
+    end
+
+    def solve_hard(lines)
+      lines.sum { |result, *operands| test_value(result, operands, use_concat: true) ? result : 0 }
+    end
+    ```
+  :replies:
+  - :author: phord
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0tuz30/
+    :body: It never occurred to me to optimize by stopping when I exceed the target. But it ran so fast from the start, I obviously didn't need to.
+    :replies: []
+- :author: masterarms
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0usl5m/
+  :body: |-
+    Not the weekend day I feared :)
+
+    ```ruby
+    eqs = input.lines.map { |l|
+        tval,eq = l.split(':')
+        [tval.to_i, eq.split().map(&:to_i)]
+    }
+
+    def can?(test, eq)
+        # p "#{test} <= #{eq}"
+        return eq[0] == test if eq.size == 1
+        # too big?
+        return false if eq[0] > test
+        can?(test , [eq[0] + eq[1] , *eq[2..]]) ||
+        can?(test, [eq[0] * eq[1] , *eq[2..]])
+    end
+
+    def can2?(test, eq)
+        # p "#{test} <= #{eq}"
+        return eq[0] == test if eq.size == 1
+        # too big?
+        return false if eq[0] > test
+        can2?(test , [eq[0] + eq[1] , *eq[2..]]) ||
+        can2?(test, [eq[0] * eq[1] , *eq[2..]]) ||
+        can2?(test , ["#{eq[0]}#{eq[1]}".to_i , *eq[2..]])
+    end
+
+    eqs.map { |t,eq|
+        [can?(t,eq) ? t : 0,
+         can2?(t,eq)? t : 0]
+    }.transpose.map(&:sum)
+    ```
+  :replies:
+  - :author: masterarms
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0w9n1j/
+    :body: |-
+      Going from right to left is _much_ faster.
+
+      ```ruby
+      eqs = input.lines.map { |l|
+          tval,eq = l.split(':')
+          [tval.to_i, eq.split().map(&:to_i)]
+      }
+
+      ## Checking from left to right can only trim
+      ## multiplication branches if the result is too big
+      ## If you do it from right to left you can stop checking
+      ## the 'multiplication' branch if the equation part is not a
+      ## divisor of the current target. This is *much* faster
+
+      def can?(target, eq)
+          # p "#{target},#{eq}"
+          return eq[0] == target if eq.size == 1
+          tail = eq[-1]
+          return true if target % tail == 0 && can?(target/tail, eq[0..-2])
+          return true if target > tail && can?(target-tail, eq[0..-2])
+          return false
+      end
+
+      def can2?(target, eq)
+          # p "#{target},#{eq}"
+          return eq[0] == target if eq.size == 1
+          tail = eq[-1]
+          return true if target % tail == 0 && can2?(target/tail, eq[0..-2])
+          return true if target > tail && can2?(target-tail, eq[0..-2])
+          tail_s = tail.to_s
+          return true if target.to_s.end_with?(tail_s) && can2?(target/10.pow(tail_s.size), eq[0..-2])
+          return false
+      end
+
+      ok_can, nok_can = eqs.partition { |t, eq| can?(t,eq) }
+      part1 = ok_can.map(&:first).sum
+      ok_can2, _ = nok_can.partition { |t, eq| can2?(t,eq) }
+      part2 = ok_can2.map(&:first).sum + part1
+      [part1, part2]
+      ```
+    :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0v417f/
+  :body: |-
+    I could smell the Dynamic Programming from far away, but this is the first time I've realized that I don't have to build up that whole double array to keep track of everything. Probably also the first time I wrote a nested `reduce` like that.
+
+    ```ruby
+    require 'set'
+
+    input = File
+      .readlines('input07.txt')
+      .map { _1.scan(/\d+/).map(&:to_i) }
+
+    def dp(numbers)
+      return numbers
+        .drop(1)
+        .reduce(Set[numbers.first]) { |prev_nums,next_num|
+          prev_nums.reduce(Set[]) { |acc,prev_num| acc.merge(yield prev_num, next_num) }
+        }
+    end
+
+    p input.filter { |result, *numbers|
+        dp(numbers) { |a,b| [a+b, a*b] }.include? result
+      }.sum(&:first)
+
+    p input.filter { |result, *numbers|
+        dp(numbers) { |a,b| [a+b, a*b, "#{a}#{b}".to_i] }.include? result
+      }.sum(&:first)
+    ```
+  :replies:
+  - :author: el_daniero
+    :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0v9d0d/
+    :body: |-
+      And a brute force solution for good measure
+
+      ```ruby
+      input = File
+        .readlines('../input/07.txt')
+        .map { _1.scan(/\d+/).map(&:to_i) }
+
+      ops = [
+        lambda(&:+),
+        lambda(&:*),
+        #lambda { |a,b| (a.to_s + b.to_s).to_i }
+      ]
+
+      p input.filter { |res,a,*b|
+        ops.repeated_permutation(b.length).any? { |perm|
+          perm.zip(b).reduce(a) { |acc,(op,n)| op[acc,n] } == res
+        }
+      }.sum(&:first)
+      ```
+    :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0v7ys7/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day07.rb)"
+  :replies: []
+- :author: mpyne
+  :url: https://www.reddit.com/r/adventofcode/comments/1h8l3z5/2024_day_7_solutions/m0vjiih/
+  :body: |-
+    I was doing my solutions in Rust this year, but Ruby has an iterator operator that is more or less genetically designed for this problem, `repeated_permutation`, so I wanted to throw it in and test it out.
+
+    - Part 1: https://github.com/purinchu/advent-of-code/tree/main/2024/13
+    - Part 2: https://github.com/purinchu/advent-of-code/tree/main/2024/14
+  :replies: []

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

@@ -0,0 +1,187 @@
+---
+- :author: yourparadigm
+  :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m0zmy7o/
+  :body: |-
+    767/751
+
+    First sub-1000 this year! I really love ~~Array#permutation~~ `Array#combination`
+
+    [Github](https://github.com/phene/advent-of-code/blob/main/2024/08/8.rb)
+  :replies:
+  - :author: FCBStar-of-the-South
+    :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m0zs1g0/
+    :body: Ah this is a nice implementation. I should've thought about passing the range of search as a parameter instead of just duplicating my part 1 code with some extra logic haha
+    :replies: []
+- :author: NullT3rminated
+  :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m0zn5lg/
+  :body: |-
+    1460/1044
+
+    [paste](https://topaz.github.io/paste/#XQAAAQAhBAAAAAAAAAA5GUqKNoFH6SMqVwa6yG0l+GabeOhtkUXHD/4ozp9AjlKFr4zlGfaA1sRKskz0ctUOG9Np0DS349GTSGYESmUgdTr7rFM5/AHaqxUGGNE+1EJKpIYxVqkGWFC+0JhxLQDE4cvOeQMW7pDsSPl1QR9Za74byBkKHtdQM1ALdE29hwAnn73I9ELdAkvLUreJ0Dh8u+HTKJLyeNc1rnG/nX8tWYIKerADYYtVL0e1kYKb/PiShEfcfJLBNq8hU0yoKbqp21cDzwa8eFzs/FZ8BW76PZ4eeIhBNgtw/CGrmbVcm5SoBZ3SbPIMMJD9KaFMzavYoDi66pV5B3uLfg0p0iC/C6cehDCfZua2BGVSCAuK+KBB3mYRz1Xf3/gQJm3GOf2SwjnjIJi8NfiAze/7EOl9twKq1sRfiytWZLq5xhNo3SI/kUMd/O06UYLGzzY/plX/k+FSmzLC9zEjWVdM8zzjcoIJGKjmNIojpz5N+MftwY0cQihFw4nu7p7Gcfey/+1kN6LGAGJ0P21BXOM4TqDcv1nhJc2MN26nLm+vulsOE7QZy3V6BJTF9awlqpARgdjGpBvWIQq8mZiXWS0A9gEGolB/L76LWATFskCfUB4hTRmiEgllr8I1+jrLWPYKFyZjcJNYlQLayXGpscCiifHWDoGlsfGxKFx+DOYQ0JewVzA+Nv5DFtg=)
+
+    perhaps the worst code I've ever written. But it works.
+  :replies:
+  - :author: yourparadigm
+    :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m0znay2/
+    :body: Fellow fan of `Array#permutation` I see! Could have just used `Array#combination`, though.
+    :replies:
+    - :author: NullT3rminated
+      :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m0znlsy/
+      :body: I think they should add `Array#digg` to the standard library
+      :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m10ymdx/
+  :body: |-
+    ```ruby
+    input = File.read("input.txt").split("\n")
+    @width, @height = input.size, input[0].size
+    antennas = Hash.new{ |h,k| h[k] = [] }
+
+    @width.times do |y|
+      @height.times do |x|
+        antennas[input[y][x]] << Complex(x,y) unless input[y][x] == ?.
+      end
+    end
+
+    def inbounds?(c) = c.real.between?(0, @width-1) && c.imag.between?(0, @height-1)
+
+    antinodes1, antinodes2 = Set.new, Set.new
+
+    antennas.values.each do |a|
+        a.combination(2) do |x,y|
+           diff = x-y
+           f = 0
+           while inbounds?(pos = x + f*diff) do
+             antinodes1 << pos if f==1
+             antinodes2 << pos
+             f+=1
+           end
+           f = 0
+           while inbounds?(pos = y - f*diff) do
+             antinodes1 << pos if f==1
+             antinodes2 << pos
+             f+=1
+           end
+        end
+    end
+
+    puts "Part 1: #{antinodes1.count}", "Part 2: #{antinodes2.count}"
+    ```
+  :replies:
+  - :author: Ill_Information_9522
+    :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m1b1zz8/
+    :body: I've been using your complex number trick for grids... thanks again, works like a charm! Need to catch up on your solutions after spending the last day catching up myself on the puzzles. How much harder will it get? :p
+    :replies: []
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m0zrsv3/
+  :body: |-
+    [paste](https://topaz.github.io/paste/#XQAAAQCWBwAAAAAAAAA5GUqKNoFH9WVqAtfQAlEIpeJL/pI3jz8l8zNIKbgBcDs8e/jkEufM3yoDFdhZ+yEf8qLEaYbQkVMczFDglBo54Df7x04iyapFESymP4RpA8pK7/Oo81GULm0seNo4p2lgswLwoNgGrdZhMabcEyYWZIT4KUpQErXdOPoKse6pKtT3JZL0rB1tPM2EkwStv2DpPpJo+GKSP9yHTrSm9ZneZ+KYGmUTRxErhBtg93jpclModLhQSpnwYneVUFMFQiCrkqDGmefi8uKhKQ88epNB0Tncu4DKTPI8YoXaPXuHPsbsntKZGWQaj7wAXSBNEMAf9DV6sn5/VtUy6wrVNIHfnJFjsNXb7+T5Y76WZ0sC1cSadqiooQ6syScsmSrKQ3nxYn0uSWlZzv2DILX4sEXAosmJXvjRGXdMlynUjmqvxz7XMi6vvhpvcf7gTbUIckFKkEV1PDWV+U91MaX4ZgkX13RB8RIRsbrA2m4/1WtjB9ymoJd+5QzhxwTyYsRXg4+S1l8rb4n5oa3p8S5HB+PekoacUxxCnMdFGEBR+e+dkcKd/Boqm788e+/5YS6p19zjz0UIweVnSOOSGO7VJoTmWeKQI9kI7g4/y+jfN4ThSSz3cJVxbw9Trl6Zt/At5DRknhmggN3EIev3B/11n0YEgQ6U/t3/OsBHvlh4DXMxjcYL0HlqvNy2QdAlPNHuFd9bCKsELx3HpPjRg7YsIASS01aViLS3PEsi4cYg/ldcZgIHNYE09pTe5EMBnvGL4BTGlSvDc7zqy1HM7PUCGxywfdCeH57c8n+C3HfE8lRLT3f/EkIJNkE+MCtBaC2KBBGJO9P+gYOQVjaVf+X5Ujf05SsiIUbPSnOV0xPZ6i9J/+v5axI=)
+
+    Abuse of Ruby map and not my proudest code
+  :replies: []
+- :author: alexbaguette1
+  :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m0zsyz0/
+  :body: |-
+    Suprised it worked this easily.
+
+    Accidentally copied and pasted an old (non working for part 1) version to part 2 and it somehow worked after adding the part 2 logic. Maybe I'm just incredibly luckly to get away with buggy code...
+
+    [Part 1](https://topaz.github.io/paste/#XQAAAQA5AgAAAAAAAAA5GUqKNoFH6SMqoVC09YUYpRrZq3oCFpfxXu9nP0lKhMM6pt8OBX3NbPRuatlL47kGgI+ZTKskiShBT3sxm24XXUTwUH9yfPPOQGUeUudn/tXPSUVxzv9ThJ5G/RRixgnwBWorLUqr1mm99Ia1IzKBJTQyDdXDkIePw1MRehVyM+daRqSRKfiVxilt2RkzP3lWzxE1uaql2iSOyz40jXQsa6h+btA4+MX2s/vTr3Gi3emXq9WNzcpGDbecGD0QnDECukkKO206GNETwJaH60N6ilAoUmk/BHSxCUFHjtX1+jcMCE1Odp/zGCV8OitbdBRgy6WB881aE0qXcq5LZ7rgrEUeaE7HSyJV+ryMwNWqqb/3/AWzIGPIdCsdTaX0X9b2gfDJpVayJ4vm3DjP7adKujNPgpIiqMB0qkBES6yDB1h1TRnSE/8ux7mqjYolYDASlngIio2vrY83/mKYww==)
+
+    [Part 2](https://topaz.github.io/paste/#XQAAAQBaAgAAAAAAAAA5GUqKNoFH6SMqoVC09YUYpRrZq3oCFpfxXu9nP0lKhMM6pt8OBX3NbPRuatlL47kGgI+ZTKskiShBT3sxm24XXUTwUH9yfPPOQGUeUudn/tXPSUVxzv9ThJ5G/RRixgnwBWorLUqr1mm99Ia1IzKBJTQyDdXDkIePw1MRehVyM+daRqSRKfiVxilt2RkzP3lWzxE1uaql2iSOyz40jXQsa6h+btA4+MX2s/vTr3Gi3emXq9WNzcpGDbecGD0QnDECukkKO206GNETwJaH60N6ilAoUmk/BHSxCUFHjtX1+jcMCE1Odp/zGCV8OitbdBRgy6WB881aE0qXcq5LZ7rgrEUeaE7HSyJV+ryMwNWqqXdpR9FTHdn/mDvbtFVS7xh6J2pg3YXAc4T3qR72QURNe+3JNGbKSBUlQqlsk6SvDsOBvV3fpotIxajopInM2QHToU1ozeC1Seqfg/7eXukKhqjbb5BqmZEhAP/4Ehvh)
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m10n7o3/
+  :body: |-
+    ```ruby
+    input = File.readlines('input08.txt').map(&:chomp)
+    positions = Hash.new { |h,k| h[k] = [] }
+    input.each_with_index { |row,y|
+      row.chars.each_with_index { |char,x|
+        positions[char] << [x,y] unless char == '.'
+      }
+    }
+
+    def in_bounds(input, x, y) = y >= 0 && y < input.length && x >= 0 && x < input[y].length
+
+    # Part 1
+    p positions.flat_map { |char,positions|
+        positions
+          .permutation(2)
+          .map { |(x1,y1),(x2,y2)| [2*x1 - x2, 2*y1 - y2] }
+          .filter { |nx,ny| in_bounds(input, nx, ny) }
+      }
+      .uniq.size
+
+    # Part 2
+    p positions.flat_map { |char,positions|
+        positions.permutation(2).flat_map { |(x1,y1),(x2,y2)|
+          dx, dy = x2-x1, y2-y1
+
+          0.step.lazy
+            .map { |v| [x1 - dx*v, y1 - dy*v] }
+            .take_while { |nx,ny| in_bounds(input, nx, ny) }.to_a
+        }
+      }
+      .uniq.size
+    ```
+  :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m11b8pf/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day08.rb)"
+  :replies: []
+- :author: fredster231
+  :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m11jdl1/
+  :body: |-
+    Full code: https://gist.github.com/scockram/7749109cfd64074051dd33b69817222d
+
+    Fun little pattern , with the lambda:
+
+    ```ruby
+    vec_do = ->(op,u,v) { u.zip(v).map { _1.send(op, _2) } }
+    ```
+
+    Can write this for part 2 (where a and b are [x0, y0], [x1, y1])
+
+    ```ruby
+    [[a, :-], [b, :+]].flat_map { |init,op|
+      Enumerator
+        .produce(init) { |prev| vec_do.(op, prev, ab) }
+        .take_while { _1.between?(0, input.length-1) && _2.between?(0, input[0].length-1) }
+        .to_a
+    }
+    ```
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m11vdbe/
+  :body: |-
+    Took longer to code this than I thought, but it was pretty straight forward, my initial instinct worked perfectly and the change for part 2 was trivial. Manhatten distance and some algebra. Solution runs in a few milisecond.
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/8](https://github.com/careyi3/aoc_2024/tree/master/solutions/8)
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m104v61/
+  :body: |-
+    Pretty straightforward one today but I got hit hard by reading comprehension. I totally missed that the antennas themselves became antinodes in part 2. After I was done I went back and tightened my code up and realized this whole thing becomes really simple if you represent the x,y coordinates as complex numbers.
+
+    ```ruby
+      antenna.each.with_object(Set.new) { |coords, antinodes|
+        coords.permutation(2).each { |a, b|
+          (0..).each { |step|
+            c = a + step*(b - a)
+            break unless in_bounds?(max, c)
+            antinodes << c
+          }
+        }
+      }.size
+    ```
+
+    [github - solution](https://github.com/globalreset/advent_of_code/blob/main/challenges/2024/08/solution.rb)
+  :replies: []
+- :author: RivtenGray
+  :url: https://www.reddit.com/r/adventofcode/comments/1h9bdmp/2024_day_8_solutions/m10dpu8/
+  :body: |-
+    [Github](https://github.com/rivten/aoc-2024/blob/main/08/rivten/08.rb)Learning Ruby for this year's AoC, I like how I get more comfortable with Ruby and the code is reducing in size while keeping clarity (or so I think !)
+
+    Also thank you to /u/4HbQ for mentionning complex numbers a few days ago. Really helped here !
+  :replies: []

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

@@ -0,0 +1,32 @@
+---
+- :author: FCBStar-of-the-South
+  :url: https://www.reddit.com/r/adventofcode/comments/1ha27bo/2024_day_9_solutions/m1815dt/
+  :body: "[paste](https://topaz.github.io/paste/#XQAAAQB1BQAAAAAAAAAyGkrNYxPxU6xvuZs/8lAz4jUZdGtcxCNrBlC+wPZSIDCK+g6seBP+9oUsdbVzJL5ksqfGzfPMJiBUynSKfmWy48YAHBo3XXqY09VJhNgCNrGH4b5VkevJmdwCZ48IvIsCD4C41qLQ4TCOpq4PSwIHaAHcgyjTmp7fXbB6N+JhgKUFq4I+e3H5Tf7IpIqgJYEqikCAW7JZWjcfIcyYtAEpH8Deaa6NOC4yGDlh3SmtkTAi+5I+uhmwsoV/uygBiM5P0xx2DklvGiyGSYUr0LxxZ5ZWgaR6DV8amRFRD1OTMSs0xaCht3gm9f7PbYnsdLS/+AWidd2Vz/yFZFss3oHjCEOTYaneg9x27vCrMcdmCX9k09H/SYEIPZyJpO7og862N0n5XbUIABEmNhEuu/KHiUHRfpJ16RFPsPg0RSxJcQ36bjxRLksZsSNLXZObB2YmiSHqwYWZruEABgOGEjWn1NdF7XwLijc9evs6dadKH+CxIieymrVEpcG51j9+8aES2D5k/gjxtUAChtJsWKJDcv8jdy8KwmpQa+q7dOsRO7hLkUsbkYQnajDl7c9K1mafLwIXXGQHGN3Xs00YOnV7Kd41mqamwyEGLbHV0inapBOBK6ByHN0WH3yfUoE80E25GVeqx2/v/CivLZZ2erhIpXo0OICU+1Az7hJfwpsMOnLKOS53OmBbm0TWYGZoipp6TPapv1pOfzkaKA/4cHnZFAjqrA6c6Mgx//MJAm8=)"
+  :replies: []
+- :author: globalreset
+  :url: https://www.reddit.com/r/adventofcode/comments/1ha27bo/2024_day_9_solutions/m17lx73/
+  :body: |-
+    I was really proud of my part 1 approach, even though the code is not very tidy. I never expanded the filesystem but instead calculated the checksum as I go through, alternating between calculating it on a file node from the left and then popping a file off the end and trying to squeeze it into the next free space.
+
+    For part 2, I just couldn't figure out how to get my part 1 style solution to work. So I gave up and went to a linked-list. This made the file move operation very simple. Part 1 runs in 6ms and part 2 runs in 800ms.
+
+    [github - solution](https://github.com/globalreset/advent_of_code/blob/main/challenges/2024/09/solution.rb)
+  :replies: []
+- :author: careyi4
+  :url: https://www.reddit.com/r/adventofcode/comments/1ha27bo/2024_day_9_solutions/m18upf8/
+  :body: |-
+    Didn't really enjoy today, but we got it done, brute force with minor optimisations.
+
+    [https://github.com/careyi3/aoc\_2024/tree/master/solutions/9](https://github.com/careyi3/aoc_2024/tree/master/solutions/9)
+  :replies: []
+- :author: Infinite-Club4374
+  :url: https://www.reddit.com/r/adventofcode/comments/1ha27bo/2024_day_9_solutions/m16d4z9/
+  :body: |-
+    All of my solutions are super verbose just cuz my mind doesn’t work the same way as some of you folks but idc I’m completing them and I’m pretty happy about that
+
+    https://github.com/Leftyxiv/advent_of_code/blob/main/2024/day9/day9.rb
+  :replies: []
+- :author: Stronbold
+  :url: https://www.reddit.com/r/adventofcode/comments/1ha27bo/2024_day_9_solutions/m16xzes/
+  :body: "[Solution](https://github.com/Alvaro-Kothe/Advent-of-Code/blob/main/2024/day09.rb)"
+  :replies: []