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);
}

代码生成 length 非重复数字的所有可能选择，其中选择中的数字是按升序，并且可选地查找这些选择的所有可能的排列

如果您的最大值为10且长度为5，并且您的选择按升序排列，那么对于第一个项目，您只能选择1到6之间的数字（否则您将赢得＃t; t有足够的数字来填写选择的其余部分而不重复或退出升序。因此，算法迭代第一项的可能合法值，然后为每个值递归地生成可构成列表其余部分的可能选择，通过传入第一个值加1作为最小值来强制执行升序。 / p>

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

Answer 2

看起来你有一个解决方案。现在你只需要能够处理n的任意值。如果没有n个变量a，b，c，...你将这些值存储在一个数组[n]中怎么办？你能模拟出n个循环吗？

Answer 3

我在Adam's建议中提出的代码

    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的所有可能选择

3 个答案: