We only need to track orientation

Ref: https://www.reddit.com/r/adventofcode/comments/18k9ne5/comment/kdqeywd

Author: mnvr

17.hs

@@ -15,30 +15,30 @@ parse s = Grid { items = M.fromList xs, lastNode = fst (last xs) }
 enum :: [a] -> [(Int, a)]
 enum = zip [0..]
 
-data Direction = L | R | U | D deriving (Eq, Ord)
+data Direction = H | V deriving (Eq, Ord)
 data Cell = Cell { node :: Node, direction :: Direction } deriving  (Eq, Ord)
 data Neighbour = Neighbour { cell :: Cell, distance :: Int }
 
 neighbours :: Grid Int -> [Int] -> Cell -> [Neighbour]
 neighbours Grid { items } range = concat . adjacent
   where
-    adjacent Cell { node = (x, y), direction = d }
-      | d `elem` [L, R] = [cells (\m -> Cell (x, y - m) U),
-                           cells (\m -> Cell (x, y + m) D)]
-      | otherwise = [cells (\m -> Cell (x - m, y) R),
-                     cells (\m -> Cell (x + m, y) L)]
+    adjacent Cell { node = (x, y), direction } = case direction of
+      H -> [cells (\m -> Cell (x, y - m) V), cells (\m -> Cell (x, y + m) V)]
+      V -> [cells (\m -> Cell (x - m, y) H), cells (\m -> Cell (x + m, y) H)]
     cells mkCell = snd $ foldl (mkNeighbour mkCell) (0, []) [1..maximum range]
-    mkNeighbour mkCell (d, xs) m = let cell = mkCell m in case M.lookup (node cell) items of
-      Just d2 -> (d + d2, if m `elem` range then Neighbour cell (d + d2) : xs else xs)
-      _ -> (d, xs)
+    mkNeighbour mkCell (d, xs) m =
+      let c = mkCell m in case M.lookup (node c) items of
+        Just d2 -> let dc = d + d2
+                   in (dc, if m `elem` range then Neighbour c dc : xs else xs)
+        _ -> (d, xs)
 
 shortestPath :: [Int] -> Grid Int -> Int
 shortestPath moveRange grid@Grid { lastNode } = go startDist S.empty startQ
   where
-    -- Start in both directions so that we never have to go straight and can
-    -- just always turn. This way, we don't even need to track moves.
-    startCells = [Cell { node = (0, 0), direction = L },
-                  Cell { node = (0, 0), direction = D }]
+    -- Start on both axes so that we never have to go straight and can just
+    -- always turn. This way, we don't even need to track moves.
+    startCells = [Cell { node = (0, 0), direction = H },
+                  Cell { node = (0, 0), direction = V }]
     startDist = M.fromList $ zip startCells [0, 0]
     startQ = S.fromList $ zip [0, 0] startCells
     isEnd Cell { node } = node == lastNode

17.swift

@@ -22,7 +22,7 @@ func readInput() -> Grid {
 }
 
 enum Direction {
-    case l, r, u, d
+    case h, v
 }
 
 struct Cell: Hashable {
@@ -32,20 +32,20 @@ struct Cell: Hashable {
 
 func shortestPath(grid: Grid, moveRange: ClosedRange<Int>) -> Int {
     let startNode = Node(x: 0, y: 0)
-    // Create two starting cells, one for each axis of movement, so that when
-    // considering neighbours, we never need to go straight, we can always turn.
-    let startL = Cell(node: startNode, direction: .l)
-    let startD = Cell(node: startNode, direction: .d)
+    // Create two starting cells, one for each axis of movement, so that we only
+    // need to turn.
+    let startH = Cell(node: startNode, direction: .h)
+    let startV = Cell(node: startNode, direction: .v)
     func isEnd(_ cell: Cell) -> Bool { cell.node == grid.lastNode }
 
     func adj(_ u: Cell) -> some Sequence<Neighbour> {
         neighbours(grid: grid, moveRange: moveRange, cell: u)
     }
 
-    var dist: [Cell: Int] = [startL: 0, startD: 0]
+    var dist: [Cell: Int] = [startH: 0, startV: 0]
     var seen: Set<Cell> = Set()
     // Use the inverse of the distance map to simulate a priority queue.
-    var inverseDistance = [0: Set([startL, startD])]
+    var inverseDistance = [0: Set([startH, startV])]
 
     func popNearest() -> (Cell, Int)? {
         while let d = inverseDistance.keys.min() {
@@ -94,12 +94,12 @@ func neighbours(
 
     let (x, y) = (cell.node.x, cell.node.y)
     switch cell.direction {
-    case .l, .r:
-        return [seq({ make((x, y - $0), .u) }),
-                seq({ make((x, y + $0), .d) })].joined()
-    default:
-        return [seq({ make((x - $0, y), .r) }),
-                seq({ make((x + $0, y), .l) })].joined()
+    case .h:
+        return [seq({ make((x, y - $0), .v) }),
+                seq({ make((x, y + $0), .v) })].joined()
+    case .v:
+        return [seq({ make((x - $0, y), .h) }),
+                seq({ make((x + $0, y), .h) })].joined()
     }
 }