Question

我在这里浏览了所有关于Permutation String的方法，我是一个接近的方法，但它仍然没有像我期望的那样工作。如何从此输入生成输出：输入：5，输出：显示从a到zzzzz的字符串组合。如果我输入6作为输入，它将来自a的{{1}}输出。

这里有办法吗？我发现如果我放3，我应该使用3个循环，6个输入意味着6个循环，但我仍然是静态的，而不是动态的。我的意思是我不能通过3输入制作3个循环。

这是我目前的代码：

zzzzzz

*编辑：*我上面的代码直接显示5长度，这是我希望它从1长度到5（输入）开始。

Answer 1

我认为这是一个“学习练习”而不是真正的编程问题。（没有人在正确的思想中尝试将26^6（即3.08亿）行写入标准输出......）

所以这是一个提示：

使用递归，StringBuilder或char[]。

我还应该补充一点，这不是置换问题。这是组合问题。而且这里没有排序。而是按顺序生成字符串。

Answer 2

首先，让我们看看你当前的代码是做什么的：

您有整数i，j和k，它们都从0开始。整数i对应于pattern变量中的字母你将使用你的字符串的第一个位置。整数j对应于第二个位置，k对应于第三个位置。

然后，您的循环按以下顺序修改i，j和k的值：

i=0, j=0, k=0 => corresponds to "aaa"
i=0, j=0, k=1 => corresponds to "aab"
i=0, j=0, k=2 => corresponds to "aac"

这一直持续到

i=0, j=0, k=25 => corresponds to "aaz"
i=0, j=1, k=0  => corresponds to "aba"

我们看到j递增1并k重置为0.同样，当j = 25且k = 25后，我们会增加{ {1}}一个，并将i和j重置为0.然后我们再次开始递增k。它类似于我们的十进制表示法，在199之后我们得到200.

因此，要将其应用于不断变化的长度，我们需要一种以动态方式存储变量的方法。最好的工具是整数数组。

想象一下整数数组k。它的长度取决于你的输入。您可以像这样初始化它：

int idx[]

现在我们将使用int idx[] = new int[n];//where n is the length of the generated strings来存储idx，i和j等整数，它们将对应于用于生成字符串的字符。例如，如果k数组的长度为6且值为[0,0,2,4,25,25]，则它将对应于字符串“aacezz”。

要生成所有可能的字符串，请将idx的所有值设置为0（对应于“aaaaaa”），然后创建while循环。在每次迭代中，您“递增”idx in的值以获取下一个生成的字符串。这是基本结构的样子

idx

请注意，我没有输入代码 - 只是描述了java注释中应该发生的事情。你应该能够填补其余部分。

祝你好运！

Answer 3

以下是使用两种方法相互调用的递归模式示例。

private String pattern = "abcdefghijklmnopqrstuvxyz";
private int numChar = 3;

public void permutateY(String prefix, int charPos, int patternPos) {
    if (patternPos>=pattern.length()) return;

    if (prefix == null) {
        permutateX(String.valueOf(pattern.charAt(patternPos)), charPos+1, 0);
    } else {
        permutateX(prefix + String.valueOf(pattern.charAt(patternPos)), charPos+1, 0);
    }
    permutateY(prefix, charPos, patternPos+1);
}

public void permutateX(String combi, int charPos, int patternPos) {
    if (charPos < numChar) {
        permutateY(combi, charPos, 0);
    } else {
        System.out.println(combi);
    }
}

然而，我完全赞同@Stephen C，它打印出来的疯狂26 ^ 6：p

Answer 4

这将按预期工作。但请记住斯蒂芬C所说的话。

import java.util.*;

public class Main {
public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    Map<Integer, String> myMap = new HashMap<>();
    myMap.put(1, "a");
    myMap.put(2, "b");
    myMap.put(3, "c");
    myMap.put(4, "d");
    myMap.put(5, "e");
    myMap.put(6, "f");
    myMap.put(7, "g");
    myMap.put(8, "h");
    myMap.put(9, "i");
    myMap.put(10, "j");
    myMap.put(11, "k");
    myMap.put(12, "l");
    myMap.put(13, "m");
    myMap.put(14, "n");
    myMap.put(15, "o");
    myMap.put(16, "p");
    myMap.put(17, "q");
    myMap.put(18, "r");
    myMap.put(19, "s");
    myMap.put(20, "t");
    myMap.put(21, "u");
    myMap.put(22, "v");
    myMap.put(23, "w");
    myMap.put(24, "x");
    myMap.put(25, "y");
    myMap.put(26, "z");

    Scanner in = new Scanner(System.in);
    System.out.println("Enter limit here [input type: integer]\n");
    int lim = in.nextInt();
    String[] arr = new String[26 * lim];
    int i = 0;
    int j = lim;
    int k = 1;
    while (i < arr.length) {
        while (lim > 0) {
            arr[i] = myMap.get(k);
            lim--;
            i++;
        }
        lim = j;
        k++;
    }
    print_nCr(arr,arr.length, lim);
}

public static final void print_nCr(String[] arr,final int n, final int r) {
    int[] res = new int[r];
    for (int i = 0; i < res.length; i++) {
        res[i] = i + 1;
    }
    boolean done = false;
    while (!done) {
        for(int i=0;i<res.length;i++){
            System.out.print(arr[res[i]-1]);
        }
        System.out.print("\n");
        done = getNext(res, n, r);
    }
}
public static final boolean getNext(final int[] num, final int n, final int r) {
    int target = r - 1;
    num[target]++;
    if (num[target] > ((n - (r - target)) + 1)) {
        while (num[target] > ((n - (r - target)))) {
            target--;
            if (target < 0) {
                break;
            }
        }
        if (target < 0) {
            return true;
        }
        num[target]++;
        for (int i = target + 1; i < num.length; i++) {
            num[i] = num[i - 1] + 1;
        }
    }
    return false;
}

}

以下是您编辑过的问题的答案。试试这个

import java.util.*;

public class Main {
public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    Map<Integer, String> myMap = new HashMap<>();
    myMap.put(1, "a");
    myMap.put(2, "b");
    myMap.put(3, "c");
    myMap.put(4, "d");
    myMap.put(5, "e");
    myMap.put(6, "f");
    myMap.put(7, "g");
    myMap.put(8, "h");
    myMap.put(9, "i");
    myMap.put(10, "j");
    myMap.put(11, "k");
    myMap.put(12, "l");
    myMap.put(13, "m");
    myMap.put(14, "n");
    myMap.put(15, "o");
    myMap.put(16, "p");
    myMap.put(17, "q");
    myMap.put(18, "r");
    myMap.put(19, "s");
    myMap.put(20, "t");
    myMap.put(21, "u");
    myMap.put(22, "v");
    myMap.put(23, "w");
    myMap.put(24, "x");
    myMap.put(25, "y");
    myMap.put(26, "z");

    Scanner in = new Scanner(System.in);
    System.out.println("Enter limit here [input type: integer]\n");
    int lim = in.nextInt();
    String[] arr;
    for(int x=1;x<lim+1;x++){
        arr= new String[26 * x];
        int i = 0;
        int j = x;
        int k = 1;
        while (i < arr.length) {
            while (x > 0) {
                arr[i] = myMap.get(k);
                x--;
                i++;
            }
            x = j;
            k++;
        }
        print_nCr(arr,arr.length, x);

    }

}

public static final void print_nCr(String[] arr,final int n, final int r) {
    int[] res = new int[r];
    for (int i = 0; i < res.length; i++) {
        res[i] = i + 1;
    }
    boolean done = false;
    while (!done) {
        for(int i=0;i<res.length;i++){
            System.out.print(arr[res[i]-1]);
        }
        System.out.print("\n");
        done = getNext(res, n, r);
    }
}
public static final boolean getNext(final int[] num, final int n, final int r) {
    int target = r - 1;
    num[target]++;
    if (num[target] > ((n - (r - target)) + 1)) {
        while (num[target] > ((n - (r - target)))) {
            target--;
            if (target < 0) {
                break;
            }
        }
        if (target < 0) {
            return true;
        }
        num[target]++;
        for (int i = target + 1; i < num.length; i++) {
            num[i] = num[i - 1] + 1;
        }
    }
    return false;
}

}

Java Sorted String Permutation具有一定限制

4 个答案: