Question

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

E.g。 [1,2,3,4]

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

E.g。假设最大高度为8。

[1,2,3,8] - ＆gt; [1,2,4,5]

现在直到这里，我的代码才有效。但是当最后两个数字达到最大高度时，它将不再增加第三个数字。

E.G。 [1,2,7,8] - ＆gt; [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：

结果数组只包含唯一的数字，所以yes [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

这是python：

def choose_iter(elements, length):
    for i in xrange(len(elements)):
        if length == 1:
            yield (elements[i],)
        else:
            for next in choose_iter(elements[i+1:len(elements)], length-1):
                yield (elements[i],) + next

输出：

>>> for res in choose_iter([1, 2, 3, 4, 5, 6, 7, 8], 4):
        print res


(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, 5)
(1, 3, 4, 6)
(1, 3, 4, 7)
(1, 3, 4, 8)
(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, 6)
(1, 4, 5, 7)
(1, 4, 5, 8)
(1, 4, 6, 7)
(1, 4, 6, 8)
(1, 4, 7, 8)
(1, 5, 6, 7)
(1, 5, 6, 8)
(1, 5, 7, 8)
(1, 6, 7, 8)
(2, 3, 4, 5)
(2, 3, 4, 6)
(2, 3, 4, 7)
(2, 3, 4, 8)
(2, 3, 5, 6)
(2, 3, 5, 7)
(2, 3, 5, 8)
(2, 3, 6, 7)
(2, 3, 6, 8)
(2, 3, 7, 8)
(2, 4, 5, 6)
(2, 4, 5, 7)
(2, 4, 5, 8)
(2, 4, 6, 7)
(2, 4, 6, 8)
(2, 4, 7, 8)
(2, 5, 6, 7)
(2, 5, 6, 8)
(2, 5, 7, 8)
(2, 6, 7, 8)
(3, 4, 5, 6)
(3, 4, 5, 7)
(3, 4, 5, 8)
(3, 4, 6, 7)
(3, 4, 6, 8)
(3, 4, 7, 8)
(3, 5, 6, 7)
(3, 5, 6, 8)
(3, 5, 7, 8)
(3, 6, 7, 8)
(4, 5, 6, 7)
(4, 5, 6, 8)
(4, 5, 7, 8)
(4, 6, 7, 8)
(5, 6, 7, 8)

我在这里提出一个不同的方法 - 而不是考虑正确地增加数字，将其视为按顺序挑选元素。实施将是非常不同的，因为它是一种完全不同的方法。

Answer 2

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

这种方法可以很容易地适应各种要求。

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]

Answer 3

我认为没有理由在这里使用（或不使用）递归，如果我是你，我不会。

问题是你没有定义当其中一个数字已经在maxIndex时会发生什么。

我会建议一个解决方案但你没有定义你的程序在这种情况下应该如何表现。

此时它的作用是增加它。

您可能希望跳过已经在maxIndex（或更高版本）的所有位置，其中包含以下内容：

while (position >= 0 && index[position] >= maxIndex) position--; 
if (position == -1) return; //in case all positions are already at maximum value

在提高订单时增加一系列唯一数字

3 个答案: