Day 5: part 1

Author: horothesun

src/main/scala/Day05.scala

@@ -0,0 +1,55 @@
+import cats.Eq
+import cats.data.NonEmptyList
+import cats.derived.*
+import cats.syntax.all.*
+
+object Day05:
+
+  case class Page(n: Int)
+
+  object Page:
+    def parse(s: String): Option[Page] = s.toIntOption.map(Page.apply)
+
+  case class OrderRule(before: Page, after: Page) derives Eq:
+    def reverse: OrderRule = OrderRule(before = after, after = before)
+
+  object OrderRule:
+    def parse(s: String): Option[OrderRule] = s.split('|') match {
+      case Array(before, after) => (Page.parse(before), Page.parse(after)).mapN(OrderRule.apply)
+      case _                    => None
+    }
+
+  case class Update(pages: NonEmptyList[Page]):
+
+    def allOrderRules: List[OrderRule] = pages.toList.zip(pages.tail).map(OrderRule.apply)
+
+    def middlePage: Page =
+      val midIndex = pages.length / 2
+      pages.get(if pages.length % 2 == 0 then midIndex - 1 else midIndex).get
+
+    def firstViolatedOrderRules(rules: NonEmptyList[OrderRule]): Option[OrderRule] =
+      allOrderRules.map(_.reverse).find(rules.contains_)
+
+  object Update:
+    def parse(s: String): Option[Update] = s.split(',').toList.toNel.flatMap(_.traverse(Page.parse).map(Update.apply))
+
+  extension [A](as: List[A])
+    def splitBySeparator(sep: A): List[List[A]] =
+      as.reverse.foldLeft(List(List.empty[A]))((l, a) => if a == sep then List.empty :: l else (a :: l.head) :: l.tail)
+
+  case class Input(rules: NonEmptyList[OrderRule], updates: NonEmptyList[Update]):
+    def correctlyOrderedUpdatesMiddlePageSum: Int =
+      updates
+        .collect(u => u.firstViolatedOrderRules(rules) match { case None => u })
+        .foldMap(_.middlePage.n)
+
+  object Input:
+    def parse(rows: List[String]): Option[Input] =
+      rows.splitBySeparator("") match {
+        case rules :: updates :: Nil =>
+          (
+            rules.toNel.flatMap(rulesNel => rulesNel.traverse(OrderRule.parse)),
+            updates.toNel.flatMap(_.traverse(Update.parse))
+          ).mapN(Input.apply)
+        case _ => None
+      }

src/test/scala/Day05Suite.scala

@@ -0,0 +1,140 @@
+import Day05.*
+import Day05Suite.*
+import cats.data.NonEmptyList
+import cats.syntax.all.*
+import munit.ScalaCheckSuite
+
+class Day05Suite extends ScalaCheckSuite:
+
+  test("big input parsed to something"):
+    assert(Input.parse(bigInput).isDefined)
+
+  test("small input parsed to something"):
+    assert(Input.parse(smallInput).isDefined)
+
+  test("List splitBySeparator example"):
+    assertEquals(
+      List(1, 2, 3, 100, 4, 5, 100, 6).splitBySeparator(100),
+      List(List(1, 2, 3), List(4, 5), List(6))
+    )
+
+  test("all order rules from update example"):
+    assertEquals(
+      Update(pages = NonEmptyList.of(1, 2, 3, 4).map(Page.apply)).allOrderRules,
+      List(
+        OrderRule(before = Page(1), after = Page(2)),
+        OrderRule(before = Page(2), after = Page(3)),
+        OrderRule(before = Page(3), after = Page(4))
+      )
+    )
+
+  test("middle page from update with even # of pages example"):
+    assertEquals(
+      Update(pages = NonEmptyList.of(1, 2, 3, 4).map(Page.apply)).middlePage,
+      Page(2)
+    )
+
+  test("middle page from update with odd # of pages example"):
+    assertEquals(
+      Update(pages = NonEmptyList.of(1, 2, 3, 4, 5).map(Page.apply)).middlePage,
+      Page(3)
+    )
+
+  test("middle page from update with only one page example"):
+    assertEquals(
+      Update(pages = NonEmptyList.of(1).map(Page.apply)).middlePage,
+      Page(1)
+    )
+
+  test("first violated order rule for small input's first update is None"):
+    assertEquals(
+      Input.parse(smallInput).flatMap(input => input.updates.head.firstViolatedOrderRules(input.rules)),
+      None
+    )
+
+  test("first violated order rule for small input's second update is None"):
+    assertEquals(
+      Input
+        .parse(smallInput)
+        .flatMap(input => input.updates.toNev.get(1).flatMap(_.firstViolatedOrderRules(input.rules))),
+      None
+    )
+
+  test("first violated order rule for small input's third update is None"):
+    assertEquals(
+      Input
+        .parse(smallInput)
+        .flatMap(input => input.updates.toNev.get(2).flatMap(_.firstViolatedOrderRules(input.rules))),
+      None
+    )
+
+  test("first violated order rule for small input's fourth update is 97|75"):
+    assertEquals(
+      Input
+        .parse(smallInput)
+        .flatMap(input => input.updates.toNev.get(3).flatMap(_.firstViolatedOrderRules(input.rules))),
+      OrderRule(before = Page(97), after = Page(75)).some
+    )
+
+  test("first violated order rule for small input's fifth update is 29|13"):
+    assertEquals(
+      Input
+        .parse(smallInput)
+        .flatMap(input => input.updates.toNev.get(4).flatMap(_.firstViolatedOrderRules(input.rules))),
+      OrderRule(before = Page(29), after = Page(13)).some
+    )
+
+  test("first violated order rule for small input's sixth update is 75|13"):
+    assertEquals(
+      Input
+        .parse(smallInput)
+        .flatMap(input => input.updates.toNev.get(5).flatMap(_.firstViolatedOrderRules(input.rules))),
+      OrderRule(before = Page(75), after = Page(13)).some
+    )
+
+  test("small input correctly ordered updates middle page sum is 143"):
+    assertEquals(
+      Input.parse(smallInput).map(_.correctlyOrderedUpdatesMiddlePageSum),
+      143.some
+    )
+
+  test("big input correctly ordered updates middle page sum is 5_064"):
+    assertEquals(
+      Input.parse(bigInput).map(_.correctlyOrderedUpdatesMiddlePageSum),
+      5_064.some
+    )
+
+object Day05Suite:
+
+  val bigInput: List[String] = getLinesFromFile("src/test/scala/day05_input.txt")
+
+  val smallInput: List[String] = List(
+    "47|53",
+    "97|13",
+    "97|61",
+    "97|47",
+    "75|29",
+    "61|13",
+    "75|53",
+    "29|13",
+    "97|29",
+    "53|29",
+    "61|53",
+    "97|53",
+    "61|29",
+    "47|13",
+    "75|47",
+    "97|75",
+    "47|61",
+    "75|61",
+    "47|29",
+    "75|13",
+    "53|13",
+    "",
+    "75,47,61,53,29",
+    "97,61,53,29,13",
+    "75,29,13",
+    "75,97,47,61,53",
+    "61,13,29",
+    "97,13,75,29,47"
+  )