Day 4: part 2

Author: horothesun

src/main/scala/Day04.scala

@@ -19,77 +19,92 @@ object Day04:
   enum WordCheckResult:
     case Found, NotFound
 
+    def toInt: Int = this match {
+      case Found    => 1
+      case NotFound => 0
+    }
+    def toBoolean: Boolean = this match {
+      case Found    => true
+      case NotFound => false
+    }
+
+  object WordCheckResult:
+    def from(b: Boolean): WordCheckResult = if b then Found else NotFound
+
   case class Grid(rows: List[List[Char]]):
 
     val toVectors: Vector[Vector[Char]] = rows.map(_.toVector).toVector
 
-    val toStore: StoreGrid = Store(
-      p => toVectors.get(p.row).flatMap(_.get(p.col)),
-      s = Pos.zero
-    )
+    val toStore: StoreGrid = Store(p => toVectors.get(p.row).flatMap(_.get(p.col)), s = Pos.zero)
 
     val allPositions: List[Pos] =
       rows.zipWithIndex.flatMap((row, rowIndex) => row.zipWithIndex.map((_, colIndex) => Pos(rowIndex, colIndex)))
 
+    def allOccurrences(s: String): Int =
+      val w = Word(s)
+      (allWordChecks(w) ++ allWordChecks(w.reverse)).foldMap(_.toInt)
+
     def allWordChecks(w: Word): List[WordCheckResult] =
       toStore
-        .coflatMap(s =>
-          List(
-            horizontalPositions,
-            verticalPositions,
-            ascDiagonalPositions,
-            descDiagonalPositions
-          ).map(wordCheck(_)(w, s))
-        )
+        .coflatMap(wordChecks(w, _))
         .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
-      }
+    // part 2
+    def allCrossOccurrences(s: String): Int =
+      toStore
+        .coflatMap(crossWordCheck(Word(s), _))
+        .experiment(_ => allPositions)
+        .foldMap(_.toInt)
 
   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 wordChecks(w: Word, store: StoreGrid): List[WordCheckResult] =
+      List(
+        horizontalPositions,
+        verticalPositions,
+        ascDiagonalPositions,
+        descDiagonalPositions
+      ).map(wordCheck(_, w, store))
+
+    def wordCheck(positions: Word => Pos => List[Pos], w: Word, store: StoreGrid): WordCheckResult =
+      WordCheckResult.from(w.toOptionalChars == store.experiment(positions(w)))
+
+    /* XMAS
+       ....
+       ....
+       .... */
     def horizontalPositions(w: Word)(from: Pos): List[Pos] =
       List.range(start = from.col, end = from.col + w.length).map(col => Pos(from.row, col))
 
-    /*
-      X...
-      M...
-      A...
-      S...
-     */
+    /* 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
-      ..A.
-      .M..
-      X...
-     */
+    /* ...S
+       ..A.
+       .M..
+       X... */
     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))
 
-    /*
-      X...
-      .M..
-      ..A.
-      ...S
-     */
+    /* X...
+       .M..
+       ..A.
+       ...S */
     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))
+
+    // part 2
+    def crossWordCheck(w: Word, store: StoreGrid): WordCheckResult =
+      def ascDiagonalCheck: Word => Boolean = wordCheck(ascDiagonalPositions, _, store).toBoolean
+      def descDiagonalCheck: Word => Boolean = wordCheck(descDiagonalPositions, _, store).toBoolean
+      WordCheckResult.from(
+        (ascDiagonalCheck(w) || ascDiagonalCheck(w.reverse)) &&
+          (descDiagonalCheck(w) || descDiagonalCheck(w.reverse))
+      )

src/test/scala/Day04Suite.scala

@@ -9,16 +9,31 @@ class Day04Suite extends ScalaCheckSuite:
 
   test("small input parsed correctly"):
     assertEquals(
-      Grid.parse(rows = List("abc", "def")),
-      Grid(rows = List(List('a', 'b', 'c'), List('d', 'e', 'f'))).some
+      Grid.parse(
+        rows = List(
+          "abc",
+          "def"
+        )
+      ),
+      Grid(
+        rows = List(
+          List('a', 'b', 'c'),
+          List('d', 'e', 'f')
+        )
+      ).some
     )
 
   test("big input parsed to something"):
     assert(Grid.parse(rows = bigInput).isDefined)
 
   test("Grid allPositions example"):
     assertEquals(
-      Grid(rows = List(List('a', 'b', 'c'), List('d', 'e', 'f'))).allPositions,
+      Grid(
+        rows = List(
+          List('a', 'b', 'c'),
+          List('d', 'e', 'f')
+        )
+      ).allPositions,
       List(
         Pos(row = 0, col = 0),
         Pos(row = 0, col = 1),
@@ -72,28 +87,37 @@ 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"
-    )
+  test("small input contains 18 \"XMAS\" occurrences"):
     assertEquals(Grid.parse(smallInput).map(_.allOccurrences("XMAS")), 18.some)
 
-  test("big input contains 2_578 occurrences of \"XMAS\""):
+  test("big input contains 2_578 \"XMAS\" occurrences"):
     assertEquals(Grid.parse(bigInput).map(_.allOccurrences("XMAS")), 2_578.some)
 
+  // part 2
+
+  test("small input contains 9 cross-\"MAS\" occurrences"):
+    assertEquals(Grid.parse(smallInput).map(_.allCrossOccurrences("MAS")), 9.some)
+
+  test("big input contains 1_972 cross-\"MAS\" occurrences"):
+    assertEquals(Grid.parse(bigInput).map(_.allCrossOccurrences("MAS")), 1_972.some)
+
 object Day04Suite:
 
   val bigInput: List[String] = getLinesFromFile("src/test/scala/day04_input.txt")
 
+  val smallInput = List(
+    "MMMSXXMASM",
+    "MSAMXMSMSA",
+    "AMXSXMAAMM",
+    "MSAMASMSMX",
+    "XMASAMXAMM",
+    "XXAMMXXAMA",
+    "SMSMSASXSS",
+    "SAXAMASAAA",
+    "MAMMMXMMMM",
+    "MXMXAXMASX"
+  )
+
   val nonEmptyGridGen: Gen[Grid] = Gen.zip(Gen.choose(1, 10), Gen.choose(1, 10)).flatMap { (r, c) =>
     Gen.listOfN(r, Gen.listOfN(c, Gen.alphaUpperChar)).map(Grid.apply)
   }