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}