Question

嗨，有些人请以简单的方式向我解释下面的紊乱/排列计划。

从过去的一周开始，我正在敲打我的头脑以了解该计划。我已经了解了所有方法，但我无法理解＆＃34; else部分＆＃34; 。我已经尝试过调试程序但是没有清楚地知道else部分发生了什么。

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. 数组只是您输入的数字列表，已订购从最低有效数字到最重要数字。

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

i = 2
对于由外部索引的数字数组中的每个数字 - 将修复设置为当前存储在数组第一个元素中的数字

       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设置为数字数组当前表示的十进制数，除了该修复是最低有效数字
打印uniqueNo作为当前值j

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

如果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个数字，则只有两个排列，当然1个数字只有一个排列，所以这些是特殊情况。如果迭代每个数字，保持一个数字“固定”的最大排列数是阶乘/数字位数。

有人可以解释我这个排列/紊乱程序

1 个答案: