java - 按升序递增一组唯一数字

Question

所以我有这个数组，它只包含唯一的数字，索引 0 处的数字最低，数组末尾的数字最高。

例如[1,2,3,4]

现在我每次将后面的数字加1。但是当任何数字达到一定高度时，它应该增加左边的数字。

例如假设最大高度为 8。

[1,2,3,8] -> [1,2,4,5]

现在我的代码可以正常工作了。但是当最后两个数字达到最大高度时，它不会再增加倒数第三个。

例如[1,2,7,8] -> [1,3,4,5]

我写的代码是递归的。

//Position is the index in the array of which element should be incremented by 1
public int[] increaseArray(int[] index, int maxIndex, int position) {
        int tmp = index[position];
        if (tmp < maxIndex) {
            index[position] = tmp + 1;
            return index;
        } else {
            if (positie != 0 && index[position - 1] + 2 <= maxIndex) {
                index[position] = index[position - 1] + 2;
                return increaseArray(index, maxIndex, position - 1);
            } else {
                return null;
            }
        }
    }

---

编辑 1:

结果数组只包含唯一的数字，所以是的 int[2] 在这里最大为 7。

我还编辑了代码。我觉得我快到了，尽管最后一个数字仍然有问题......

public int[] increaseIndex(int[] index, int maxIndex, int position) {
    int tmp = index[position];
    if (tmp < maxIndex + position - 2) {
        index[position] = tmp + 1;
        return index;
    } else {
        if (position > 0) {
                            //The following line of code is the problem...
            index[position] = index[position - 1] + 2;
            return increaseIndex(index, maxIndex, position - 1);
        } else {
            return null;
        }
    }
}

---

编辑 2:

现在真的很近了。我像说的那样修复了 maxIndex。现在有一些小错误，当超过 2 个数字应该递增时。

代码

public int[] increaseIndex(int[] index, int maxIndex, int position) {
    int size = index.length;
    int tmp = index[position];
    if (tmp < maxIndex - (size-position-1)) {
        index[position] = tmp + 1;
        return index;
    } else {
        if (position > 0) {
            //The following line is the problem i think...
            index[position] = index[position - 1] + 2;
            return increaseIndex(index, maxIndex, position - 1);
        } else {
            return null;
        }
    }
}

当我使用以下执行代码时，这会给我以下输出，例如 maxIndex 8

int[] index = new int[] {1,2,3,4};
index = increaseIndex(index, row.length - 1, k - 2);
    while (index != null) {
        printArray(index);
        index = increaseIndex(index, row.length - 1, k - 2);
    }

---

[1, 2, 3, 4]
[1, 2, 3, 5]
[1, 2, 3, 6]
[1, 2, 3, 7]
[1, 2, 3, 8]
[1, 2, 4, 5]
[1, 2, 4, 6]
[1, 2, 4, 7]
[1, 2, 4, 8]
[1, 2, 5, 6]
[1, 2, 5, 7]
[1, 2, 5, 8]
[1, 2, 6, 7]
[1, 2, 6, 8]
[1, 2, 7, 8]
[1, 3, 4, 9] //wrong
[1, 3, 5, 6]
[1, 3, 5, 7]
[1, 3, 5, 8]
[1, 3, 6, 7]
[1, 3, 6, 8]
[1, 3, 7, 8]
[1, 4, 5, 9] //wrong
[1, 4, 6, 7]
[1, 4, 6, 8]
[1, 4, 7, 8]
[1, 5, 6, 9] //wrong
[1, 5, 7, 8]
[1, 6, 7, 9] //wrong
[2, 3, 8, 9] //wrong
[2, 4, 5, 10]//wrong
[2, 4, 6, 7]
[2, 4, 6, 8]
[2, 4, 7, 8]
[2, 5, 6, 9] //wrong
[2, 5, 7, 8]
[2, 6, 7, 9] //wrong
[3, 4, 8, 9] //wrong
[3, 5, 6, 10]//wrong
[3, 5, 7, 8]
[3, 6, 7, 9] //wrong
[4, 5, 8, 9] //wrong
[4, 6, 7, 10]//wrong
[5, 6, 8, 9] //wrong

Answer 1

这是一种不使用递归的不同方法。它会尝试所有组合并过滤掉那些不唯一的组合。

这种方法可以很容易地适应一系列要求。

public static void main(String... args) {
    uniqueCombinations(4, 8);
}

private static void uniqueCombinations(int depth, int maxValue) {
    int[] ints = new int[depth];
    long combinations = (long) Math.pow(maxValue, depth);
    LOOP:
    for (long l = 0; l < combinations; l++) {
        long l2 = l;
        // create a combination.
        for (int i = ints.length - 1; i >= 0; i--) {
            ints[i] = (int) (l2 % maxValue + 1);
            l2 /= maxValue;
        }
        // check the combination.
        for (int i = 0; i < ints.length; i++)
            for (int j = i + 1; j < ints.length; j++)
                if (ints[i] == ints[j]) continue LOOP;
        // print a result.
        System.out.println(Arrays.toString(ints));
    }
}

打印

[1, 2, 3, 4]
[1, 2, 3, 5]
[1, 2, 3, 6]
[1, 2, 3, 7]
[1, 2, 3, 8]
[1, 2, 4, 3]
.....
[8, 7, 5, 6]
[8, 7, 6, 1]
[8, 7, 6, 2]
[8, 7, 6, 3]
[8, 7, 6, 4]
[8, 7, 6, 5]