more words

scripts/find-chunk-words.mjs

@@ -0,0 +1,90 @@
+// Finds common English words that can be built from exactly 4 existing tiles
+// (chunks) in the target-word pool, but aren't target words yet.
+//
+// Usage: node scripts/find-chunk-words.mjs [--max-tier=35] [--json]
+import wl from 'wordlist-english';
+import { DICTIONARY_SET } from '../src/data/lexicon.js';
+import { TARGET_WORDS_POOL } from '../src/data/puzzles.js';
+
+const args = Object.fromEntries(process.argv.slice(2).map(a => a.replace(/^--/, '').split('=')));
+const MAX_TIER = Number(args['max-tier'] || 35);
+const TIERS = [10, 20, 35, 40, 50].filter(t => t <= MAX_TIER);
+
+// Every chunk currently used by a target word
+const chunks = new Set(TARGET_WORDS_POOL.flatMap(w => w.tiles.map(t => t.toLowerCase())));
+const existing = new Set(TARGET_WORDS_POOL.map(w => w.word));
+
+// Common words only (frequency tiers from wordlist-english)
+const candidates = new Set();
+for (const t of TIERS) for (const w of wl[`english/${t}`] || []) candidates.add(w);
+
+// Try to split a word into exactly 4 distinct chunks (each >= 2 letters).
+// Returns the most balanced split, or null.
+function split(word) {
+  let best = null;
+  const n = word.length;
+  for (let a = 2; a <= n - 6; a++) {
+    const t1 = word.slice(0, a);
+    if (!chunks.has(t1)) continue;
+    for (let b = a + 2; b <= n - 4; b++) {
+      const t2 = word.slice(a, b);
+      if (!chunks.has(t2)) continue;
+      for (let c = b + 2; c <= n - 2; c++) {
+        const t3 = word.slice(b, c);
+        const t4 = word.slice(c);
+        if (!chunks.has(t3) || !chunks.has(t4)) continue;
+        const tiles = [t1, t2, t3, t4];
+        if (new Set(tiles).size !== 4) continue;
+        const lens = tiles.map(t => t.length);
+        const spread = Math.max(...lens) - Math.min(...lens);
+        if (!best || spread < best.spread) best = { tiles, spread };
+      }
+    }
+  }
+  return best && best.tiles;
+}
+
+// Skip inflected forms whose base word exists (walked, happier, quickly, kittens...)
+const allWords = new Set(wl.english);
+function isInflection(w) {
+  const bases = [];
+  if (w.endsWith('ies')) bases.push(w.slice(0, -3) + 'y');
+  if (w.endsWith('es')) bases.push(w.slice(0, -2));
+  if (w.endsWith('s')) bases.push(w.slice(0, -1));
+  if (w.endsWith('ed')) bases.push(w.slice(0, -2), w.slice(0, -1), w.slice(0, -3));
+  if (w.endsWith('ied')) bases.push(w.slice(0, -3) + 'y');
+  if (w.endsWith('ing')) bases.push(w.slice(0, -3), w.slice(0, -3) + 'e', w.slice(0, -4));
+  if (w.endsWith('ly')) bases.push(w.slice(0, -2), w.slice(0, -3) + 'e');
+  if (w.endsWith('ily')) bases.push(w.slice(0, -3) + 'y');
+  if (w.endsWith('er')) bases.push(w.slice(0, -2), w.slice(0, -1), w.slice(0, -3));
+  if (w.endsWith('est')) bases.push(w.slice(0, -3), w.slice(0, -2), w.slice(0, -4));
+  if (w.endsWith('ness')) bases.push(w.slice(0, -4));
+  return bases.some(b => b.length >= 3 && allWords.has(b));
+}
+
+// Skip near-duplicates of words already in the pool (e.g. "dolphin" vs "dolphins")
+function isInflectionOfExisting(w) {
+  const stems = [w.replace(/s$/, ''), w.replace(/es$/, ''), w.replace(/ies$/, 'y'), w + 's', w + 'es', w.replace(/y$/, 'ies')];
+  return stems.some(s => s !== w && existing.has(s));
+}
+
+const found = [];
+for (const word of candidates) {
+  if (word.length < 8 || word.length > 14) continue;
+  if (!/^[a-z]+$/.test(word)) continue;
+  if (existing.has(word)) continue;
+  if (word.endsWith('tion')) continue;
+  if (!DICTIONARY_SET.has(word)) continue;
+  if (isInflectionOfExisting(word)) continue;
+  if (!('keep-inflections' in args) && isInflection(word)) continue;
+  const tiles = split(word);
+  if (tiles) found.push({ word, tiles });
+}
+
+found.sort((a, b) => a.word.localeCompare(b.word));
+if ('json' in args) {
+  console.log(JSON.stringify(found));
+} else {
+  for (const f of found) console.log(`${f.word}|${f.tiles.join('-')}`);
+  console.error(`\n${chunks.size} chunks, ${found.length} new words found (tiers <= ${MAX_TIER})`);
+}