day7 done bitch

Author: spaenleh

Sources/AdventOfCode.swift

@@ -8,6 +8,7 @@ let allChallenges: [any AdventDay] = [
   Day04(),
   Day05(),
   Day06(),
+  Day07(),
 ]
 
 @main

Sources/Day06.swift

@@ -141,7 +141,7 @@ struct Day06: AdventDay {
 
   func part2() -> Int {
     var count = 0
-    let obstacles = guardPatrol().obstacles
+    let (_, steps, obstacles) = guardPatrol()
 
     var newObstacles: [Coord] = [Coord]()
     for (offset, candidates) in obstacles.windows(ofCount: 4).enumerated() {
@@ -154,14 +154,16 @@ struct Day06: AdventDay {
       if offset > 4 {
 
         // TODO: this is not right
-        for (idx, elem) in obstacles[0...0].enumerated() {
+        for (idx, elem) in obstacles[0...offset].enumerated() {
           print("trying", idx, elem)
           let wrappedOffset = offset % 4
           c[3] = elem
           if let coord = isAValidLoop(wrappedOffset: wrappedOffset, c: c) {
-            count += 1
-            newObstacles.append(coord)
-            print(c)
+            if steps.contains(coord) {
+              count += 1
+              newObstacles.append(coord)
+              print(c)
+            }
           }
         }
 

Sources/Day07.swift

@@ -0,0 +1,106 @@
+import Algorithms
+
+struct Calibration {
+  var result: Int
+  var values: [Int]
+}
+extension Calibration {
+  init<S: StringProtocol>(from line: S) {
+    let parts = line.split(separator: ":")
+    result = Int(parts[0]) ?? 0
+    values = parts[1].integers()
+  }
+}
+extension Calibration: CustomStringConvertible {
+  var description: String {
+    "\(self.result): \(self.values.map {String($0)}.joined(separator: " "))"
+  }
+}
+
+struct Day07: AdventDay {
+  var calibrations: [Calibration]
+  init(data: String) {
+    calibrations = data.lines().map { Calibration(from: $0) }
+  }
+
+  func isValidCalibration(_ calibration: Calibration) -> Bool {
+    // early return
+    if calibration.values.count == 1 {
+      return calibration.result == calibration.values[0]
+    }
+    // generate all operators permutations using a cartesian product method
+    let allPermutations = product(["+", "*"], repeated: calibration.values.count - 1)
+    for ops in allPermutations {
+      var res = calibration.values[0]
+      let products = zip(ops, calibration.values[1..<calibration.values.count])
+      for (op, value) in products {
+        if op == "+" {
+          res += value
+        }
+        if op == "*" {
+          res *= value
+        }
+      }
+      // print(calibration, "->", res)
+      if res == calibration.result {
+
+        // early from the loop
+        return true
+      }
+    }
+    // none of the permutations allowed to get the expected result
+    return false
+  }
+
+  func part1() -> Int {
+    let possibleCalibrations = calibrations.filter {
+      isValidCalibration($0)
+    }
+
+    return possibleCalibrations.map { $0.result }.sum
+  }
+
+  func isValidCalibration2(_ calibration: Calibration) -> Bool {
+    // early return
+    if calibration.values.count == 1 {
+      return calibration.result == calibration.values[0]
+    }
+    // generate all operators permutations using a cartesian product method
+    let allPermutations = product(["+", "*", "||"], repeated: calibration.values.count - 1)
+    for ops in allPermutations {
+      var res = calibration.values[0]
+      let products = zip(ops, calibration.values[1..<calibration.values.count])
+      for (op, value) in products {
+        if op == "+" {
+          res += value
+        }
+        if op == "*" {
+          res *= value
+        }
+        if op == "||" {
+          res = Int(String(res) + String(value)) ?? 0
+        }
+      }
+      // print(calibration, "->", res)
+      if res == calibration.result {
+
+        // early from the loop
+        return true
+      }
+    }
+    // none of the permutations allowed to get the expected result
+    return false
+  }
+
+  func part2() -> Int {
+    let possibleCalibrations = calibrations.filter { calibration in
+      if isValidCalibration(calibration) {
+        return true
+      } else {
+        return isValidCalibration2(calibration)
+      }
+    }
+
+    return possibleCalibrations.map { $0.result }.sum
+  }
+}

Sources/Helpers/CartesianProduct.swift

@@ -0,0 +1,57 @@
+/// An iterator-sequence for the Cartesian product of multiple sequences of the same type.
+/// See `product(_:)`.
+public struct CartesianProduct<S: Sequence>: IteratorProtocol, Sequence {
+
+  private let sequences: [S]
+  private var iterators: [S.Iterator]
+  private var currentValues: [S.Iterator.Element] = []
+
+  fileprivate init(_ sequences: [S]) {
+    self.sequences = sequences
+    self.iterators = sequences.map { $0.makeIterator() }
+  }
+
+  public mutating func next() -> [S.Iterator.Element]? {
+    guard !currentValues.isEmpty else {
+      var firstValues: [S.Iterator.Element] = []
+      for index in iterators.indices {
+        guard let value = iterators[index].next() else {
+          return nil
+        }
+        firstValues.append(value)
+      }
+      currentValues = firstValues
+      return firstValues
+    }
+
+    for index in currentValues.indices.reversed() {
+      if let value = iterators[index].next() {
+        currentValues[index] = value
+        return currentValues
+      }
+
+      guard index != 0 else {
+        return nil
+      }
+
+      iterators[index] = sequences[index].makeIterator()
+      currentValues[index] = iterators[index].next()!
+    }
+
+    return currentValues
+  }
+}
+
+/// Returns an iterator-sequence for the Cartesian product of the sequence repeated with itself a number of times.
+/// ```
+/// let values = product([1, 2, 3], repeated: 2)
+/// // Equivalent to product([1, 2, 3], [1, 2, 3])
+/// ```
+/// - Parameters:
+///    - sequence: The sequence from which to compute the product.
+///    - repeated: The number of times to repeat the sequence with itself in computing the product.
+/// - Returns: An iterator-sequence for the Cartesian product of the sequence repeated with itself a number of times.
+public func product<S: Sequence>(_ sequence: S, repeated: Int) -> CartesianProduct<S> {
+  let sequences = Array(repeating: sequence, count: repeated)
+  return CartesianProduct(sequences)
+}

Tests/Day07.swift

@@ -0,0 +1,30 @@
+import Testing
+
+@testable import aoc
+
+@Suite("Day07")
+struct Day07Tests {
+  let testData = """
+    190: 10 19
+    3267: 81 40 27
+    83: 17 5
+    156: 15 6
+    7290: 6 8 6 15
+    161011: 16 10 13
+    192: 17 8 14
+    21037: 9 7 18 13
+    292: 11 6 16 20
+    """
+
+  @Test("part1")
+  func testPart1() async throws {
+    let challenge = Day07(data: testData)
+    #expect(challenge.part1() == 3749)
+  }
+
+  @Test("part2")
+  func testPart2() async throws {
+    let challenge = Day07(data: testData)
+    #expect(challenge.part2() == 11387)
+  }
+}