javascript - 在 JS 中查找与给定模式匹配的所有可能的字符串组合

Question

所以我有一个字典，其中每个键都映射到一个字母数组:

tCategories = { "T": ["t","d","th"],
                "P": ["p","t","k","q"],
                "N": ["m","n"] };

还有一个输入字符串，其中包含一些用逗号分隔的模式，例如 "aT,Ps,eNe,NP" ，其中子字符串是 tCategories 的有效键代替 tCategories[key] 中的任何字母.
我想弄清楚的是如何找到输入字符串中列出的每个模式的每个组合，并将它们全部放在一个数组中。所以例如 foo("aT,Ps,eNe,NP") 的预期输出将是 ["at","ad","ath","ps","ts","ks","qs","eme","ene","mp","mt","mk","mq","np","nt","nk","nq"] .
我的第一 react 是调用 String.split(",")在输入字符串上分别处理每个子字符串，否则通过 for (var key in tCategories) { input.replace(new RegExp(key, "g"), "["+tCategories[key].join("|")+"]" } 进行迭代，或其他东西......但我似乎无法在这些和预期输出之间找到有用的途径。它将涉及...什么，基本上实现了分配属性，但对于字母而不是数字？我该怎么做呢？

Answer 1

有关原始答案，请参见下文。
更新的答案
此答案适用于递归并收集组，例如

a[Ps,T]

它创建了一个新类别 (Ps-T)通过替换括号和逗号并获取结果

Ps,T
ps ts ks qs t d th

这也适用于嵌套括号。替换顺序从内到外括号。
通过这一更改，有必要接受比仅一个字符更长的键。现在它从最长的键搜索到最小的键。如果不存在键，则需要一个字母来进行笛卡尔准备。

function convert(string, tCategories) {
    const cartesian = (a, b) => a.reduce((r, v) => r.concat(b.map(w => [].concat(v, w))), []);

    let change;

    do {
        change = false;
        string = string.replace(/\[([^\[\]]+)\]/g, (_, p) => {
            const key = `(${p.replace(/,/g, '-')})`;
            tCategories[key] = convert(p, tCategories);
            change = true;
            return key;
        });
    } while (change);

    return string
        .split(/,/)
        .map(s => {
            const
                keys = Object.keys(tCategories).sort((a, b) => b.length - a.length),
                result = [];

            while (s.length) {
                const sub = keys.find(k => s.startsWith(k));
                if (sub) {
                    result.push(tCategories[sub]);
                    s = s.slice(sub.length);
                } else {
                    result.push([s[0]]);
                    s = s.slice(1);
                }
            }
            while (result.length < 2) result.push(['']);
            return result;
        })
        .map(a => a.reduce(cartesian).map(a => a.join('')))
        .flat();
}

const
    tCategories = { T: ["t", "d", "th"], P: ["p", "t", "k", "q"], N: ["m", "n"], Approx: ["j", "w"] };

console.log(convert('Ps,T', { ...tCategories }));
console.log(convert('a[Ps,T]', { ...tCategories }));
console.log(convert('a[Ps,T[aPbcApprox]],eNe,NP', { ...tCategories }));
console.log(convert("V,eNe,a[Ps,T],,ApproxT", { ...tCategories }));

.as-console-wrapper { max-height: 100% !important; top: 0; }

原始答案
你可以用逗号分割字符串，用它们的数组替换组，用数组中的字符替换单个字符，得到笛卡尔积，加入内部数组并得到带有结果的数组。
最后展平阵列。

const 
    cartesian = (a, b) => a.reduce((r, v) => r.concat(b.map(w => [].concat(v, w))), []),
    foo = string => string
        .split(',')
        .map(s => Array.from(s, c => tCategories[c] || [c]))
        .map(a => a.reduce(cartesian).map(a => a.join('')))
        .flat(),
    tCategories = { T: ["t", "d", "th"], P: ["p", "t", "k", "q"], N: ["m", "n"] };

console.log(...foo("aT,Ps,eNe,NP"));