progress

Author: spaenleh

Sources/AdventOfCode.swift

@@ -3,16 +3,17 @@ import ArgumentParser
 // Add each new day implementation to this array:
 let allChallenges: [any AdventDay] = [
   Day01(),
-  Day02(),
-  Day03(),
-  Day04(),
-  Day05(),
-  Day06(),
-  Day07(),
-  Day08(),
-  Day09(),
-  Day10(),
-  Day11(),
+  // Day02(),
+  // Day03(),
+  // Day04(),
+  // Day05(),
+  // Day06(),
+  // Day07(),
+  // Day08(),
+  // Day09(),
+  // Day10(),
+  // Day11(),
+  Day12(),
 ]
 
 @main

Sources/Day12.swift

@@ -1,14 +1,104 @@
 import Algorithms
 
+enum Border: Hashable {
+  case north(y: Int)
+  case east(x: Int)
+  case south(y: Int)
+  case west(x: Int)
+
+  static func create(direction: Int, coord: Coord) -> (Self, Int) {
+    switch direction {
+    case 0: (north(y: coord.y), coord.x)
+    case 1: (east(x: coord.x), coord.y)
+    case 2: (south(y: coord.y), coord.x)
+    case 3: (west(x: coord.x), coord.y)
+    default: (north(y: -1), -1)
+    }
+  }
+
+  func toCardDirection() -> CardDirection {
+    switch self {
+    case .north: .north
+    case .south: .south
+    case .east: .east
+    case .west: .west
+    }
+  }
+
+}
+
+enum CardDirection: Int, CustomStringConvertible {
+  var description: String {
+    switch self {
+    case .north: "N"
+    case .south: "S"
+    case .east: "E"
+    case .west: "W"
+    }
+  }
+
+  case north = 0
+  case east
+  case south
+  case west
+}
+
+struct Side: CustomStringConvertible {
+  var description: String {
+    "Side(\(direction)|\(border) \(values))"
+  }
+
+  var direction: CardDirection
+  var border: Border
+  var values: [Int]
+}
+
 struct Field {
   var id: Character
-  var area: Int = 1
+  var area: Int = 0
   var perimeter: Int = 0
   var coords: [Coord] = [Coord]()
+  var sides: [Border: [Int]] = [Border: [Int]]()
+  var sideCount: Int {
+    let allSides = sides.values.map { side in
+      let sortedSide = side.sorted()
+      print("sorted", sortedSide)
+      return zip(sortedSide, sortedSide.dropFirst()).map { $1 - $0 }.filter { $0 > 1 }.count + 1
+    }
+    print("allsides", allSides)
+    return allSides.compactMap { $0 }.count
+  }
 
-  func compute() -> Int {
+  // mutating func extendSides(idx: Int, pos: Coord) {
+  //   let (border, otherAxis) = Border.create(direction: idx, coord: pos)
+  //   let sideIdx = sides.firstIndex { side in
+  //     if side.direction == border.toCardDirection() && side.border == border {
+  //       let max = side.values.max() ?? -1
+  //       let min = side.values.min() ?? -1
+  //       if max + 1 == otherAxis || min - 1 == otherAxis {
+  //         return true
+  //       }
+  //     }
+  //     return false
+  //   }
+  //   if let sideIdx {
+  //     sides[sideIdx].values.append(otherAxis)
+  //   } else {
+  //     sides.append(Side(direction: border.toCardDirection(), border: border, values: [otherAxis]))
+  //   }
+  // }
+
+  mutating func addSide(idx: Int, pos: Coord) {
+    let (border, otherAxis) = Border.create(direction: idx, coord: pos)
+    sides[border, default: []].append(otherAxis)
+  }
+
+  func compute1() -> Int {
     area * perimeter
   }
+  func compute2() -> Int {
+    sideCount * area
+  }
 
   mutating func visited(coord: Coord) {
     coords.append(coord)
@@ -17,7 +107,7 @@ struct Field {
 extension Field {
   init(id: Character) {
     self.id = id
-    area = 1
+    area = 0
     perimeter = 0
   }
 }
@@ -34,58 +124,67 @@ struct Day12: AdventDay {
     field.visited(coord: pos)
     field.area += 1
     // explore the grid
-    for neighbor in pos.crossNeighbors {
-      print("checking for", neighbor)
+    for (idx, neighbor) in pos.crossNeighbors.enumerated() {
+      if field.coords.contains(neighbor) {
+        continue
+      }
       if let candidate = grid[neighbor] {
         if candidate == id {
-          print("we are together")
           // same value means we have a new area tile
-          return exploreField(from: neighbor, id: id, field: field)
+          field = exploreField(from: neighbor, id: id, field: field)
         } else {
-          print("someone else")
           // this is a frontier
           field.perimeter += 1
+          field.addSide(idx: idx, pos: neighbor)
+          // print("border found at", pos)
+          // print(field.sides)
         }
       } else {
-        print("grid boundary")
         // this is the frontier of the grid
         field.perimeter += 1
+        field.addSide(idx: idx, pos: neighbor)
+        // print(field.sideCount)
+
       }
     }
     return field
   }
 
-  func part1() -> Int {
-
+  func getFields() -> [Field] {
     var record = [Coord: Bool]()
     var fields = [Field]()
     for y in 0..<grid.height {
       for x in 0..<grid.width {
         let currentPos = Coord(x: x, y: y)
-        print(currentPos)
         // position has already been visited
         guard record[currentPos] == nil else {
-          print("already visited")
           continue
         }
 
         if let gridValue = grid[currentPos] {
           // start a new field
-          print("starting a new field")
           let field = exploreField(
             from: currentPos, id: gridValue, field: Field(id: gridValue))
           fields.append(field)
           field.coords.forEach { s in
             record[s] = true
           }
-          print("-------", field)
+          print("sides of ", gridValue, field.sideCount)
         }
       }
     }
-    return fields.map { $0.compute() }.sum
+    return fields
+  }
+
+  func part1() -> Int {
+
+    return getFields().map { $0.compute1() }.sum
   }
 
   func part2() -> Int {
-    0
+    // merge sides that are next to each other
+
+    return getFields().map { $0.compute2() }.sum
+
   }
 }

Tests/Day12.swift

@@ -17,15 +17,75 @@ struct Day12Tests {
     MMMISSJEEE
     """
 
+  @Test("first")
+  func testFirst() async throws {
+    let challenge = Day12(
+      data: """
+        AAAA
+        BBCD
+        BBCC
+        EEEC
+        """)
+    #expect(challenge.part1() == 140)
+  }
+
+  @Test("second")
+  func testSecond() async throws {
+    let challenge = Day12(
+      data: """
+        OOOOO
+        OXOXO
+        OOOOO
+        OXOXO
+        OOOOO
+        """)
+    #expect(challenge.part1() == 772)
+  }
+
   @Test("part1")
   func testPart1() async throws {
     let challenge = Day12(data: testData)
     #expect(challenge.part1() == 1930)
   }
 
+  @Test("simple2")
+  func testSimple2() async throws {
+    #expect(
+      Day12(
+        data: """
+          AAAA
+          BBCD
+          BBCC
+          EEEC
+          """
+      ).part2() == 80)
+    print("------")
+    #expect(
+      Day12(
+        data: """
+          EEEEE
+          EXXXX
+          EEEEE
+          EXXXX
+          EEEEE
+          """
+      ).part2() == 236)
+    #expect(
+      Day12(
+        data: """
+          AAAAAA
+          AAABBA
+          AAABBA
+          ABBAAA
+          ABBAAA
+          AAAAAA
+          """
+      ).part2() == 236)
+  }
+
   @Test("part2")
   func testPart2() async throws {
     let challenge = Day12(data: testData)
-    #expect(challenge.part2() == 0)
+    #expect(challenge.part2() == 1206)
   }
 }