advent_of_ruby 0.1.0 → 0.3.0

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

@@ -0,0 +1,70 @@
+---
+- :name: day-05-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-05
+  :solution: |-
+    seeds, *maps = input.split("\n\n")
+
+    seeds = seeds.scan(/\d+/).map(&:to_i)
+
+    maps.map! {
+      map = {}
+
+      _1.split("\n")[1..-1].each do |line|
+        dest, source, length = line.split.map(&:to_i)
+
+        range = source..(source + length)
+        offset = dest - source
+
+        map[range] = offset
+      end
+
+      map
+    }
+
+    def overlapping_range(a, b)
+      if b.begin <= a.end && a.begin <= b.end
+        [a.begin, b.begin].max..[a.end, b.end].min
+      end
+    end
+
+    seed_ranges = seeds.each_slice(2).map do |from, length|
+      from..(from + length)
+    end
+
+    maps
+      .reduce(seed_ranges) { |sources, map|
+        sources.flat_map { |source_range|
+          destinations = []
+
+          curr = source_range.begin
+
+          map
+            .sort_by { |range, offset| range.begin }
+            .each { |range, offset|
+              matching_range = overlapping_range(range, source_range)
+
+              if matching_range
+                if matching_range.begin != curr
+                  # This doesn't seem to be required for my given input
+                  # but I _think_ this is required for sources where there
+                  # is no mapping
+                  destinations << (curr..(matching_range.begin - 1))
+                end
+
+                destinations << (
+                  (matching_range.begin + offset)..(matching_range.end + offset)
+                )
+                curr = matching_range.end + 1
+              end
+            }
+
+          if curr < source_range.end
+            destinations << (curr..source_range.end)
+          end
+
+          destinations
+        }
+      }
+      .min_by(&:begin)
+      .begin
+      .tap { puts _1 }

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

@@ -0,0 +1,15 @@
+---
+- :name: day-06-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-06
+  :solution: |-
+    times, distances = input.split("\n")
+
+    times = times.scan(/\d+/).map(&:to_i)
+    distances = distances.scan(/\d+/).map(&:to_i)
+
+    times.zip(distances)
+      .map { |time, record|
+        time.times.count { _1 * (time - _1) > record }
+      }
+      .inject(:*)
+      .tap { puts _1 }

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

@@ -0,0 +1,12 @@
+---
+- :name: day-06-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-06
+  :solution: |-
+    time, distance = input.split("\n")
+
+    time = time.scan(/\d+/).join.to_i
+    record = distance.scan(/\d+/).join.to_i
+
+    time.times
+      .count { _1 * (time - _1) > record }
+      .tap { puts _1 }

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

@@ -0,0 +1,58 @@
+---
+- :name: day-07-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-07
+  :solution: |-
+    class Hand
+      CARDS = %w(A K Q J T 9 8 7 6 5 4 3 2)
+
+      attr_reader :hand
+
+      def initialize(hand)
+        @hand = hand
+      end
+
+      def rank
+        tally = hand.chars.tally.values.sort
+
+        if tally == [5]
+          0
+        elsif tally == [1, 4]
+          1
+        elsif tally == [2, 3]
+          2
+        elsif tally.include?(3)
+          3
+        elsif tally.count { _1 == 2 } == 2
+          4
+        elsif tally.include?(2)
+          5
+        else
+          6
+        end
+      end
+
+      # Strongest hands first
+      def <=>(other)
+        result = self.rank <=> other.rank
+
+        return result unless result.zero?
+
+        hand.chars.zip(other.hand.chars)
+          .map { |a, b| CARDS.index(a) <=> CARDS.index(b) }
+          .reject(&:zero?)
+          .first
+      end
+    end
+
+    input.each_line
+      .map {
+        hand, bid = _1.split
+
+        [ Hand.new(hand), bid.to_i ]
+      }
+      .sort_by(&:first)
+      .reverse
+      .map(&:last)
+      .each_with_index
+      .sum { |bid, idx| (idx + 1) * bid }
+      .tap { puts _1 }

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

@@ -0,0 +1,65 @@
+---
+- :name: day-07-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-07
+  :solution: |-
+    class Hand
+      CARDS = %w(A K Q T 9 8 7 6 5 4 3 2 J)
+
+      attr_reader :hand
+
+      def initialize(hand)
+        @hand = hand
+      end
+
+      def rank
+        tally = hand.chars.tally.reject! { _1 == ?J } || {}
+
+        max = tally.values.max
+        best = tally.key(max)
+
+        tally = hand
+          .gsub(?J, best || ?J)
+          .chars.tally.values.sort
+
+        if tally == [5]
+          0
+        elsif tally == [1, 4]
+          1
+        elsif tally == [2, 3]
+          2
+        elsif tally.include?(3)
+          3
+        elsif tally.count { _1 == 2 } == 2
+          4
+        elsif tally.include?(2)
+          5
+        else
+          6
+        end
+      end
+
+      # Strongest hands first
+      def <=>(other)
+        result = self.rank <=> other.rank
+
+        return result unless result.zero?
+
+        hand.chars.zip(other.hand.chars)
+          .map { |a, b| CARDS.index(a) <=> CARDS.index(b) }
+          .reject(&:zero?)
+          .first
+      end
+    end
+
+    input.each_line
+      .map {
+        hand, bid = _1.split
+
+        [ Hand.new(hand), bid.to_i ]
+      }
+      .sort_by(&:first)
+      .reverse
+      .map(&:last)
+      .each_with_index
+      .sum { |bid, idx| (idx + 1) * bid }
+      .tap { puts _1 }

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

@@ -0,0 +1,28 @@
+---
+- :name: day-08-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-08
+  :solution: |-
+    steps, map = input.split("\n\n")
+
+    steps = steps.chars
+
+    network = {}
+
+    map.each_line {
+      from, *dest = _1.scan(/\w+/)
+      network[from] = dest
+    }
+
+    i = 0
+    curr = "AAA"
+
+    while curr != "ZZZ"
+      step = steps[i % (steps.length)]
+
+      dir = step == ?L ? 0 : 1
+      curr = network[curr][dir]
+
+      i += 1
+    end
+
+    puts i

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

@@ -0,0 +1,34 @@
+---
+- :name: day-08-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-08
+  :solution: |-
+    steps, map = input.split("\n\n")
+
+    steps = steps.chars
+
+    network = {}
+
+    map.each_line {
+      from, *dest = _1.scan(/\w+/)
+      network[from] = dest
+    }
+
+    starts = network.keys.select { _1 =~ /A$/ }
+
+    starts
+      .map { |curr|
+        i = 0
+
+        while !curr.match?(/Z$/)
+          step = steps[i % (steps.length)]
+
+          dir = step == ?L ? 0 : 1
+          curr = network[curr][dir]
+
+          i += 1
+        end
+
+        i
+      }
+      .inject(:lcm)
+      .tap { puts _1 }

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

@@ -0,0 +1,25 @@
+---
+- :name: day-09-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-09
+  :solution: |-
+    input.each_line
+      .sum { | line|
+        i = line.split.map(&:to_i)
+
+        seqs = [i]
+
+        while !seqs.last.all?(&:zero?)
+          seqs << seqs.last.each_cons(2).map { _2 - _1 }
+        end
+
+        seqs.reverse_each.with_index { |seq, idx|
+          if idx.zero?
+            seq << 0
+          else
+            seq << (seq.last + seqs[-idx].last)
+          end
+        }
+
+        seqs.first.last
+      }
+      .tap { puts _1 }

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

@@ -0,0 +1,25 @@
+---
+- :name: day-09-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-09
+  :solution: |-
+    input.each_line
+      .sum { | line|
+        i = line.split.map(&:to_i)
+
+        seqs = [i]
+
+        while !seqs.last.all?(&:zero?)
+          seqs << seqs.last.each_cons(2).map { _2 - _1 }
+        end
+
+        seqs.reverse_each.with_index { |seq, idx|
+          if idx.zero?
+            seq.unshift(0)
+          else
+            seq.unshift(seq.first - seqs[-idx].first)
+          end
+        }
+
+        seqs.first.first
+      }
+      .tap { puts _1 }

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

@@ -0,0 +1,61 @@
+---
+- :name: day-10-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-10
+  :solution: |-
+    input     = File.read(file_path)
+
+    DIRS = {
+      n: [0, -1],
+      s: [0, 1],
+      w: [-1, 0],
+      e: [1, 0]
+    }
+
+    PIPES = {
+      '|': { n: :n, s: :s },
+      '-': { w: :w, e: :e },
+      'L': { w: :n, s: :e },
+      'J': { s: :w, e: :n },
+      '7': { n: :w, e: :s },
+      'F': { w: :s, n: :e }
+    }
+
+    map = input.each_line.map { _1.strip.chars }
+
+    height = map.length
+    width = map.first.length
+
+    _, sy = map.each.with_index.find { |row, _| row.include?(?S) }
+    sx = map[sy].index(?S)
+
+    curr = [sx, sy]
+    dir = nil
+
+    path = []
+
+    DIRS.each do |direction, mod|
+      x, y = curr.zip(mod).map(&:sum)
+
+      next if x < 0 || y < 0 || x >= width || y >= height
+
+      c = map[y][x].to_sym
+
+      if PIPES[c][direction]
+        dir = direction
+        curr = [x, y]
+        path << [curr, dir]
+        break
+      end
+    end
+
+    while map[curr[1]][curr[0]] != ?S
+      c = map[curr[1]][curr[0]]
+      dir = PIPES[c.to_sym][dir]
+      mod = DIRS[dir]
+
+      curr = curr.zip(mod).map(&:sum)
+
+      path << [curr, dir]
+    end
+
+    puts path.count / 2

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

@@ -0,0 +1,167 @@
+---
+- :name: day-10-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-10
+  :solution: |-
+    input     = File.read(file_path)
+
+    DIRS = {
+      n: [0, -1],
+      s: [0, 1],
+      w: [-1, 0],
+      e: [1, 0]
+    }
+
+    PIPES = {
+      '|': { n: :n, s: :s },
+      '-': { w: :w, e: :e },
+      'L': { w: :n, s: :e },
+      'J': { s: :w, e: :n },
+      '7': { n: :w, e: :s },
+      'F': { w: :s, n: :e }
+    }
+
+    map = input.each_line.map { _1.strip.chars }
+
+    height = map.length
+    width = map.first.length
+
+    _, sy = map.each.with_index.find { |row, _| row.include?(?S) }
+    sx = map[sy].index(?S)
+
+    curr = [sx, sy]
+    dir = nil
+
+    path = []
+
+    DIRS.each do |direction, mod|
+      x, y = curr.zip(mod).map(&:sum)
+
+      next if x < 0 || y < 0 || x >= width || y >= height
+
+      c = map[y][x].to_sym
+
+      if PIPES[c][direction]
+        dir = direction
+        curr = [x, y]
+        path << [curr, dir]
+        break
+      end
+    end
+
+    while map[curr[1]][curr[0]] != ?S
+      c = map[curr[1]][curr[0]]
+      dir = PIPES[c.to_sym][dir]
+      mod = DIRS[dir]
+
+      curr = curr.zip(mod).map(&:sum)
+
+      path << [curr, dir]
+    end
+
+    puts path.count / 2
+
+    pipes = path.map(&:first).to_set
+
+    voids = width.times.to_a
+      .product(height.times.to_a)
+      .reject { |pos| pipes.include?(pos) }
+      .to_set
+
+    def neighbours(x, y, height, width)
+      [
+        [x - 1, y],
+        [x + 1, y],
+        [x, y - 1],
+        [x, y + 1]
+      ]
+        .reject { |x, y| x < 0 || y < 0 }
+        .reject { |x, y| x >= width }
+        .reject { |x, y| y >= height }
+    end
+
+
+    # Map position to a group of connected voids
+    candidates = {}
+    groups = []
+
+    voids.each { |pos|
+      next if candidates[pos]
+
+      group = Set.new([pos])
+      candidates[pos] = group
+      groups << group
+
+      to_visit = [pos]
+      while to_visit.any?
+        pos = to_visit.pop
+
+        neighbours(*pos, height, width)
+          .select { voids.include?(_1) }
+          .reject { candidates[_1] }
+          .each { |pos|
+            group << pos
+            candidates[pos] = group
+            to_visit << pos
+          }
+      end
+    }
+
+    # Identify the cells belonging to a group on a border
+    outside = groups
+      .select { |group|
+        group.any? { |x, y| x == 0 || x == width - 1 || y == 0 || y == height - 1 }
+      }
+      .flat_map(&:to_a)
+      .to_set
+
+    RIGHT = {
+      n: :e,
+      s: :w,
+      e: :s,
+      w: :n
+    }
+
+    LEFT = {
+      n: :w,
+      s: :e,
+      e: :n,
+      w: :s
+    }
+
+    def right(dir, pos)
+      RIGHT[dir]
+        .then { DIRS[_1] }
+        .zip(pos)
+        .map(&:sum)
+    end
+
+    def left(dir, pos)
+      LEFT[dir]
+        .then { DIRS[_1] }
+        .zip(pos)
+        .map(&:sum)
+    end
+
+    # Determine which direction (from the pipe's perspective), is facing inside
+    inside_dir = path.lazy
+      .map { |pos, dir|
+        if left(dir, pos).then { outside.include?(_1) }
+          :right
+        elsif right(dir, pos).then { outside.include?(_1) }
+          :left
+        end
+      }
+      .compact
+      .first
+
+    surrounding = Set.new
+
+    path.each_cons(2) do |(pos, curr_dir), (_, next_dir)|
+      [curr_dir, next_dir].uniq.each do |dir|
+        send(inside_dir, dir, pos)
+          .then { candidates[_1] }
+          &.tap { surrounding.merge(_1) }
+      end
+    end
+
+    puts surrounding.count

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

@@ -0,0 +1,40 @@
+---
+- :name: day-11-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-11
+  :solution: |-
+    grid = input.each_line.map { _1.strip.chars }
+
+    width = grid.first.count
+    height = grid.count
+
+    y_expand = height.times.select {
+      grid[_1].join.match?(/\A\.*\z/)
+    }
+
+    transposed_grid = grid.transpose
+
+    x_expand = width.times.select {
+      transposed_grid[_1].join.match?(/\A\.*\z/)
+    }
+
+    y_expand.each_with_index { |row, idx|
+      grid.insert(row + idx, Array.new(width, "."))
+    }
+
+    height = grid.count
+    grid = grid.transpose
+
+    x_expand.each_with_index { |row, idx|
+      grid.insert(row + idx, Array.new(height, "."))
+    }
+
+    grid = grid.transpose
+    width = grid.first.count
+
+    height.times.to_a
+      .product(width.times.to_a)
+      .select { grid[_1][_2] == ?# }
+      .map { [_2, _1] }
+      .combination(2)
+      .sum { |(x1, y1), (x2, y2)| (x1 - x2).abs + (y1 - y2).abs }
+      .tap { puts _1 }

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

@@ -0,0 +1,33 @@
+---
+- :name: day-11-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-11
+  :solution: |-
+    grid = input.each_line.map { _1.strip.chars }
+
+    width = grid.first.count
+    height = grid.count
+
+    y_expand = height.times.select {
+      grid[_1].join.match?(/\A\.*\z/)
+    }
+
+    transposed_grid = grid.transpose
+
+    x_expand = width.times.select {
+      transposed_grid[_1].join.match?(/\A\.*\z/)
+    }
+
+    height.times.to_a
+      .product(width.times.to_a)
+      .select { grid[_1][_2] == ?# }
+      .map { [_2, _1] }
+      .combination(2)
+      .sum { |(x1, y1), (x2, y2)|
+        x_range = Range.new(*[x1, x2].sort)
+        y_range = Range.new(*[y1, y2].sort)
+
+        x_range.size + y_range.size - 2 +
+          999_999 * x_expand.count { x_range.include?(_1) } +
+          999_999 * y_expand.count { y_range.include?(_1) }
+      }
+      .tap { puts _1 }

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

@@ -0,0 +1,50 @@
+---
+- :name: day-12-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-12
+  :solution: |-
+    def count_arrangements(pattern, groups, cache = {})
+      result = cache[[pattern, groups]]
+      return result if result
+
+      if groups.empty?
+        if !pattern&.match?(/#/)
+          count = 1
+        else
+          count = 0
+        end
+
+        cache[[pattern, groups]] = count
+        return count
+      end
+
+      expected = groups[0]
+      remainder = groups[1..]
+
+      # Minimum width required to satistify the remaining groups
+      reserved = remainder.sum + remainder.length
+
+      # Amount of width (less expected split) available to test
+      space = pattern.size - reserved - (expected - 1)
+
+      candidates = space.times.map { "." * _1 + "#" * expected + "." }
+
+      candidates
+        .select {
+          _1.chars.zip(pattern.chars).all? do |c, p|
+            c == p || p == "?" || p.nil?
+          end
+        }
+        .sum {
+          count_arrangements(pattern[_1.length..], remainder, cache)
+        }
+        .tap { cache[[pattern, groups]] = _1 }
+    end
+
+    input.each_line
+      .sum {
+        pattern, groups = _1.split
+        groups = groups.split(",").map(&:to_i)
+
+        count_arrangements(pattern, groups)
+      }
+      .tap { puts _1 }