Day 4: part 1

Author: horothesun

src/main/scala/Day04.scala

@@ -1,11 +1,13 @@
+import Day04.Grid.*
 import cats.data.Store
 import cats.syntax.all.*
 
 object Day04:
 
   case class Word(s: String):
     val length: Int = s.length
-    val toOptionChars: List[Option[Char]] = s.toList.map(Some.apply)
+    val toOptionalChars: List[Option[Char]] = s.toList.map(_.some)
+    def reverse: Word = Word(s.reverse)
 
   case class Pos(row: Int, col: Int)
 
@@ -21,28 +23,58 @@ object Day04:
 
     val toVectors: Vector[Vector[Char]] = rows.map(_.toVector).toVector
 
-    def toStore: StoreGrid = Store(
+    val toStore: StoreGrid = Store(
       p => toVectors.get(p.row).flatMap(_.get(p.col)),
       s = Pos.zero
     )
 
-    def allPositions: List[Pos] =
+    val allPositions: List[Pos] =
       rows.zipWithIndex.flatMap((row, rowIndex) => row.zipWithIndex.map((_, colIndex) => Pos(rowIndex, colIndex)))
 
+    def allWordChecks(w: Word): List[WordCheckResult] =
+      toStore
+        .coflatMap(s =>
+          List(
+            horizontalPositions,
+            verticalPositions,
+            ascDiagonalPositions,
+            descDiagonalPositions
+          ).map(wordCheck(_)(w, s))
+        )
+        .experiment(_ => allPositions)
+        .flatten
+
+    def allOccurrences(s: String): Int =
+      val w = Word(s)
+      (allWordChecks(w) ++ allWordChecks(w.reverse)).foldMap {
+        case WordCheckResult.Found    => 1
+        case WordCheckResult.NotFound => 0
+      }
+
   object Grid:
 
     def parse(rows: List[String]): Option[Grid] = Grid(rows = rows.map(_.toList)).some
 
+    def wordCheck(positions: Word => Pos => List[Pos])(w: Word, store: StoreGrid): WordCheckResult =
+      if w.toOptionalChars == store.experiment(positions(w)) then WordCheckResult.Found else WordCheckResult.NotFound
+
     /*
       XMAS
       ....
       ....
       ....
      */
-    def topLeftPositions(w: Word)(from: Pos): List[Pos] =
+    def horizontalPositions(w: Word)(from: Pos): List[Pos] =
       List.range(start = from.col, end = from.col + w.length).map(col => Pos(from.row, col))
 
-    def wordCheckTopLeft(w: Word, store: StoreGrid): WordCheckResult = wordCheck(topLeftPositions, w, store)
+    /*
+      X...
+      M...
+      A...
+      S...
+     */
+    def verticalPositions(w: Word)(from: Pos): List[Pos] =
+      List.range(start = from.row, end = from.row + w.length).map(row => Pos(row, from.col))
 
     /*
       ...S
@@ -53,8 +85,6 @@ object Day04:
     def ascDiagonalPositions(w: Word)(from: Pos): List[Pos] =
       List.range(start = 0, end = w.length).reverse.map(i => Pos(row = i + from.row, col = w.length - i - 1 + from.col))
 
-    def wordCheckAscDiagonal(w: Word, store: StoreGrid): WordCheckResult = wordCheck(ascDiagonalPositions, w, store)
-
     /*
       X...
       .M..
@@ -63,8 +93,3 @@ object Day04:
      */
     def descDiagonalPositions(w: Word)(from: Pos): List[Pos] =
       List.range(start = 0, end = w.length).map(i => Pos(row = i + from.row, col = i + from.col))
-
-    def wordCheckDescDiagonal(w: Word, store: StoreGrid): WordCheckResult = wordCheck(descDiagonalPositions, w, store)
-
-    def wordCheck(positions: Word => Pos => List[Pos], w: Word, store: StoreGrid): WordCheckResult =
-      if w.toOptionChars == store.experiment(positions(w)) then WordCheckResult.Found else WordCheckResult.NotFound

src/test/scala/Day04Suite.scala

@@ -34,7 +34,7 @@ class Day04Suite extends ScalaCheckSuite:
 
   test("topLeftPositions example"):
     assertEquals(
-      Grid.topLeftPositions(Word("XYZ"))(from = Pos(row = 2, col = 4)),
+      Grid.horizontalPositions(Word("XYZ"))(from = Pos(row = 2, col = 4)),
       List(
         Pos(row = 2, col = 4),
         Pos(row = 2, col = 5),
@@ -62,6 +62,24 @@ class Day04Suite extends ScalaCheckSuite:
       )
     )
 
+  test("small input contains 18 occurrences of \"XMAS\""):
+    val smallInput = List(
+      "MMMSXXMASM",
+      "MSAMXMSMSA",
+      "AMXSXMAAMM",
+      "MSAMASMSMX",
+      "XMASAMXAMM",
+      "XXAMMXXAMA",
+      "SMSMSASXSS",
+      "SAXAMASAAA",
+      "MAMMMXMMMM",
+      "MXMXAXMASX"
+    )
+    assertEquals(Grid.parse(smallInput).map(_.allOccurrences("XMAS")), 18.some)
+
+  test("big input contains 2_578 occurrences of \"XMAS\""):
+    assertEquals(Grid.parse(bigInput).map(_.allOccurrences("XMAS")), 2_578.some)
+
 object Day04Suite:
 
   val bigInput: List[String] = getLinesFromFile("src/test/scala/day04_input.txt")