打印从 1 到 x 的所有可能选项

Question

有没有办法在没有重复数字且数字数量可变的情况下打印 1 到 x 的所有可能选择？

所以基本上如果 x = 10，并且 n（列表的长度）= 5

[1,2,3,4,5],  [1,2,3,4,6]...
[2,1,3,4,5]...
[10,9,8,7,6]

生成这些列表的顺序无关紧要，因此如果方便的话，示例中的第二个列表可以最后打印

编辑

到目前为止我已经尝试过，但不容易改变

    for (int a = 1; a < x; a++) {
        Set<Integer> data = new HashSet<>();
        data.add(a);

        for (int b = 1; b < x; b++) {
            if(data.contains(b)) continue;
            data.add(b);
            for (int c = 1; c < x; c++) {
                if(data.contains(c)) continue;
                data.add(c);
                for (int d = 1; d < x; d++) {
                    if(data.contains(d)) continue;
                    data.add(d);
                    for (int e = 1; e < x; e++) {
                        if(data.contains(d)) continue;
                        //code
                    }
                }
            }
        }

Answer 1

这里有一些代码可以找到所有可能的选择，而不依赖于存储先前生成的选择并检查您是否已经输出它们：

public static void permuteArray(int[] array, int start) {
    if (array.length == start) {
         System.out.println(Arrays.toString(array));
    } else {
        for (int i = start; i < array.length; i++) {
            int temp = array[i];
            array[i] = array[start];
            array[start] = temp;
            permuteArray(array, start + 1);
            temp = array[i];
            array[i] = array[start];
            array[start] = temp;
        }
    }
}
public static void makeCombinations(int[] array, int startElement, int minValue, int maxValue, int length, boolean permute)
{
    // iterate through all values from minValue to maxValue minus the remaining spaces
    int remainingSpacesAfterThisOne = (length - 1) - startElement;
    for(int i = minValue; i <= (maxValue - remainingSpacesAfterThisOne); i++)
    {
        array[startElement] = i;
        if(startElement < (length - 1))
           makeCombinations(array, startElement + 1, i + 1, maxValue, length, permute);
        else
        {
            if(permute)
                // print out all permutations of this array:
                permuteArray(array, 0);
            else
                // print out the combination
                System.out.println(Arrays.toString(array));
        }
    }
}

public static void makeCombinations(int max, int length, boolean permute)
{
    int[] array = new int[length];
    makeCombinations(array, 0, 1, max, length, permute);
}

public static void main (String[] args)
{
    makeCombinations(10, 5, true);
}

代码生成所有可能的长度非重复数字选择，其中选择中的数字是升序，并且可选找到这些选择的所有可能排列。

如果您的最大值为 10，长度为 5，并且您的选择是按升序排列的，那么对于第一项，您只能选择 1 到 6（含）之间的一个数字（否则您不会有足够的数字来填写其余的选择，而无需重复一个或不按升序排列）。因此，该算法迭代第一项的可能合法值，然后为每个值递归生成可以构成列表其余部分的可能选择，通过传入第一个值加一个作为最小值来强制升序。

一旦没有更多的值可以生成，递归就会停止，然后可以使用简单的递归置换函数来置换升序选择，以找到所有可能的顺序。

Answer 2

看来你有办法了。现在您只需要能够处理 n 的任意值。如果不是将 n 个变量 a,b,c,... 存储在 Array[n] 中会怎么样？你能模拟有 n 个循环吗？

Answer 3

我根据建议

想出的代码

    int[] array = new int[len];
    Arrays.fill(array, 1);

    while(array[0] < X) {
        System.out.println(Arrays.toString(array));

        //CODE

        array[len-1]++;
        for(int a = len-1; a > 0; a--) {
            for(int b = a-1; b >= 0;) {
                if(array[a] == array[b]) {
                    array[a]++;
                } else b--;

            }

            if(array[a] >= X) {
                array[a] = 1;
                array[a-1]++;
            }
        }

打印从 1 到 x 的所有可能选项

Print all possible choices from 1 to x

java

algorithm

combinations