advent_of_ruby 0.3.4 → 0.4.0

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

@@ -0,0 +1,369 @@
+---
+- :author: StillFast7545
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/nskw3ne
+  :body: |-
+    Part 1: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_3/lobby\_part\_1.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_3/lobby_part_1.rb)
+
+    Part 2: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_3/lobby\_part\_2.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_3/lobby_part_2.rb)
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns7xmkh
+  :body: |-
+    ```ruby
+    input = File.readlines("input.txt", chomp: true)
+
+    def solve(source, digits, result="")
+      return result if result.length == digits
+
+      chunk = source[..result.length - digits]
+      i = chunk.index(chunk.chars.max)
+      solve(source[i+1..], digits, result+source[i])
+    end
+
+    puts input.sum{ solve(it, 2).to_i }
+    puts input.sum{ solve(it, 12).to_i }
+    ```
+  :replies: []
+- :author: SleepingInsomniac
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns6trgt
+  :body: |-
+    https://asciinema.org/a/vFZ0jkcQ4wAPhLVFvY3v391i9 https://github.com/SleepingInsomniac/adventofcode/blob/master/2025-12-03/
+
+    ```ruby
+    class Bank
+      def initialize(values, count)
+        @values = values.chars.map(&:to_i)
+        @pointers = ((@values.size - count)...@values.size).to_a
+      end
+
+      def count = @pointers.size
+      def pointer_value(i) = @values[@pointers[i]]
+      def bank_value(i) = @values[i]
+
+      def maximize
+        limit = 0
+        bi = @values.size - count - 1
+        pi = 0
+
+        until pi >= count
+          limit = (pi == 0 ? 0 : @pointers[pi - 1] + 1)
+
+          bi.downto(limit) do |i|
+            @pointers[pi] = i if bank_value(i) >= pointer_value(pi)
+          end
+
+          pi += 1
+          bi += 1
+        end
+
+        self
+      end
+
+      def joltage = @pointers.map.with_index { |p, i| @values[p] * (10 ** (count - i - 1)) }.sum
+    end
+
+    def solve(input, count)
+      total = 0
+      until input.eof?
+        total += Bank.new(input.gets.chomp, count).maximize.joltage
+      end
+      total
+    end
+
+    puts solve(input, 2)
+    puts solve(input, 12)
+    ```
+  :replies: []
+- :author: Early_Guarantee57
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns5ktdp
+  :body: |-
+    Day 3:
+
+    [Day 3](https://github.com/odrodriguezc/advent-of-code-2025/blob/main/lib/advent_of_code_2025/solvers/three.rb)
+  :replies: []
+- :author: srugh
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns4z90v
+  :body: |-
+    Shared parsing, otherwise part 1 (find largest value not at the end, then largest number from what remains) and part 2 (iterating through string with managing offsets)
+
+    [GitHub: Day-03 parts 1 and 2](https://github.com/srugh/AdventOfCode/blob/main/2025/day-03.rb)
+  :replies: []
+- :author: Nnnes
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns0zphu
+  :body: |-
+    This really seems like a day that'd be easy to fully fit into half a punchcard in plenty of different languages, but I don't see any here yet! (Honorable mention to the [x86\_64 asm solution](https://old.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns0ub0u/) that fits each part in half a punchcard.)
+
+    _edit: I think this can have a `[Red(dit) One]` label for being the first full half-punchcard solution_
+
+    ```ruby
+    lines = STDIN.read.split(?\n).map(&:chars)
+    puts [2, 12].map { |n| lines.sum { |b|
+      l, r = -1, -n
+      b.select { _1 == b[(l += 1)..r].max && r += 1 }.join.to_i
+    }}
+    ```
+
+    This uses the same simple greedy algorithm as many (most?) of the other solutions.
+
+    The right side bound is tracked by the negative index `r`. When we've `select`ed enough batteries, `r` is incremented to 0 and `b[(l += 1)..r]` always returns an empty array, effectively skipping the remainder of the elements (luckily, `[].max` is `nil` and not a bounds error).
+  :replies: []
+- :author: justjarvo
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns172l7
+  :body: |-
+    ```ruby
+    def joltage(bank, battery_size:)
+      size = bank.size - battery_size
+      battery = []
+
+      bank.each_char.lazy.map(&:to_i).each do |n|
+        battery.pop && size -= 1 while size > 0 && battery[-1] && battery[-1] < n
+        battery << n
+      end
+
+      battery[0...battery_size].join.to_i
+    end
+
+    input = File.readlines("input/d03.txt", chomp: true)
+    p1, p2 = 0, 0
+    input.each do |bank|
+      p1 += joltage(bank, battery_size: 2)
+      p2 += joltage(bank, battery_size: 12)
+    end
+
+    p [p1, p2]
+    ```
+  :replies: []
+- :author: xr51z
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns24lw2
+  :body: |-
+    ```ruby
+    def aoc2503(batteries)
+      input = File.readlines("03_input.txt", chomp: true)
+      result = 0
+      input.each do |x|
+        joltage = ""
+        s_end = batteries
+        s_start = 0
+        batteries.times do |i|
+          y = x[s_start..-s_end]
+          9.downto(0) do |j|
+            j = j.to_s
+            if y.index(j) != nil
+              joltage << j
+              s_start += y.index(j) + 1
+              s_end -= 1
+              break
+            end
+          end
+        end
+      result += joltage.to_i
+    end
+      return result
+    end
+
+    puts "Part 1: ", aoc2503(2)
+    puts "Part 2: ", aoc2503(12)
+    ```
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns1096p
+  :body: |-
+    I got a bit lost for some reason, but in the end the solution seems nice enough to me.
+
+    ```ruby
+    def max_bank(numbers, want:)
+      found = []
+      want.downto(1) do |need|
+        top, idx = max_bank_helper(numbers, need:)
+        found << top
+        numbers = numbers[(idx + 1)..]
+      end
+      found.reverse.map.with_index { |v, i| v * (10**i) }.sum
+    end
+
+    def max_bank_helper(numbers, need:)
+      numbers[..-need].each_with_index.max_by { |v, i| [v, -i] }
+    end
+
+    def solve_easy(lines)
+      lines.sum { |row| max_bank(row, want: 2) }
+    end
+
+    def solve_hard(lines)
+      lines.sum { |row| max_bank(row, want: 12) }
+    end
+    ```
+  :replies: []
+- :author: bulinutza
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns1n75z
+  :body: |-
+    I ended up with a function that works for both puzzle parts, taking the expected size as an argument.
+
+    ```ruby
+    def process_battery(battery_line, expected_size)
+        index = 0
+
+        expected_size.downto(1).collect do |size|
+            found_digit = 0
+
+            index.upto(battery_line.size - size).each do |i|
+                digit = battery_line[i].to_i
+
+                if digit > found_digit
+                    found_digit = digit
+                    index = i + 1
+                end
+            end
+
+            found_digit
+        end.join('')
+    end
+
+    input.split("\n").sum{ |battery_line| process_battery(battery_line, 12).to_i }
+    ```
+  :replies: []
+- :author: pedantic_git
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns1no9d
+  :body: |-
+    Thought I was being clever on part 1 by statically compiling all the possibilities as regexps (actually really fast!)
+
+    ```ruby
+    #!/usr/bin/env ruby
+
+    REGEXPS = 99.downto(11).to_h { [it.to_s.chars.then {Regexp.new("#{_1}.*#{_2}")}, it]}
+
+    def joltage(bank)
+      REGEXPS.find {|r,_| r.match?(bank)}.last
+    end
+
+    puts ARGF.inject(0) {|acc,bank| acc + joltage(bank)}
+    ```
+
+    Not so good for part 2, though! (I solved it the same way as many of you.)
+  :replies: []
+- :author: systemnate
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns2ofba
+  :body: |-
+    For part 1, I just used Array#combination, but this was too slow for N=12. For part 2, I used a [monotonic stack](https://www.geeksforgeeks.org/dsa/introduction-to-monotonic-stack-2/). Notice that the sample input is at the end of the file under "\_\_END\_\_" this is a not very well known Ruby trick where DATA will refer to the data underneath \_\_END\_\_ and treat it as a File. Pretty cool.
+
+    ```ruby
+    require_relative "../utils.rb"
+
+    # some custom logic I made to either read
+    # from the sample input or download the input
+    # from the website
+    raw = AOC::Input.resolve(ARGV, DATA)
+    data = AOC::Parser.line_numbers(raw)
+
+    class BatteryBank
+      attr_reader :banks
+
+      def initialize(banks)
+        @banks = banks
+      end
+
+      # first attempt, brute force
+      def joltage
+        banks.combination(2).max.map(&:to_s).join.to_i
+      end
+
+      # second attempt, monotonic stack
+      def joltage_fast(n = 12)
+        number_to_remove = banks.length - n
+
+        banks.each_with_object([]) do |digit, stack|
+          while number_to_remove > 0 && !stack.empty? && stack.last < digit
+            stack.pop
+
+            number_to_remove -= 1
+          end
+
+          stack << digit
+        end.first(n).map(&:to_s).join.to_i
+      end
+    end
+
+    # part 1
+    part_one = data.map { |banks| BatteryBank.new(banks).joltage }
+    puts part_one.sum
+
+    # part 2
+    part_two = data.map { |banks| BatteryBank.new(banks).joltage_fast }
+    puts part_two.sum
+
+    __END__
+    987654321111111
+    811111111111119
+    234234234234278
+    818181911112111
+    ```
+  :replies: []
+- :author: Mahedros
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns325ct
+  :body: |-
+    Decided to teach myself a new language starting today. Is this good Ruby? Probably not, but it's technically the best Ruby I've ever written
+
+    ```ruby
+    def part1
+      total = 0
+      File.foreach('input').each do |line|
+        line = line.strip()
+        first_digit = 0
+        second_digit = 0
+        for i in 0...line.length
+          digit = Integer(line[i])
+          if digit > first_digit && i != (line.length - 1)
+            first_digit = digit
+            second_digit = 0
+            next
+          end
+          if digit > second_digit
+            second_digit = digit
+          end
+        end
+        total += (first_digit * 10) + second_digit
+      end
+      puts total
+    end
+
+    def part2
+      total = 0
+      File.foreach('input').each do |line|
+        line = line.strip()
+        digits = [0] * 12
+        for i in 0...line.length
+          digit = Integer(line[i])
+          for j in 0...digits.length
+            digit_set = check_digit(line, digits, digit, i, j)
+            if digit_set
+              break
+            end
+          end
+        end
+        total += Integer(digits.join)
+      end
+      puts total
+    end
+
+    def check_digit(line, digits, digit, i, digit_pos)
+      if digit > digits[digit_pos] and i < (line.length - (digits.length - 1 - digit_pos))
+        digits[digit_pos] = digit
+        for j in (digit_pos + 1)...digits.length
+          digits[j] = 0
+        end
+        return true
+      end
+      return false
+    end
+
+    if __FILE__ == $PROGRAM_NAME
+      Dir.chdir(File.dirname( __FILE__ ))
+      part1
+      part2
+    end
+    ```
+  :replies: []
+- :author: onyx_and_iris
+  :url: https://www.reddit.com/r/adventofcode/comments/1pcvaj4/2025_day_3_solutions/ns39fbu
+  :body: "[https://git.onyxandiris.online/onyx\\_online/aoc2025/src/branch/main/day\\_03](https://git.onyxandiris.online/onyx_online/aoc2025/src/branch/main/day_03)"
+  :replies: []

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

@@ -0,0 +1,217 @@
+---
+- :author: StillFast7545
+  :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/nskwjkx
+  :body: |-
+    Part 1: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_4/part\_1.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_4/part_1.rb)
+
+    Part 2: [https://github.com/MarioPerac/AdventOfCode2025/blob/main/day\_4/part\_2.rb](https://github.com/MarioPerac/AdventOfCode2025/blob/main/day_4/part_2.rb)
+  :replies: []
+- :author: SleepingInsomniac
+  :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/nsbq4e6
+  :body: |-
+    https://asciinema.org/a/ZJUVtS4mkmD8bYUTUChU8xcGN
+
+    ## Both parts
+
+    ```ruby
+    class Grid
+      include Enumerable
+
+      def initialize(data, width, height)
+        @data, @width, @height = data, width, height
+      end
+
+      def neighbors(x, y)
+        [
+          [-1, -1], [0, -1], [1, -1],
+          [-1, 0], [1, 0],
+          [-1, 1], [0, 1], [1, 1],
+        ]
+          .map { |dx, dy| [x + dx, y + dy] }
+          .reject { |x, y| x < 0 || y < 0 || x >= @width || y >= @height }
+      end
+
+      def roll?(x, y) = self[x, y] != '.'
+      def count_neighbors(x, y) = neighbors(x, y).count { |x, y| roll?(x, y) }
+      def [](x, y) = @data[y * @width + x]
+
+      def []=(x, y, value)
+        @data[y * @width + x] = value
+      end
+
+      def accessible?(x, y) = count_neighbors(x, y) < 4
+      def each = 0.upto(@height - 1) { |y| 0.upto(@width - 1) { |x| yield x, y } }
+      def count_accessible = count { |x, y| roll?(x, y) && accessible?(x, y) }
+      def accessible_rolls = select { |x, y| roll?(x, y) && accessible?(x, y) }
+      def remove(rolls) = rolls.each { |x, y| self[x, y] = "." }
+    end
+
+    lines = input.readlines(chomp: true)
+    width, height = lines.first.size, lines.size
+    grid = Grid.new(lines.join.chars, width, height)
+
+    part_1 = grid.accessible_rolls.count
+    total = 0
+
+    loop do
+      removable = grid.accessible_rolls
+      break if removable.empty?
+      removable.each { |x, y| grid[x, y] = grid[x, y].colorize(:red) }
+      total += removable.count
+      grid.remove(removable)
+    end
+
+    part_2 = total
+    ```
+  :replies: []
+- :author: srugh
+  :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/nsazos6
+  :body: |-
+    Each part shares parsing, otherwise each solved independently. Part 1 simple traverse the grid, Part 2 continue transversing the grid until 0 can be removed, updating/mutating the grid while scanning (since the final result is all that matters and not the count per iteration which may reduce total grid traversals needed).
+
+    [2025 Day-04 ruby solution for Part 1 and Part 2](https://github.com/srugh/AdventOfCode/blob/main/2025/day-04.rb)
+  :replies: []
+- :author: Mahedros
+  :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/ns7aezz
+  :body: "[Link to Code](https://topaz.github.io/paste/#XQAAAQCtCAAAAAAAAAARiEJHiiMzw3cPM/1Vl+2nyBa63n8Kw6AjPxpQKi2L5b7FYOvRiQfnq6pZ3l8BSNmGYKISOzndSPcw7D2gplGGLncIWHEOAn7SbfQYcXKwBQIfezoST/lGr7XVS7qy18NnC/9ELffeJkT8m+KerUvQfHh8jY6mx3NjCloW+B5ywHAIbgocLq/m01dacocMWl9Mil55F8dV7gyRkGUk1GvigihDKrvFuMVS4MOUHF9yoouRBNLuS5ht3AJUkQbNn1GFXkUl3XVXJm106Z2WCqxngZjTo9mkVYQ1Bl/LvTgXaAPsOThyf3gzigQZGeK7hOYQ/z3OK56Es5IEpSYQQRUsayyNXuh/a7Q3dEdJeNEtIFMLyyBbWr6ePJ18SrWT51lzRj1PJSc0zTEFJHPCOMGz6t7dB8qZ2ACBu91G3gdqYxgdoiWccLar2qbA2GOlZsxap09U+vuK4DNRcZFpovEbzlREvRYunnP/Or2TjjH9WiqiOX2giLX91aYUW1jycEOpyOXVaSGmyx6AYOazMtjcdgZUFGUyfIWkc1k03xFxc/BW7uxAmx9ZqWD67Z2b8Zv9ClmpxpE9WXdBlTg6yEtvzjTuJ94u0XtOwxfnItHRgcrzeTduOhcdGnNVuVJ3MJ8BU0LLg/mpH05x0sgwSCU9/EnA9pjhJXYKLPD7OFH7fe8qmYGYK2YujZBtR7astJ9rA2fObPDJjpH8rJPE)"
+  :replies:
+  - :author: munchler
+    :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/ns7cap6
+    :body: 'Ruby: The OG vibe-coding language.'
+    :replies: []
+- :author: pedantic_git
+  :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/ns7l9y7
+  :body: |-
+    Love it when I can solve a puzzle this far in within 45 minutes of my alarm going off in the morning. Thanks to my trusty `grid.rb` that has been growing over the years of solving AoC!
+
+    [https://github.com/pedantic-git/aoc2025/blob/main/04/04.rb](https://github.com/pedantic-git/aoc2025/blob/main/04/04.rb)
+
+    [https://github.com/pedantic-git/aoc2025/blob/main/utils/grid.rb](https://github.com/pedantic-git/aoc2025/blob/main/utils/grid.rb)
+  :replies: []
+- :author: riffraff
+  :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/ns7ezro
+  :body: |-
+    look, I have a helper class, but it's trivial. horrible solutin but I can't believe I got it right, I always screw up these.
+
+    ```ruby
+    def solve_easy(grid)
+      count = 0
+      grid.each_with_position do |tile, i, j|
+        if tile.value == '@'
+          close_rolls = grid.neighbors8(tile).select { |t| t.value == '@' }
+          if close_rolls.size < 4
+            count += 1
+          end
+        end
+      end
+      count
+    end
+
+    def solve_hard(grid)
+      queue = grid.tiles_with_value('@')
+      removed = 0
+      loop do
+        break if queue.empty?
+        current = queue.shift
+        next if grid[current.i, current.j].value == '.'
+        close_rolls = grid.neighbors8(current).select { |t| t.value == '@' }
+        if close_rolls.size < 4
+          grid[current.i, current.j] = '.'
+          removed += 1
+          queue.concat(close_rolls)
+        end
+      end
+      removed
+    end
+    ```
+  :replies: []
+- :author: _tfa
+  :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/ns81d1z
+  :body: |-
+    ```ruby
+    input = File.readlines("input.txt")
+
+    GRID = Set.new
+    input.each_with_index do |l, y|
+      l.chars.each_with_index do |c, x|
+        GRID << Complex(x,y) if c == ?@
+      end
+    end
+
+    ADJ = [-1-1i, -1+0i, -1+1i, 0-1i, 0+1i, +1-1i, +1+0i, +1+1i]
+
+    def accessible(grid) = grid.reject{ |i| ADJ.map{it+i}.count{ grid.include?(it)} >=4 }
+
+    acc = accessible(GRID)
+    puts acc.count
+
+    g = GRID.dup
+    until acc.empty?
+      g -= acc
+      acc = accessible(g)
+    end
+    puts GRID.count - g.count
+    ```
+  :replies: []
+- :author: Nnnes
+  :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/ns7jzl2
+  :body: |-
+    The half punchcard is more cramped for today's problem, but still very achievable.
+
+    ```ruby
+    g = STDIN.read; g += ?\n * (w = g.index(?\n)) * 2
+    loop { g.tr! ?#, ?-; (h = g.chars).each_with_index { |c, i| next if c != ?@
+      g[i] = ?# if [*(-w-2..-w), -1, 1, *(w..w+2)].count{ h[i + _1] == ?@ } < 4 }
+      p g.count ?# if !g[?-]; break if !g[?#] }
+    p g.count ?-
+    ```
+
+    Despite calling my input `g` for "grid", it remains a one-dimensional string. Newline characters form "walls" so I don't run into trouble with wrapping across lines. I suspect there's some better way to enumerate adjacent indices but I can't think of one at the moment.
+
+    The removed rolls are marked with a `#`; then, at the beginning of each pass, all `#`s are replaced with `-`s. After a pass, if there are no `-`s then part 1 is done and if there are no `#`s then part 2 is done.
+
+    _Edit: the newline walls weren't big enough for all inputs (top left corner could "see" the bottom right corner). Added `* 2` to line 1 to fix._
+  :replies:
+  - :author: Nnnes
+    :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/ns7rcqt
+    :body: |-
+      > better way to enumerate adjacent indices
+
+      ```ruby
+      g = STDIN.read; g = ?. * (w = g.index(?\n)) + g + ?. * w
+      loop { g.tr! ?#, ?-; (h = g.chars).each_with_index { |c, i| next if c != ?@
+        g[i] = ?# if [-w - 2, -1, w].sum([]) { h[i + _1, 3] }.count(?@) <= 4 }
+        puts g.count ?# if !g[?-]; break if !g[?#] }
+      p g.count ?-
+      ```
+
+      Better? Not sure, but at least it's noticeably faster.
+    :replies: []
+- :author: justjarvo
+  :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/ns7vvo3
+  :body: |-
+    ```ruby
+    require_relative "grid"
+
+    def remove_rolls(grid)
+      grid.each_cell
+        .filter_map { |x, y, c| [x, y] if c == "@" && grid.adjacent_values(x, y).count { _1 == "@" } < 4 }
+        .each { |x, y| grid[x, y] = "R" }
+    end
+
+    grid = Grid.parse(File.read("input/d04.txt"))
+    removed = remove_rolls(grid)
+    p1 = p2 = removed.size
+    p2 += removed.size while (removed = remove_rolls(grid)).any?
+
+    p [p1, p2]
+    ```
+
+    Grid code: [https://github.com/leejarvis/adventofcode/blob/master/2025/grid.rb](https://github.com/leejarvis/adventofcode/blob/master/2025/grid.rb)
+
+    Vacation for the next few days so no AoC for me, excited to get stuck into some challenges when I return.
+  :replies: []
+- :author: onyx_and_iris
+  :url: https://www.reddit.com/r/adventofcode/comments/1pdr8x6/2025_day_4_solutions/ns7zt95
+  :body: "[https://git.onyxandiris.online/onyx\\_online/aoc2025/src/branch/main/day\\_04](https://git.onyxandiris.online/onyx_online/aoc2025/src/branch/main/day_04)"
+  :replies: []