advent_of_ruby 0.3.4 → 0.4.0

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

@@ -0,0 +1,25 @@
+---
+- :name: day-01-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-01
+  :solution: |-
+    rotations = input.split("\n")
+
+    position = 50
+    count_zero = 0
+
+    rotations.each do |rotation|
+      direction, distance = rotation.scan(/[LR]+|\d+/)
+      distance = distance.to_i
+
+      case direction
+      when "L"
+        position -= distance
+      when "R"
+        position += distance
+      end
+
+      position %= 100
+      count_zero += 1 if position == 0
+    end
+
+    puts count_zero

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

@@ -0,0 +1,32 @@
+---
+- :name: day-01-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-01
+  :solution: |-
+    rotations = input.split("\n")
+
+    position = 50
+    count_zero = 0
+
+    rotations.each do |rotation|
+      direction, distance = rotation.scan(/[LR]+|\d+/)
+      distance = distance.to_i
+
+      case direction
+      when "L"
+        if position == 0
+          count_zero += (distance / 100)
+        elsif distance >= position
+          count_zero += 1 + (distance - position) / 100
+        end
+
+        position -= distance
+      when "R"
+        count_zero += (position + distance) / 100
+
+        position += distance
+      end
+
+      position %= 100
+    end
+
+    puts count_zero

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

@@ -0,0 +1,18 @@
+---
+- :name: day-02-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-02
+  :solution: |-
+    ranges = input.split(?,)
+
+    ranges.sum { |range|
+      min, max = range.split(?-).map(&:to_i)
+
+      (min..max)
+        .select { |n|
+          str = n.to_s
+          mid = str.length / 2
+
+          str.length.even? && str[0...mid] == str[mid..-1]
+        }
+        .sum
+    }.tap { puts _1}

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

@@ -0,0 +1,21 @@
+---
+- :name: day-02-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-02
+  :solution: |-
+    ranges.sum { |range|
+      min, max = range.split(?-).map(&:to_i)
+
+      (min..max)
+        .select { |n|
+          str = n.to_s
+
+          length = str.length
+
+          (1...length)
+            .select { length % _1 == 0 }
+            .any? { |i|
+              str.match?(/\A(#{str[0...i]})+\z/)
+            }
+        }
+        .sum
+    }.tap { puts _1}

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

@@ -0,0 +1,15 @@
+---
+- :name: day-03-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-03
+  :solution: |-
+    banks = input.split("\n").map(&:chars).map { _1.map(&:to_i) }
+
+    banks.sum { |bank|
+      tens, idx = bank[0...-1]
+        .each.with_index
+        .max_by { |value, _idx| value }
+
+      ones = bank[(idx + 1)..-1].max
+
+      tens * 10 + ones
+    }.tap { puts _1 }

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

@@ -0,0 +1,23 @@
+---
+- :name: day-03-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-03
+  :solution: |-
+    banks = input.split("\n").map(&:chars).map { _1.map(&:to_i) }
+
+    banks.sum { |bank|
+      digits = []
+      target_digits = 12
+      idx = 0
+
+      while digits.size < target_digits
+        digit, rel_idx = bank[idx..(-target_digits + digits.size)]
+          .each.with_index
+          .max_by { |value, _idx| value }
+
+        idx += rel_idx + 1
+
+        digits << digit
+      end
+
+      digits.join.to_i
+    }.tap { puts _1 }

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

@@ -0,0 +1,27 @@
+---
+- :name: day-04-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-04
+  :solution: |-
+    grid = input.split("\n").map.map(&:chars)
+
+    count = 0
+
+    grid.each_with_index do |row, x|
+      row.each_with_index do |char, y|
+        next if char == ?.
+
+        neighbours = 0
+        (x - 1..x+ 1).each do |r|
+          (y - 1..y+ 1).each do |c|
+            next if r == x && c == y
+            next if r < 0 || r >= grid.length
+            next if c < 0 || c >= grid[0].length
+            neighbours += 1 if grid[r][c] != ?.
+          end
+        end
+
+        count += 1 if neighbours < 4
+      end
+    end
+
+    puts count

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

@@ -0,0 +1,40 @@
+---
+- :name: day-04-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-04
+  :solution: |-
+    grid = input.split("\n").map.map(&:chars)
+
+    to_remove = []
+    removed_count = 0
+    stop = false
+
+    while !stop
+      grid.each_with_index do |row, x|
+        row.each_with_index do |char, y|
+          next if char == ?.
+
+          neighbours = 0
+          (x - 1..x + 1).each do |r|
+            (y - 1..y + 1).each do |c|
+              next if r == x && c == y
+              next if r < 0 || r >= grid.length
+              next if c < 0 || c >= grid[0].length
+
+              neighbours += 1 if grid[r][c] != ?.
+            end
+          end
+
+          to_remove << [x, y] if neighbours < 4
+        end
+      end
+
+      to_remove.each do |x, y|
+        grid[x][y] = ?.
+      end
+
+      removed_count += to_remove.length
+      stop = to_remove.empty?
+      to_remove = []
+    end
+
+    puts removed_count

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

@@ -0,0 +1,20 @@
+---
+- :name: day-05-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-05
+  :solution: |-
+    ranges, ids = input.split("\n\n")
+
+    fresh = ranges
+      .each_line
+      .map { |line|
+        line
+          .split("-")
+          .map(&:to_i)
+          .then { Range.new(_1, _2) }
+      }
+
+    ids
+      .each_line
+      .map(&:to_i)
+      .count { |id| fresh.any? { |range| range.include?(id) } }
+      .tap { |count| puts count }

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

@@ -0,0 +1,36 @@
+---
+- :name: day-05-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-05
+  :solution: |-
+    ranges, ids = input.split("\n\n")
+
+    fresh = ranges
+      .each_line
+      .map { |line|
+        line
+          .split("-")
+          .map(&:to_i)
+          .then { Range.new(_1, _2) }
+      }
+      .sort_by(&:begin)
+
+    reduced_fresh = []
+
+    current = fresh.shift
+
+    while current
+      next_range = fresh.first
+
+      if next_range && current.end >= next_range.begin
+        current = Range.new(current.begin, [current.end, next_range.end].max)
+        fresh.shift
+      else
+        reduced_fresh << current
+        current = fresh.shift
+      end
+    end
+
+    reduced_fresh
+      .map { _1.end - _1.begin + 1 }
+      .sum
+      .tap { puts _1}

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

@@ -0,0 +1,11 @@
+---
+- :name: day-06-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-06
+  :solution: |-
+    input
+      .each_line
+      .map(&:split)
+      .transpose
+      .map { _1[0...-1].map(&:to_i).inject(_1[-1]) }
+      .sum
+      .tap { puts _1 }

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

@@ -0,0 +1,28 @@
+---
+- :name: day-06-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-06
+  :solution: |-
+    lines = input.each_line.to_a
+
+    lines.last.strip
+      .chars
+      .each_with_index
+      .select { |char, _idx| char != " " }
+      .map { _2 } # get indices of operators
+      .<<(lines.map(&:length).max)
+      .each_cons(2)
+      # Build ranges from the start of the current range to end of the previous
+      # range minus one (to account for space)
+      .map { _1..(_2 - 2) }
+      .map { |range|
+        lines[0...-1]
+          .map { _1[range] }
+          .map { _1.ljust(range.size, " ") }
+          .map(&:chars)
+          .transpose
+          .map(&:join)
+          .map(&:to_i)
+          .inject(lines.last[range.begin])
+      }
+      .sum
+      .tap { puts _1 }

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

@@ -0,0 +1,33 @@
+---
+- :name: day-07-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-07
+  :solution: |-
+    lines = input
+      .each_line
+      .each_slice(2) # skip every second line
+      .map(&:first)
+
+    beams = [
+      lines.first.index("S")
+    ]
+
+    splits = 0
+
+    lines[1..-1].each do |line|
+      new_beams = []
+
+      beams.each do |beam|
+        if line[beam] == ?^
+          splits += 1
+
+          new_beams << beam - 1
+          new_beams << beam + 1
+        else
+          new_beams << beam
+        end
+      end
+
+      beams = new_beams.uniq
+    end
+
+    puts splits

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

@@ -0,0 +1,29 @@
+---
+- :name: day-07-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-07
+  :solution: |-
+    lines = input
+      .each_line
+      .each_slice(2) # skip every second line
+      .map(&:first)
+
+    beams = {
+      lines.first.index("S") => 1
+    }
+
+    lines[1..-1].each do |line|
+      new_beams = Hash.new(0)
+
+      beams.each do |beam, count|
+        if line[beam] == ?^
+          new_beams[beam - 1] += count
+          new_beams[beam + 1] += count
+        else
+          new_beams[beam] += count
+        end
+      end
+
+      beams = new_beams
+    end
+
+    puts beams.values.sum

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

@@ -0,0 +1,48 @@
+---
+- :name: day-08-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-08
+  :solution: |-
+    boxes = input.split("\n")
+      .map { |line| line.split(?,).map(&:to_i) }
+
+    sets = []
+    set_lookup = {}
+
+    closest_pairs = boxes
+      .combination(2)
+      .sort_by { |box1, box2|
+        box1.zip(box2)
+          .map { |a, b| a - b }
+          .map { _1 * _1}
+          .sum
+          .**(0.5)
+      }
+
+    1000.times do |i|
+      closest = closest_pairs.shift
+      box1, box2 = closest
+
+      if set_lookup[box1] && set_lookup[box2] && set_lookup[box1] == set_lookup[box2]
+        next
+      end
+
+      closest_sets = closest.map { |box| set_lookup[box] }.compact
+
+      if closest_sets.empty?
+        set = Set.new(closest)
+        sets << set
+        closest.each { set_lookup[_1] = set }
+      elsif closest_sets.size == 1
+        set = closest_sets.first
+        closest.each { |box| set.add(box); set_lookup[box] = set }
+      else # merge sets
+        set = Set.new
+        closest_sets.each { set.merge(_1) }
+        closest_sets.each { sets.delete(_1) }
+
+        set.each { |box| set_lookup[box] = set }
+        sets << set
+      end
+    end
+
+    puts sets.map(&:size).sort.last(3).reduce(:*)

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

@@ -0,0 +1,48 @@
+---
+- :name: day-08-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-08
+  :solution: |-
+    boxes = input.split("\n")
+      .map { |line| line.split(?,).map(&:to_i) }
+
+    sets = []
+    set_lookup = {}
+
+    closest_pairs = boxes
+      .combination(2)
+      .sort_by { |box1, box2|
+        box1.zip(box2)
+          .map { |a, b| a - b }
+          .map { _1 * _1}
+          .sum
+          .**(0.5)
+      }
+
+    while sets.map(&:size).sum < boxes.size
+      closest = closest_pairs.shift
+      box1, box2 = closest
+
+      if set_lookup[box1] && set_lookup[box2] && set_lookup[box1] == set_lookup[box2]
+        next
+      end
+
+      closest_sets = closest.map { |box| set_lookup[box] }.compact
+
+      if closest_sets.empty?
+        set = Set.new(closest)
+        sets << set
+        closest.each { set_lookup[_1] = set }
+      elsif closest_sets.size == 1
+        set = closest_sets.first
+        closest.each { |box| set.add(box); set_lookup[box] = set }
+      else # merge sets
+        set = Set.new
+        closest_sets.each { set.merge(_1) }
+        closest_sets.each { sets.delete(_1) }
+
+        set.each { |box| set_lookup[box] = set }
+        sets << set
+      end
+    end
+
+    puts box1[0] * box2[0]

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

@@ -0,0 +1,16 @@
+---
+- :name: day-09-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-09
+  :solution: |-
+    tiles = input
+      .split(/\n|,/)
+      .map(&:to_i)
+      .each_slice(2)
+      .to_a
+
+    tiles.combination(2).lazy
+      .map { |(x1, y1), (x2, y2)|
+        ((x1 - x2).abs + 1) * ((y1 - y2).abs + 1)
+      }
+      .max
+      .tap { puts _1 }

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

@@ -0,0 +1,60 @@
+---
+- :name: day-09-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2025/day-09
+  :solution: |-
+    tiles = input
+      .split(/\n|,/)
+      .map(&:to_i)
+      .each_slice(2)
+      .to_a
+
+    # Build compressed coordinate mapping
+    unique_xs = tiles.map(&:first).uniq.sort
+    unique_ys = tiles.map(&:last).uniq.sort
+
+    x_map = unique_xs.each_with_index.to_h
+    y_map = unique_ys.each_with_index.to_h
+
+    # Compressed tiles
+    compressed_tiles = tiles.map { |x, y| [x_map[x], y_map[y]] }
+
+    def build_edge_lookup(tiles, axis:)
+      other_axis = 1 - axis
+
+      tiles
+        .group_by { _1[axis] }
+        .values
+        .map(&:sort)
+        .flatten(1)
+        .each_slice(2)
+        .to_a
+        .group_by { _1.first[axis] }
+        .transform_values { _1.map { |pair| pair.map { |p| p[other_axis] } } }
+    end
+
+    vertical_edge_lookup   = build_edge_lookup(compressed_tiles, axis: 0)
+    horizontal_edge_lookup = build_edge_lookup(compressed_tiles, axis: 1)
+
+    # Find max area rectangle without edges inside
+    def edges_inside?(range, lookup, c1, c2)
+      range.any? do |i|
+        lookup[i]&.any? { |e1, e2| (c1 >= e1 && c1 < e2) || (c2 > e1 && c2 <= e2) }
+      end
+    end
+
+    tiles.combination(2).lazy
+      .map { |(x1, y1), (x2, y2)|
+        area = ((x1 - x2).abs + 1) * ((y1 - y2).abs + 1)
+
+        cx1, cx2 = [x_map[x1], x_map[x2]].sort
+        cy1, cy2 = [y_map[y1], y_map[y2]].sort
+
+        [area, [cx1, cy1], [cx2, cy2]]
+      }
+      .reject { |_area, (cx1, cy1), (cx2, cy2)|
+        edges_inside?((cx1 + 1)...cx2, vertical_edge_lookup, cy1, cy2) ||
+          edges_inside?((cy1 + 1)...cy2, horizontal_edge_lookup, cx1, cx2)
+      }
+      .map(&:first)
+      .max
+      .tap { puts _1 }

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

@@ -0,0 +1,49 @@
+---
+- :name: day-10-part-1.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|
+        lights = lights.chars[1...-1].map { _1 == "#" ? 1 : 0 }
+
+        buttons = buttons
+          .scan(/
+            \(          # Opening parenthesis
+            (\d[,\d+]*) # One or more digits separated by commas
+            \)          # Closing parenthesis
+            /x)
+          .flatten
+          .map { _1.split(",").map(&:to_i) }
+
+        [lights, buttons]
+      }
+
+    machines
+      .map { |lights, buttons|
+        # BFS
+        queue = [[Array.new(lights.size, 0), 0]]
+        visited = Set.new
+
+        until queue.empty?
+          state, presses = queue.shift
+
+          next if visited.include?(state)
+          visited.add(state)
+
+          if state == lights
+            count = presses
+            break
+          end
+
+          buttons.each do |button|
+            new_state = state.dup
+            button.each { |pos| new_state[pos] ^= 1 }
+
+            queue << [new_state, presses + 1]
+          end
+        end
+
+        count
+      }
+      .sum
+      .tap { puts _1 }