Question

我需要在特定范围内生成所有可能的字符串。例如
上限 - aaa
Lowe界限 - ccc

也可能是aab-caa，hhu - kkk，但不是aaz - ccc 值应为

    aaa
    aab
    aac
    aba
    abb
    abc
    aca
    acb
    acc
    caa
    cab
    cac
    cca
    ccb
    ccc

我写了这样的方法，但它没有正常工作，我不知道如何正确地做到这一点，现在我很难抓住所有可能的情况，请帮忙

 public static List<String> generateAllPossibleStrings(String start, String end) {
        if (start.length() != end.length()) {
            return null;
        }
        List<String> variants = new ArrayList<>();
        char startArray[] = start.toCharArray();
        char endArray[] = end.toCharArray();
        char currentArray[] = Arrays.copyOf(startArray, startArray.length);
        variants.add(new String(currentArray));
        for (int i = startArray.length - 1; i >= 0; i--) {
            while (currentArray[i] != endArray[i]) {
                currentArray[i]++;
                variants.add(new String(currentArray));
                for (int j = startArray.length - 1; j > i; j--) {
                    while (currentArray[j] != endArray[j]) {
                        currentArray[j]++;
                        variants.add(new String(currentArray));
                    }
                    currentArray[j] = startArray[j];

                }
            }
            currentArray[i] = startArray[i];
        }

        System.out.println(Arrays.toString(variants.toArray()));
        return variants;
    }

上面的例子我得到了

[aaa, aab, aac, aba, abb, abc, aca, acb, acc, baa, bab, bac, bba, bca, caa, cab, cac, cba, cca]

正如您所看到的，缺少一些值。

请帮助纠正此方法并使其正常工作，或者可能应将其实现为递归方法。

说明

为什么aaz - ccc不可能，因为下边界（ccc）中的任何字符都应该更大，在此示例aaz中上限（z）中的相应字符比c更重要，所以这是不正确的。

Answer 1

编辑：我可能误解了这个问题，我认为结束字符串位于每个位置的起始字符串之上，但是其他例子似乎并非如此。你能告诉你应该在hhu-kkk上输出什么，并解释一下aaz-ccc有什么问题吗？

EDIT2：我怀疑，hhu-kkk输入错误（u> k），你应该再次编辑你的问题。

将字符串视为一个数字，然后递增。

当你在一个位置上方的结束字符串之上时，你会改为起始字符串的字母并增加下一个字母，就像带有进位的加法一样。

这是您的代码的修改版本。它现在还检查两个字符串是否满足您描述的所有属性（如果正确使用该函数，则不应该这样做。）

public static List<String> generateAllPossibleStrings(String start, String end) {
    if(start==null||end==null)
        return null;
    if (start.length() != end.length())
        return null;
    int n = start.length();
    List<String> variants = new ArrayList<>();
    char startArray[] = start.toCharArray();
    char endArray[] = end.toCharArray();
    char currentArray[] = Arrays.copyOf(startArray, startArray.length);
    variants.add(new String(currentArray));

    //We check if the start string is really above the end string as specified
    //We output an empty string if it is not the case
    boolean possible = true;
    for(int i = 0; i<n; i++)
        possible = possible && (startArray[i]<=endArray[i]);
    if (!possible)
        return variants;


    while(!end.equals(new String(currentArray))){
        currentArray[n-1]+=1;
        int i = n-1;
        while(currentArray[i]>endArray[i]){
            currentArray[i]=startArray[i];
            i--;
            currentArray[i]++;
        }
        variants.add(new String(currentArray));
    }

    System.out.println(Arrays.toString(variants.toArray()));
    return variants;
}

Answer 2

我会使用single responsibility principle，将实现拆分为小的clear方法并使用递归

import java.util.ArrayList;
import java.util.List;

public final class Permutations {

    public static List<String> generate(String begin, String end) {
        List<String> result = new ArrayList<>();

        String current = begin;
        while (true) {
            result.add(current);
            if (current.equals(end))
                break;
            current = getNextPermutation(current, end);
        }

        return result;
    }

    private static String getNextPermutation(String current, String end) {
        char[] candidate = current.toCharArray();
        createNextPermutation(candidate, current.length()-1, end);
        return String.valueOf(candidate);
    }

    private static void createNextPermutation(char[] candidate, int index, String end) {
        char c = getNextChar(candidate[index]);
        if (c > end.charAt(index)) {
            candidate[index] = 'a';
            createNextPermutation(candidate, index-1, end);
        }
        else {
            candidate[index] = c;
        }
    }

    private static char getNextChar(char c) {
        return (char)(c + 1);
    }
}

生成范围内的所有可能字符串

2 个答案: