day 10, part 1

Author: Robb Kidd

2023/ruby/day10.rb

@@ -0,0 +1,152 @@
+require_relative 'day'
+require_relative 'grid'
+require_relative 'ugly_sweater'
+
+class Day10 < Day # >
+  include UglySweater
+  # @example
+  #   day.part1 #=> 4
+  # @example more complex input
+  #   day = Day10.new(MORE_COMPLEX_INPUT)
+  #   day.part1 #=> 8
+  def part1
+    pipe_maze = PipeMaze.new(input)
+    # puts pipe_maze.to_ugly_sweater
+    pipe_maze.loop_path.length / 2
+  end
+
+  # @example
+  # day.part2 #=> 'how are you'
+  def part2
+  end
+
+  EXAMPLE_INPUT = <<~INPUT
+    .....
+    .S-7.
+    .|.|.
+    .L-J.
+    .....
+  INPUT
+
+  MORE_COMPLEX_INPUT= <<~INPUT
+    ..F7.
+    .FJ|.
+    SJ.L7
+    |F--J
+    LJ...
+  INPUT
+end
+
+class PipeMaze
+  attr_reader :start
+
+  # @example
+  #   maze = PipeMaze.new(Day10::EXAMPLE_INPUT)
+  #   maze.start #=> [1,1]
+  def initialize(input)
+    @input = input
+    @start = nil
+    @grid = Grid.new(input)
+    @grid.parse { |coords, value| @start = coords if value == "S" }
+  end
+
+  def loop_path
+    @loop_path ||= find_loop
+  end
+
+  def find_loop
+    probes =
+      DIRECTION_OFFSETS.keys
+        .map {|direction|
+          step_from(start, direction)
+        }
+        .compact!
+        .map {|first_step, direction| [ [start, first_step], direction ] }
+
+    while probes do
+      path, direction = probes.pop
+      next_coords, direction = step_from(path.last, direction)
+
+      case direction
+      when :north, :south, :west, :east
+        probes << [(path + [next_coords]), direction]
+      when :stop
+        return path
+      end
+    end
+  end
+
+  def step_from(coords, direction)
+    maybe_next_coords = towards(coords, direction)
+    return nil unless @grid.cover?(maybe_next_coords)
+
+    maybe_next_direction = PIPE_FLOWS.fetch([direction, at(maybe_next_coords)], nil)
+    return nil unless maybe_next_direction
+    [
+      maybe_next_coords,
+      maybe_next_direction
+    ]
+  end
+
+  def at(coords)
+      @grid.at(coords)
+  end
+
+  def towards(from_coords, direction)
+    raise("what kind of direction is #{direction.inspect}?") if !DIRECTION_OFFSETS.keys.include?(direction)
+    from_coords
+      .zip(DIRECTION_OFFSETS[direction])
+      .map { |p| p.reduce(&:+) }
+  end
+
+  DIRECTION_OFFSETS = {
+    north: [-1, 0],
+    south: [ 1, 0],
+    west:  [ 0,-1],
+    east:  [ 0, 1],
+    stop:  [ 0, 0],
+  }
+
+  # [step travel direction, pipe type] => next step travel direction
+  PIPE_FLOWS = {
+    # | is a vertical pipe connecting north and south.
+    [:north, "|"] => :north,
+    [:south, "|"] => :south,
+    # - is a horizontal pipe connecting east and west.
+    [:east, "-"] => :east,
+    [:west, "-"] => :west,
+    # L is a 90-degree bend connecting north and east.
+    [:south, "L"] => :east,
+    [:west, "L"] => :north,
+    # J is a 90-degree bend connecting north and west.
+    [:south, "J"] => :west,
+    [:east, "J"] => :north,
+    # 7 is a 90-degree bend connecting south and west.
+    [:east, "7"] => :south,
+    [:north, "7"] => :west,
+    # F is a 90-degree bend connecting south and east.
+    [:west, "F"] => :south,
+    [:north, "F"] => :east,
+    # . is ground; there is no pipe in this tile.
+    "." => :cannot_enter_ground,
+    # S is the starting position of the animal;
+    # there is a pipe on this tile, but your sketch doesn't
+    # show what shape the pipe has.
+    # Let start be entered from any direction and then
+    # there are no further steps.
+    [:north, "S"] => :stop,
+    [:south, "S"] => :stop,
+    [:east, "S"] => :stop,
+    [:west, "S"] => :stop,
+  }
+
+  def to_ugly_sweater
+    @grid.to_s { |coords, value|
+      if loop_path.include?(coords)
+        value.make_it_red
+      else
+        value.make_it_green
+      end
+    }
+  end
+end

2023/ruby/grid.rb

@@ -0,0 +1,239 @@
+class Grid
+  require "fc"
+  include Enumerable
+
+  attr_reader :row_bounds, :column_bounds
+
+  def initialize(input)
+    @input = input
+    @the_grid = Hash.new { |(r, c)| raise "No data parsed." }
+  end
+
+  def each
+    @the_grid.each { |coords, value| yield coords, value }
+  end
+
+  # @example
+  #   grid = new("")
+  #   grid.at([0,0])       #=> raise("No data loaded.")
+  #   grid.set([0,0], ".")
+  #   grid.at([0,0])      #=> "."
+  def set(coords, value)
+    @the_grid[coords] = value
+  end
+
+  # @example
+  #   grid = new("S..\n.\n..")
+  #   grid.at([0,0])       #=> raise "No data parsed."
+  #   grid.parse
+  #   grid.at([0,0])       #=> "S"
+  #   grid.at([-100,-100]) #=> raise KeyError, "Coordinates not found on grid: [-100, -100]"
+  def at(coords)
+    (@value_transform_proc || DEFAULT_VALUE_TRANFORM_PROC).call(
+      @the_grid[coords]
+    )
+  end
+
+  DEFAULT_VALUE_TRANFORM_PROC = proc { |v| v }
+
+  def values_are_integers
+    set_value_transform_proc { |v| v.to_i }
+  end
+
+  def set_value_transform_proc(&block)
+    raise "#{__method__} must be called with a block." unless block_given?
+    @value_transform_proc = block
+
+    self
+  end
+
+  def cover?(coords)
+    raise "No data loaded." unless (@row_bounds && @column_bounds)
+    @row_bounds.cover?(coords[0]) && @column_bounds.cover?(coords[1])
+  end
+
+  def manhattan_distance(here, there)
+    [here, there].transpose.map { |a, b| (a - b).abs }.reduce(&:+)
+  end
+
+  OFFSET_TO_DIRECTION = {
+    # r   c
+    [-1, 0] => "^", # up a row
+    [1, 0] => "v", # down a row
+    [0, -1] => "<", # left a column
+    [0, 1] => ">" # right a column
+  }
+
+  # @example exception when grid hasn't been populated
+  #   grid = new(Day12::EXAMPLE_INPUT)
+  #   grid.neighbors_for([2,5]) #=> raise "No data loaded."
+  #
+  # @example in bounds
+  #   grid = new(Day12::EXAMPLE_INPUT).parse
+  #   grid.neighbors_for([2,5]) #=> [ [1,5], [3,5], [2,4], [2,6] ]
+  #
+  # @example on the edge
+  #   grid = new(Day12::EXAMPLE_INPUT).parse
+  #   grid.neighbors_for([0,0]) #=> [ [1,0], [0,1] ]
+  def neighbors_for(coords)
+    OFFSET_TO_DIRECTION
+      .keys
+      .map { |offset| coords.zip(offset).map { |p| p.reduce(&:+) } }
+      .select { |neighbor_coords| self.cover? neighbor_coords }
+  end
+
+  # default cost to step to a neighbor
+  # if some neighbors ought to be excluded outright, return Float::INFINITY as their cost
+  DEFAULT_STEP_COST_CALCULATOR_PROC =
+    proc { |_grid, _from_coords, _to_coords| 1 }
+
+  # just in case you want to keep multiple procs around and swap them in and out
+  attr_writer :step_cost_calculator_proc
+
+  # or use this to chain setting it during grid initialization
+  def set_step_cost_calculator(&block)
+    raise "#{__method__} must be called with a block." unless block_given?
+    @step_cost_calculator_proc = block
+
+    self
+  end
+
+  def shortest_path_between(start, goal, &block)
+    cost_calculator =
+      if block_given?
+        block
+      elsif @step_cost_calculator_proc
+        @step_cost_calculator_proc
+      else
+        DEFAULT_STEP_COST_CALCULATOR_PROC
+      end
+
+    backsteps = Hash.new
+    backsteps[start] = nil # there's no previous step from the start of a path
+
+    costs = Hash.new(Float::INFINITY) # until computed, the cost to step to a neighbor is infinitely expensive
+    costs[start] = 0 # we start here, though, so it's cheap
+
+    survey_queue = FastContainers::PriorityQueue.new(:min)
+    survey_queue.push(start, 0)
+    while !survey_queue.empty?
+      check_pos = survey_queue.pop
+      break if check_pos == goal
+
+      neighbors_for(check_pos).each do |neighbor|
+        neighbor_cost =
+          costs[check_pos] + cost_calculator.call(self, check_pos, neighbor)
+
+        if neighbor_cost < costs[neighbor]
+          costs[neighbor] = neighbor_cost
+          backsteps[neighbor] = check_pos
+
+          survey_queue.push(neighbor, neighbor_cost)
+        end
+      end
+    end
+
+    return [] unless backsteps.include?(goal)
+
+    path = [goal]
+    step_backwards = backsteps[goal]
+    while step_backwards
+      path.push(step_backwards)
+      step_backwards = backsteps[step_backwards]
+    end
+    path
+  end
+
+  def render_path(path)
+    step_directions = path_to_direction_map(path)
+
+    self.to_s do |coords, value|
+      if coords == path.first
+        at(coords)
+      elsif dir = step_directions[coords]
+        "\e[41m\e[1m#{dir}\e[0m"
+      else
+        "\e[32m.\e[0m"
+      end
+    end
+  end
+
+  def path_to_direction_map(path)
+    direction_of_travel_from = Hash.new
+    path.each_cons(2) do |to, from|
+      offset = [to[0] - from[0], to[1] - from[1]]
+      direction_of_travel_from[from] = OFFSET_TO_DIRECTION.fetch(offset)
+    end
+    direction_of_travel_from
+  end
+
+  # @example
+  #
+  def parse
+    @input
+      .split("\n")
+      .map { |line| line.chars }
+      .each_with_index do |row, r|
+        row.each_with_index do |char, c|
+          @the_grid[[r, c]] = char
+          yield [r, c], char if block_given?
+        end
+      end
+
+    @the_grid.default_proc =
+      proc do |_hash, key|
+        raise KeyError, "Coordinates not found on grid: #{key}"
+      end
+
+    @row_bounds, @column_bounds =
+      @the_grid.keys.transpose.map { |dimension| Range.new(*dimension.minmax) }
+
+    self
+  end
+
+  # @example by default, stringifies input value for a grid location
+  #   grid = new("abcd\nefgh\n").parse
+  #   grid.to_s  #=> "abcd\nefgh\n"
+  #
+  # @example transforms with an assigned to_s_proc
+  #   grid = new("abcd\nefgh\n").parse
+  #   grid.to_s  #=> "abcd\nefgh\n"
+  #   grid.to_s_proc = proc {|_coords, value| (value.ord + 1).chr }
+  #   grid.to_s  #=> "bcde\nfghi\n"
+  #   grid.to_s_proc = nil
+  #   grid.to_s  #=> "abcd\nefgh\n"
+  #
+  # @example transforms with a given block
+  #   grid = new("abcd\nefgh\n").parse
+  #   grid.to_s  #=> "abcd\nefgh\n"
+  #   grid.to_s { |_coords, value| (value.ord + 1).chr } #=> "bcde\nfghi\n"
+  #   grid.to_s  #=> "abcd\nefgh\n"
+  #
+  # @example block given takes priority over assigned to_s_proc
+  #   grid = new("abcd\nefgh\n").parse
+  #   grid.to_s  #=> "abcd\nefgh\n"
+  #   grid.to_s_proc = proc {|_, _| raise "to_s_proc called" }
+  #   grid.to_s  #=> raise "to_s_proc called"
+  #   grid.to_s { |_coords, value| (value.ord + 1).chr } #=> "bcde\nfghi\n"
+  #
+  attr_writer :to_s_proc
+  DEFAULT_TO_S_PROC = proc { |_coords, value| value.to_s }
+  def to_s(&block)
+    transformer =
+      if block_given?
+        block
+      elsif @to_s_proc
+        @to_s_proc
+      else
+        DEFAULT_TO_S_PROC
+      end
+
+    @row_bounds
+      .map do |row|
+        @column_bounds
+          .map { |column| transformer.call([row, column], at([row, column])) }
+          .join("")
+      end
+      .join("\n") + "\n"
+  end
+end