根据Java中的特定字母规则替换生成可能的单词组合

我很难找到递归生成特定字母组合的最佳方法

目前，我有一个方法，可以更改字符串并更改某些字符来创建单词的单个替换

然而，这并不能满足单词的不同组合。例如，如果我有一个单词kjng通常会出现错误的打印机字符，例如：

[j=>i, i=>j, v=>u, u=>v, s=>f, f=>s, uu=>w, vv=>w]  (map lookup, "=>" this is symbolic for key, value representation to make it extra clear) 

根据这种方法，这个词将变成国王。对于一个只有一种可能性的词来说，这很好。然而，出现了murdir，这将产生以下内容：

  murdir
  mvrdjr
  mvrdir
  murdjr

---

关于这一点的一点建议将是非常好的，目前我不确定如何最好地管理这个场景。例如，如何跟踪更改，在字符块中执行（1、2、3等）

如果您的问题只是跟踪更改，并且您希望确保生成的组合全部，但其中无两次，那么您只需找到所有可能组合集的排序

我会将您的可能替换列表映射到一系列位，如下所示：

j=>i   ~ bit 0
i=>j   ~ bit 1
v=>u   ~ bit 2
u=>v   ~ bit 3
s=>f   ~ bit 4
f=>s   ~ bit 5
uu=>w  ~ bit 6
vv=>w  ~ bit 7

76543210
00101011 means you replace j=>i, i=>j, u=>v, f=>s
11000001 means you replace j=>i, uu=>w, vv=>w

然后实现某种二进制计数（0、1、10、11、100、101、110、111、1000、1001、1010、1011、1100等），并根据数字生成组合

我不是说它们必须是单个长/整数变量的位，但排序的思想是这样的。当然，如果您没有超过64个替换项，那么一个长变量就可以了：

String input = ...
List<...> replacements = ...
List<String> combinations = new ArrayList<>();
for (long count = 0; count < ...; count++) {
    String output = input;
    for (bit = 0; bit < 64; bit++) {
        if ((count & (1L << bit)) != 0) { // the bit is set
            // replace the characters based on replacements.get(bit)
            // output = ...
        }
    }
    combinations.add(output);
}

字符串输入=。。。
列表替换=。。。
列表组合=新的ArrayList（）；
用于（长计数=0；计数<…；计数++）{
字符串输出=输入；
用于（位=0；位<64；位++）{
如果（（计数和（1L 64），您可以使用相同的想法，对所有组合的集合进行排序，并根据来自的想法实施。
如果您的问题只是跟踪更改，并且您希望确保生成了所有组合，但没有一个组合，但它们两次，则只需找到排序f所有可能组合的集合

我会将您的可能替换列表映射到一系列位，如下所示：

j=>i   ~ bit 0
i=>j   ~ bit 1
v=>u   ~ bit 2
u=>v   ~ bit 3
s=>f   ~ bit 4
f=>s   ~ bit 5
uu=>w  ~ bit 6
vv=>w  ~ bit 7

76543210
00101011 means you replace j=>i, i=>j, u=>v, f=>s
11000001 means you replace j=>i, uu=>w, vv=>w

然后实现某种二进制计数（0、1、10、11、100、101、110、111、1000、1001、1010、1011、1100等），并根据数字生成组合

我的意思不是说它们必须是单个长/整数变量的位，但排序的思想是这样的。当然，如果没有超过64个替换项，那么单个长变量是好的：

String input = ...
List<...> replacements = ...
List<String> combinations = new ArrayList<>();
for (long count = 0; count < ...; count++) {
    String output = input;
    for (bit = 0; bit < 64; bit++) {
        if ((count & (1L << bit)) != 0) { // the bit is set
            // replace the characters based on replacements.get(bit)
            // output = ...
        }
    }
    combinations.add(output);
}

字符串输入=。。。
列表替换=。。。
列表组合=新的ArrayList（）；
用于（长计数=0；计数<…；计数++）{
字符串输出=输入；
用于（位=0；位<64；位++）{
如果（（计数和（1L 64），您可以使用相同的想法，对所有组合的集合进行排序，并根据来自的想法实施。
如果您的问题只是跟踪更改，并且您希望确保生成了所有组合，但没有一个组合，但它们两次，则只需找到排序f所有可能组合的集合

我会将您的可能替换列表映射到一系列位，如下所示：

j=>i   ~ bit 0
i=>j   ~ bit 1
v=>u   ~ bit 2
u=>v   ~ bit 3
s=>f   ~ bit 4
f=>s   ~ bit 5
uu=>w  ~ bit 6
vv=>w  ~ bit 7

76543210
00101011 means you replace j=>i, i=>j, u=>v, f=>s
11000001 means you replace j=>i, uu=>w, vv=>w

然后实现某种二进制计数（0、1、10、11、100、101、110、111、1000、1001、1010、1011、1100等），并根据数字生成组合

我的意思不是说它们必须是单个长/整数变量的位，但排序的思想是这样的。当然，如果没有超过64个替换项，那么单个长变量是好的：

String input = ...
List<...> replacements = ...
List<String> combinations = new ArrayList<>();
for (long count = 0; count < ...; count++) {
    String output = input;
    for (bit = 0; bit < 64; bit++) {
        if ((count & (1L << bit)) != 0) { // the bit is set
            // replace the characters based on replacements.get(bit)
            // output = ...
        }
    }
    combinations.add(output);
}

字符串输入=。。。
列表替换=。。。
列表组合=新的ArrayList（）；
用于（长计数=0；计数<…；计数++）{
字符串输出=输入；
用于（位=0；位<64；位++）{
如果（（计数和（1L 64），您可以使用相同的想法，对所有组合的集合进行排序，并根据来自的想法实施。
如果您的问题只是跟踪更改，并且您希望确保生成了所有组合，但没有一个组合，但它们两次，则只需找到排序f所有可能组合的集合

我会将您的可能替换列表映射到一系列位，如下所示：

j=>i   ~ bit 0
i=>j   ~ bit 1
v=>u   ~ bit 2
u=>v   ~ bit 3
s=>f   ~ bit 4
f=>s   ~ bit 5
uu=>w  ~ bit 6
vv=>w  ~ bit 7

76543210
00101011 means you replace j=>i, i=>j, u=>v, f=>s
11000001 means you replace j=>i, uu=>w, vv=>w

然后实现某种二进制计数（0、1、10、11、100、101、110、111、1000、1001、1010、1011、1100等），并根据数字生成组合

我的意思不是说它们必须是单个长/整数变量的位，但排序的思想是这样的。当然，如果没有超过64个替换项，那么单个长变量是好的：

String input = ...
List<...> replacements = ...
List<String> combinations = new ArrayList<>();
for (long count = 0; count < ...; count++) {
    String output = input;
    for (bit = 0; bit < 64; bit++) {
        if ((count & (1L << bit)) != 0) { // the bit is set
            // replace the characters based on replacements.get(bit)
            // output = ...
        }
    }
    combinations.add(output);
}

字符串输入=。。。
列表替换=。。。
列表组合=新的ArrayList（）；
用于（长计数=0；计数<…；计数++）{
字符串输出=输入；
用于（位=0；位<64；位++）{
如果（（count&（1L 64），您可以使用相同的思想对所有组合的集合进行排序，并根据中的思想进行实现。
如果需要递归执行，那么这样做如何？这是类似python的伪代码

#
# make a list of locations of all possible typos
# 

s = []     # list
for i in range(0, len(source)):
    if source[i] might be typo:
        s.append(i)

# 
# and to the recursion to find all combinations
#
print do_recurse(source, s)

# 
# method that returns the correct char corresponding to the typo
# 
def correction(char):
    # you should implement

# 
# the actual recursion method
#
def do_recurse(str, locations):
    '''
    return the list of all combinations
    '''
    if len(locations) <= 0:
        return []

    ret = []
    for loc in locations:
        # do the recursion with the string before the modification
        r = do_recurse(str, locations[1:])
        ret.extend( r )

        # do the recursion with the modified string
        str[loc] = correction(str[loc])
        r = do_recurse(str, locations[1:])
        ret.extend( r )

    return ret

#
#列出所有可能的打字错误的位置
# 
s=[]#列表
对于范围（0，len（源））中的i：
如果来源[i]可能是打字错误：
s、 附加（i）
# 
#和递归，以找到所有的组合
#
重复打印（源，s）
# 
#方法，该方法返回与键入相对应的正确字符
# 
def校正（字符）：
#你应该实施
# 
#实际递归方法
#
def do_递归（str，位置）：
'''
返回所有组合的列表
'''
如果len（locations）如果需要递归执行，那么这个呢