[2023][ruby][3.*] clean up parsing

2023/ruby/day_03.rb

@@ -1,69 +1,55 @@
+require "strscan"
+
 Part = Data.define(:number) do
   def eql?(other)
     self.object_id == other.object_id
   end
 end
-CurrentNumber = Data.define(:coords, :acc)
 
-cur_num = nil
+def parse(input)
-nums = {}
+  ss = StringScanner.new(input)
-syms = {}
+  y = x = 0
-ARGF.readlines(chomp: true).each.with_index do |row, y|
+  schematic = {}
-  row.chars.each.with_index do |c, x|
+  until ss.eos?
-    case c
+    case
-    when /\d/
+      when ss.scan(/\./)
-      if cur_num
+        x += 1
-        cur_num.coords << [y,x]
+      when num = ss.scan(/\d+/)
-        cur_num.acc << c
+        coords = (0...num.length).map {|dx| [y, x+dx] }
-      else
+        part = Part.new(num.to_i)
-        cur_num = CurrentNumber.new([[y,x]], c)
+        schematic.merge!(coords.to_h { [_1, part] })
-      end
+        x += num.length
+      when ss.scan(/\n/)
+        y += 1
+        x = 0
+      when sym = ss.scan(/./)
+        schematic[[y,x]] = sym
+        x += 1
       else
-      if cur_num
+        fail
-        part = Part.new(cur_num.acc.to_i)
-        nums.merge!(cur_num.coords.to_h { [_1, part] })
-        cur_num = nil
-      end
-
-      if c != ?.
-        syms[[y,x]] = c
     end
   end
+  schematic
 end
 
-  if cur_num
+schematic = parse(ARGF.read)
-    part = Part.new(cur_num.acc.to_i)
+syms, nums = schematic.partition { String === _2 }.map(&:to_h)
-    nums.merge!(cur_num.coords.to_h { [_1, part] })
+neighboring_parts = ->((y,x)) {
-    cur_num = nil
-  end
-end
-
-# part one
-p syms
-  .flat_map {|(y,x), _|
   dy = (-1..1).to_a
   dx = (-1..1).to_a
   dy.product(dx)
     .map {|dy,dx| [y+dy,x+dx] }
     .filter_map { nums.fetch(_1, nil) }
-      .uniq
 }
-  .sum(&:number)
 
+# part one
+p syms.keys.flat_map { neighboring_parts.(_1) }.uniq.sum(&:number)
+
+# part two
 p syms
   .select { _2 == ?* }
-  .filter_map {|(y,x), _|
+  .filter_map {|coord, _|
-    dy = (-1..1).to_a
+    parts = neighboring_parts.(coord).uniq
-    dx = (-1..1).to_a
+    parts.length == 2 ? parts : nil
-    parts = dy.product(dx)
-      .map {|dy,dx| [y+dy,x+dx] }
-      .filter_map { nums.fetch(_1, nil) }
-      .uniq
-
-    if parts.length == 2
-      parts
-    else
-      nil
-    end
   }
   .sum { _1.map(&:number).inject(:*) }