如何在java中打印数组长度的可能排列

Question

我正在处理任务，我必须显示数组长度的可能排列。我尝试了一些技巧，但它仍然提供了许多输出的列表，最后我的项目崩溃了。

我已经在数学上尝试过，我得到了答案“39916800。

例如：对于输入数组[3,2,1,4,6]，总共有5个！ = 120可能。

问题是：

鉴于int [] a = [3,10,4,6,1,8,5,9,0,11,7,2]。在你再次获得一次之前，你有多少经常与自己置换（这就是所谓的a度）？

示例：[0,2,1]的度数为2，因为置换（[0,2,1]，[0,2,1]）= [0,1,2]和置换（[0,1， 2]，[0,2,1]）= [0,2,1]。

答案应该是8位数。

这是我的代码：

public class Permute{
static void permute(java.util.List<Integer> arr, int k){
    for(int i = k; i < arr.size(); i++){
        java.util.Collections.swap(arr, i, k);
        permute(arr, k+1);
        java.util.Collections.swap(arr, k, i);
    }
    if (k == arr.size() -1){
        System.out.println(java.util.Arrays.toString(arr.toArray()));
    }
}
public static void main(String[] args){
    Permute.permute(java.util.Arrays.asList(3,4,6,2,1), 0);
}

}

Answer 1

看看下面的例子：

public class Main {
    static int[] requestedNumbs = {3,4,6,2,1};


public static List<List<Integer>> permuteUnique(int[] nums, int index) {
        List<List<Integer>> newList = new LinkedList<>();
        if (index == nums.length - 1) {
            List<Integer> newPermute = new LinkedList<>();
            newPermute.add(nums[index]);
            newList.add(newPermute);
        } else {
            List<List<Integer>> oldList = permuteUnique(nums, index + 1);
            for (List<Integer> permute : oldList) {
                int permuteSize = permute.size();
                int i = 0;
                for (; i < permuteSize; i++) {
                    List<Integer> newPermute = new LinkedList<>();
                    newPermute.addAll(permute.subList(0, i));
                    newPermute.add(nums[index]);
                    newPermute.addAll(permute.subList(i, permuteSize));
                    newList.add(newPermute);
                    if (permute.get(i) == nums[index]) {
                        break;
                    }
                }
                if (i == permuteSize) {
                    List<Integer> newPermute = new LinkedList<>();
                    newPermute.addAll(permute.subList(0, permuteSize));
                    newPermute.add(nums[index]);
                    newList.add(newPermute);
                }
            }
        }
        return newList;
    }

    public static void main(String[] args) {
       List<List<Integer>> list = permuteUnique(requestedNumbs,0);
       System.out.println("Size of a list: " + list.size());
       System.out.println(list);
    }
}

Answer 2

如果您的任务只是计算给定数组的可能排列数，则无需实际制作和输出这些排列。请注意，数字呈指数增长。相反，您可以用数学方式计算数字。做吧！在一个简单的for循环中。

如果确实只有唯一的整数：

public int permutations(int[] numbers){
  int result = 1;
  for(int i=2; i<=numbers.size(); i++){
    result*=i;
  }
  return result;
}