2022 grid and such

Author: Robb Kidd

2022/ruby/Gemfile

@@ -2,9 +2,13 @@
 
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 gem "rake"
 gem "pry"
 gem "yard-doctest"
+gem "rspec"
 gem "priority_queue_cxx"
+
+gem "debug"
+gem "ruby-lsp", "~> 0.3.7", group: :development

2022/ruby/Gemfile.lock

@@ -2,13 +2,44 @@ GEM
   remote: https://rubygems.org/
   specs:
     coderay (1.1.3)
+    debug (1.7.0)
+      irb (>= 1.5.0)
+      reline (>= 0.3.1)
+    diff-lcs (1.5.0)
+    io-console (0.5.11)
+    irb (1.6.1)
+      reline (>= 0.3.0)
+    language_server-protocol (3.17.0.2)
     method_source (1.0.0)
     minitest (5.16.3)
+    prettier_print (1.1.0)
     priority_queue_cxx (0.3.5)
     pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
     rake (13.0.6)
+    reline (0.3.2)
+      io-console (~> 0.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    ruby-lsp (0.3.7)
+      language_server-protocol (~> 3.17.0)
+      sorbet-runtime
+      syntax_tree (>= 4.0.2, < 5.0.0)
+    sorbet-runtime (0.5.10590)
+    syntax_tree (4.3.0)
+      prettier_print (>= 1.0.2)
     webrick (1.7.0)
     yard (0.9.28)
       webrick (~> 1.7.0)
@@ -18,13 +49,15 @@ GEM
 
 PLATFORMS
   arm64-darwin-22
-  ruby
 
 DEPENDENCIES
+  debug
   priority_queue_cxx
   pry
   rake
+  rspec
+  ruby-lsp (~> 0.3.7)
   yard-doctest
 
 BUNDLED WITH
-   2.3.26
+   2.3.7

2022/ruby/doctest_helper.rb

@@ -1,3 +1,4 @@
+require "grid"
 require "day"
 require WhichDay.klass_name.downcase
 

2022/ruby/grid.rb

@@ -0,0 +1,264 @@
+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 loaded." }
+  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("S1234\n56789\n")
+  #   grid.at([0,0])       #=> raise("No data loaded.")
+  #   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(EXAMPLE_INPUT)
+  #   grid.neighbors_for([2,5]) #=> raise "No data loaded."
+  #
+  # @example in bounds
+  #   grid =  new(EXAMPLE_INPUT).parse
+  #   grid.neighbors_for([2,5]) #=> [ [1,5], [3,5], [2,4], [2,6] ]
+  #
+  # @example on the edge
+  #   grid =  new(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
+
+  # @example
+  #   grid = new(EXAMPLE_INPUT).parse
+  #   grid.line_between([8,4],[8,7]) #=> [[8,4],[8,5],[8,6],[8,7]]
+  def line_between(from, to)
+    [from, to].transpose.map { |dimension_ends| Range.new(dimension_ends) }
+  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
+
+  def parse
+    parse_rows_and_columns
+    loaded!
+
+    self
+  end
+
+  def loaded!
+    @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
+
+  def parse_rows_and_columns
+    @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
+
+    self
+  end
+
+  attr_writer :to_s_proc
+  DEFAULT_TO_S_PROC = proc { |_coords, value| value.to_s }
+  #
+  # @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"
+  #
+  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
+
+  EXAMPLE_INPUT = <<~INPUT
+    Sabqponm
+    abcryxxl
+    accszExk
+    acctuvwj
+    abdefghi
+  INPUT
+end