advent_of_ruby 0.2.0 → 0.3.0

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

@@ -0,0 +1,50 @@
+---
+- :name: day-12-part-2.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] * 5).join("?"), groups * 5)
+      }
+      .tap { puts _1 }

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

@@ -0,0 +1,26 @@
+---
+- :name: day-13-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-13
+  :solution: |-
+    def row_count(grid)
+      (grid.count - 1)
+        .times
+        .map { |y|
+          left = grid[0..y].reverse
+          right = grid[y+1..]
+
+          left.count if left.zip(right).select(&:last).all? { _1 == _2 }
+        }
+        .compact
+        .first
+    end
+
+    input
+      .split("\n\n")
+      .map { |pattern|
+        grid = pattern.each_line.map(&:strip).map(&:chars)
+
+        row_count(grid.transpose) || row_count(grid) * 100
+      }
+      .sum
+      .tap { puts _1 }

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

@@ -0,0 +1,30 @@
+---
+- :name: day-13-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-13
+  :solution: |-
+    def row_count(grid)
+      (grid.count - 1)
+        .times
+        .map { |y|
+          left = grid[0..y].reverse
+          right = grid[y+1..]
+
+          errors = left.zip(right).select(&:last).sum { |l, r|
+            l.zip(r).count { _1 != _2 }
+          }
+
+          left.count if errors == 1
+        }
+        .compact
+        .first
+    end
+
+    input
+      .split("\n\n")
+      .map { |pattern|
+        grid = pattern.each_line.map(&:strip).map(&:chars)
+
+        row_count(grid.transpose) || row_count(grid) * 100
+      }
+      .sum
+      .tap { puts _1 }

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

@@ -0,0 +1,29 @@
+---
+- :name: day-14-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-14
+  :solution: |-
+    grid = input.each_line.map { _1.strip.chars }
+
+    # Tilt left
+    def tilt(grid)
+      grid.map do |row|
+        row
+          .join
+          .split(?#)
+          .map { |section|
+            count = section.chars.count { _1 == ?O }
+
+            ?O * count + ?. * (section.length - count)
+          }
+          .join(?#)
+          .ljust(row.length, ?#)
+          .chars
+      end
+    end
+
+    grid
+      .then { tilt(_1.transpose).transpose }
+      .map { |row| row.count { _1 == ?O } }
+      .each_with_index
+      .sum { |count, idx| count * (grid.length - idx) }
+      .tap { puts _1 }

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

@@ -0,0 +1,56 @@
+---
+- :name: day-14-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-14
+  :solution: |-
+    grid = input.each_line.map { _1.strip.chars }
+
+    # Tilt left
+    def tilt(grid)
+      grid.map do |row|
+        row
+          .join
+          .split(?#)
+          .map { |section|
+            count = section.chars.count { _1 == ?O }
+
+            ?O * count + ?. * (section.length - count)
+          }
+          .join(?#)
+          .ljust(row.length, ?#)
+          .chars
+      end
+    end
+
+    def cycle(grid)
+      # north, west, south, east
+      grid
+        .then { tilt(_1.transpose).transpose }
+        .then { tilt(_1) }
+        .then { tilt(_1.transpose.map(&:reverse)).map(&:reverse).transpose }
+        .then { tilt(_1.map(&:reverse)).map(&:reverse) }
+    end
+
+    CYCLES = 1_000_000_000
+
+    states = Hash.new { |h, k| h[k] = [] }
+
+    CYCLES.times do |idx|
+      grid = cycle(grid)
+
+      state = grid.map(&:join).join("\n")
+      states[state] << idx
+
+      # Identify a loop
+      if states[state].count > 1
+        cycle = states[state][-1] - states[state][-2]
+
+        # Is this the 1 billionth state?
+        break if (CYCLES - idx - 1) % cycle == 0
+      end
+    end
+
+    grid
+      .map { |row| row.count { _1 == ?O } }
+      .each_with_index
+      .sum { |count, idx| count * (grid.length - idx) }
+      .tap { puts _1 }

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

@@ -0,0 +1,15 @@
+---
+- :name: day-15-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-15
+  :solution: |-
+    input
+      .strip
+      .split(",")
+      .sum {
+        _1.chars.inject(0) { |val, chr|
+          val += chr.ord
+          val *= 17
+          val %= 256
+        }
+      }
+      .tap { puts _1 }

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

@@ -0,0 +1,41 @@
+---
+- :name: day-15-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-15
+  :solution: |-
+    boxes = Hash.new { |h, k| h[k] = [] }
+
+    input
+      .strip
+      .split(",")
+      .each {
+        label = _1.scan(/\w*/).first
+
+        bi = label.chars.inject(0) { |bi, chr|
+          bi += chr.ord
+          bi *= 17
+          bi %= 256
+        }
+
+        box = boxes[bi]
+
+        op, fl = _1.strip.chars[label.length..]
+        fl = fl.to_i
+
+        idx = box.index { |lab, _| lab == label }
+
+        if op == ?-
+          box.delete_at(idx) if idx
+        elsif idx
+          box[idx] = [label, fl]
+        else
+          box << [label, fl]
+        end
+      }
+
+    boxes
+      .sum { |box, lenses|
+        lenses.each.with_index.sum { |(_, fl), idx|
+          (box + 1) * (idx + 1) * fl
+        }
+      }
+      .tap { puts _1 }

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

@@ -0,0 +1,78 @@
+---
+- :name: day-16-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-16
+  :solution: |-
+    input     = File.read(file_path)
+
+    DIRS = {
+      n: [0, -1],
+      s: [0, 1],
+      w: [-1, 0],
+      e: [1, 0]
+    }
+
+    MIRRORS = {
+      ?| => {
+        w: [:n ,:s],
+        e: [:n ,:s],
+        n: [:n],
+        s: [:s]
+      },
+      ?- => {
+        n: [:w ,:e],
+        s: [:w ,:e],
+        w: [:w],
+        e: [:e]
+      },
+      "/" => {
+        n: [:e],
+        e: [:n],
+        s: [:w],
+        w: [:s]
+      },
+      "\\" => {
+        n: [:w],
+        e: [:s],
+        s: [:e],
+        w: [:n]
+      },
+      ?. => {
+        n: [:n],
+        e: [:e],
+        w: [:w],
+        s: [:s]
+      }
+    }
+
+    grid = input.each_line.map { _1.strip.chars }
+
+    width = grid.first.length
+    height = grid.count
+
+    paths = [[-1, 0, :e]]
+    visited = Set.new
+
+    while paths.any?
+      *pos, dir = paths.pop
+
+      x, y = DIRS[dir].zip(pos).map(&:sum)
+
+      next if x < 0 || y < 0 || x >= width || y >= height
+
+      cell = grid[y][x]
+
+      MIRRORS[cell][dir].each do |dir2|
+        path = [x, y, dir2]
+
+        if !visited.include?(path)
+          paths << path
+          visited << path
+        end
+      end
+    end
+
+    visited
+      .map { |*pos, _| pos }
+      .uniq
+      .count
+      .tap { puts _1 }

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

@@ -0,0 +1,94 @@
+---
+- :name: day-16-part-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-16
+  :solution: |-
+    input     = File.read(file_path)
+
+    DIRS = {
+      n: [0, -1],
+      s: [0, 1],
+      w: [-1, 0],
+      e: [1, 0]
+    }
+
+    MIRRORS = {
+      ?| => {
+        w: [:n ,:s],
+        e: [:n ,:s],
+        n: [:n],
+        s: [:s]
+      },
+      ?- => {
+        n: [:w ,:e],
+        s: [:w ,:e],
+        w: [:w],
+        e: [:e]
+      },
+      "/" => {
+        n: [:e],
+        e: [:n],
+        s: [:w],
+        w: [:s]
+      },
+      "\\" => {
+        n: [:w],
+        e: [:s],
+        s: [:e],
+        w: [:n]
+      },
+      ?. => {
+        n: [:n],
+        e: [:e],
+        w: [:w],
+        s: [:s]
+      }
+    }
+
+    grid = input.each_line.map { _1.strip.chars }
+
+    width = grid.first.length
+    height = grid.count
+
+    beams = []
+
+    (0..(width-1)).each do |x|
+      beams << [x, -1, :s]
+      beams << [x, height, :n]
+    end
+
+    (0..(height-1)).each do |y|
+      beams << [-1, y, :e]
+      beams << [width, y, :w]
+    end
+
+    beams
+      .map { |x, y, dir|
+        paths = [[x, y, dir]]
+        visited = Set.new
+
+        while paths.any?
+          *pos, dir = paths.pop
+
+          x, y = DIRS[dir].zip(pos).map(&:sum)
+
+          next if x < 0 || y < 0 || x >= width || y >= height
+
+          cell = grid[y][x]
+
+          MIRRORS[cell][dir].each do |dir2|
+            path = [x, y, dir2]
+
+            if !visited.include?(path)
+              paths << path
+              visited << path
+            end
+          end
+        end
+
+        visited
+          .map { |*pos, _| pos }
+          .uniq
+          .count
+      }
+      .max
+      .tap { puts _1}

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

@@ -0,0 +1 @@
+--- []

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

@@ -0,0 +1,151 @@
+---
+- :name: day-17-part-1-and-2.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-17
+  :solution: |-
+    DIRS = {
+      n: [0, -1],
+      s: [0, 1],
+      w: [-1, 0],
+      e: [1, 0]
+    }
+
+    RIGHT = {
+      n: :e,
+      s: :w,
+      e: :s,
+      w: :n
+    }
+
+    LEFT = {
+      n: :w,
+      s: :e,
+      e: :n,
+      w: :s
+    }
+
+    # Reference PriorityQueue implementation is sourced from ChatGPT
+    #
+    # RubyGem options include `algorithms` or `priority_queue_cxx`
+    #
+    # This is a min binary heap (elements with the lowest priority
+    # are ordered first).
+    #
+    # https://en.wikipedia.org/wiki/Binary_heap
+    #
+    class PriorityQueue
+      def initialize
+        @heap = []
+      end
+
+      def any?
+        @heap.any?
+      end
+
+      def enqueue(element, priority)
+        @heap << { element: element, priority: priority }
+        heapify_up
+      end
+
+      def dequeue
+        return nil if @heap.empty?
+
+        swap(0, @heap.length - 1)
+        max = @heap.pop
+        heapify_down
+        max[:element]
+      end
+
+      private
+
+      def heapify_up
+        index = @heap.length - 1
+
+        while index > 0
+          parent_index = (index - 1) / 2
+          break if @heap[parent_index][:priority] <= @heap[index][:priority]
+
+          swap(parent_index, index)
+          index = parent_index
+        end
+      end
+
+      def heapify_down
+        index = 0
+
+        while true
+          child_l_index = 2 * index + 1
+          child_r_index = 2 * index + 2
+          break if child_l_index >= @heap.length
+
+          swap_index =
+            if child_r_index >= @heap.length ||
+              @heap[child_l_index][:priority] <= @heap[child_r_index][:priority]
+              child_l_index
+            else
+              child_r_index
+            end
+
+          break if @heap[index][:priority] <= @heap[swap_index][:priority]
+
+          swap(index, swap_index)
+          index = swap_index
+        end
+      end
+
+      def swap(i, j)
+        @heap[i], @heap[j] = @heap[j], @heap[i]
+      end
+    end
+
+    grid = input.each_line.map { _1.strip.chars.map(&:to_i) }
+
+    def solve(grid:, min_steps: 1, max_steps: 3)
+      h = grid.count
+      w = grid.first.count
+
+      queue = PriorityQueue.new
+
+      # cost, x, y, direction, steps in direction, priority/cost
+      queue.enqueue([0, 0, 0, :e, 0], 0)
+      queue.enqueue([0, 0, 0, :s, 0], 0)
+
+      require 'set'
+      visited = Set.new
+
+      while queue.any?
+        hl, x, y, dir, steps = queue.dequeue
+
+        ops = []
+        ops << RIGHT[dir] if steps >= min_steps
+        ops << LEFT[dir]  if steps >= min_steps
+        ops << dir        if steps < max_steps
+
+        ops.each do |n_dir|
+          nx, ny = DIRS[n_dir].zip([x,y]).map(&:sum)
+
+          next if nx < 0 || ny < 0 || nx >= w || ny >= h
+
+          nsteps = n_dir != dir ? 1 : steps + 1
+          nhl = grid[ny][nx] + hl
+
+          if nx == (w - 1) && ny == (h - 1) && nsteps >= min_steps
+            return nhl
+          end
+
+          state = [nhl, nx, ny, n_dir, nsteps]
+
+          next if visited.include?(state.last(4))
+          visited << state.last(4)
+
+          queue.enqueue(state, nhl)
+        end
+      end
+    end
+
+    # Part 1
+    solve(grid: grid)
+      .tap { puts _1 }
+
+    # Part 2
+    solve(grid: grid, min_steps: 4, max_steps: 10)
+      .tap { puts _1 }

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

@@ -0,0 +1,88 @@
+---
+- :name: day-18-part-1.rb
+  :url: https://github.com/gchan/advent-of-code-ruby/blob/main/2023/day-18
+  :solution: |-
+    DIRS = {
+      U: [0, -1],
+      D: [0, 1],
+      L: [-1, 0],
+      R: [1, 0]
+    }
+
+    pos = [0, 0]
+    dug = [pos]
+
+    input.each_line {
+      dir, dis, _ = _1.split
+      dis = dis.to_i
+
+      dis.times {
+        pos = DIRS[dir.to_sym].zip(pos).map(&:sum)
+
+        dug << pos
+      }
+    }
+
+    min_x = dug.map(&:first).min
+    max_x = dug.map(&:first).max
+    min_y = dug.map(&:last).min
+    max_y = dug.map(&:last).max
+
+    width = max_x - min_x + 1
+    height = max_y - min_y + 1
+
+    grid = []
+
+    height.times {
+      grid << Array.new(width, ".")
+    }
+
+    dug.each do |x ,y|
+      x1 = x - min_x
+      y1 = y - min_y
+
+      grid[y1][x1] = ?#
+    end
+
+    require 'set'
+    empty = Set.new
+
+    # Find external area and flood fill
+    width.times.each do |x|
+      if grid[0][x] == ?.
+        empty << [x, 0]
+      end
+
+      if grid[height-1][x] == ?.
+        empty << [x, height-1]
+      end
+    end
+
+    height.times.each do  |y|
+      if grid[y][0] == ?.
+        empty << [0, y]
+      end
+
+      if grid[y][width-1] == ?.
+        empty << [width-1, y]
+      end
+    end
+
+    queue = empty.to_a
+
+    while queue.any?
+      x, y = queue.pop
+
+      [[0, -1], [0, 1], [-1, 0], [1, 0]].each do |move|
+        x1, y1 = move.zip([x,y]).map(&:sum)
+
+        next if x1 < 0 || x1 >= width || y1 < 0 || y1 >= height
+        next if grid[y1][x1] == ?#
+        next if empty.include?([x1, y1])
+
+        queue << [x1, y1]
+        empty << [x1, y1]
+      end
+    end
+
+    pp (width * height) - empty.count