const fs = require("fs");
const path = require("path");

const OUTFILE = process.argv.includes("--output")
  ? process.argv[process.argv.indexOf("--output") + 1]
  : "groups.csv";
const MAX_GROUPS = process.argv.includes("--max")
  ? parseInt(process.argv[process.argv.indexOf("--max") + 1], 10)
  : 0;
const PROGRESS_EVERY = process.argv.includes("--progressEvery")
  ? parseInt(process.argv[process.argv.indexOf("--progressEvery") + 1], 10)
  : 200;

function uniqCount5(s) {
  return new Set(s).size === 5;
}

function buildMasks(words) {
  const charIndex = new Map();
  let next = 0;
  const masks = [];
  for (let w of words) {
    let m = 0n;
    for (let ch of w) {
      let id = charIndex.get(ch);
      if (id === undefined) {
        id = next++;
        charIndex.set(ch, id);
      }
      m |= 1n << BigInt(id);
    }
    masks.push(m);
  }
  return masks;
}

function popcntBigInt(bn) {
  let c = 0n;
  while (bn) { bn &= (bn - 1n); c++; }
  return c;
}

const wordsPath = path.resolve("words.json");
let words = JSON.parse(fs.readFileSync(wordsPath, "utf8"))
  .map(w => String(w).trim().toLowerCase())
  .filter(w => w.length === 5 && uniqCount5(w));

const N = words.length;
console.log(`Слов с 5 уникальными буквами: ${N}`);

const masks = buildMasks(words);

// совместимость — соседи только с бОльшими индексами
const neighbors = Array.from({ length: N }, () => []);
for (let i = 0; i < N; i++) {
  for (let j = i + 1; j < N; j++) {
    if ((masks[i] & masks[j]) === 0n) neighbors[i].push(j);
  }
}

const out = fs.createWriteStream(OUTFILE, { encoding: "utf8" });
out.write("word1,word2,word3,word4,word5\n");

let found = 0;
let buf = [];
const started = Date.now();

function flushBuf() {
  if (buf.length === 0) return true;
  const ok = out.write(buf.join(""));
  buf = [];
  return ok;
}

function printProgress(i) {
  const elapsed = ((Date.now() - started) / 1000).toFixed(1);
  const pct = ((i / Math.max(1, N - 5)) * 100).toFixed(2);
  process.stdout.write(`\rПрогресс i: ${i}/${N - 5} (${pct}%), найдено: ${found}, время: ${elapsed}s`);
}

(async () => {
  const mark = new Uint8Array(N);

  outer: for (let i = 0; i <= N - 5; i++) {
    const ni = neighbors[i];
    if (ni.length < 4) { if (i % PROGRESS_EVERY === 0) printProgress(i); continue; }

    for (const v of ni) mark[v] = 1;
    for (const j of ni) {
      const candK = [];
      for (const v of neighbors[j]) if (v > j && mark[v]) candK.push(v);
      if (candK.length < 3) continue;
      for (const v of candK) mark[v] = 2;

      for (const k of candK) {
        const candL = [];
        for (const v of neighbors[k]) if (v > k && mark[v] === 2) candL.push(v);
        if (candL.length < 2) continue;
        for (const v of candL) mark[v] = 3;

        for (const l of candL) {
          const candM = [];
          for (const v of neighbors[l]) if (v > l && mark[v] === 3) candM.push(v);
          for (const m of candM) {
            const u = masks[i] | masks[j] | masks[k] | masks[l] | masks[m];
            if (popcntBigInt(u) !== 25n) continue;

            buf.push(`${words[i]},${words[j]},${words[k]},${words[l]},${words[m]}\n`);
            found++;
            if (buf.length >= 1000) {
              if (!flushBuf()) await new Promise(res => out.once("drain", res));
            }
            if (MAX_GROUPS && found >= MAX_GROUPS) break outer;
          }
        }

        for (const v of candL) mark[v] = 2;
      }
      for (const v of candK) mark[v] = 1;
    }
    for (const v of ni) mark[v] = 0;

    if (i % PROGRESS_EVERY === 0) printProgress(i);
  }

  flushBuf();
  await new Promise(res => out.end(res));
  printProgress(N - 5);
  const dt = ((Date.now() - started) / 1000).toFixed(1);
  console.log(`\nГотово. Найдено групп: ${found}. Время: ${dt}s. Файл: ${OUTFILE}`);
})();

Консольные команды я не просил и не использовал, но скрипт какой получил, такой и оставил.