crossmate

main.swift (8872B)

---

 import Foundation
 
 let gridSize = 15
 
 struct Options {
     var gridsPath = "Sources/Fillmake/Resources/grid_list.json"
     var limit: Int?
     var format = "tsv"
 }
 
 struct GridEntry: Decodable {
     let grid: [String]
     let date: String
 }
 
 struct Slot {
     enum Direction: String {
         case across
         case down
     }
 
     let id: Int
     let cells: [Int]
     let direction: Direction
 }
 
 struct GridStats {
     let index: Int
     let date: String
     let score: Int
     let slotCount: Int
     let openCellCount: Int
     let threeLetterSlots: Int
     let fourLetterSlots: Int
     let fiveSixLetterSlots: Int
     let sevenPlusLetterSlots: Int
     let maxShortCluster: Int
     let averageSlotLength: Double
 }
 
 struct GridmakeError: Error, CustomStringConvertible {
     let description: String
 }
 
 func printUsage() {
     print("""
     Usage: Gridmake [options]
 
     Options:
       --grids PATH        Grid list JSON path. Default: Sources/Fillmake/Resources/grid_list.json
       --limit N           Print only the top N ranked grids.
       --format tsv|json   Output format. Default: tsv.
       -h, --help          Show this help.
     """)
 }
 
 func requireValue(_ arguments: [String], _ index: inout Int, _ name: String) throws -> String {
     index += 1
     guard index < arguments.count else {
         throw GridmakeError(description: "Missing value for \(name)")
     }
     return arguments[index]
 }
 
 func parseOptions() throws -> Options {
     var options = Options()
     let arguments = Array(CommandLine.arguments.dropFirst())
     var index = 0
 
     while index < arguments.count {
         let argument = arguments[index]
         switch argument {
         case "--grids":
             options.gridsPath = try requireValue(arguments, &index, argument)
         case "--limit":
             let value = try requireValue(arguments, &index, argument)
             guard let limit = Int(value), limit > 0 else {
                 throw GridmakeError(description: "--limit must be a positive integer")
             }
             options.limit = limit
         case "--format":
             let format = try requireValue(arguments, &index, argument)
             guard ["tsv", "json"].contains(format) else {
                 throw GridmakeError(description: "--format must be tsv or json")
             }
             options.format = format
         case "-h", "--help":
             printUsage()
             exit(0)
         default:
             throw GridmakeError(description: "Unknown argument: \(argument)")
         }
         index += 1
     }
 
     return options
 }
 
 func loadJSON<T: Decodable>(_ type: T.Type, from path: String) throws -> T {
     let url = URL(fileURLWithPath: path)
     let data = try Data(contentsOf: url)
     return try JSONDecoder().decode(T.self, from: data)
 }
 
 func buildSlots(black: [Bool]) -> [Slot] {
     var slots: [Slot] = []
 
     for row in 0..<gridSize {
         var column = 0
         while column < gridSize {
             let cell = row * gridSize + column
             if black[cell] {
                 column += 1
                 continue
             }
             var cells: [Int] = []
             while column < gridSize && !black[row * gridSize + column] {
                 cells.append(row * gridSize + column)
                 column += 1
             }
             if cells.count > 1 {
                 slots.append(Slot(id: slots.count, cells: cells, direction: .across))
             }
         }
     }
 
     for column in 0..<gridSize {
         var row = 0
         while row < gridSize {
             let cell = row * gridSize + column
             if black[cell] {
                 row += 1
                 continue
             }
             var cells: [Int] = []
             while row < gridSize && !black[row * gridSize + column] {
                 cells.append(row * gridSize + column)
                 row += 1
             }
             if cells.count > 1 {
                 slots.append(Slot(id: slots.count, cells: cells, direction: .down))
             }
         }
     }
 
     return slots
 }
 
 func maxShortCluster(in slots: [Slot]) -> Int {
     let shortSlotIDs = Set(slots.filter { $0.cells.count <= 4 }.map(\.id))
     guard !shortSlotIDs.isEmpty else {
         return 0
     }
 
     var cellToShortSlots: [Int: [Int]] = [:]
     for slot in slots where shortSlotIDs.contains(slot.id) {
         for cell in slot.cells {
             cellToShortSlots[cell, default: []].append(slot.id)
         }
     }
 
     var adjacency: [Int: Set<Int>] = [:]
     for connectedSlots in cellToShortSlots.values where connectedSlots.count > 1 {
         for left in connectedSlots {
             for right in connectedSlots where right != left {
                 adjacency[left, default: []].insert(right)
             }
         }
     }
 
     var visited = Set<Int>()
     var largest = 1
 
     for slotID in shortSlotIDs where !visited.contains(slotID) {
         var stack = [slotID]
         visited.insert(slotID)
         var size = 0
 
         while let current = stack.popLast() {
             size += 1
             for next in adjacency[current, default: []] where !visited.contains(next) {
                 visited.insert(next)
                 stack.append(next)
             }
         }
 
         largest = max(largest, size)
     }
 
     return largest
 }
 
 func stats(for entry: GridEntry, index: Int) throws -> GridStats {
     guard entry.grid.count == gridSize * gridSize else {
         throw GridmakeError(description: "Grid \(entry.date) has \(entry.grid.count) cells, expected \(gridSize * gridSize)")
     }
 
     let black = entry.grid.map { $0 == "." }
     let slots = buildSlots(black: black)
     let lengths = slots.map { $0.cells.count }
     let slotCount = slots.count
     let openCellCount = black.filter { !$0 }.count
     let threeLetterSlots = lengths.filter { $0 == 3 }.count
     let fourLetterSlots = lengths.filter { $0 == 4 }.count
     let fiveSixLetterSlots = lengths.filter { (5...6).contains($0) }.count
     let sevenPlusLetterSlots = lengths.filter { $0 >= 7 }.count
     let shortCluster = maxShortCluster(in: slots)
     let averageSlotLength = lengths.isEmpty ? 0 : Double(lengths.reduce(0, +)) / Double(lengths.count)
 
     let score = sevenPlusLetterSlots * 20
         + fiveSixLetterSlots * 8
         - threeLetterSlots * 35
         - fourLetterSlots * 15
         - shortCluster * 50
         + Int(averageSlotLength * 6)
         - max(0, slotCount - 78) * 6
 
     return GridStats(
         index: index,
         date: entry.date,
         score: score,
         slotCount: slotCount,
         openCellCount: openCellCount,
         threeLetterSlots: threeLetterSlots,
         fourLetterSlots: fourLetterSlots,
         fiveSixLetterSlots: fiveSixLetterSlots,
         sevenPlusLetterSlots: sevenPlusLetterSlots,
         maxShortCluster: shortCluster,
         averageSlotLength: averageSlotLength
     )
 }
 
 func printTSV(_ rankedStats: [GridStats]) {
     print("rank\tindex\tdate\tscore\tslots\topen_cells\tlen3\tlen4\tlen5_6\tlen7_plus\tmax_short_cluster\tavg_slot_length")
     for (rank, stats) in rankedStats.enumerated() {
         let average = String(format: "%.2f", stats.averageSlotLength)
         print("\(rank + 1)\t\(stats.index)\t\(stats.date)\t\(stats.score)\t\(stats.slotCount)\t\(stats.openCellCount)\t\(stats.threeLetterSlots)\t\(stats.fourLetterSlots)\t\(stats.fiveSixLetterSlots)\t\(stats.sevenPlusLetterSlots)\t\(stats.maxShortCluster)\t\(average)")
     }
 }
 
 func jsonString(_ value: String) -> String {
     let data = try! JSONEncoder().encode(value)
     return String(data: data, encoding: .utf8) ?? "\"\""
 }
 
 func printJSON(_ rankedStats: [GridStats]) {
     print("[")
     for (offset, stats) in rankedStats.enumerated() {
         let comma = offset == rankedStats.count - 1 ? "" : ","
         let average = String(format: "%.4f", stats.averageSlotLength)
         print("""
           {"rank":\(offset + 1),"index":\(stats.index),"date":\(jsonString(stats.date)),"score":\(stats.score),"slots":\(stats.slotCount),"open_cells":\(stats.openCellCount),"len3":\(stats.threeLetterSlots),"len4":\(stats.fourLetterSlots),"len5_6":\(stats.fiveSixLetterSlots),"len7_plus":\(stats.sevenPlusLetterSlots),"max_short_cluster":\(stats.maxShortCluster),"avg_slot_length":\(average)}\(comma)
         """)
     }
     print("]")
 }
 
 do {
     let options = try parseOptions()
     let grids = try loadJSON([GridEntry].self, from: options.gridsPath)
     let rankedStats = try grids.enumerated()
         .map { try stats(for: $0.element, index: $0.offset) }
         .sorted {
             if $0.score != $1.score {
                 return $0.score > $1.score
             }
             return $0.index < $1.index
         }
         .prefix(options.limit ?? grids.count)
 
     if options.format == "json" {
         printJSON(Array(rankedStats))
     } else {
         printTSV(Array(rankedStats))
     }
 } catch {
     fputs("Gridmake: \(error)\n", stderr)
     exit(1)
 }