refactor and use more Enumerable

Author: invalidusrname

2024/ruby/lib/advent_04_ceres_search.rb

@@ -18,6 +18,10 @@ def count_at(row, col)
     count
   end
 
+  def letter_at(row, col)
+    in_bounds?(row, col) ? data[row][col] : ""
+  end
+
   def horizontal_word(row, col)
     first = col
     last = col + word.length - 1
@@ -32,88 +36,37 @@ def horizontal?(row, col)
   end
 
   def vertical_word(row, col)
-    first = row
-    last = row + word.length - 1
-
-    return "" unless in_bounds?(first, last)
-
-    str = ""
-
-    data.each_index do |r|
-      data[r].each_index do |c|
-        str << data[r][c] if col == c && r.between?(first, last)
-      end
-    end
-
-    str
+    (row..row+word.length-1).map do |pos|
+      letter_at(pos, col)
+    end * ''
   end
 
   def vertical?(row, col)
     match?(vertical_word(row, col))
   end
 
   def diagonal_top_left_word(row, col)
-    str = ""
-
-    (0..word.length - 1).each do |pos|
-      new_row = row - pos
-      new_col = col - pos
-
-      return str unless in_bounds?(new_row, new_col)
-
-      str += data[new_row][new_col]
-    end
-
-    str
+    (0..word.length - 1).map do |pos|
+      letter_at(row-pos, col-pos)
+    end * ''
   end
 
   def diagonal_top_right_word(row, col)
-    str = ""
-
-    (0..word.length - 1).each do |pos|
-      new_row = row - pos
-      new_col = col + pos
-
-      return str unless in_bounds?(new_row, new_col)
-
-      str += data[new_row][new_col]
-    end
-
-    str
-  end
-
-  def letter_at(row, col)
-    in_bounds?(row, col) ? data[row][col] : ""
+    (0..word.length - 1).map do |pos|
+      letter_at(row-pos, col+pos)
+    end * ""
   end
 
   def diagonal_bottom_right_word(row, col)
-    str = ""
-
-    (0..word.length - 1).each do |pos|
-      new_row = row + pos
-      new_col = col + pos
-
-      return str unless in_bounds?(new_row, new_col)
-
-      str += data[new_row][new_col]
-    end
-
-    str
+    (0..word.length - 1).map do |pos|
+      letter_at(row+pos, col+pos)
+    end * ''
   end
 
   def diagonal_bottom_left_word(row, col)
-    str = ""
-
-    (0..word.length - 1).each do |pos|
-      new_row = row + pos
-      new_col = col - pos
-
-      return str unless in_bounds?(new_row, new_col)
-
-      str += data[new_row][new_col]
-    end
-
-    str
+    (0..word.length - 1).map do |pos|
+      letter_at(row+pos, col-pos)
+    end * ''
   end
 
   def match?(str)
@@ -133,70 +86,52 @@ def cross_word_at?(row, col)
   end
 
   def cross_word_count
-    count = 0
-
-    data.each_index do |x|
-      data[x].each_index do |y|
-        count += 1 if cross_word_at?(x, y)
+    data.each_index.sum do |x|
+      data[x].each_index.sum do |y|
+        cross_word_at?(x, y) ? 1 : 0
       end
     end
-
-    count
   end
 
   def word_count
-    count = 0
-
-    data.each_index do |x|
-      data[x].each_index do |y|
-        count += count_at(x, y)
+    data.each_index.sum do |x|
+      data[x].each_index.sum do |y|
+        count_at(x, y)
       end
     end
-
-    count
   end
 
   def vertical_count
-    count = 0
-    data.each_index do |x|
-      data[x].each_index do |y|
-        count += 1 if vertical?(x, y)
+    data.each_index.sum do |x|
+      data[x].each_index.sum do |y|
+        vertical?(x, y) ? 1 : 0
       end
     end
-
-    count
   end
 
   def horizonal_count
-    count = 0
-    data.each_index do |x|
-      data[x].each_index do |y|
-        count += 1 if horizontal?(x, y)
+    data.each_index.sum do |x|
+      data[x].each_index.sum do |y|
+        horizontal?(x, y) ? 1 : 0
       end
     end
-
-    count
   end
 
   def diagonal_count_at(row, col)
-    count = 0
-    count += 1 if diagonal_top_right_word(row, col) == word
-    count += 1 if diagonal_top_left_word(row, col) == word
-    count += 1 if diagonal_bottom_right_word(row, col) == word
-    count += 1 if diagonal_bottom_left_word(row, col) == word
-    count
+    [
+      diagonal_top_right_word(row, col),
+      diagonal_top_left_word(row, col),
+      diagonal_bottom_right_word(row, col),
+      diagonal_bottom_left_word(row, col),
+    ].sum { |str| str == word ? 1 : 0}
   end
 
   def diagonal_count
-    count = 0
-
-    data.each_index do |x|
-      data[x].each_index do |y|
-        count += diagonal_count_at(x, y)
+    data.each_index.sum do |x|
+      data[x].each_index.sum do |y|
+        diagonal_count_at(x, y)
       end
     end
-
-    count
   end
 
   def log_match(prefix, row, col, check)