java - 有人能给我解释一下这个排列/紊乱程序吗

Question

你好，有人可以用简单的方式向我解释下面的紊乱/排列程序吗？

从过去的一周开始，我一直在努力理解这个程序。我已经了解所有方法，但无法理解“其他部分”。我已尝试调试该程序，但不清楚其他部分发生了什么。

import java.util.Scanner;

public class Deranged {

    public static void main(String args[]) {
        Scanner s = new Scanner(System.in);
        System.out.println("Enter a number");
        int num = s.nextInt();
        System.out.println("Number :" + num);
        int size = digitSize(num);
        System.out.println("Size :" + size);
        System.out.println("Permutation :" + fact(size));
        int swap = fact(size);
        int array[] = digitArray(num, size);
        if (size < 3) {
            if (size < 2) {
                System.out.print(num);
            } else {
                System.out.println(array[0] + "" + array[1]);
                System.out.println(array[1] + "" + array[0]);
            }
        } else {    // NEED CLARITY FROM HERE
            int i = 2;
            for (int outer = 0; outer <= size - 1; outer++) {
                int fix = array[0];
                for (int j = 1; j <= swap / size; j++) {
                    if (i == size) {
                        i = 2;
                    }
                    int temp = array[i - 1];
                    array[i - 1] = array[i];
                    array[i] = temp;
                    i++;
                    int uniqueNo = fix;
                    for (int k = 1; k < size; k++) {
                        uniqueNo = (uniqueNo * 10) + array[k];
                    }
                    System.out.println(j + ": " + uniqueNo);
                }
                int t = array[0];
                if ((outer + 1) > size - 1) {
                    array[0] = array[outer];
                    array[outer] = t;
                } else {
                    array[0] = array[outer + 1];
                    array[outer + 1] = t;
                }
            }
        }
    }

    public static int fact(int num) {
        int factNo = 1;
        for (int i =num; i > 0; i--) 
        {
            factNo = factNo * i;
        }
        return factNo;
    }

    public static int digitSize(int num) {

        //int count = String.valueOf(num).length();
        // return count;
        int count = 0;
        while(num>0)
        {
            num/=10;
            count++;
        }
        return count;
    }

    public static int[] digitArray(int num, int size) {
        int count[] = new int[size];
        int i = size - 1, rem;
        while (num > 0) {
            rem = num % 10;
            count[i] = rem;
            num = num / 10;
            i--;
        }
        return count;
    }
}

Answer 1

在代码中，size 是您号码中的位数，swap 是位数的阶乘。例如，如果您输入一个 5 位数字，fact 函数计算 5 * 4 * 3 * 2 * 1。array 只是您输入的数字列表，按顺序排列从最低有效位到最高有效位。

所以这是数字位数为 3 或更大的情况的伪代码。我交错了代码以使其更清晰。

我=2
对于由 outer
索引的数字数组中的每个数字 - 将 fix 设置为当前存储在数组第一个元素中的数字

       int i = 2;
        for (int outer = 0; outer <= size - 1; outer++) {
            int fix = array[0];

对于每个索引j从1到位数除以位数的阶乘
- 如果 i 等于位数，则设置 i 等于 2
- 将数字 i-1 与数字数组中的数字 i 交换
- 增量 I

            int fix = array[0];
            for (int j = 1; j <= swap / size; j++) {
                if (i == size) {
                    i = 2;
                }
                int temp = array[i - 1];
                array[i - 1] = array[i];
                array[i] = temp;
                i++;

设置uniqueNo为digit数组当前代表的十进制数，除了fix是最低位
打印 j 的当前值的 uniqueNo

                int uniqueNo = fix;
                for (int k = 1; k < size; k++) {
                    uniqueNo = (uniqueNo * 10) + array[k];
                }
                System.out.println(j + ": " + uniqueNo);

如果outer的当前值是digit数组的最后一个元素
- 将数组中的第一个数字与最后一个数字交换
否则
- 将数组的第一个数字与 outer+1 处的数字交换

           int t = array[0];
            if ((outer + 1) > size - 1) {
                array[0] = array[outer];
                array[outer] = t;
            } else {
                array[0] = array[outer + 1];
                array[outer + 1] = t;
            }  

该代码基本上是为输入的数字的每个数字迭代阶乘/数字次数，并在每次迭代中以从最后一位数字到第一个数字的方式重新排列数字。很难理解，部分原因是变量名称没有提供信息。

n个不同对象的排列数是n! (阶乘)，所以代码只是列出了输入数字的所有可能的排列。如果只有2位，就只有2个排列，当然1个位也只有1个排列，所以都是特例。如果您遍历每个数字，则保持一个数字“固定”的最大排列数是阶乘/数字数。