Add day 13

Common.scala

@@ -24,3 +24,8 @@ extension [T](ss: Seq[T])
       f(head) match
         case None        => tail.findMap(f)
         case v @ Some(_) => v
+
+  def splitBy(cond: T => Boolean): Seq[Seq[T]] =
+    val splitPos = ss.indexWhere(cond)
+    if splitPos == -1 then Seq(ss)
+    else ss.take(splitPos) +: ss.drop(splitPos + 1).splitBy(cond)

Day13.scala

@@ -0,0 +1,54 @@
+package aoc.day13
+
+import aoc._
+
+type Board = List[Seq[Char]]
+
+val boards: Seq[Board] =
+  lines.toSeq
+    .splitBy(_ == "")
+    .map(_.map(_.toSeq).toList)
+
+extension [T](ss: List[T])
+  def splits =
+    def loop(prefix: List[T], cur: List[T]): Seq[(List[T], List[T])] = cur match
+      case head :: next =>
+        (prefix, cur) +: loop(head +: prefix, next)
+      case Nil => Seq((prefix, cur))
+    loop(List.empty, ss)
+
+def reflections(ok: (Board, Board, Int) => Boolean)(board: Board): Seq[Int] =
+  board.toList.splits.zipWithIndex
+    .filter {
+      case ((Nil, _) | (_, Nil), _) => false
+      case ((top, bottom), _) =>
+        val smudges = top.lazyZip(bottom).map(_.lazyZip(_).count(_ != _)).sum
+        ok(top, bottom, smudges)
+    }
+    .map(_._2)
+
+inline def boardReflections(ok: (Board, Board, Int) => Boolean)(board: Board) =
+  val rowReflections = reflections(ok)(board)
+  val colReflections = reflections(ok)(board.transpose)
+  // println(s"$rowReflections $colReflections")
+  (rowReflections.sum * 100L + colReflections.sum)
+
+// part 1
+
+def part1 =
+  val res = boards
+    .map(boardReflections((_, _, s) => s == 0)(_))
+    .sum
+  println(res)
+
+// part 2
+
+def part2 =
+  val res = boards
+    .map(boardReflections((_, _, s) => s == 1)(_))
+    .sum
+  println(res)
+
+@main def Day13(part: Int) = part match
+  case 1 => part1
+  case 2 => part2

Day5.scala

@@ -76,12 +76,6 @@ end Parser
 
 val seeds = Parser.parse(Parser.seeds, lines.next()).get
 
-extension [T](xs: Seq[T])
-  def splitBy(cond: T => Boolean): Seq[Seq[T]] =
-    val splitPos = xs.indexWhere(cond)
-    if splitPos == -1 then Seq(xs)
-    else xs.take(splitPos) +: xs.drop(splitPos + 1).splitBy(cond)
-
 val maps = lines.toSeq.tail /* remove first empty line */
   .splitBy(_ == "")
   .map { case title :: entries =>