使用 goto 与运行时代码评估

Question

最近，在编程课上，我们被分配用任何语言编写一个程序，给定n，将为大小<的数组p产生所有可能的混乱。 em>n 使得 p[i] != i 对于所有 i: 0 <= i <名词我们必须使用迭代器，例如yield。

示例：n=3，[0, 1, 2] 不是乱序，但 [2, 0, 1] 和 [1, 2, 0] 一样。

我想出了一个可行的伪代码解决方案，但问题是它需要电源循环（即，n 个嵌套循环，其中 n 仅在运行时才知道）。为此，我在字符串中的 Ruby 代码中生成了n 个嵌套循环，然后对该字符串进行了eval-ed。我的解决方案有效，但是我的教授认为使用一些 goto 会比动态代码生成更好的解决方案（至少更容易阅读）。

我的印象是 goto 始终是一个糟糕的选择。为什么动态生成代码的运行时评估可能比 goto 更糟糕？生成的代码干净简单，对于给定的问题似乎相当有效。代码生成所依赖的唯一用户输入是n，它会被预先检查以确保它是一个整数值。它产生只是独特的混乱，正如它应该的那样。

我不是要求解决我的编程作业，我只是想知道使用 goto 而不是动态代码评估背后的原因，反之亦然。

编辑：澄清一下，作业包括使用迭代器编写一个程序和使用递归编写另一个程序，因此迭代版本不一定是高效的。

Answer 1

在我看来，GOTO 和代码生成对于这个问题来说都是不优雅的解决方案。有一种递归算法可能是这里的正确答案。

Answer 2

这是一个非常有趣的问题 - 我不确定是否有明确的答案。

goto 的问题在于它以非结构化方式使用 - goto 是一种“大规模随机跳跃”，因此在一般情况下，在跳跃之后，您不知道自己来自哪里，这会导致各种问题调试和可维护性，以及 - 在更正式的意义上证明代码的“正确性”。当然，在某些语言（我已经使用了一段时间）中，您无法选择在代码上强加结构。底线是，并不是 GOTO 不好，而是 goto 的使用（和滥用）方式不好，这使得它成为一个危险的结构。

使用代码生成然后评估结果是聪明的:)然而“聪明”并不总是一件好事，我怀疑使用它作为解决方案的部分问题在于它实际上没有按预期解决问题。从某种意义上说，这可能是“作弊”——至少就你的教授而言——不会使你的解决方案无效，但可能会使其“不优雅”。代码方面还存在调试和维护问题。

递归解决方案——尤其是我依稀记得有人教我（大约 25 年前），人们通常可以将递归展开到循环中——可能是最优雅的。

绝对是一个有趣的问题！

Answer 3

如果没有看到你的代码，我会倾向于站在教授一边。如果要在 GoTo 和动态代码之间进行选择，我会倾向于前者。 GoTo 并不总是一个糟糕的选择。

Answer 4

无需使用 GoTos 即可解决几乎所有问题。特别是对于循环，您可以使用 break 和 continue 语句来隐式使用 goto，同时仍保持代码标准。

n 嵌套循环听起来像是一个糟糕的计划，我建议您转而研究递归函数。每次需要执行 n 循环时，您都应该始终考虑递归。

Answer 5

动态代码在编译时不可检查，这意味着在运行时之前不会检测到任何错误。可能会使它们更难找到。对于 ruby​​，这意味着 IDE 或编辑器不会发现语法错误，无论您使用的是哪一个。这是选择 goto 的一个优点。

我认为在这种情况下我必须同时考虑双方的意见才能做出决定。我还没有看到代码，但我愿意打赌有一个很好的解决方案，不使用动态代码或 goto。 goto 并不总是不好，但如果您正在考虑使用它，那么您可能到目前为止还没有做出最佳的设计决策，并且可能想要重新审视您的解决方案。

Answer 6

在我大学的一项作业中，我曾经不得不做一些相对相似的事情
我的解决方案是使用递归函数，传递数组、数组的大小和嵌套级别作为参数。然后该函数以嵌套级别 +1 调用自身，直到嵌套级别等于数组的大小。没有 Goto，没有代码评估，只有干净的代码！

例子

function computeDerangement(yourArray, loopLevel, arraySize)
{
    //We check to see if the loop level is the same as the array size
    //if true, then we have executed exactly n loop
    if (loopLevel == arraySize) {
         display(yourArray); //Display being some kind of function that show the array,
                             //you get the idea
    } else {
        while(something) {
            //Here you put the logic that you execute at one level of the loop

            //Then you call yourself with one more level of nesting
            computeDerangement(yourArray, loopLevel + 1, arraySize);
        }
    }
}

希望有帮助！

我一生中从未使用过 goto，所以我很确定总有办法避免它们

Answer 7

人们避免使用 goto 语句的主要原因是它们会让你的程序更难理解。

如果没有看过你的代码，我猜它比使用 goto 的等效程序更难理解......

Answer 8

GOTO 解决方案——模拟函数调用时，goto 很方便。这是一个非递归解决方案，它使用堆栈和 goto 标签简单地模拟递归解决方案，以返回到函数调用发生的位置。

请参阅递归过程（我已将其作为单独的答案发布）进行比较。

选项严格开启
上显式选项

模块 Module1
Dim x As Stack

Private Sub printGeneratedList(ByVal generatedList As List(Of Integer))
    For Each el In generatedList
        Console.Write(el & " ")
    Next
    Console.WriteLine()
End Sub
Private Sub generateAux(ByVal i As Integer, ByVal n As Integer, _
                        ByVal generatedList As List(Of Integer))
    Dim stackI As Stack(Of Integer) = New Stack(Of Integer)
    Dim stackJ As Stack(Of Integer) = New Stack(Of Integer)


    Dim j As Integer

开始标签：

    j = 0

    If i >= n Then
        printGeneratedList(generatedList)
        If stackI.Count = 0 Then
            Return
        Else
            GoTo ReturnLabel
        End If
    End If

     While j < n
        If Not j = i Then
            If Not generatedList.Contains(j) Then
                generatedList.Add(j)
                stackI.Push(i)
                stackJ.Push(j)
                i = i + 1
                GoTo StartLabel

返回标签：

                i = stackI.Pop()
                j = stackJ.Pop()
                generatedList.Remove(j)
            End If
        End If
        j = j + 1
    End While
    If stackI.Count = 0 Then
        Return
    Else
        GoTo ReturnLabel
    End If
End Sub

Private Sub generate(ByVal n As Integer)
    Console.WriteLine("Generating for n = " & n.ToString())
    Dim l As List(Of Integer) = New List(Of Integer)
    If n < 0 Then
        Throw New Exception("n must be >= 0")
    End If
    generateAux(0, n, l)
End Sub

Sub Main()
    generate(0)
    Console.ReadLine()
    generate(1)
    Console.ReadLine()
    generate(2)
    Console.ReadLine()
    generate(3)
    Console.ReadLine()
    generate(4)
    Console.ReadLine()
End Sub

结束模块

Answer 9

goto 不干净。但是如果需要高性能，有时您需要打破一些编码规则...

如果速度确实很重要，例如，如果您想编写一个非常迫切的库或代码，您可能会考虑使用 goto 。当然你必须注意一切顺利。

评论：最后，执行的CPU除了简单的跳转之外什么也不做。只是编程语言/编译器创建它们。谨慎使用，不要乱用。

Answer 10

goto 解决方案和动态代码生成想法都不好。正如其他人提到的，这可以通过递归解决方案轻松解决。您只需递归地生成所有排列（标准递归解决方案），并且当生成完成时（即在递归的叶子处），只需跳过返回不是混乱的排列。

Answer 11

递归解决方案——这是一个早期修剪的解决方案。我唯一的问题是关于枚举：他是否希望您创建一个枚举器，在每次成功调用时都会生成列表中的下一项？通过创建该程序的 lambda 版本，这可能是最简单的实现方法 - 在编写查询生成器时，我一直在 lisp 中执行此操作，该查询生成器在执行 prolog 解释器样式查询时生成问题的下一个答案。

选项严格开启
模块上显式选项

Module1

Private Sub printGeneratedList(ByVal generatedList As List(Of Integer))
    For Each el In generatedList
        Console.Write(el & " ")
    Next
    Console.WriteLine()
End Sub

Private Sub generateAux(ByVal i As Integer, ByVal n As Integer, _
                    ByVal generatedList As List(Of Integer))
    If i >= n Then
        printGeneratedList(generatedList)
        Return
    End If
    For j As Integer = 0 To n - 1
        If Not j = i Then
            If Not generatedList.Contains(j) Then
                generatedList.Add(j)
                generateAux(i + 1, n, generatedList)
                generatedList.Remove(j)
            End If
        End If
    Next
End Sub

Private Sub generate(ByVal n As Integer)
    Console.WriteLine("Generating for n = " & n.ToString())
    Dim l As List(Of Integer) = New List(Of Integer)
    If n < 0 Then
        Throw New Exception("n must be >= 0")
    End If
    generateAux(0, n, l)
End Sub

Sub Main()
     generate(0)

    Console.ReadLine()
    generate(1)

    Console.ReadLine()
    generate(2)

    Console.ReadLine()
    generate(3)

    Console.ReadLine()
    generate(4)

    Console.ReadLine()

End Sub

终端模块