Day 6: Store only northward turns

hs/src/Day22.hs

@@ -1,6 +1,7 @@
 {-# LANGUAGE MagicHash #-}
 {-# LANGUAGE PartialTypeSignatures #-}
 {-# LANGUAGE UnboxedTuples #-}
+{-# OPTIONS_GHC -Wno-partial-type-signatures #-}
 
 -- |
 -- Module:         Day22

hs/src/Day6.hs

@@ -10,7 +10,7 @@ import Data.List.NonEmpty (NonEmpty ((:|)))
 import Data.Maybe (catMaybes, isJust)
 import Data.Semigroup (Max (Max), sconcat)
 import Data.Set (Set)
-import Data.Set qualified as Set (empty, insert, lookupGE, member, notMember, singleton)
+import Data.Set qualified as Set (empty, insert, member, singleton)
 import Data.Text (Text)
 import Data.Text qualified as T (lines, unpack)
 
@@ -52,14 +52,11 @@ part1 input = length $ nubOrd $ map fst $ start >>= visited maxes blocks
 
 part2 :: Text -> Int
 part2 input =
-  length . filter id . parMap rseq isLoop $
-    start >>= (zip `ap` scanl (flip Set.insert) Set.empty) . visited maxes blocks
+  length $ filter id $ start >>= (parMap rseq . isLoop) `ap` (nubOrd . map fst . visited maxes blocks)
   where
     (maxes, blocks, start) = parse input
-    isLoop (start'@((y, x), (dy, dx)), seen) =
-      pos' `Set.notMember` blocks
-        && Just pos' /= (fst <$> Set.lookupGE (pos', minBound) seen)
-        && or (zipWith Set.member `ap` scanl (flip Set.insert) seen $ visited maxes blocks' start')
-      where
-        pos' = (y + dy, x + dx)
-        blocks' = Set.insert pos' blocks
+    isLoop start' block = isLoop' 0 Set.empty $ visited maxes (Set.insert block blocks) start'
+    isLoop' _ _ [] = False
+    isLoop' (-1) seen ((_, (dy, _)) : rest) = isLoop' dy seen rest
+    isLoop' _ seen ((pos, (-1, _)) : rest) = pos `Set.member` seen || isLoop' (-1) (Set.insert pos seen) rest
+    isLoop' _ seen ((_, (dy, _)) : rest) = isLoop' dy seen rest

kt/aoc2024-lib/src/commonMain/kotlin/com/github/ephemient/aoc2024/Day6.kt

@@ -24,7 +24,13 @@ class Day6(input: String) {
     suspend fun part2() = initialWalk.asFlow().drop(1).flatMapMerge { (y, x) ->
         val lines = lines.toMutableList()
         lines[y] = StringBuilder(lines[y]).apply { set(x, '#') }.toString()
-        flowOf(Unit).filter { !lines.walk(initialPosition).all(mutableSetOf<Any?>()::add) }
+        flowOf(Unit).filter {
+            var last = 0
+            val visited = mutableSetOf<IntPair>()
+            !lines.walk(initialPosition).all { (pos, dir) ->
+                (last == -1 || dir.first != -1 || visited.add(pos)).also { last = dir.first }
+            }
+        }
     }.count()
 
     companion object {

py/aoc2024/day6.py

@@ -81,11 +81,13 @@ def _part2(
     max_bounds: tuple[int, int],
     obstructions: Iterable[tuple[int, int]],
 ) -> bool:
-    visited = set()
-    for key in _visit(initial_pos, max_bounds, obstructions):
-        if key in visited:
-            return True
-        visited.add(key)
+    last_dy, visited = None, set()
+    for pos, (dy, _) in _visit(initial_pos, max_bounds, obstructions):
+        if last_dy != -1 and dy == -1:
+            if pos in visited:
+                return True
+            visited.add(pos)
+        last_dy = dy
     return False
 
 

rs/src/day6.rs

@@ -108,9 +108,13 @@ pub fn part2(data: &str) -> Option<usize> {
             .filter(|candidate| {
                 let mut data = data.clone();
                 assert!(data.obstacles.insert(*candidate));
+                let mut last_dy = 0;
                 let mut visited = BTreeSet::new();
-                let ok = data.iter().any(|state| !visited.insert(state));
-                ok
+                !data.iter().all(|(pos, (dy, _))| {
+                    let ok = last_dy == -1 || dy != -1 || visited.insert(pos);
+                    last_dy = dy;
+                    ok
+                })
             })
             .count(),
     )