tiles placed in correct locations

day20/Sources/day20/Tile.swift

@@ -7,6 +7,8 @@
 
 import Foundation
 
+enum TileType { case edge, corner, regular }
+
 struct Tile: Hashable {
     let id: Int
     let data: [[Character]]
@@ -41,3 +43,7 @@ extension Tile {
 
     }
 }
+
+extension Tile: CustomStringConvertible {
+    var description: String { "\(id)" }
+}

day20/Sources/day20/TileSorter.swift

@@ -7,46 +7,79 @@
 
 import Foundation
 
-enum TileType { case edge, corner, nonEdge }
+typealias TilesByEdge = [Edge: Set<Tile>]
 
-struct TileSorter {
-
-    //private var tilesByType: [TileType: Set<Tile>]
+private func buildTilesByEdge(_ tiles: Set<Tile>) -> TilesByEdge {
+    let tilesByEdge: [Edge: Set<Tile>] = tiles.reduce(into: [:]) { result, value in
+        for edge in value.allEdges {
+            result[edge, default: []].insert(value)
+        }
+    }
+    return tilesByEdge
+}
 
-    var cornerTiles: Set<Tile>
-    var edgeTiles: Set<Tile>
-    var nonEdgeTiles: Set<Tile>
+struct TileSorter {
+    var cornerTiles: Set<Tile> {
+        Set(tilesByTypeByEdge[.corner]?.values.flatMap { $0 } ?? [])
+    }
 
-    var tilesByEdge: [Edge: [Tile]]
+    private var tilesByTypeByEdge: [TileType: TilesByEdge]
 
     init(_ source: String) {
         let allTiles = Set(source.components(separatedBy: "\n\n").map(Tile.init))
 
-        tilesByEdge = allTiles.reduce(into: [:]) { result, value in
+        let tilesByEdge: [Edge: [Tile]] = allTiles.reduce(into: [:]) { result, value in
             for edge in value.allEdges {
                 result[edge, default: []].append(value)
             }
         }
 
-        edgeTiles = Set(tilesByEdge.values.filter { $0.count == 1 }.flatMap { $0 })
+        var edgeTiles = Set(tilesByEdge.values.filter { $0.count == 1 }.flatMap { $0 })
 
-        nonEdgeTiles = allTiles.subtracting(edgeTiles)
+        let nonEdgeTiles = allTiles.subtracting(edgeTiles)
 
         let edgeToCount: [Edge: Int] = edgeTiles.reduce(into: [:]) { result, value in
             for edge in value.allEdges {
                 result[edge, default: 0] += 1
             }
         }
 
-        cornerTiles = edgeTiles.filter { tile in
+        let cornerTiles = edgeTiles.filter { tile in
             guard tile.horizontalEdges.compactMap({ edgeToCount[$0] }).reduce(0, +) == 3 else { return false }
             guard tile.verticalEdges.compactMap({ edgeToCount[$0] }).reduce(0, +) == 3 else { return false }
             return true
         }
         edgeTiles.subtract(cornerTiles)
+
+
+        tilesByTypeByEdge = [
+            .corner: buildTilesByEdge(cornerTiles),
+            .edge: buildTilesByEdge(edgeTiles),
+            .regular: buildTilesByEdge(nonEdgeTiles)
+        ]
     }
 
-//    mutating func removeTile(_ type: TileType, matching: Tile, edge: Edge.Side) -> Tile? {
-//
-//    }
+    mutating func removeEdge(_ edge: Edge) {
+        tilesByTypeByEdge[.corner]?[edge] = nil
+        tilesByTypeByEdge[.edge]?[edge] = nil
+        tilesByTypeByEdge[.regular]?[edge] = nil
+    }
+
+    // returns the tile of the specified type which matches an edge of the specified tile.
+    // NOTE: if a match is found, the edge is removed from the sorter so it won't be found again
+    mutating func findMatch(_ type: TileType, matching: Tile) -> Tile? {
+        for edge in matching.allEdges {
+            if let tiles = tilesByTypeByEdge[type]?[edge], let tile = tiles.first(where: { $0 != matching }) {
+                removeEdge(edge)
+                return tile
+            }
+        }
+        return nil
+    }
+
+    mutating func removeCommonEdge(_ a: Tile, _ b: Tile) {
+        let commonEdges = Set(a.allEdges).intersection(b.allEdges)
+        guard let edge = commonEdges.first, commonEdges.count == 1 else { fatalError("didn't expect multiple common edges")}
+        removeEdge(edge)
+    }
 }

day20/Sources/day20/main.swift

@@ -1,15 +1,61 @@
 import Foundation
 
-let sorter = TileSorter(input)
+var sorter = TileSorter(input)
 let cornerTileProduct = sorter.cornerTiles.map(\.id).reduce(1, *)
 print("answer to part one: \(cornerTileProduct)") // 4006801655873
 
 var puzzle: [[Tile?]] = Array(repeating: Array(repeating: nil, count: 12), count: 12)
 
-puzzle[0][0] = sorter.cornerTiles.randomElement()
+puzzle[0][0] = sorter.cornerTiles.first
+
+func printPuzzle() {
+    for row in puzzle {
+        let values: [String] = row.map {
+            if let id = $0?.id {
+                return "\(id)"
+            } else {
+                return "----"
+            }
+        }
+        print(values)
+    }
+}
+
+func fillTopEdge() {
+    let cornerIdx = puzzle.count - 1
+    for i in 1..<cornerIdx {
+        puzzle[0][i] = sorter.findMatch(.edge, matching: puzzle[0][i - 1]!)
+    }
+
+    if puzzle[0][cornerIdx] == nil {
+        puzzle[0][cornerIdx] = sorter.findMatch(.corner, matching: puzzle[0][cornerIdx - 1]!)
+    }
+}
+
+func fillRow(_ rowIdx: Int) {
+    for i in rowIdx..<(puzzle.count - 1 - rowIdx) {
+        guard let match = sorter.findMatch(.regular, matching: puzzle[rowIdx - 1][i]!) else { fatalError() }
+        sorter.removeCommonEdge(match, puzzle[rowIdx][i - 1]!)
+        puzzle[rowIdx][i] = match
+    }
+}
+
+for _ in 0..<4 {
+    fillTopEdge()
+    puzzle.rotateLeft()
+}
+
+for i in 1...5 {
+    for _ in 0..<4 {
+        fillRow(i)
+        puzzle.rotateLeft()
+    }
+}
+printPuzzle()
+
+let ids = puzzle.flatMap { $0 }.map { $0!.id }
+print(ids.count)
+print(Set(ids).count)
+
+// 2789
 
-//func fillTopEdge() {
-//    for i in 1..<(puzzle.count - 1) {
-//
-//    }
-//}