← All repositories

crossmate

A collaborative crossword app for iPhone and iPad

git clone https://code.inqk.net/crossmate.git


Crossmake/Sources/Pickmake/main.swift (12137B)

1import Foundation
2
3let gridSize = 15
4let letterWeights: [UInt8: Int] = [
5    65: 9, 66: 2, 67: 2, 68: 4, 69: 12, 70: 2, 71: 3, 72: 2, 73: 9,
6    74: 1, 75: 1, 76: 4, 77: 2, 78: 6, 79: 8, 80: 2, 81: 1, 82: 6,
7    83: 4, 84: 6, 85: 4, 86: 2, 87: 2, 88: 1, 89: 2, 90: 1
8]
9
10struct Options {
11    var countsPath = "Generated/answer_counts.json"
12    var qualityPath = "Generated/word_quality.json"
13    var count = 10
14    var maxAnswerUsages = 2
15    var disallowRepeatedSelectedAnswers = false
16    var unusualScoreThreshold = 110
17    var inputs: [String] = ["Generated"]
18    var verbose = false
19}
20
21struct WordQuality: Decodable {
22    let count: Int?
23    let badClueCount: Int?
24    let obscureNameClueCount: Int?
25    let fillBlankCount: Int?
26    let rejectionReason: String?
27
28    enum CodingKeys: String, CodingKey {
29        case count
30        case badClueCount = "bad_clue_count"
31        case obscureNameClueCount = "obscure_name_clue_count"
32        case fillBlankCount = "fill_blank_count"
33        case rejectionReason = "rejection_reason"
34    }
35}
36
37struct Candidate {
38    let path: String
39    let answers: [String]
40    let counts: [String: Int]
41    let unusualAnswers: Set<String>
42    let score: Int
43}
44
45struct PickmakeError: Error, CustomStringConvertible {
46    let description: String
47}
48
49func parseOptions(_ arguments: [String]) throws -> Options {
50    var options = Options()
51    var index = 1
52    var inputs: [String] = []
53
54    func requireValue(_ name: String) throws -> String {
55        guard index + 1 < arguments.count else {
56            throw PickmakeError(description: "Missing value for \(name)")
57        }
58        index += 1
59        return arguments[index]
60    }
61
62    while index < arguments.count {
63        let arg = arguments[index]
64        switch arg {
65        case "--counts":
66            options.countsPath = try requireValue(arg)
67        case "--quality":
68            options.qualityPath = try requireValue(arg)
69        case "--count":
70            let value = try requireValue(arg)
71            guard let parsed = Int(value), parsed > 0 else {
72                throw PickmakeError(description: "--count must be a positive integer")
73            }
74            options.count = parsed
75        case "--max-answer-usages":
76            let value = try requireValue(arg)
77            guard let parsed = Int(value), parsed > 0 else {
78                throw PickmakeError(description: "--max-answer-usages must be a positive integer")
79            }
80            options.maxAnswerUsages = parsed
81        case "--disallow-all-repeats":
82            options.disallowRepeatedSelectedAnswers = true
83        case "--unusual-score-threshold":
84            let value = try requireValue(arg)
85            guard let parsed = Int(value) else {
86                throw PickmakeError(description: "--unusual-score-threshold must be an integer")
87            }
88            options.unusualScoreThreshold = parsed
89        case "--verbose":
90            options.verbose = true
91        case "--help", "-h":
92            printUsage()
93            exit(0)
94        default:
95            inputs.append(arg)
96        }
97        index += 1
98    }
99
100    if !inputs.isEmpty {
101        options.inputs = inputs
102    }
103    return options
104}
105
106func printUsage() {
107    print("""
108    Usage: Pickmake [options] [XD files or directories...]
109
110    Options:
111      --count N                       Number of puzzles to select. Default: 10
112      --counts PATH                   Answer frequency JSON path. Default: Generated/answer_counts.json
113      --quality PATH                  Word quality metadata JSON path. Default: Generated/word_quality.json
114      --max-answer-usages N           Reject puzzles using one answer more than N times. Default: 2
115      --disallow-all-repeats
116                                      Disallow any repeated answers across selected puzzles. Default: only unusual answers cannot repeat.
117      --unusual-score-threshold N     Answers scoring below N cannot repeat across selected puzzles. Default: 110
118      --verbose                       Print rejected puzzle details to stderr.
119      -h, --help                      Show this help.
120    """)
121}
122
123func loadJSON<T: Decodable>(_ type: T.Type, from path: String) throws -> T {
124    let data = try Data(contentsOf: URL(fileURLWithPath: path))
125    return try JSONDecoder().decode(T.self, from: data)
126}
127
128func vowelCount(_ bytes: [UInt8]) -> Int {
129    bytes.filter { $0 == 65 || $0 == 69 || $0 == 73 || $0 == 79 || $0 == 85 }.count
130}
131
132func hasRunOfThree(_ bytes: [UInt8]) -> Bool {
133    guard bytes.count >= 3 else {
134        return false
135    }
136    for index in 2..<bytes.count where bytes[index] == bytes[index - 1] && bytes[index] == bytes[index - 2] {
137        return true
138    }
139    return false
140}
141
142func qualityScore(text: String, count: Int?, quality: WordQuality?) -> Int {
143    let bytes = Array(text.utf8)
144    let length = bytes.count
145    let frequency = count ?? 0
146    var score = length * 12
147
148    if frequency > 0 {
149        score += min(80, frequency * 4)
150    } else {
151        score -= length >= 8 ? 30 : 80
152    }
153
154    if length >= 8 {
155        score += min(80, (length - 7) * 14)
156    }
157    if (5...7).contains(length) && frequency <= 2 {
158        score -= 70
159    }
160    if length == 4 && frequency < 10 {
161        score -= 60
162    }
163    if length <= 3 && frequency < 25 {
164        score -= 80
165    }
166
167    let vowels = vowelCount(bytes)
168    if vowels == 0 {
169        score -= 90
170    } else if length >= 5 && Double(vowels) / Double(length) < 0.22 {
171        score -= 35
172    }
173    if hasRunOfThree(bytes) {
174        score -= 110
175    }
176
177    if let quality {
178        let evidenceCount = max(quality.count ?? frequency, 1)
179        let badRatio = Double(quality.badClueCount ?? 0) / Double(evidenceCount)
180        let obscureRatio = Double(quality.obscureNameClueCount ?? 0) / Double(evidenceCount)
181        let blankRatio = Double(quality.fillBlankCount ?? 0) / Double(evidenceCount)
182
183        if quality.rejectionReason != nil {
184            score -= length >= 8 ? 80 : 140
185        }
186        if length <= 4 {
187            score -= Int(badRatio * 100)
188            score -= Int(obscureRatio * 70)
189            score -= Int(blankRatio * 45)
190        } else if length <= 7 {
191            score -= Int(badRatio * 45)
192            score -= Int(obscureRatio * 35)
193            score -= Int(blankRatio * 20)
194        } else {
195            score -= Int(badRatio * 20)
196            score -= Int(obscureRatio * 15)
197        }
198    }
199
200    return score + bytes.reduce(0) { $0 + (letterWeights[$1] ?? 0) }
201}
202
203func discoverXDPaths(inputs: [String]) throws -> [String] {
204    let fileManager = FileManager.default
205    var paths: [String] = []
206
207    for input in inputs {
208        var isDirectory: ObjCBool = false
209        guard fileManager.fileExists(atPath: input, isDirectory: &isDirectory) else {
210            throw PickmakeError(description: "Input not found: \(input)")
211        }
212
213        if isDirectory.boolValue {
214            let url = URL(fileURLWithPath: input)
215            guard let enumerator = fileManager.enumerator(at: url, includingPropertiesForKeys: [.isRegularFileKey]) else {
216                continue
217            }
218            for case let fileURL as URL in enumerator where fileURL.pathExtension.lowercased() == "xd" {
219                paths.append(fileURL.path)
220            }
221        } else if input.lowercased().hasSuffix(".xd") {
222            paths.append(URL(fileURLWithPath: input).path)
223        }
224    }
225
226    return Array(Set(paths)).sorted()
227}
228
229func answers(in path: String) throws -> [String] {
230    let contents = try String(contentsOfFile: path, encoding: .utf8)
231    return contents.split(separator: "\n").compactMap { line in
232        guard let separator = line.range(of: " ~ ") else {
233            return nil
234        }
235        let answer = line[separator.upperBound...].trimmingCharacters(in: .whitespaces)
236        guard !answer.isEmpty, answer.allSatisfy({ $0 >= "A" && $0 <= "Z" }) else {
237            return nil
238        }
239        return answer
240    }
241}
242
243func storedFillScore(in path: String) throws -> Int? {
244    let contents = try String(contentsOfFile: path, encoding: .utf8)
245    for line in contents.split(separator: "\n") {
246        guard line.hasPrefix("Fill Score:") else {
247            continue
248        }
249        let value = line.dropFirst("Fill Score:".count).trimmingCharacters(in: .whitespaces)
250        return Int(value)
251    }
252    return nil
253}
254
255func makeCandidate(path: String, counts: [String: Int], quality: [String: WordQuality], unusualScoreThreshold: Int) throws -> Candidate {
256    let words = try answers(in: path)
257    let answerCounts = Dictionary(grouping: words, by: { $0 }).mapValues(\.count)
258    var unusual = Set<String>()
259    var score = 0
260
261    for word in words {
262        let key = word.lowercased()
263        let wordScore = qualityScore(text: word, count: counts[key], quality: quality[key])
264        score += wordScore
265        if wordScore < unusualScoreThreshold {
266            unusual.insert(word)
267        }
268    }
269
270    return Candidate(path: path, answers: words, counts: answerCounts, unusualAnswers: unusual, score: try storedFillScore(in: path) ?? score)
271}
272
273func run() throws {
274    let options = try parseOptions(CommandLine.arguments)
275    let counts = try loadJSON([String: Int].self, from: options.countsPath)
276    let quality = try loadJSON([String: WordQuality].self, from: options.qualityPath)
277    let paths = try discoverXDPaths(inputs: options.inputs)
278    let candidates = try paths.map {
279        try makeCandidate(path: $0, counts: counts, quality: quality, unusualScoreThreshold: options.unusualScoreThreshold)
280    }.sorted {
281        if $0.score != $1.score {
282            return $0.score > $1.score
283        }
284        return $0.path < $1.path
285    }
286
287    var selected: [Candidate] = []
288    var selectedUnusual = Set<String>()
289    var selectedAnswers = Set<String>()
290    var rejectedForInternalRepeats = 0
291    var rejectedForAnswerRepeats = 0
292    var rejectedForUnusualRepeats = 0
293
294    for candidate in candidates {
295        let overused = candidate.counts
296            .filter { $0.value > options.maxAnswerUsages }
297            .sorted { $0.key < $1.key }
298        if !overused.isEmpty {
299            rejectedForInternalRepeats += 1
300            if options.verbose {
301                let details = overused.map { "\($0.key)=\($0.value)" }.joined(separator: ", ")
302                fputs("Rejected \(candidate.path): answer usage > \(options.maxAnswerUsages) (\(details))\n", stderr)
303            }
304            continue
305        }
306        let repeatedAnswers = Set(candidate.answers).intersection(selectedAnswers).sorted()
307        if options.disallowRepeatedSelectedAnswers && !repeatedAnswers.isEmpty {
308            rejectedForAnswerRepeats += 1
309            if options.verbose {
310                fputs("Rejected \(candidate.path): repeated selected answers (\(repeatedAnswers.joined(separator: ", ")))\n", stderr)
311            }
312            continue
313        }
314        if !options.disallowRepeatedSelectedAnswers {
315            let repeatedUnusual = candidate.unusualAnswers.intersection(selectedUnusual).sorted()
316            if !repeatedUnusual.isEmpty {
317                rejectedForUnusualRepeats += 1
318                if options.verbose {
319                    fputs("Rejected \(candidate.path): repeated unusual answers (\(repeatedUnusual.joined(separator: ", ")))\n", stderr)
320                }
321                continue
322            }
323        }
324
325        selected.append(candidate)
326        selectedAnswers.formUnion(candidate.answers)
327        selectedUnusual.formUnion(candidate.unusualAnswers)
328        if selected.count == options.count {
329            break
330        }
331    }
332
333    for candidate in selected {
334        print(candidate.path)
335    }
336
337    fputs("Selected \(selected.count) of \(options.count) requested puzzles from \(candidates.count) candidates.\n", stderr)
338    fputs("Rejected \(rejectedForInternalRepeats) for answer usage > \(options.maxAnswerUsages); \(rejectedForAnswerRepeats) for repeated selected answers; \(rejectedForUnusualRepeats) for repeated unusual answers below score \(options.unusualScoreThreshold).\n", stderr)
339}
340
341do {
342    try run()
343} catch {
344    fputs("Pickmake: \(error)\n", stderr)
345    exit(1)
346}