advent_of_ruby 0.3.4 → 0.4.0

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

@@ -0,0 +1,213 @@
+---
+- :author: thaadjarvis
+  :url: https://www.reddit.com/r/adventofcode/comments/1pg9w66/2025_day_7_solutions/ntdpc7f
+  :body: |-
+    [solution](https://github.com/mtking2/aoc-ruby/blob/main/lib/solutions/year2025/day07.rb)
+
+    Part 1 just iterating and counting splits
+
+    Part 2 using \>!recursion and memoization!\<
+  :replies: []
+- :author: SleepingInsomniac
+  :url: https://www.reddit.com/r/adventofcode/comments/1pg9w66/2025_day_7_solutions/nsv51ep
+  :body: |-
+    https://asciinema.org/a/sabtPpvg27FtpvZ27zS4VxaIH
+
+    https://github.com/SleepingInsomniac/adventofcode/tree/master/2025-12-07
+  :replies: []
+- :author: srugh
+  :url: https://www.reddit.com/r/adventofcode/comments/1pg9w66/2025_day_7_solutions/nsum8ms
+  :body: |-
+    Solutions in Ruby for part 1 and part 2. No recursion, no dfs, etc.
+
+    [GitHub Day 7 part 1 and part 2](https://github.com/srugh/AdventOfCode/blob/main/2025/day-07.rb)
+  :replies: []
+- :author: Intelligent_Net_9057
+  :url: https://www.reddit.com/r/adventofcode/comments/1pg9w66/2025_day_7_solutions/nsucl6w
+  :body: |-
+    ```ruby
+    tree = File.readlines('test_input', chomp: true)
+    beams = [0] * tree[0].length
+    beams[tree.shift.chars.find_index('S')] = 1
+    splits = 0
+
+    tree.each do |line|
+      line.chars.each_with_index do |c, i|
+        if c == '^' && beams[i] > 0
+          splits += 1
+          beams[i-1] += beams[i]
+          beams[i+1] += beams[i]
+          beams[i] = 0
+        end
+      end
+    end
+
+    puts "Part 1 : #{splits}"
+    puts "Part 2 : #{beams.sum}"
+    ```
+  :replies: []
+- :author: Mahedros
+  :url: https://www.reddit.com/r/adventofcode/comments/1pg9w66/2025_day_7_solutions/nsszky8
+  :body: |-
+    For once I've managed to overcome my stubbornness and actually go back to make something efficient rather than just let the brute force code run for 12 hours
+
+    [Code Link](https://topaz.github.io/paste/#XQAAAQAKCAAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8KxkURAq1MNsPbt6HX6Vl9MUBsAFA2fZ7UeLBp9rfMabILJJXIO9G6n2aBBUDc2ZX4vbyOrCXe0HqHl8HWoSGrxseDo04/PSV3b/iXlpH6vER64cio881Jqa+7Mhqt9elIwPY8GahLlfkZIIaL4QJx643qKHkXkwxIWgqSrhbNsSkbtQhIyu+ErfQxFBjRynZlErvYWVeCiG1cdx5D42vfNkk8CRuzZK9j6biojXeKy67X0c8AKYf9j5OSZaMS1DckVOmRl7fjoThUccEXAMSxAr9cAx/fUcBcwUMeUR7IuSRoyW06f1cJNdRfcsrDjX689srtYHcC+TfFLZQ//bsifDqKRVpJ4Oo0cpd/gru/5FS03FFTlblHnA7hD84FAQ477KBnX+U1Wgw9Dwpz2HF7CUo5lJ51Kk5maRcib6QIUuYq+/v1HxayxJ00soKfcTb8DfCBmoBED5FSWuev2Sg8tz0v2lfOFbMzLfVE2+PFW/ddx2zu35BHAw7l+5jZtLrzcPno7KLYV/efeNpwSvz5i0lRPltYPZXfygAMnTop0TDazKLgl1xTgoutd/+wQ5AGz+rp14Niq8LUe3NLKL1jLoA6GbR+LvIc/IG5Nachqoe+5G78SOmdt/gFTIeaSvWT6L0v9dbwRAyP/sD8K+dv+xcjpSkw5vrylVPuxLloOVLObw5GqnKaAkX/ISwhRNYm6iXW2QisDNkrbHgphpmLhRF6U4q+UgpNbdtJEC5o1IAOLtX4mU3y7eb7TZzowRkq3/JGtPM+chw2TI70g0LmJCbMsMp+ksXoqG9MHXhK1F6CQHNCOU7Ep25E3YafvHf/iV8FEg==)
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1pg9w66/2025_day_7_solutions/nsq8fmy
+  :body: |-
+    ugly, but it works. Somehow I got tripped when doing part 2 using the same way I was doing part 1, probably order of updates or something, so had to change that
+
+    ```ruby
+    def solve_easy(grid)
+      split = 0
+      grid.rows.each_with_index do |row, nrow|
+        0.upto(row.length - 1) do |ncol|
+          if ["|", "S"].include?(grid.rows[nrow - 1][ncol])
+            if row[ncol] == "^"
+              row[ncol - 1] = "|"
+              row[ncol + 1] = "|"
+              split += 1
+            elsif row[ncol] == "."
+              row[ncol] = "|"
+            end
+          end
+        end
+      end
+      split
+    end
+
+    def solve_hard(grid)
+      timelines = Hash.new(0)
+      grid.rows.size.times do |nrow|
+        row = grid.rows[nrow]
+        row.size.times do |ncol|
+          if row[ncol] == "S"
+            timelines[[nrow + 1, ncol]] += 1
+          elsif row[ncol] == "^"
+            timelines[[nrow + 1, ncol - 1]] += timelines[[nrow, ncol]]
+            timelines[[nrow + 1, ncol + 1]] += timelines[[nrow, ncol]]
+          else
+            timelines[[nrow + 1, ncol]] += timelines[[nrow, ncol]]
+          end
+        end
+      end
+      timelines.keys.select { |nrow, _| nrow == grid.rows.size }.sum { |k| timelines[k] }
+    end
+    ```
+  :replies: []
+- :author: xr51z
+  :url: https://www.reddit.com/r/adventofcode/comments/1pg9w66/2025_day_7_solutions/nsr8zk1
+  :body: |-
+    \
+
+    ```ruby
+    # Note: this won't work with '^^' but the input doesn't include any
+
+    input = File
+              .readlines("07_input.txt", chomp: true)
+              .map { |x| x.split("") }
+
+    def splitter(x) x == "^" end
+    def beam(x) x == "|" end
+    def int(x) x.is_a? Integer end
+
+    # Part 1
+
+    result = 0
+
+    start = input[0].index("S")
+    input[1][start] = "|"
+
+    input.each_with_index do |row, x|
+      row.each_with_index do |col, y|
+        if splitter(col) and beam(input[x-1][y])
+          row[y-1] = row[y+1] = "|" # split beam
+          input[x+1][y-1] = input[x+1][y+1] = "|" # continue beam
+          result += 1
+        elsif !splitter(col) and beam(input[x-1][y])
+          row[y] = "|"
+        end
+      end
+    end
+
+    puts "Part 1: ", result
+
+    # Part 2
+
+    input[1][start] = 1 # initial beam
+
+    input.each_with_index do |row, x|
+      row.prepend(0); row.append(0) # to avoid issues near the end
+      row.each_with_index do |col, y|
+        if col == "." then row[y] = 0 end
+        if beam(col)
+          if splitter(row[y-1]) and splitter(row[y+1])
+            row[y] = input[x-1][y-1].to_i + input[x-1][y+1].to_i + input[x-1][y]
+            # last one doesn't need to_i as it is always 0 or an int
+          elsif splitter(row[y-1]) and !splitter(row[y+1])
+            row[y] = input[x-1][y-1] + input[x-1][y]
+          elsif !splitter(row[y-1]) and splitter(row[y+1])
+            row[y] = input[x-1][y+1] + input[x-1][y]
+          elsif int(input[x-1][y])
+            row[y] = input[x-1][y]
+          end
+        end
+      end
+    end
+
+    puts "Part 2: ", input[-1].inject(:+)
+    ```
+  :replies:
+  - :author: xr51z
+    :url: https://www.reddit.com/r/adventofcode/comments/1pg9w66/2025_day_7_solutions/nsr9qhw
+    :body: Admittedly [this post](https://www.reddit.com/r/adventofcode/comments/1pgbg8a/2025_day_7_part_2_visualization_for_the_sample/) helped me a lot to visualize the problem in my head.
+    :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1pg9w66/2025_day_7_solutions/nsrk303
+  :body: |-
+    Part 1
+
+    ```ruby
+    GRID = File.readlines("input.txt").map(&:chars)
+    start = Complex(GRID[0].index(?S), 0)
+
+    beams = [start]
+    count = 0
+
+    (GRID.size-1).times do |o|
+        nextBeams = []
+        beams.each do |pos|
+            if GRID[pos.imag+1][pos.real] == ?^
+                nextBeams << pos + 1+1i
+                nextBeams << pos - 1+1i
+                count += 1
+            else
+                nextBeams << pos + 0+1i
+            end
+        end
+        nextBeams.uniq!
+        beams = nextBeams
+    end
+    puts count
+    ```
+
+    Part 2
+
+    ```ruby
+    GRID = File.readlines("input.txt").map(&:chars)
+    start = Complex(GRID[0].index(?S), 0)
+    MEM = {}
+
+    def solve(pos) =
+        MEM[pos] ||= case
+                       when pos.imag == GRID.size - 1
+                          1
+                       when GRID[pos.imag+1][pos.real] == ?^
+                          solve(pos + 1+1i) + solve(pos - 1+1i)
+                       else
+                          solve(pos + 0+1i)
+                     end
+    puts solve(start)
+    ```
+  :replies: []

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

@@ -0,0 +1,73 @@
+---
+- :author: srugh
+  :url: https://www.reddit.com/r/adventofcode/comments/1ph3tfc/2025_day_8_solutions/nt09027
+  :body: |-
+    Used DSU / Union find for this one.
+
+    [GitHub solution for both part 1 and part 2 using Ruby](https://github.com/srugh/AdventOfCode/blob/main/2025/day-08.rb)
+  :replies: []
+- :author: xr51z
+  :url: https://www.reddit.com/r/adventofcode/comments/1ph3tfc/2025_day_8_solutions/nszpat1
+  :body: "[LINK](https://topaz.github.io/paste/#XQAAAQAtBgAAAAAAAAA5GUqKNoFH6SMqoVC09YUYdlQd9lvuD0yaWfOoUhdmwU3iFZtA1EYdUcBXWSpoi3hN8NnYO0x/Gu4Ryyma/PBexBnUS4FSGlRH8HAStpcRgm4VvwdrQdaBGB+6KVd8QOY7UPjNJxP1WsqcmlgaBVZQ2HykpWjforhlkvJiD2qbkXYLiWa0bge05ExU8bfy5Xc0AoYMf2oFnd+90vCDPAmQN7YirC9kgdpv2UjP2d9XDdQSzl0x6tIHI6IHEl/MIiYC6XsRGKujfG55OigVsKVuZuhHRhm/reIjNLL2rADiZsux3zmVUC5a6M7TiAqcDFpS1ksMa4ViXvUqnBkxQibgTG6eAKLrPmAY47kP4amjXQkPm3yr8VErm27Cfyw4xBVdp37qYmj95Jm4eivZk7xNqZDq7t2tpFJtWIncfaWejMuyFRMDErAS2R8GioxnlxRdXQ0mdsiP9qrPt5oG2ufepAx8A6jmhNv2ZoQMBkNvNDnJSJatu/e3/r8DYqiCJ89WciuLR0+imr0KEqPgffryUtgSlLKtmBzF0fzyNl3Tp1teEJKtH7w5v1yWWIcjXNlnPEoRpNLUXczWa7E5Z0i1mg5KmPNuwj0VkfT1RZ8UeYG6LLAKy99k5Sj2xuaU3NvAN7a0qCR6chCG+iXAwhLSa2AfiVv6M3s+9FJwB8BMZ/dnypZ2JEbWnHD8J2MoYpwOr/EMmlnIvb/ItdDfEU0HoxGQez19ND1iujQfxMtTmKBf/X3X4EwIzWa6H+eQEd6eO7blL0Ih2ISpKUOCUdKXt3DAAALqysSG+TRrt+lBlwtvi/aVTVNXq7pUmOdvFqDLmuYei7bxBxUhAqC+y5o++gEbyZh2rU9Dao6r6DPwkHv/0k8fhw==)"
+  :replies: []
+- :author: el_daniero
+  :url: https://www.reddit.com/r/adventofcode/comments/1ph3tfc/2025_day_8_solutions/nswfxdm
+  :body: |-
+    ```ruby
+    N = 1000
+    input = File.readlines('input08.txt').map { it.scan(/\d+/).map(&:to_i) }
+
+    circuits = input.to_h { [it,Set[it]] }
+    by_distance = input.combination(2).sort_by { |a,b| Math.sqrt(a.zip(b).sum { |ai,bi| (ai-bi)**2 }) }
+
+    print "Part 1: "
+    by_distance.take(N).each do |a,b|
+      ca,cb = circuits.values_at a,b
+      next if ca == cb
+
+      ca.merge cb
+      cb.each { circuits[it] = ca }
+    end
+
+    puts circuits.values.uniq.map(&:size).max(3).reduce(:*)
+
+    print "Part 2: "
+    by_distance.drop(N).each do |a,b|
+      ca,cb = circuits.values_at a,b
+      next if ca == cb
+
+      ca.merge cb
+      cb.each { circuits[it] = ca }
+
+      if circuits.values.uniq.size == 1
+        puts a[0]*b[0]
+        break
+      end
+    end
+    ```
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1ph3tfc/2025_day_8_solutions/nswnuat
+  :body: |-
+    Part 1: [paste](https://topaz.github.io/paste/#XQAAAQBbAwAAAAAAAAAxmwhIY/U8uRGJe0wm8TD4UT8WFHJqY/veL97LoU6Dy/WfRDFYXlfX6PjMyFZoF8VZun3D1xbCBR5/xZWxa8nYpneP1J6Urt17E/nNd2krWX/S+KjyBuHsfryhXtVCu/TnNa/avwE2Yd65Kbjwwjienr5idmOgnAvTMZxWJSfOuLcl1Xg00guFCtB3eNN0xrXviKSbTlLxgMVpUrLIMWD8C2Hc1mCyDjetNVM501wtP/v3A8fVC9WvWolqt485zm9FMi/2Nsk5HOcCDCrMXykV/gzbL3mcvf0bV3dSRS6lTpFRhL1PASsYp8OHHFCFrJUGqyJb7BcqJS29RbLEeLZ7v+qjvIcc1fdeYcmrkyeOt2F2INUIBH95nWxItt2s1pNEUnFAsCPC6lBOGxh1rAFBwUrM/vxk6sditaCmCz8bTu3a26qje11ipUYkpdbVutFu4bqIoWgyZzCIg8BtDhv9lNmlzicNOp48ysOBjI1ZikOHb+aJ9ltB/GU5JV5gsscCUCAI2sQJR/pc0EJnIPJvKwEgE/Vg/5QNa8N3br4DfE+jWLQyyAFPXlNABv8/mXnjiLvalBLlXjrmUi6senq90iigWzz74q2wAnIRUl8lfbX+cdd0TVytbLeNtNIFB/wz/3+1SwA=)
+
+    Part 2 (easier than part 1 today):
+
+    ```ruby
+    def dist(x,y) = x.zip(y).map{it.reduce(&:-)}.sum{it**2}
+    circuit = Set.new
+
+    File.readlines("08/input.txt")
+                .map{ it.split(?,).map(&:to_i) }
+                .combination(2)
+                .sort_by{ dist *it }
+                .each do |a,b|
+        circuit << a << b
+        (puts a[0] * b[0]; break) if circuit.size == 1000
+    end
+    ```
+  :replies:
+  - :author: xr51z
+    :url: https://www.reddit.com/r/adventofcode/comments/1ph3tfc/2025_day_8_solutions/nszqlqq
+    :body: I also do AoC in Ruby and I love seeing how efficiently you do this (and previous entries). It's like we have the exact same idea but your code is a third of my amount of lines. Learning a lot! Thank you!
+    :replies: []

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

@@ -0,0 +1,26 @@
+---
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1phywvn/2025_day_9_solutions/nu6tir3
+  :body: |-
+    I got inspired by the _Coordinate System Compression_ approach.
+
+    [Paste](https://topaz.github.io/paste/#XQAAAQB0BwAAAAAAAAA3G8iwV4Qppo79/Ujg+7qaomHJcVmcDMXaCHzF/szaCN1B3OQWh7s2tQ+43K8lY7nmb4hhnibJfso5Wp2gdiVwWpld8FvJMlogqHwXRsgKiG4gk5i1GhO18WRb2sZTD5UhPgnsJMZhH/uE9rJ/aLju1p65CuS37k9jNTquS0mpBEck6DeQvTOdrZtxojQmmHm9OTfHtOllBF8aMRTksb0giU3KTyDv8gw0p1irAzaVLw9CzWN0nSThmhndqHysOQGdnMkE+3g+5sNnflIk0wqEc5njuru8L0EMNpa5rJ3O5h/TkpnJqftNERqIjScxvd7fgn3edpy2MhgZq3WEXwNoiE1XpI4JGI4wGB8bsk/22v21PMtyrVXN0oIwrVT+jMq4iT7vfCifWR9aqh+JmRXkOZvwI89QpRr+Eq2SDlxR7niZqUIJepcBa9Hx1fcMyf7NKswJRi/6rM5+voiFEOV3M8awwM7weBXv7jJMUpM2ZO9Gy72gTBeFvgL7HODU06uZfj/Rfz4VqMVhF8sQ3p22sZ1rjkyaghzV2BVzK6G5/37H3qvzrrsW604oWAijGFkcOp6fduK7wV2AW+/qMkHyfeVzP1829Lvdjxoe7OjoN4aLnygfkEcZiNyNDuCfG/aOAEgxeTR5GXVEPI3Nwk/yDm/wxrdCBAspp+6Z+PiS4Phq6mqsUN9q8IBc67ET/USi8uT05elS/Kh4pHnTGCHqgdexUOYOmH2jVshG3LUeyCZa9Agohl5MkxwLjdjvWJDu0XfdaHIESqCaocskhTCFYymIlM3LkoTfWjHOJfedmM88GuK/MJOU/0fK35rIV2hmzIeXRZG1kxjR8xz3RmJECiWIiBoyBr+5oQpLW+UOoG34eWT2jFM97BjR1RlQ4tq7QYCJay346itBZxn7bkHf29WrBqypVTz2x2tgss8FOOUBOmRL/A5X1/9W7Ht0flaVodT68Qj4ekba/QF3DV6rA1M6zCUnCnMKa5UBlBnoPRQKbOhyqfTTKfHcYGnzTdpIrs9JoEw7Ff7RyJnaxA20w/G02pP3tdTZ0USYDtCaUk80w+3/0NLZzAnS2tM3YIGUKDnzekwCb0FWeEGpYjUAsDAJ1AlJy/rjcdo3t6rtss/SQtTJ60uIwSOXt7aXtPY4Yuax6X3r/LDjKg==)
+  :replies:
+  - :author: craigontour
+    :url: https://www.reddit.com/r/adventofcode/comments/1phywvn/2025_day_9_solutions/nw082oo
+    :body: |-
+      Struggled with part2, so looked at your solution for tips, but when I run I get "undefined local variable or method 'it'". What do you do different for 'it' to work?
+
+      [Edit] It see it's supported in 3.4.
+    :replies:
+    - :author: _tfa
+      :url: https://www.reddit.com/r/adventofcode/comments/1phywvn/2025_day_9_solutions/nw0e9ft
+      :body: That's right. You have to update Ruby.
+      :replies: []
+- :author: xr51z
+  :url: https://www.reddit.com/r/adventofcode/comments/1phywvn/2025_day_9_solutions/nt7uca8
+  :body: |-
+    [Link](https://topaz.github.io/paste/#XQAAAQDOCQAAAAAAAAA5GUqKNoFH6SMqoVC09YUYoyM0HaPFXythHlAP4pnJzZ/mGYNycp42xxVNhQ0tL4RBJLGPO5bk+V0PGuI9TwnUwUp1Z/rgB5cXuK6002ovOWs3hT/F3Xi18HNzcrRtXCNQbXSr0Nr9o9OhD1grYOkQbPSDkUpFxHF/rIA2YhN2zmcsbxJ4E6mXXdWTACvNlSAp1hhbSbcWfkbKwkUT++y62UfIJ26s2pgajxJE7yDUb56tSqH/F/VCGFJ5ps6Pxnwr1+7/JtBNGW15Ru/gLfk+8oKJnUaH6NHv9jAHo1mwVWoPnHy4PKDAQ1Uey+pM8Q3LSiWWGuvUaPZ8LDiO73DhamUylLxCo7kZKPt0EDl/fGlsoLsxMhm4BkQY9izQmVVYlo8vqsYLkznXDaKmgqJq4bAhEm2pu1xUy7GaHtTBdgIG4yb7lCZzLj/Bxp35YpxyP64glLpEWR2fY0reypQGY1o989ghmxXKbFvfBuuKWTnOg8KouNO10TiRUxkgkHje02hq7IqDU7Za7yQvvvUElxXsGRB1dnK5F80O1f/xrLlHJWIVLCYPJIZIx6+axxSLMjiD2GvBvznqVb+3YdDddXvrS7KnoJBSqRuHcHjUW7UcJMxKQx1yQE97mJHBFZJjFsCQYyw+cpD0ak3KQoj/YT0qIVBXDRSacDTjEb995fPlCAOok0cFWpuQu1KMeSG+BGoHUJcRqilkqncmlQ/gROU/mISTNuh0uczMwwVgBT0uFMzXFMGZvwxssm21HJ5Mpm8JM+kbawMRxp5Kw8JCZN+3dOoXWflshvBclC4ene1xpOrm9jQ+fW7vKwnN/e5sTFE21j5MEo3RENT6fUB+ecg5uSqxqcIrMWo+ulnGlvIfuDGbqPp6JLV4b3Ztap+2mOWoUpjQEGykJJCn6y1S2FLNs/IYV6JGZrNjVKZKHcJs3hqlGbvVmp1mczI4uhTEHwH02SvpAlOUCJefRu2KHC93W1d9dKTEHrbtpN/yQNz6kOftUW5zNHiHZwWpBqNxen5W1wS2YNl9jiHANPGe8eUdGiXjcO5uRwv/thXWEDFb6bs2tmlheTNZFReCnRJXHTmAjXbKsQG1ZHp+Fo7+cP1wXGUyoEv/qDs7Lg==)
+
+    Definitely hardest one so far. Part 1 was super easy, part 2 kept me up until 3AM. At least I got a script that shouldn't take over 30 minutes to find the solution, ahem. Good night.
+  :replies: []

data/data/solutions/reddit/ruby/2025/10.yml

@@ -0,0 +1,73 @@
+---
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1pity70/2025_day_10_solutions/nudj3n0
+  :body: |-
+    Part 1:
+
+    ```ruby
+    input = File.readlines("input.txt")
+                .map{ it.scan(/\[(.+)\] ([()\d,]+)/)}
+                .flatten(1)
+                .map{ |l,b|
+                            [
+                                l.reverse.gsub(?.,?0).gsub(?#,?1).to_i(2),
+                                b.scan(/\((.+?)\)/).flatten.map{ it.split(?,).map{1 << it.to_i}.reduce(&:|)}
+                            ]
+                }
+
+    puts input.sum {|z,b| 1.upto(b.size).find{|c| b.combination(c).any?{ it.reduce(&:^) == z}} }
+    ```
+
+    Part 2:
+
+    That was a tough one. I got inspired by [this thread](https://www.reddit.com/r/adventofcode/comments/1pk87hl/2025_day_10_part_2_bifurcate_your_way_to_victory/): [Paste](https://topaz.github.io/paste/#XQAAAQBuBwAAAAAAAAA0m4poOBCMftdkRQiciXYGFBdLcr8czW9TNbult1FTw8hi7RjuG3N7nWSKl+Ojw06rUyBOmI9nnOAUVyMm5QlJapUyR9NlpWwZzKsITW+HqmGVBBpKCGEi39GLox2a7Q2is/by5448BGD5LaYgscEy76hSq2fSfZNLSCqj1b2rFlLwTcx4s+R9zyHBaTUGS5CuL4vPbxRBmK9TSXz4CrYBsjGJ6q19eJZyWCOqKUAWS5SFPahQUQsYY2OWLBFQUCD5QJOsfhbn8KaypJQWP3X6QQEWfLWjWt3y/bulu9coB1hORtBAsN3p556Ibi2/Flrzpk29Ku1diBrfIG3Pv4GmP7QGBgfhNhXMorUeni+zHGgsRNzeNuDiaR4A/2ZAXc79BgQWYov+u0Mg7+j3WUYwtWBkV0f+5czVTchDZr9uAytgZ8pURAM91yYxLcZdpQ/So/oup3Hwvsuj/JmN2esbuAh64l5hzqhgiBW4DLJbAgutb46rq+LXodg00A4Ze5RvaMQUPthJWJeCkhTT312nJsZV3yMIi3ZHxYRVa/7kwyo2OdXQZJVc3w8Wz1KmbVdOdWpfplcftf68nXBkgC63SSAktBtF+6tIgV2fwHBcfnlVOwEIZ4MxxdN2dC+2Eowf7wBr7CaWV+QQCptGgUM6woqi6xE9RmBuk+rfBELDrcxkoy7MZlHoUPHjWm8HnHoQ9oEUMMyCUktfjBwApikIPUQbbeXtonl/LbSV24mJ9BAtNiZJtV9lxXQCgXd2eoKogoe2aQz8p1+CN8nCEZg4MWbXe3cQMVr6d1jZEyJDlk5y8ZudZ3MBmIh0D7LpUF9DBtKvBkAYN/peVQAmmSw8rBiSSwyhnIi1ig/w4YCjxE3CaPsiUCCOw1tRjMMZWYIBMbqpyIRFZFgAhMgg6jmy1U/lTgZ4s7LO7Bdsc+rY70TkynHUOjweCgVdLWOCOy266g+TrZAUaBci/uKJO3kfD37TUT00ceL/xiss5FvDGZlFOEZlAbEY9Gu+JQJKzukIh/xHLe4=)
+  :replies: []
+- :author: xr51z
+  :url: https://www.reddit.com/r/adventofcode/comments/1pity70/2025_day_10_solutions/ntctd7p
+  :body: |-
+    [LINK](https://topaz.github.io/paste/#XQAAAQBnBAAAAAAAAAA0m4poOBCMftdkRQicgxqzrJtesqtO5HNoJyV8IUlraV1wGhmrxaU8vq+N/svmLBfE4aEwMN6Edw7/eQI/cYcwlyLfkogF0+1QwXfgUz3OzIQ6fs4vW8poF3IpWH3gZFRPWy7CKBQx0mPB8cZZZvaYtPl3PPtdL//aSIAbg0OGUir3CbK+c8PpiJ5gaGEzHVRblYJVc5LF+bq9LwL9Hcq8v6C+JwHoUCcIdJoYRT0RkNpo1jbEJ+SKS14FMm3HYzsNF0D0KMt3U5Z7d4w2gIX+lJP/iEZx2eU16l+bL3LbmCQOrW1nK0OV52u2YR0u0xlRtoVK2WsAxFiklno+kZBEjpOyTqjos+v7P86Fm6C+c1qx1CFvhfUFDlD0yGABl/Xu91UufiSOUbkKE8VEnN9xk6nUq+tR4YUPLZmrIV/hU6nOGtasWbv/SNhV2G0juL8aS6O7v0PXeXc2TxPA0IFrvPB/XfWxq3eScswOxw+dkXhpnSk1Ud8L8jj6g0litGuZ2Otx9t3zdr8QCqsxBSBaTkQv5vUx823pXxh6oRan9LUtGWZNBhWapixYFVn2GW2S0yWvq8SaVxpGS/lFJcfhTgOmTm2Zi1pg6jOujLXwV9mIgYjA0gxWO1xBow9xP5r5psahBZ4Anqvw7nqnr/3WhWo=) (part 1 only)
+
+    I am not a programmer, just a 30s-something guy who decide to learn coding earlier this year, and today I am defeated for the first time this AoC.
+
+    Part 1 went really well, I had the solution after about 20 minutes. However, I've been chewing on part 2 for hours now and I've decided to give up. I wanted to write my own algorithm (lol) but failed, then investigated this (to me unbeknownst) Z3 thing everyone's talking about, but decided to call it a day. You win, elves!
+  :replies:
+  - :author: flwyd
+    :url: https://www.reddit.com/r/adventofcode/comments/1pity70/2025_day_10_solutions/nwj1dec
+    :body: If it makes you feel any better, I _am_ a professional programmer and it took me two weeks to fully solve part 2.
+    :replies: []
+  - :author: ChupeDeJaiba
+    :url: https://www.reddit.com/r/adventofcode/comments/1pity70/2025_day_10_solutions/ntdfawe
+    :body: |-
+      I loled at the `puts "Part 2: ", "ERROR: brain too small"`
+
+      A few suggestions from a fellow ruby enthusiast (?)
+
+      Since only the min amount of button presses is needed, I think that changing `buttons.length.downto(1)` to `1.upto(buttons.length)` will allow you to exit as soon as a sequence reaches the end state instead of going trough all combinations. Something like `Enumerable#find`
+
+      To avoid being `#hacky` you can use `Float::INFINITY` as an initial minpresses value
+
+      Look into `String#scan` and some REGEX for input parsing, is pretty useful for AoC
+    :replies: []
+- :author: Sharparam
+  :url: https://www.reddit.com/r/adventofcode/comments/1pity70/2025_day_10_solutions/nt9vc46
+  :body: |-
+    [LANGUAGE: Python]
+
+    [Did part 1 in Ruby](https://github.com/Sharparam/advent-of-code/blob/main/src/y2025/d10/solve.rb), and then had to admit defeat and [use Python and Z3 for part 2](https://github.com/Sharparam/advent-of-code/blob/main/src/y2025/d10/sandbox.ipynb).
+
+    Makes me wish there were Z3 bindings for Ruby that are not in ["very early stages of development"](https://github.com/taw/z3).
+  :replies:
+  - :author: firetech_SE
+    :url: https://www.reddit.com/r/adventofcode/comments/1pity70/2025_day_10_solutions/ntawa5m
+    :body: |-
+      They might be in early stages, but they are still [perfectly usable](https://github.com/firetech/advent-of-code/blob/0fb1c0178b4b6250487f0a6fbf0191e4331471e4/2025/10/factory_z3.rb). ;)
+
+      My first instance of using it was three years ago, in 2022, and I've never had any issues (except that just `require 'z3'` slows down general Ruby a bit due to [some hacks](https://github.com/taw/z3/blob/master/lib/z3/hacks.rb)).
+    :replies:
+    - :author: Sharparam
+      :url: https://www.reddit.com/r/adventofcode/comments/1pity70/2025_day_10_solutions/ntbxsc5
+      :body: |-
+        Oh that is some good news, thank you for pointing it out!
+
+        One less thing to need Python for :)
+      :replies: []

data/data/solutions/reddit/ruby/2025/11.yml

@@ -0,0 +1,69 @@
+---
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1pjp1rm/2025_day_11_solutions/nuhk3ir
+  :body: |-
+    Part 1:
+
+    ```ruby
+    TREE = File.readlines("input.txt").map{ it.scan(/(...): (.*)/)}
+               .flatten(1)
+               .map{|node, neighbours| [node, neighbours.split]}
+               .to_h
+
+    def solve(node, target)
+        return 1 if node == target
+        TREE[node].map{solve(it, target)}.sum
+    end
+
+    puts solve("you", "out")
+    ```
+
+    Part 2: [Paste](https://topaz.github.io/paste/#XQAAAQCOBAAAAAAAAAAjlIQlg38G5hKsB77A1DF67Y2pXyBxCQxuOlWiLUsdIzsv54a3zV6twiVZqW2FXkkywX+ffAsHE8J3i577QRXKM41LIbMWodpfzMUo4t9RF0MC9/m3xRkqkvdZSIinGyZ6W2o1DRGBIqjxIxSWj1wrgJSqVePXJ72kVvxtShjBDheqGFW9MJIFxoN+hCbSoxWHOSXDN/B7fLfBt2m5z36Pnyqw6xXNUtYjpafCmRrsMiT/wuuhLeOsl77OwEEwGc8E49VpTjDYdQI2/Ob8VxU0xrz5G8UP3EKRd3Njg6Mqlk9+zA/Eoobn1P3k2Wh3pnFkjVRm0L/dY/LZx9QxjyjfIWVzY6wX/KqCWUPUdYZZFmYP/yR8SemlPO0TAlZarFK1DwD9s6xIrL+9JeVXhf8RKSQpQkVR1UuohNiGQpeEX3/7lrrYYqiCjh/ulhfupd+wcZyxNAabEM7wNosTX5uf5zwmvj4H42qOA6y36+UzvlCHNVjKIVzFGlGynfqTVnltRkZDFHsu6I8gyMBZJ+T0mOgsFfJ8LvfrhPVCfBh0HX2DKCtdi6Zx8j51HnvwSnOB+VXAxmiGyi+CsPLmQ1AglO3dDeSTyX2Xq+IiSGoxptLHBD6vmCGIKxfakjirmo3WU7AVHv7DLzlQ6Z2CRZ7MPzTY5iMk3tuxQfwAisEw/rKk3ZNKaorv68obMOXW84/9uw+EoeX/3YN+4w==)
+  :replies: []
+- :author: srugh
+  :url: https://www.reddit.com/r/adventofcode/comments/1pjp1rm/2025_day_11_solutions/nti5say
+  :body: |-
+    Part 1 - basic recursive dfs counting paths, nothing fancy at all.
+
+    Part 2 - DP on a DAG using memo and filters.
+
+    [GitHub for both part 1 and part 2](https://github.com/srugh/AdventOfCode/blob/main/2025/day-11.rb)
+  :replies: []
+- :author: notathrowaway0983
+  :url: https://www.reddit.com/r/adventofcode/comments/1pjp1rm/2025_day_11_solutions/ntgbu1d
+  :body: |-
+    Pretty happy with my 100ms, given I only know about graphs that they have nodes and you can kinda move from one to another. Here I assume no cycles, but `fft` and `dac` can be an any order. Also works good when there are more nodes to visit, found solutions (or lack of them, output contains separate counts for all possible paths) for 30 nodes in 12 seconds.
+
+    ```ruby
+    require "set"
+
+    $nodes = input.lines.to_h do |l|
+      from, *to = l.chomp.split(" ")
+      [from[0..-2], to]
+    end
+
+    $memory = Hash.new
+    $to_visit = ["fft", "dac"].to_set
+    $nothing = Set.new
+
+    def count_paths(node)
+      return { $nothing => 1 } if node == "out"
+      return $memory[node] if $memory[node]
+
+      child_counts = $nodes[node]
+        .map { |n| count_paths(n) }
+        .reduce do |s, e|
+          s.merge(e) { |_, a, b| a + b }
+        end
+
+      if $to_visit.include? node
+        child_counts = child_counts.to_h { |k,v| [k + [node], v]}
+      end
+
+      $memory[node] = child_counts
+    end
+
+    pp count_paths("you")
+    pp count_paths("svr")
+    ```
+  :replies: []

data/data/solutions/reddit/ruby/2025/12.yml

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

data/lib/arb/arb.rb

@@ -9,11 +9,6 @@ require "reverse_markdown"
 require "rspec/core"
 require "yaml"
 
-module Arb
-  InputError = Class.new(StandardError)
-  PASTEL = Pastel.new
-end
-
 Dir[File.join(__dir__, "**", "*.rb")].each do |file|
   require file
 end

data/lib/arb/cli/bootstrap.rb

@@ -5,7 +5,7 @@ module Arb
     def self.bootstrap(year: nil, day: nil)
       WorkingDirectory.prepare!
 
-      year, day = YearDayValidator.validate_year_and_day(year:, day:)
+      year, day = YearDayValidator.validate_and_fill_in_year_and_day(year:, day:)
 
       instructions_path = Files::Instructions.download(year:, day:)
       others_1_path, others_2_path = Files::OtherSolutions.download(year:, day:)

data/lib/arb/cli/commit.rb

@@ -26,7 +26,7 @@ module Arb
         Git.commit!(filenames:, message:)
 
         # TODO less naive check: ensure prev. days are finished too
-        if !files_modified && day == "25"
+        if !files_modified && day == Util.max_day(year:).to_s.rjust(2, "0")
           puts
           puts "🎉 You've finished #{year}!"
           puts

data/lib/arb/cli/progress.rb

@@ -7,6 +7,7 @@ module Arb
 
       total_count = committed.values.sum(&:count)
       my_counts_by_year = committed
+        .transform_keys(&:to_i)
         .transform_values { it.values.count(&:itself) }
         .reject { |k, v| v.zero? }
       my_total_count = my_counts_by_year.values.sum
@@ -20,16 +21,11 @@ module Arb
       puts
 
       my_counts_by_year.each do |year, my_count|
-        year_count =
-          if year.to_i == Date.today.year
-            this_year_count
-          else
-            25
-          end
+        max_day = Util.years_and_max_days[year]
 
-        year_percent = (my_count.to_f / year_count * 100).round
+        year_percent = (my_count.to_f / max_day * 100).round
 
-        puts "#{PASTEL.blue("#{year}:")}\t#{year_percent}%\t#{my_count}/#{year_count}"
+        puts "#{PASTEL.blue("#{year}:")}\t#{year_percent}%\t#{my_count}/#{max_day}"
       end
     end
   end

data/lib/arb/cli/run.rb

@@ -10,7 +10,7 @@ module Arb
         raise InputError, "Don't use --spec (-s) with --one (-o) or --two (-t)"
       end
 
-      year, day = YearDayValidator.validate_year_and_day(year:, day:, default_to_untracked_or_last_committed: true)
+      year, day = YearDayValidator.validate_and_fill_in_year_and_day(year:, day:, default_to_untracked_or_last_committed: true)
 
       if Git.uncommitted_puzzles.empty? && !Git.last_committed_puzzle(year:)
         bootstrap(year:, day:)

data/lib/arb/cli/shared/git.rb

@@ -52,10 +52,9 @@ module Arb
       def self.committed_by_year
         committed_solution_files = `git log --diff-filter=A --name-only --pretty=format: src`
 
-        previous_days = (2015..Date.today.year - 1).map { [it, (1..25).to_a] }.to_h
-        if Date.today.month == 12
-          previous_days[Date.today.year] = (1..Date.today.day)
-        end
+        previous_days = Util.years_and_max_days.transform_values { |max_day|
+          (1..max_day).to_a
+        }
 
         committed_days = committed_solution_files
           .split("\n")

data/lib/arb/cli/shared/year_day_validator.rb

@@ -1,7 +1,7 @@
 module Arb
   module Cli
     class YearDayValidator
-      def self.validate_year_and_day(year:, day:, default_to_untracked_or_last_committed: false)
+      def self.validate_and_fill_in_year_and_day(year:, day:, default_to_untracked_or_last_committed: false)
         year, day = year&.to_s, day&.to_s&.rjust(2, "0")
 
         # The first two digits of the year may be omitted.
@@ -22,7 +22,7 @@ module Arb
 
               if day && !default_to_untracked_or_last_committed
                 day =
-                  if day == "25"
+                  if day == Util.max_day(year:).to_s.rjust(2, "0")
                     :end
                   else
                     day.next
@@ -73,12 +73,7 @@ module Arb
         year = Integer(year, exception: false) || (raise InputError, "Year must be a number.")
         day = Integer(day.delete_prefix("0"), exception: false) || (raise InputError, "Day must be a number.")
 
-        unless year.between?(2015, Date.today.year)
-          raise InputError, "Year must be between 2015 and this year."
-        end
-        unless day.between?(1, 25) && Date.new(year, 12, day) <= Date.today
-          raise InputError, "Day must be between 1 and 25, and <= today."
-        end
+        Util.validate_year_and_day(year:, day:)
 
         [year.to_s, day.to_s.rjust(2, "0")]
       end

data/lib/arb/files/spec.rb

@@ -30,11 +30,11 @@ module Arb
             end
 
             it "solves Part One" do
-              expect(subject.part_1(input)).to eq(:todo)
+              expect(subject.part_1(input)).to eq :todo
             end
 
             xit "solves Part Two" do
-              expect(subject.part_2(input)).to eq(:todo)
+              expect(subject.part_2(input)).to eq :todo
             end
           end
         END_OUTER

data/lib/arb/formatters/rubocop.rb

@@ -1,24 +1,31 @@
 module Formatters
   module RuboCop
     # Formats newly created files using RuboCop if it is bundled at the top
-    # level, i.e. as `gem "rubocop"` in the Gemfile. Does nothing if RuboCop
-    # isn't bundled or is just a dependency, e.g. of Standard.
+    # level (i.e. as `gem "rubocop"` in the Gemfile) or if a RuboCop config file
+    # is present. Does nothing if RuboCop isn't bundled or is just a dependency
+    # (e.g. of Standard), and if there is no RuboCop config file.
     def self.format(file_path)
-      return unless rubocop_bundled_at_top_level?
+      require "bundler"
+      require "rubocop"
+      return unless rubocop_bundled_at_top_level? || rubocop_config_exists?
 
-      begin
-        require "rubocop"
-        RuboCop::CLI.new.run(["-A", file_path, "--out", File::NULL])
-      rescue LoadError
-        # Do nothing if RuboCop is bundled but not actually installed.
-      end
+      ::RuboCop::CLI.new.run(["-A", file_path, "--out", File::NULL])
+    rescue LoadError
+      # Do nothing if Bundler is not installed, or if RuboCop is bundled but not
+      # actually installed.
     end
 
     private_class_method def self.rubocop_bundled_at_top_level?
-      require "bundler"
       Bundler.definition.dependencies.any? { it.name == "rubocop" }
-    rescue LoadError, Bundler::GemfileNotFound
+    rescue Bundler::GemfileNotFound
       false
     end
+
+    # A shorter approach would be simply `File.exist?(".rubocop.yml")`, but
+    # the approach below avoids directly reading a file.
+    private_class_method def self.rubocop_config_exists?
+      config_path = ::RuboCop::ConfigFinder.find_config_path(Dir.pwd)
+      config_path && !config_path.end_with?("config/default.yml")
+    end
   end
 end