java - 计算数字中不重复的数字

Question

我正在尝试优化我的程序计数器。这取决于数字的大小(从 3 到 10 位数字，没有重复) - 例如012、013214等我的第一个解决方案是 for 循环，如下所示:

private void sample() {
        int[] varValue = new int[3];
        innerloop: for (int a = 0; a < 10; a++) {
            for (int b = 0; b < 10; b++) {
                if (a == b)
                    continue;
                for (int c = 0; c < 10; c++) {
                    if (c == b)
                        continue;
                    if (c == a)
                        continue;
                    varValue[0] = a;
                    varValue[1] = b;
                    varValue[2] = c;

                    int EqOne = varValue[0] * 100 + varValue[1] * 10 + varValue[2];

                    if (EqOne == 432) {
                        System.out.println(varValue[0]);
                        System.out.println(varValue[1]);
                        System.out.println(varValue[2]);
                        break innerloop;
                    }

                }
            }

        }
    }

或 10 位数字 ( https://gist.github.com/TrollerN/6a0e470c539c57fd4cd73086cf6eb41b )

然后我可以将这些 a、b、c 添加到 int[] 或 ArrayList 中并使用它。没关系，但是对于 10 个不同的数字，它需要 10 个带有 if 语句的 for 循环 + 我必须创建 8 种不同的方法 - 每个数字一个。

我还尝试创建 10 位数字(0,1,2,3,4,5,6,7,8,9)的 ArrayList，对其进行洗牌，并返回 3-10 位数字，但它可能永远不会- 9-10 位数字的结束循环。

我的下一个“伟大”想法(不，老实说，这是迄今为止最愚蠢的一个:D)是针对每种情况将组合的 ArrayList 保存到文件中，然后加载所需的组合并通过它来找到解决方案。

我正在考虑创建一些方法来获取位数(“这样它就知道需要多少个循环”)和/或最后一个解决方案，以便它知道要开始。

编辑: 我已经用示例方法修改了问题。当然， int EqOne 和 If 语句要复杂得多，但它在技术上显示了我想要实现的目标 - 至少我希望:P

我正在寻找的是一种方法，它将根据需要创建尽可能多的循环和大数组/数组列表？

Answer 1

假设您想要给定长度的数字，而不是字符串，一种方法是使用boolean[10]记住当前正在使用哪些数字，这样就可以快速跳过它们。

然后将数字保留在数组中，并像普通数字一样增加最后一位数字。当它翻转时，您将增加倒数第二个数字，依此类推，将尾随数字重置为未使用的数字。

示例:如果当前号码是 1097，则如下所示:

Digits  In Use               Description
1097    0 1 _ _ _ _ _ 7 _ 9
1097    0 1 _ _ _ _ _ _ _ 9  Clear in-use of last digit
1098    0 1 _ _ _ _ _ _ _ 9  Increment last digit
1098    0 1 _ _ _ _ _ _ 8 9  Mark in-use
=======================================================
1098    0 1 _ _ _ _ _ _ _ 9  Clear in-use of last digit
1099    0 1 _ _ _ _ _ _ _ 9  Increment last digit, but it's in use
109?    0 1 _ _ _ _ _ _ _ 9  Rollover, so go to previous digit
109?    0 1 _ _ _ _ _ _ _ _  Clear in-use
10??    0 1 _ _ _ _ _ _ _ _  Rollover, so go to previous digit
10??    _ 1 _ _ _ _ _ _ _ _  Clear in-use
11??    _ 1 _ _ _ _ _ _ _ _  Increment digit, but it's in use
12??    _ 1 _ _ _ _ _ _ _ _  Increment digit
12??    _ 1 2 _ _ _ _ _ _ _  Mark in-use
120?    0 1 2 _ _ _ _ _ _ _  Set to first unused digit, and mark in-use
1203    0 1 2 3 _ _ _ _ _ _  Set to first unused digit, and mark in-use
=======================================================

如您所见，逻辑使其从 1097 到 1098 再到 1203。

这是其逻辑。请参阅IDEONE用于运行示例。

final class UniqueDigitCounter {
    private int[]     digits;
    private boolean[] inUse = new boolean[10];
    public UniqueDigitCounter(int digitCount) {
        if (digitCount < 1 || digitCount > 10)
            throw new IllegalArgumentException("Invalid digit count: " + digitCount);
        this.digits = new int[digitCount];
        for (int i = 0; i < digitCount; i++) {
            this.digits[i] = i;
            this.inUse[i] = true;
        }
    }
    public long next() {
        if (this.digits == null)
            return -1; // end of sequence
        long value = 0;
        for (int i = 0; i < this.digits.length; i++)
            value = value * 10 + this.digits[i];
        for (int i = this.digits.length - 1; ; i--) {
            if (i == -1) {
                this.digits = null; // end of sequence
                break;
            }
            int digit = this.digits[i];
            this.inUse[digit] = false;
            if ((digit = nextDigit(digit + 1)) != -1) {
                this.digits[i] = digit;
                while (++i < this.digits.length)
                    this.digits[i] = nextDigit(0);
                break;
            }
        }
        return value;
    }
    private int nextDigit(int minDigit) {
        for (int digit = minDigit; digit < 10; digit++)
            if (! this.inUse[digit]) {
                this.inUse[digit] = true;
                return digit;
            }
        return -1;
    }
}