advent_of_ruby 0.3.5 → 0.3.6

data/data/solutions/github/gchan/2025/10_2.yml

@@ -0,0 +1,154 @@
+---
+- :name: day-10-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-10
+  :solution: |-
+    machines = input.split("\n").map { _1.split(/(?<=\]) | (?=\{)/) }
+      .map! { |_lights, buttons, joltage|
+        joltage = joltage[1...-1].split(",").map(&:to_i)
+
+        buttons = buttons
+          .scan(/
+            \(             # Opening parenthesis
+            (\d+(?:,\d+)*) # One or more digits separated by commas
+            \)             # Closing parenthesis
+            /x)
+          .flatten
+          .map { _1.split(",").map(&:to_i) }
+
+        [joltage, buttons]
+      }
+
+    @cache = {}
+    def generate_selections(n, k)
+      return @cache[[n, k]] if @cache.key?([n, k])
+      result = []
+
+      distribute = ->(i, remaining, counts) do
+        if i == n - 1
+          counts[i] = remaining
+          result << counts
+          return
+        end
+
+        (0..remaining).each do |count|
+          counts[i] = count
+          distribute.call(i + 1, remaining - count, counts.dup)
+        end
+      end
+
+      distribute.call(0, k, Array.new(n, 0))
+      result = result.sort!.reverse!
+      @cache[[n, k]] = result
+      result
+    end
+
+    machines
+      .map.with_index { |(joltage, buttons), line|
+        # # puts [joltage, buttons].inspect
+        puts line
+
+        # Create button mapping (which buttons affect which positions)
+        button_map = Array.new(joltage.size) { [] }
+        buttons.each_with_index do |button, idx|
+          button.each { |pos| button_map[pos] << idx }
+        end
+
+        # Sort by button size (largest first) for better pruning
+        button_map.map! { |idxs| idxs.sort_by { |i| -buttons[i].size } }
+
+
+        queue = [[joltage.clone, 0, Array.new(buttons.size, 0)]]
+        visited = Hash.new(Float::INFINITY)  # state -> min_presses to reach that state
+        count = nil
+        max_button_size = buttons.map(&:size).max
+
+        while queue.any?
+          state, presses, skip_buttons = queue.shift
+
+          # Skip if we've reached this state with fewer presses before
+          next if visited[state] <= presses
+          visited[state] = presses
+
+           puts "----------------------------------------"
+           puts "line #{line}:"
+           puts "Queue size: #{queue.size}"
+           puts "Current state: #{state.inspect}"
+           puts "Buttons: #{buttons.inspect}"
+           puts "skip_buttons: #{skip_buttons.inspect}"
+           puts "skip_buttons: #{skip_buttons.map.with_index { buttons[_2] if _1 == 1 }.compact.inspect}"
+
+          # puts button_map.inspect
+          button_to_press = button_map.each.with_index.min_by { |idxs, (btn)|
+            available_idxs = idxs.reject { |idx| skip_buttons[idx] == 1 }
+
+            size = available_idxs.size.zero? ? Float::INFINITY : available_idxs.size
+
+            #size
+            [size, -state[btn]]
+          }.last
+
+          # puts "Button to press: #{button_to_press}"
+          potential_buttons = button_map[button_to_press]
+            .reject { |idx| skip_buttons[idx] != 0 }
+            .sort_by { -buttons[_1].size }
+
+          next if potential_buttons.empty?
+
+          puts "Number of potential buttons: #{potential_buttons.size}"
+
+          puts "Presses so far: #{presses}"
+          required_presses = state[button_to_press]
+          puts "Required presses: #{required_presses}"
+
+          # Prune if this path would exceed current best solution
+          next if count && presses + required_presses >= count
+
+          selections = generate_selections(potential_buttons.size, required_presses)
+
+          selections.each do |selection|
+            # Early exit if we've found a solution that's as good as this path
+            break if count && presses + required_presses >= count
+
+            new_state = state.dup
+
+            selection.each_with_index do |press, idx|
+              buttons[potential_buttons[idx]].each { |pos| new_state[pos] -= press }
+            end
+
+            next if new_state.any? { _1 < 0 }
+
+            # Calculate lower bound: minimum presses needed to reach solution from new_state
+            remaining_sum = new_state.sum
+            lower_bound = (remaining_sum.to_f / max_button_size).ceil
+            next if count && presses + required_presses + lower_bound >= count
+
+            next if visited[new_state] <= presses + required_presses
+
+            if new_state.all? { _1 == 0 }
+              count = [count, presses + required_presses].compact.min
+              puts "Found solution with #{count} presses"
+              break
+            end
+
+            # puts new_state.inspect
+            new_skip_buttons = skip_buttons.dup
+
+            potential_buttons.each do |idx|
+              new_skip_buttons[idx] = 1
+            end
+
+            queue.unshift [new_state, presses + required_presses, new_skip_buttons]
+            #queue = [] if count
+          end
+
+          #puts state.inspect
+          #puts
+        end
+
+        # puts
+
+        raise if count.nil?
+        count
+      }
+      .sum
+      .tap { puts _1 }

data/data/solutions/github/gchan/2025/11_1.yml

@@ -0,0 +1,43 @@
+---
+- :name: day-11-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-11
+  :solution: |-
+    devices = input
+      .split("\n")
+      .map {
+        src, *dest = _1.split(/: | /)
+
+       [src, dest]
+      }
+      .to_h
+
+    count = 0
+    queue = [["you"]]
+
+    while queue.any?
+      path = queue.shift
+      current = path.last
+
+      devices[current].each do |neighbour|
+        new_path = path + [neighbour]
+
+        if neighbour == "out"
+          count += 1
+        else
+          queue << new_path
+        end
+      end
+    end
+
+    puts count
+
+    # Recursive DFS solution
+    def dfs(input, devices)
+      return 1 if input == "out"
+
+      devices[input].sum do |output|
+        dfs(output, devices)
+      end
+    end
+
+    puts dfs("you", devices)

data/data/solutions/github/gchan/2025/11_2.yml

@@ -0,0 +1,33 @@
+---
+- :name: day-11-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-11
+  :solution: |-
+    devices = input
+      .split("\n")
+      .map {
+        src, *dest = _1.split(/: | /)
+
+       [src, dest]
+      }
+      .to_h
+
+    def dfs(devices:, input:, memo: {}, dac: false, fft: false)
+      if input == "out"
+        return 1 if dac && fft
+        return 0
+      end
+
+      devices[input].sum do |output|
+        key = [output, dac, fft]
+
+        memo[key] ||= dfs(
+          devices:,
+          input: output,
+          memo:,
+          dac: dac || output == "dac",
+          fft: fft || output == "fft"
+        )
+      end
+    end
+
+    puts dfs(devices:, input: "svr")

data/data/solutions/github/gchan/2025/12_1.yml

@@ -0,0 +1,51 @@
+---
+- :name: day-12-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-12
+  :solution: |-
+    shapes = input.split("\n\n")
+
+    regions = shapes.pop.split("\n")
+      .map {
+        size, shape_qty = _1.split(?:)
+
+        [
+          size.split(?x).map(&:to_i),
+          shape_qty.split.map(&:to_i)
+        ]
+      }
+
+    shapes.map! {
+      _, *shape = _1.split(?\n)
+
+      shape.join
+    }
+
+    # Cheeky solution - just compare areas
+    # Only works with the input provided and not the sample input
+    shape_areas = shapes.map.with_index { |shape, idx|
+      shape.chars.count { _1 == ?# }
+    }
+
+    regions
+      .count { |(size_x, size_y), shape_qty|
+        total_area = size_x * size_y
+
+        shape_area = shape_qty.each_with_index.sum do |qty, idx|
+          shape_areas[idx] * shape_qty[idx]
+        end
+
+        shape_area <= total_area
+      }
+      .tap { puts _1 }
+
+    # Another cheeky solution - check if there is 9 spaces for each shape
+    regions
+      .count { |(size_x, size_y), shape_qty|
+        total_spaces = size_x * size_y / 9
+
+        shape_spaces = shape_qty.sum
+        shape_spaces <= total_spaces
+      }
+      .tap { puts _1 }
+
+    # TODO - Proper solution for the sample input

data/data/solutions/reddit/ruby/2017/06.yml

@@ -142,7 +142,6 @@
     **Ruby** simply using mem-string(join) instead of array of mem-arrays as comparison made it fast enough.
 
     ```ruby
-
         data = input.split("\t").strip.map(&:to_i)
         results = []
 
@@ -173,7 +172,6 @@
           cycles += 1
         end
         puts 'part2 -------', cycles, '----------'
-
     ```
   :replies:
   - :author: jschulenklopper

data/data/solutions/reddit/ruby/2020/02.yml

@@ -640,7 +640,6 @@
     Ruby
 
     ```ruby
-
     """
     password-philosophy.rb: from day_2.txt find out how many passwords are valid according to their policies; solve puzzle at https://adventofcode.com/2020/day/2
     2 December 2020

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

@@ -262,7 +262,6 @@
   :url: https://www.reddit.com/r/adventofcode/comments/1h4ncyr/2024_day_2_solutions/m02ns7r
   :body: |-
     ```ruby
-
     puts File.read('input.txt').split("\\n").map { |line| line.split.map(&:to\_i) }.then { |data| safe = ->(r) { (r.each\_cons(2).all? { |a, b| a < b } || r.each\_cons(2).all? { |a, b| a > b }) && r.each\_cons(2).all? { |a, b| (1..3).cover?((a - b).abs) } }; "#{data.count { |r| safe\[r\] }} #{data.count { |r| safe\[r\] || (0...r.length).any? { |i| safe\[r\[0...i\] + r\[(i+1)..-1\]\] } }}"}
     ```
   :replies: []

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

@@ -0,0 +1,187 @@
+---
+- :author: StillFast7545
+  :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/nsku8t6
+  :body: |-
+    Part 1: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_1/secret\_entrance\_part\_1.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_1/secret_entrance_part_1.rb)
+
+    Part 2: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_1/secret\_entrance\_part\_2.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_1/secret_entrance_part_2.rb)
+
+    Puzzle solved with a circular linked list.
+  :replies: []
+- :author: Few-Orchid-8393
+  :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/ns61umj
+  :body: |-
+    part two in 9 lines (at a comfy and traditional 80-char width):
+
+    ```ruby
+    position = 50
+    password = 0
+    ARGF.each_line do |instruction|
+      rotation = instruction.sub(/^L/, "-").sub(/^R/, "").to_i
+      direction = rotation <=> 0
+      password += ((direction * rotation) + ((direction * position) % 100)) / 100
+      position = (position + rotation) % 100
+    end
+    puts password
+    ```
+
+    I chose Ruby because it's an elegant language, and I've been doing a little scripting in it recently. It's not as popular as it deserves to be, imo.
+
+    Since I stripped the comments from this rendition, here's the whole idea: because integer division with negatives is a little weird, for password computation purposes I render "negative" (leftward) rotation as "positive) (rightward) rotation. To do that I want to flip the sign on the rotation if it's positive, and flip the sign on the position (before restoring it to Zmod100, no negatives allowed).
+
+    By computing the sign of the rotation, I get to do this without any `if` expressions, which is pretty cool. When the direction is rightward, all the extra computation in the `password +=` expression does nothing; it's the same as `(position + rotation) / 100`. But when the direction is leftward, that formula inverts both the original position and the rotation, treating it as rightward rotation from the equivalent complementary position on the dial.
+  :replies: []
+- :author: Nnnes
+  :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/nro9mh3
+  :body: |-
+    Not very many half-punchcard solutions yet (and an unfortunate number of oversized solutions in comments). Here's one for both parts including an attempt at descriptive comments:
+
+    ```ruby
+    puts STDIN.readlines.reduce([50, 0, 0]) { |a, x| # [Initial position, P1, P2]
+      n = a[0] + x.tr('LR', '-+').to_i # Current dial position (not mod 100 yet)
+      z = n % 100 == 0 ? 1 : 0 # Is it set to zero now?
+      [n % 100, a[1] + z, a[2] + n.abs / 100 + (a[0] > 0 && n <= 0 ? 1 : 0)]
+    }[1, 2] # ^P1 , ^P2: ^Count spins, ^Add 1 if it decreased to/past 0
+    ```
+
+    For parsing, `L`s and `R`s are simply turned into `-`s and `+`s before the string is parsed as an integer.
+
+    For Part 2's edge case handling, I initially used a multiply-by-zero trick `(a[0] * (n - 1) < 0 ? 1 : 0)`, but that's the same length as the much clearer version above.
+
+    Results are added up using a simple `.reduce()` accumulator (the `a`).
+  :replies:
+  - :author: riffraff
+    :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/nroeeh5
+    :body: the `tr`usage is very clever, love it!
+    :replies: []
+- :author: SleepingInsomniac
+  :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/nrqu8i5
+  :body: |-
+    ## Part 1
+
+    ```ruby
+    def solve(input)
+      pointer = 50
+      zeros = 0
+
+      until input.eof?
+        rotation = input.readline&.chomp
+        dist = rotation.gsub('L', '-').gsub('R', '').to_i
+        pointer = (pointer + dist) % 100
+        zeros += 1 if pointer == 0
+      end
+
+      zeros
+    end
+    ```
+
+    ## Part 2
+
+    ```ruby
+    def solve(input, size = 100)
+      pointer = 50
+      zeros = 0
+
+      while rotation = input.readline&.chomp
+        dist = rotation.gsub('L', '-').gsub('R', '').to_i
+        prev_pointer = pointer
+        pointer += dist
+        crossings, pointer = pointer.divmod(size)
+        crossings = crossings.abs
+
+        crossings -= 1 if pointer == 0 && dist.positive?
+        crossings -= 1 if prev_pointer == 0 && dist.negative?
+        crossings += 1 if pointer == 0
+
+        zeros += crossings
+
+        break if input.eof?
+      end
+
+      zeros
+    end
+    ```
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/nroeoal
+  :body: |-
+    straightforward but verbose, there are better solutions
+
+    ```ruby
+    def solve_easy(lines)
+      res = 0
+      pos = 50
+      lines.each do |line|
+        move = line[0] == 'L' ? -1 : 1
+        num = line[1..].to_i
+        pos = (pos + move * num) % 100
+        res += 1 if pos == 0
+      end
+      res
+    end
+
+    def solve_hard(lines)
+      res = 0
+      pos = 50
+      lines.each do |line|
+        move = line[0] == 'L' ? -1 : 1
+        num = line[1..].to_i
+        num.times do
+          pos = (pos + move) % 100
+          res += 1 if pos == 0
+        end
+      end
+      res
+    end
+    ```
+  :replies: []
+- :author: im_sofi
+  :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/nrow8a0
+  :body: |-
+    Couldn't wrap my head around Day 1 part 2 for the longest of times, but with some tests made it quite trivial to implement without using counting.
+
+    https://codeberg.org/soupglasses/advent-of-code/src/branch/main/2025/day\_01.rb
+  :replies: []
+- :author: onyx_and_iris
+  :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/nroyuzs
+  :body: "[https://git.onyxandiris.online/onyx\\_online/aoc2025/src/branch/main/day\\_01](https://git.onyxandiris.online/onyx_online/aoc2025/src/branch/main/day_01)"
+  :replies: []
+- :author: justjarvo
+  :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/nrq9co3
+  :body: |-
+    Initially did both parts with floor/modulo but kept getting off-by-one errors for part 2 so I just stepped through like a heathen
+
+    ```ruby
+    dial, p1, p2 = 50, 0, 0
+
+    input.each do |ins|
+      ins[1..].to_i.times do
+        dial += ins[0] == "R" ? 1 : -1
+        dial = 99 if dial == -1
+        dial = 0 if dial == 100
+        p2 += 1 if dial == 0
+      end
+      p1 += 1 if dial == 0
+    end
+
+    p [p1, p2]
+    ```
+  :replies:
+  - :author: kronn
+    :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/nrqr5md
+    :body: I was equally frustrated and came to the same low as you did.
+    :replies: []
+- :author: srugh
+  :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/nrs0rxs
+  :body: |-
+    Part 1 (solve\_part\_1) and Part 2 (solve\_part\_2) each individually solved in a single file with a shared parsing function (parse\_input):
+
+    [GitHub 2025/Day-01.rb](https://github.com/srugh/AdventOfCode/blob/main/2025/day-01.rb)
+  :replies: []
+- :author: Sharparam
+  :url: https://www.reddit.com/r/adventofcode/comments/1pb3y8p/2025_day_1_solutions/nro151z
+  :body: |-
+    [GitHub](https://github.com/Sharparam/advent-of-code/blob/main/src/y2025/d01/solve.rb)
+
+    In my sleep deprived state I can't come up with a cleaner version for now, maybe I'll come back later™ and make it nicer.
+  :replies: []

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

@@ -0,0 +1,185 @@
+---
+- :author: StillFast7545
+  :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nskv362
+  :body: |-
+    Part 1: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_2/gift\_shop\_part\_1.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_2/gift_shop_part_1.rb)
+
+    Part 2: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_2/gift\_shop\_part\_2.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_2/gift_shop_part_2.rb)
+  :replies: []
+- :author: justjarvo
+  :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nrupo4w
+  :body: ". I am not good at math, so string manipulation it is \U0001F605 I wouldn't mind being pointed to some material to help me figure out how to approach this without all the string work.\n\n```ruby\ndef p1_invalid?(str)\n  n = str.size\n  n.even? && str[0, n/2] == str[n/2, n/2]\nend\n\ndef p2_invalid?(str)\n  n = str.size\n\n  (1...n).each do |m|\n    next unless n % m == 0\n    return true if str == str[0, m] * (n / m)\n  end\n\n  false\nend\n\ninput = File.read(\"input/d02.txt\").split(\",\")\np1, p2 = 0, 0\ninput.each do |range|\n  Range.new(*range.split(\"-\").map(&:to_i)).each do |num|\n    p1 += num if p1_invalid?(num.to_s)\n    p2 += num if p2_invalid?(num.to_s)\n  end\nend\n\np [p1, p2]\n```"
+  :replies: []
+- :author: srugh
+  :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nrxw6zq
+  :body: |-
+    Shared parsing, other wise part 1 (compare halves of string) and part 2 (compare chunks to full string) both independently solved.
+
+    [GitHub: Day-02 parts 1 and 2](https://github.com/srugh/AdventOfCode/blob/main/2025/day-02.rb)
+  :replies: []
+- :author: pedantic_git
+  :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nruo72g
+  :body: |-
+    It's brute force, sure, but I'm really happy with how elegant my solution is, thanks to regexps. It could be terser still but I wanted it to still be readable!
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    acc1, acc2 = 0, 0
+
+    ARGF.read.scan(/(\d+)-(\d+)/) do |l,r|
+      (l.to_i).upto(r.to_i) do
+        acc1 += it if /\A(.+)\1\Z/ =~ it.to_s
+        acc2 += it if /\A(.+)\1+\Z/ =~ it.to_s
+      end
+    end
+
+    puts acc1, acc2
+    ```
+  :replies:
+  - :author: _tfa
+    :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nruokq9
+    :body: Nice. To make it even shorter you could use strings in the upto-loop and only call to\_i when adding "it" to the accumulators.
+    :replies:
+    - :author: pedantic_git
+      :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nrur3dt
+      :body: Ooh - it feels dirty using `upto` on a string, like it's going to sort them asciibetically or something, but it does seem to work!
+      :replies: []
+- :author: SleepingInsomniac
+  :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nrwuvy2
+  :body: |-
+    ## Part 1
+
+    ```ruby
+    class IDRange
+      def self.parse(file)
+        return nil if file.eof?
+        IDRange.new(*file.gets(',').gsub(/,$/, '').split('-'))
+      end
+
+      def initialize(start, stop)
+        @start, @stop = start.to_i, stop.to_i
+      end
+
+      def range = (@start..@stop)
+      def invalid_ids = range.select { |n| n.to_s =~ /^(\d+)\1$/ }
+    end
+
+    def solve(input)
+      total = 0
+      while range = IDRange.parse(input)
+        total += range.invalid_ids.sum
+      end
+      total
+    end
+    ```
+
+    ## Part 2
+
+    ```ruby
+    ...
+      def invalid_ids = range.select { |n| n.to_s =~ /^(\d+)\1+$/ }
+    ...
+    ```
+  :replies: []
+- :author: im_sofi
+  :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nrxps5w
+  :body: |-
+    Absolutely got stuck on an assumption that 1-9 was valid numbers for part 2.
+
+    Part 1 and 2 are done by enforcing each rule and picking the lowest next number. Regex is only used for parsing. :)
+
+    https://codeberg.org/soupglasses/advent-of-code/src/branch/main/2025/day\_02.rb
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nruhu7c
+  :body: |-
+    The simplest thing I could think of, tho it is quite slow since it creates a ton of garbage, but it works. Fun fact: `Integer#digits` gives the numbers ordered from the least significant to the most, but it seems to work anyway.
+
+    ```ruby
+    def parse(io)
+      io.read.scan(/(\d+)-(\d+)/).map { |a, b| (a.to_i)..(b.to_i) }.to_a
+    end
+
+    def same_subarray?(array, length)
+      parts = array.each_slice(length)
+      parts.uniq.length == 1
+    end
+
+    def invalid?(digits)
+      return false if digits.length.odd?
+      same_subarray?(digits, digits.length / 2)
+    end
+
+    def invalid_hard?(digits)
+      1.upto(digits.length / 2).any? { |len| same_subarray?(digits, len) }
+    end
+
+    def solve(ranges, &block)
+      ranges.sum do |r|
+        r.sum do |number|
+          block.call(number.digits) ? number : 0
+        end
+      end
+    end
+
+    def solve_easy(ranges)
+      solve(ranges) { |number| invalid?(number) }
+    end
+
+    def solve_hard(ranges)
+      solve(ranges) { |number| invalid_hard?(number) }
+    end
+    ```
+  :replies:
+  - :author: riffraff
+    :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nruiioj
+    :body: btw, this works with ranges of strings too, as you can do `'1'..'20'` and get `"1","2","3",..,"20"` but I never trust that :)
+    :replies: []
+- :author: systemnate
+  :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nrwmy2f
+  :body: |-
+    ```ruby
+    data = data.split(",")
+               .map { |range| range.split("-") }
+               .map { |first, last| (first.to_i..last.to_i) }
+
+    class Product
+      def self.invalid?(product_id)
+        product_id = product_id.to_s
+        middle_point = product_id.length / 2
+        product_id.chars[0...middle_point] == product_id.chars[middle_point..]
+      end
+
+      def self.really_invalid?(product_id)
+        product_id = product_id.to_s
+
+        (1..product_id.length / 2).each do |length|
+          pattern = product_id[0...length]
+
+          return true if pattern * (product_id.length / length) == product_id
+        end
+
+        false
+      end
+    end
+
+    # part 1
+    invalid_numbers = data.each_with_object([]) do |range, invalids|
+      invalids << range.select { |n| Product.invalid?(n) }
+    end.flatten.compact
+
+    puts invalid_numbers.sum
+
+    # part 2
+    invalid_numbers = data.each_with_object([]) do |range, invalids|
+      invalids << range.select { |n| Product.really_invalid?(n) }
+    end.flatten.compact
+
+    puts invalid_numbers.sum
+    ```
+  :replies: []
+- :author: onyx_and_iris
+  :url: https://www.reddit.com/r/adventofcode/comments/1pbzqcx/2025_day_2_solutions/nrukvww
+  :body: "[https://git.onyxandiris.online/onyx\\_online/aoc2025/src/branch/main/day\\_02](https://git.onyxandiris.online/onyx_online/aoc2025/src/branch/main/day_02)"
+  :replies: []