day15 part1

Author: spaenleh

Package.swift

@@ -5,15 +5,18 @@ let dependencies: [Target.Dependency] = [
     .product(name: "Algorithms", package: "swift-algorithms"),
     .product(name: "Collections", package: "swift-collections"),
     .product(name: "ArgumentParser", package: "swift-argument-parser"),
+    .product(name: "MLX", package: "mlx-swift"),
+    .product(name: "MLXFFT", package: "mlx-swift"),
 ]
 
 let package = Package(
     name: "aoc",
-    platforms: [.macOS(.v13)],
+    platforms: [.macOS(.v14)],
     dependencies: [
         .package(
             url: "https://github.com/apple/swift-algorithms.git",
             .upToNextMajor(from: "1.2.0")),
+        .package(url: "https://github.com/ml-explore/mlx-swift.git", from: "0.21.2"),
         .package(
             url: "https://github.com/apple/swift-collections.git",
             .upToNextMajor(from: "1.0.0")),

README.md

@@ -21,8 +21,8 @@ Below is my current advancement in Advent of code:
 | Day 11 | :star: (28min) | :star: (1min) |
 | Day 12 | :star: | :star: |
 | Day 13 | :star: | :star: (5min) |
-| Day 14 |  |  |
-| Day 15 |  |  |
+| Day 14 | :star: | :star: |
+| Day 15 | :star: (1h04) |  |
 | Day 16 |  |  |
 | Day 17 |  |  |
 | Day 18 |  |  |

Sources/AdventOfCode.swift

@@ -15,6 +15,8 @@ let allChallenges: [any AdventDay] = [
   Day11(),
   Day12(),
   Day13(),
+  Day14(),
+  Day15(),
 ]
 
 @main

Sources/Day06.swift

@@ -5,7 +5,10 @@ enum Direction: Int {
   case East, South, West
 
   func heading() -> Coord {
-    Coord.cross[rawValue]
+    if Coord.cross.indices.contains(rawValue) {
+      return Coord.cross[rawValue]
+    }
+    fatalError()
   }
 
   static func fromHeading(coord: Coord) -> Self {
@@ -18,7 +21,7 @@ enum Direction: Int {
 
 }
 
-struct Guard {
+struct Guard: Hashable {
   var pos: Coord
   var direction: Direction
 
@@ -61,29 +64,28 @@ struct Day06: AdventDay {
     return (locations, steps, obstacles)
   }
 
-  func doesComeBack(step: Coord) -> Bool {
-    var officer = Guard(pos: grid.firstCoord(of: "^")!, direction: .North)
-    var locations: [Coord] = [Coord]()
-    while grid.includes(coord: officer.pos) {
-      locations.append(officer.pos)
+  func doesComeBack(step: Coord, path: [Coord].SubSequence, grid newGrid: Grid<Character>) -> Bool {
+    guard let officerPos = newGrid.firstCoord(of: "^") else {
+      return false
+    }
+    var officer = Guard(pos: officerPos, direction: .North)
+    var locations: [Guard] = [Guard]()
+    while newGrid.includes(coord: officer.pos) {
+      // check if we are going over our steps
+      if locations.contains(officer) {
+        return true
+      }
+      locations.append(officer)
 
       // move the guard
       let nextPos = officer.pos + officer.direction.heading()
-      // behave like there is a real obstacle
-      if nextPos == step {
-        officer.direction = officer.direction.makeTurn()
-      } else {
-        if !grid.includes(coord: nextPos) {
-          return false
-        }
-        if grid[nextPos] == "#" {
-          // guard is blocked
-          officer.direction = officer.direction.makeTurn()
-        }
+
+      if !newGrid.includes(coord: nextPos) {
+        return false
       }
-      // check if we are going over our steps
-      if locations.contains([officer.pos, nextPos]) {
-        return true
+      if let nextChar = newGrid[nextPos], nextChar == "#" {
+        // guard is blocked
+        officer.direction = officer.direction.makeTurn()
       }
       // move officer one step
       officer.pos = officer.pos + officer.direction.heading()
@@ -125,35 +127,25 @@ struct Day06: AdventDay {
   }
 
   func part2() -> Int {
+
+    let (_, steps, _) = guardPatrol()
     var count = 0
-    let (_, steps, obstacles) = guardPatrol()
-
-    var newObstacles: [Coord] = [Coord]()
-    for (offset, candidates) in obstacles.windows(ofCount: 4).enumerated() {
-      var c = Array(candidates)
-      let wrappedOffset = offset % 4
-      if let coord = isAValidLoop(wrappedOffset: wrappedOffset, c: c) {
-        count += 1
-        newObstacles.append(coord)
-      }
-      if offset > 4 {
-
-        // TODO: this is not right
-        for (_, elem) in obstacles[0...offset].enumerated() {
-          let wrappedOffset = offset % 4
-          c[3] = elem
-          if let coord = isAValidLoop(wrappedOffset: wrappedOffset, c: c) {
-            if steps.contains(coord) {
-              count += 1
-              newObstacles.append(coord)
-            }
-          }
+    let newSteps = steps.dropFirst()
+    for (stepIdx, step) in newSteps.enumerated() {
+      var newGrid = grid
+      if newGrid.includes(coord: step) {
+        newGrid.raw[step.y][step.x] = "#"
+        if doesComeBack(step: step, path: newSteps[0..<stepIdx], grid: newGrid) {
+          count += 1
+          print("found a loop at", step)
         }
-
       }
     }
-
+    // 125 -> too low
+    // 200 -> too low
     // 115 -> too low
+    // 1713 -> not the right answer
+
     return count
   }
 }

Sources/Day14.swift

@@ -0,0 +1,131 @@
+import Algorithms
+import Foundation
+
+func getDocumentsDirectory() -> URL {
+  let paths = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)
+  return paths[0]
+}
+
+struct Robot: CustomStringConvertible {
+  var description: String {
+    "p=\(pos) v=\(velocity)"
+  }
+
+  var pos: Coord
+  var velocity: Coord
+
+  func after(n: Int = 100, width: Int = 101, height: Int = 103) -> Self {
+    var newPos = self.pos + (self.velocity * n)
+    newPos.x %= width
+    newPos.y %= height
+    if newPos.x < 0 {
+      newPos.x += width
+    }
+    if newPos.y < 0 {
+      newPos.y += height
+    }
+    return Self(pos: newPos, velocity: self.velocity)
+  }
+}
+extension Robot {
+  init(_ values: [Coord]) {
+    pos = values[0]
+    velocity = values[1]
+  }
+}
+
+struct Picture {
+  var width: Int
+  var height: Int
+
+  func toGrid(robots: [Robot]) -> Grid<Bool> {
+    var grid = Grid<Bool>(
+      raw: [[Bool]](repeating: [Bool](repeating: false, count: width), count: height))
+    let robotPos = robots.reduce(into: [Coord: Bool]()) { partialResult, r in
+      partialResult[r.pos] = true
+    }
+    for (pos, _) in robotPos {
+      grid.raw[pos.y][pos.x] = true
+    }
+    return grid
+  }
+
+  func save(for robots: [Robot], at: Int) {
+
+    let imageData = toGrid(robots: robots).toImage()
+    let filename = getDocumentsDirectory().appendingPathComponent("aoc/\(at).pbm")
+
+    do {
+      try imageData.write(to: filename, atomically: true, encoding: String.Encoding.utf8)
+    } catch {
+      print("could not write")
+      // failed to write file – bad permissions, bad filename, missing permissions, or more likely it can't be converted to the encoding
+    }
+  }
+}
+
+struct Day14: AdventDay {
+  var robots: [Robot] = [Robot]()
+  init(data: String) {
+    robots = data.lines().map { l in
+      Robot(
+        l.replacing(/(p=)|(v=)/, with: "").split(separator: " ").map {
+          Coord.init(rawValue: String($0))!
+        })
+    }
+  }
+
+  func part1() -> Int {
+    let width = 101
+    let height = 103
+    // let width = 11
+    // let height = 7
+    let middleX = width / 2
+    let middleY = height / 2
+    let nRobots = robots.map { r in
+      r.after(n: 100, width: width, height: height)
+    }
+    let quad1 = nRobots.filter {
+      $0.pos.x >= 0 && $0.pos.x < middleX && $0.pos.y >= 0 && $0.pos.y < middleY
+    }
+    let quad2 = nRobots.filter {
+      $0.pos.x > middleX && $0.pos.y >= 0 && $0.pos.y < middleY
+    }
+    let quad3 = nRobots.filter {
+      $0.pos.x >= 0 && $0.pos.x < middleX && $0.pos.y > middleY
+    }
+    let quad4 = nRobots.filter {
+      $0.pos.x > middleX && $0.pos.y > middleY
+    }
+    let quads = [quad1.count, quad2.count, quad3.count, quad4.count]
+    return quads.reduce(1, *)
+  }
+
+  func part2_naive() -> Int {
+    let picture = Picture(width: 101, height: 103)
+    let nFrames = 8000
+    for iter in 7000..<nFrames {
+      let nRobots = robots.map { r in
+        r.after(n: iter, width: picture.width, height: picture.height)
+      }
+      picture.save(for: nRobots, at: iter)
+      if iter % 1000 == 0 {
+        print(iter)
+      }
+    }
+    return 0
+  }
+
+  func part2() -> Int {
+    let width = 101
+    let height = 103
+    let picture = Picture(width: width, height: height)
+    for iter in 0..<(width * height) {
+      let nRobots = robots.map { r in
+        r.after(n: iter, width: width, height: height)
+      }
+      picture.save(for: nRobots, at: iter)
+    }
+    return 0
+  }
+}