具有多字符替换的字符串组合（产生返回Java的替代重写）[关闭]

还有另一篇 Stack Overflow 帖子是为与车辆登记号相关的算法创建的......

根据输入的车牌（例如ABC123）和列表 替换值（例如 1 替换为 I）。我需要得到所有的可能 组合。

@ArturoMenchaca 的答案对于 C# 来说是完美的，但我希望用 Java 来实现，但考虑到“yield”不可用，我真的不知道如何转换它。

您将如何将此代码翻译成 Java？

public static IEnumerable<string> Combinations(string s, Dictionary<char, char> replacements)
{
    return Combinations(s, replacements, 0, string.Empty);
}

private static IEnumerable<string> Combinations(string original, Dictionary<char, char> replacements, int index, string current)
{
    if (index == original.Length) yield return current;
    else
    {
        foreach (var item in Combinations(original, replacements, index + 1, current + original[index]))
            yield return item;

        if (replacements.ContainsKey(original[index]))
            foreach (var item in Combinations(original, replacements, index + 1, current + replacements[original[index]]))
                yield return item;
    }
}

你会调用然后调用这样的方法..

Dictionary<char, char> dict = new Dictionary<char,char>();
dict['1'] = 'I';
dict['3'] = 'B';
dict['A'] = 'H';
dict['O'] = '0';
dict['0'] = 'O';

var combs = Combinations("ABC123", dict);

Java 没有像 C# 那样使用“推送”逻辑迭代值的功能yield return does.

Java仅支持“拉”逻辑，使用Enumeration https://docs.oracle.com/javase/8/docs/api/java/util/Enumeration.html, Iterator https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html, or Spliterator https://docs.oracle.com/javase/8/docs/api/java/util/Spliterator.html (what Stream https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html uses).

如果你有记忆，你当然可以将所有组合“推入”一个ArrayList，然后从那里“拉”值。转换yield return逻辑成list.add()调用很容易，所以我假设你不想要这样。

Java 相当于IEnumerable is Iterable https://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html，所以你需要一个Iterator执行。

下面的代码将做到这一点。它是基于我对另一个问题的回答 https://stackoverflow.com/a/46374733/5221149，所以请阅读该答案以获取整体逻辑的解释，但基本上，您的示例就像在这个锯齿状数组中生成字符组合：

{{'A', 'H'}, {'B'}, {'C'}, {'1', 'I'}, {'2'}, {'3', 'B'}}

在下面的代码中，锯齿状数组是textChars数组，但不是使用char[]它使用一个String，因为一个String实际上只是只读char[].

public static Iterable<String> combinations(String text, String... replacements) {
    Map<Character, String> repl = new HashMap<>();
    for (String r : replacements)
        if (repl.putIfAbsent(r.charAt(0), r) != null)
            throw new IllegalArgumentException("Duplicate replacement: [" + repl.get(r.charAt(0)) + "] vs [" + r + "]");
    String[] textChars = new String[text.length()];
    long count = 1;
    for (int i = 0; i < textChars.length; i++) {
        textChars[i] = repl.getOrDefault(text.charAt(i), text.substring(i, i+1));
        count = Math.multiplyExact(count, textChars[i].length());
    }
    long comboCount = count;
    return () -> new Iterator<>() {
        private long combo = 0;
        @Override
        public boolean hasNext() {
            return (this.combo < comboCount);
        }
        @Override
        public String next() {
            if (this.combo >= comboCount)
                throw new NoSuchElementException();
            long c = this.combo++;
            char[] buf = new char[textChars.length];
            for (int i = buf.length - 1; i >= 0; i--) {
                buf[i] = textChars[i].charAt((int) (c % textChars[i].length()));
                c /= textChars[i].length();
            }
            return new String(buf);
        }
    };
}

Test

combinations("ABC123", "1I", "3B", "AH", "O0", "0O").forEach(System.out::println);

Output

ABC123
ABC12B
ABCI23
ABCI2B
HBC123
HBC12B
HBCI23
HBCI2B