advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,25 @@
+---
+- :name: day-07-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-07
+  :solution: |-
+    input.split(?\n)
+      .map(&:split)
+      .map { _1.map(&:to_i) }
+      .select { |target, *nums|
+        operators = nums.size - 1
+
+        (0..(2**operators - 1)).find {
+          ops = _1.to_s(2).rjust(operators, ?0).tr("01", "*+").chars
+
+          total = nums.first
+
+          nums[1..].each.with_index { |num, idx|
+            total = total.send(ops[idx], num)
+          }
+
+          total == target
+        }
+      }
+      .map { _1.first }
+      .sum
+      .tap { puts _1 }

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

@@ -0,0 +1,32 @@
+---
+- :name: day-07-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-07
+  :solution: |-
+    input.split(?\n)
+      .map(&:split)
+      .map { _1.map(&:to_i) }
+      .select { |target, *nums|
+        operators = nums.size - 1
+
+        (0..(3**operators - 1)).find {
+          ops = _1.to_s(3).rjust(operators, ?0).tr("012", "*+|").chars
+
+          total = nums.first
+
+          nums[1..].each.with_index { |num, idx|
+            case ops[idx]
+            when ?*
+              total *= num
+            when ?+
+              total += num
+            when ?|
+              total = (total.to_s + num.to_s).to_i
+            end
+          }
+
+          total == target
+        }
+      }
+      .map { _1.first }
+      .sum
+      .tap { puts _1 }

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

@@ -0,0 +1,34 @@
+---
+- :name: day-08-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-08
+  :solution: |-
+    input     = File.read(file_path)
+
+    grid = input.split.join.chars
+
+    height = input.split.size
+    width =  input.split.first.size
+
+    antennas = Hash.new { |h, k| h[k] = Set.new }
+
+    grid.each.with_index
+      .reject { _1[0] == ?. }
+      .each { antennas[_1].add([_2 % width, _2 / width]) }
+
+    antinodes = Set.new
+
+    antennas.each do |_type, locations|
+      locations.to_a.combination(2).each do |loc1, loc2|
+        vector = loc1.zip(loc2).map { _1.inject(&:-) }
+
+        loc1.zip(vector).map { _1.inject(&:+) }
+          .tap { antinodes.add(_1) }
+
+        loc2.zip(vector).map { _1.inject(&:-) }
+          .tap { antinodes.add(_1) }
+      end
+    end
+
+    puts antinodes
+      .reject { |x, y| x < 0 || y < 0 || x >= width || y >= height }
+      .count

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

@@ -0,0 +1,41 @@
+---
+- :name: day-08-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-08
+  :solution: |-
+    input     = File.read(file_path)
+
+    grid = input.split.join.chars
+
+    height = input.split.size
+    width =  input.split.first.size
+
+    antennas = Hash.new { |h, k| h[k] = Set.new }
+
+    grid.each.with_index
+      .reject { _1[0] == ?. }
+      .each { antennas[_1].add([_2 % width, _2 / width]) }
+
+    antinodes = Set.new
+
+    def add(antinodes, location, vector, width, height)
+      while true
+        location = location.zip(vector).map { _1.inject(&:-) }
+
+        x, y = location
+
+        return if x < 0 || y < 0 || x >= width || y >= height
+
+        antinodes.add(location)
+      end
+    end
+
+    antennas.each do |_type, locations|
+      locations.to_a.combination(2).each do |loc1, loc2|
+        vector = loc1.zip(loc2).map { _1.inject(&:-) }
+
+        add(antinodes, loc1, vector, width, height)
+        add(antinodes, loc2, vector.map { _1 * -1 }, width, height)
+      end
+    end
+
+    puts antinodes.count

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

@@ -0,0 +1,59 @@
+---
+- :name: day-09-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-09
+  :solution: |-
+    disk = Hash.new { |h, k| h[k] = [] }
+    ids = []
+
+    pos = 0
+    capacity = 0
+
+    input.chars.map(&:to_i).each.with_index { |count, idx|
+      range = [pos, pos + count - 1]
+
+      if idx % 2 == 0
+        disk[idx / 2] << range
+        capacity += count
+        ids << idx / 2
+      else
+        disk[nil] << range
+      end
+
+      pos += count
+    }
+
+    # keep going until disk is compacted
+    while disk[nil][0][0] <= capacity
+      from, to = disk[nil].shift
+      gap = to - from + 1
+
+      id = ids.pop
+
+      range = disk[id].last
+      size = range.last - range.first + 1
+
+      if gap == size # simple move
+        disk[id].unshift([from, to])
+        disk[id].pop
+      elsif gap < size # slice the file
+        disk[id].unshift([from, to])
+        disk[id][-1] = [range.first, range.last - gap]
+        ids << id
+      else # gap > size; there is still a gap
+        disk[id].unshift([from, from + size - 1])
+        disk[id].pop
+        disk[nil].unshift([from + size, to])
+      end
+    end
+
+    sum = 0
+
+    disk.delete(nil)
+
+    disk.each do |id, locations|
+      locations.each do |from, to|
+        (from..to).each { sum += id * _1 }
+      end
+    end
+
+    puts sum

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

@@ -0,0 +1,73 @@
+---
+- :name: day-09-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-09
+  :solution: |-
+    disk = Hash.new { |h, k| h[k] = [] }
+    ids = []
+
+    pos = 0
+
+    input.chars.map(&:to_i).each.with_index { |count, idx|
+      range = [pos, pos + count - 1]
+
+      if idx % 2 == 0
+        disk[idx / 2] << range
+        ids << idx / 2
+      else
+        disk[nil] << range
+      end
+
+      pos += count
+    }
+
+    while ids.any?
+      id = ids.pop
+
+      range = disk[id].first
+      size = range.last - range.first + 1
+
+      # Find the leftmost empty space which can hold the file
+      from, to = disk[nil].find { |from, to| to - from + 1 >= size }
+
+      # Skip if no space is found or the space is not left of the file
+      next if from.nil? || from > range.first
+
+      gap = to - from + 1
+
+      disk[id].pop
+
+      if gap == size
+        disk[id].unshift([from, to])
+        disk[nil].delete([from, to])
+      elsif gap > size
+        disk[id].unshift([from, from + size - 1])
+
+        i = disk[nil].index([from, to])
+        disk[nil][i]= [from + size, to]
+      end
+
+      disk[nil] << range
+
+      ## Debugging
+      # str = Array.new(pos, nil)
+
+      # disk.each do |n, locations|
+      #   locations.each do |(a, b)|
+      #     (a..b).each { str[_1] = n ? n : ?. }
+      #   end
+      # end
+
+      # puts str.join
+    end
+
+    sum = 0
+
+    disk.each do |id, locations|
+      next unless id
+
+      locations.each do |from, to|
+        (from..to).each { sum += id * _1 }
+      end
+    end
+
+    puts sum

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

@@ -0,0 +1,38 @@
+---
+- :name: day-10-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-10
+  :solution: |-
+    grid = input.split.map(&:chars).map { _1.map(&:to_i) }
+
+    width = grid[0].size
+    height = grid.size
+
+    start = input.split.flat_map { _1.chars }.each
+      .map.with_index { _2 if _1 == ?0 }
+      .compact
+      .map { [_1 % width,  _1 / width] }
+
+    start.sum { |x, y|
+      visited = Set.new
+      score = 0
+      queue = [[x, y, 0]]
+
+      while queue.any?
+        x, y, lvl = queue.pop
+
+        [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]
+          .reject { _1 < 0 || _2 < 0 || _1 >= width || _2 >= height }
+          .select { grid[_2][_1] == lvl + 1 }
+          .reject { visited.include?([_1, _2]) }
+          .each {
+            visited.add([_1, _2])
+            if lvl + 1 == 9
+              score += 1
+            else
+              queue << [_1, _2, lvl + 1]
+            end
+          }
+      end
+
+      score
+    }.tap { puts _1 }

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

@@ -0,0 +1,35 @@
+---
+- :name: day-10-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-10
+  :solution: |-
+    grid = input.split.map(&:chars).map { _1.map(&:to_i) }
+
+    width = grid[0].size
+    height = grid.size
+
+    start = input.split.flat_map { _1.chars }.each
+      .map.with_index { _2 if _1 == ?0 }
+      .compact
+      .map { [_1 % width,  _1 / width] }
+
+    start.sum { |x, y|
+      score = 0
+      queue = [[x, y, 0]]
+
+      while queue.any?
+        x, y, lvl = queue.pop
+
+        [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]
+          .reject { _1 < 0 || _2 < 0 || _1 >= width || _2 >= height }
+          .select { grid[_2][_1] == lvl + 1 }
+          .each {
+            if lvl + 1 == 9
+              score += 1
+            else
+              queue << [_1, _2, lvl + 1]
+            end
+          }
+      end
+
+      score
+    }.tap { puts _1 }

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

@@ -0,0 +1,26 @@
+---
+- :name: day-11-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-11
+  :solution: |-
+    stones = input.split.map(&:to_i)
+
+    blinks = 25
+
+    blinks.times {
+      stones = stones.flat_map {
+        if _1 == 0
+          1
+        elsif _1.to_s.chars.count.even?
+          digits = _1.to_s.chars
+          length = digits.size
+          [
+            digits[0..length/2 - 1].join.to_i,
+            digits[(length/2)..-1].join.to_i
+          ]
+        else
+          _1 * 2024
+        end
+      }
+    }
+
+    puts stones.count

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

@@ -0,0 +1,33 @@
+---
+- :name: day-11-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-11
+  :solution: |-
+    blinks = 75
+
+    stones = {}
+    input.split.map(&:to_i).each { stones[_1] = 1 }
+
+    blinks.times {
+      new_stones = Hash.new { |h, k| h[k] = 0 }
+
+      stones.each { |stone, count|
+        if stone == 0
+          new_stones[1] += count
+        elsif stone.to_s.chars.count.even?
+          digits = stone.to_s.chars
+          length = digits.size
+
+          left = digits[0..length/2 - 1].join.to_i
+          right = digits[(length/2)..-1].join.to_i
+
+          new_stones[left] += count
+          new_stones[right] += count
+        else
+          new_stones[stone * 2024] += count
+        end
+      }
+
+      stones = new_stones
+    }
+
+    puts stones.values.sum

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

@@ -0,0 +1,63 @@
+---
+- :name: day-12-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-12
+  :solution: |-
+    grid = input.split.map(&:chars)
+
+    height = grid.length
+    width = grid[0].length
+
+    visited = Set.new
+
+    groups = Hash.new { |h, k| h[k] = [] }
+
+    while visited.size < width * height
+      i = (width * height).times.find { |i|
+        x = i % width
+        y = i / width
+
+        !visited.include?([x, y])
+      }
+
+      x = i % width
+      y = i / width
+
+      visited.add([x, y])
+
+      plant = grid[y][x]
+      groups[plant] << Set.new([[x, y]])
+
+      queue = []
+      queue << [x, y]
+
+      while queue.any?
+        x, y = queue.shift
+
+        plant = grid[y][x]
+
+        [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]
+          .reject { _1 < 0 || _2 < 0 || _1 >= width || _2 >= height }
+          .select { plant == grid[_2][_1] }
+          .each {
+            next if visited.include?([_1, _2])
+
+            queue << [_1, _2]
+            visited.add([_1, _2])
+            groups[plant][-1].add([_1, _2])
+          }
+      end
+    end
+
+    groups.values.flatten
+      .map { |group|
+        fence = group
+          .map { |x, y|
+            [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]
+              .reject { group.include?(_1) }
+              .count
+          }
+          .sum
+
+        fence * group.count
+      }
+      .tap { puts _1.sum }

data/data/solutions/github/gchan/2024/12_2.yml

@@ -0,0 +1,84 @@
+---
+- :name: day-12-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-12
+  :solution: |-
+    grid = input.split.map(&:chars)
+
+    height = grid.length
+    width = grid[0].length
+
+    visited = Set.new
+
+    groups = Hash.new { |h, k| h[k] = [] }
+
+    while visited.size < width * height
+      i = (width * height).times.find { |i|
+        x = i % width
+        y = i / width
+
+        !visited.include?([x, y])
+      }
+
+      x = i % width
+      y = i / width
+
+      visited.add([x, y])
+
+      plant = grid[y][x]
+      groups[plant] << Set.new([[x, y]])
+
+      queue = []
+      queue << [x, y]
+
+      while queue.any?
+        x, y = queue.shift
+
+        plant = grid[y][x]
+
+        [[x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]]
+          .reject { _1 < 0 || _2 < 0 || _1 >= width || _2 >= height }
+          .select { plant == grid[_2][_1] }
+          .each {
+            next if visited.include?([_1, _2])
+
+            queue << [_1, _2]
+            visited.add([_1, _2])
+            groups[plant][-1].add([_1, _2])
+          }
+      end
+    end
+
+    groups.values.flatten
+      .map { |group|
+        fences = group
+          .flat_map { |x, y|
+            [[x + 1, y, :e], [x - 1, y, :w], [x, y + 1, :n], [x, y - 1, :s]]
+              .reject { |x1, y1, dir| group.include?([x1, y1]) }
+          }
+
+        # grouping edges by columns and rows
+        edges_by_dir = fences.group_by { |x, y, dir|
+          [
+            dir,
+            (dir == :e || dir == :w) ? x : y
+          ]
+        }.values
+
+        # count sides by counting discontinious sequences
+        sides = edges_by_dir.sum { |edges|
+          edges
+            .sort_by { |x, y, d| (d == :e || d == :w) ? y : x }
+            .each_cons(2)
+            .select { |(x, y, d), (x1, y1)|
+              if d == :e || d == :w
+                y + 1 != y1
+              else
+                x + 1 != x1
+              end
+            }
+            .count + 1
+        }
+
+        sides * group.count
+      }
+      .tap { puts _1.sum }

data/data/solutions/github/gchan/2024/13_1.yml

@@ -0,0 +1,38 @@
+---
+- :name: day-13-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-13
+  :solution: |-
+    machines = input.split("\n\n")
+
+    machines
+      .map { |machine|
+        ax, ay, bx, by, px, py = machine.scan(/\d+/).map(&:to_i)
+
+        sa = 0
+        sb = 0
+
+        max_b = [
+          px / bx,
+          py / by,
+          100
+        ].min
+
+        (0..max_b).reverse_each { |b|
+          ry = (py - b * by)
+          next if ry % ay != 0
+
+          a = ry / ay
+          next if a > 100
+
+          rx = (px - b * bx)
+          next unless rx == 0 || (rx / a.to_f == ax)
+
+          sa = a
+          sb = b
+          break
+        }
+
+        sa * 3 + sb
+      }
+      .sum
+      .tap { puts _1 }

data/data/solutions/github/gchan/2024/13_2.yml

@@ -0,0 +1,44 @@
+---
+- :name: day-13-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-13
+  :solution: |-
+    machines = input.split("\n\n")
+
+    machines
+      .map { |machine|
+        ax, ay, bx, by, px, py = machine.scan(/\d+/).map(&:to_i)
+
+        px += 10000000000000
+        py += 10000000000000
+
+        sa = 0
+        sb = 0
+
+        # ax * sa + bx * sb = px
+        # ay * sa + by * sb = py
+        #
+        # sb = ( px - ax * sa ) / bx
+        #
+        # ay * sa = py - by * sb
+        #         = py - by * (( px - ax * sa ) / bx)
+        #         = py - ( by * px - by * ax * sa ) / bx
+        #
+        # ay * sa * bx = py * bx - ( by * px - by * ax * sa )
+        #              = py * bx - by * px + by * ax * sa
+        #
+        # ay * sa * bx - by * ax * sa = py * bx - by * px
+        # sa ( ay * bx - by * ax ) = ( py * bx - by * px )
+        # sa = ( py * bx - by * px ) / ( ay * bx - by * ax )
+        #
+
+        sa = ( py * bx - by * px ) / ( ay * bx - by * ax ).to_f
+        sb = ( px - ax * sa ) / bx
+
+        if sa.to_i == sa
+          sa * 3 + sb
+        else
+          0
+        end
+      }
+      .sum.to_i
+      .tap { puts _1 }

data/data/solutions/github/gchan/2024/14_1.yml

@@ -0,0 +1,39 @@
+---
+- :name: day-14-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2024/day-14
+  :solution: |-
+    width = 101
+    height = 103
+    iter = 100
+
+    robots = input.split(?\n)
+
+    locations = robots.map { |robot|
+      x, y, vx, vy = robot.scan(/-*\d+/).map(&:to_i)
+
+      iter.times {
+        x = (x + vx) % width
+        y = (y + vy) % height
+      }
+
+      [x, y]
+    }
+
+    my = height / 2
+    mx = width / 2
+
+    x = [0...mx, (mx + 1)...width]
+    y = [0...my, (my + 1)...height]
+
+    quadrants = x.product(y)
+    count = [0, 0, 0, 0]
+
+    locations.each do |x, y|
+      idx = quadrants.find_index { |x1, y1|
+        x1.cover?(x) && y1.cover?(y)
+      }
+
+      count[idx] += 1 if idx
+    end
+
+    p count.inject(:*)