推广越来越多的嵌套循环算法

Question

对不起，糟糕的标题，但我不知道如何在这里概括（或简化）我的循环案例。

我有一个程序可以迭代到整数序列，例如维度 = 1 到 5。 在每次迭代中，都会有一个主循环，在主循环内部，会有一个嵌套循环。嵌套循环的数量将是 [维度]。 例如，在维度=1 中，有一个 For 循环。在维度 = 2 中，For 循环内部有一个 For 循环。等等。

有没有可能的方法来简化算法？目前我正在为 [dimension] 的每个值手动编写完全不同的代码。想象一下，如果维度 = 1 到 100？我会死的。

这是我的一段程序（用 VB.NET 编写）

对于维度=2

Dim result(2) As Integer
For i = 0 To 1
    For j = 0 To 1
        result(0)=i
        result(1)=j
    Next
Next

对于维度=3

 Dim result(3) As Integer
 For i = 0 To 1
     For j = 0 To 1
         For k = 0 To 1
             result(0)=i
             result(1)=j
             result(2)=k
         Next
     Next
 Next

对于维度=4

Dim result(4) As Integer
For i = 0 To 1
    For j = 0 To 1
        For k = 0 To 1
            For l = 0 To 1
                result(0)=i
                result(1)=j
                result(2)=k
                result(3)=l
            Next
        Next
   Next
Next

等等..

有什么建议吗？ 谢谢！

Answer 1

有很多解决方案：

递归

Idk，如果 vb.net 支持方法，但如果支持，这可能是最简单的：

void nestedLoop(int lower , int upper , int remaining_loops , int[] values)
    if(remaining_loops == 0)
        //process values list
    else
        for int i in [lower , upper)
            values[remaining_loops] = i
            nestedLoop(lower , upper , remaining_loops - 1)

整数变换

理论上，一个数字可以用任何基数表示：

d_i * radix ^ i + d_i-1 * radix ^ (i - 1) ... + d_0 * radix ^ 0

将每个数字视为嵌套循环之一的值：

for int i in [0 , max)
    for int j in [0 , max)
        for int k in [0 , max)
            ...

可以用基数为 max 的 3 位数字表示，其中 d_0 = i、d_1 = j 等。基本上每个数字如何映射到其中一个值可以是任意的，只会影响顺序的输出。

void nestedLoops(int upper , int dimension)
    for int i in [0 , pow(upper , dimension))
        int[] values
        int digit_sub = 1

        int tmp = i
        for int j in [0 , dimension)
            values[j] = tmp % dimension
            tmp /= dimension

        //all values of the loops are now in values
        //process them here

还有其他一些选项，但这些是最常见的。

Answer 2

请注意，当你这样做时

Dim result(2) As Integer

您实际上是在声明一个 3 元素数组see this question for why。这是VB.NET的细微差别

话虽如此，我假设您要声明一个仅包含 2 个元素的数组。如果是这种情况，那么您可以构建并调用这样的递归函数

LoopOver(result) 

Sub LoopOver(ByRef array() As Integer, ByVal Optional level As Integer = 0)
    If array.Length = level Then
        Return
    Else
        array(level) = 1
        LoopOver(array, level + 1)
    End If
End Sub

此递归函数将调用自身（即，它将循环）与数组大小一样多的次数。