如何愚弄“尝试一些测试用例”启发式算法：看起来正确但实际上不正确的算法

为了尝试测试某个问题的算法是否正确，通常的出发点是尝试在多个简单的测试案例上手动运行该算法-在一些示例问题实例（包括一些简单的“拐角案例”）上进行尝试”。这是一种很好的启发式方法：这是一种快速清除算法中许多错误尝试并了解为什么该算法无效的好方法。

但是，在学习算法时，有些学生很想停在这里：如果他们的算法在一些示例上都能正常工作，包括他们认为可以尝试的所有极端情况，那么他们得出的结论是算法必须正确。总是有一个学生问：“如果我可以在几个测试用例上尝试一下，为什么我需要证明我的算法正确？”

那么，如何欺骗“尝试一堆测试用例”启发式方法？我正在寻找一些很好的例子来表明这种启发式方法是不够的。换句话说，我正在寻找一个或多个算法的示例，这些示例从表面上看可能是正确的，并且在任何人都可能想出的所有小输入上输出正确答案，但是该算法实际上在哪里不起作用。也许该算法恰好在所有小输入上都能正常工作，仅对大输入失败，或者仅对具有异常模式的输入失败。

具体来说，我在寻找：

1. 一种算法。该缺陷必须在算法级别上。我不是在寻找实现错误。（例如，该示例至少应与语言无关，并且该缺陷应与算法问题有关，而不是与软件工程或实现问题有关。）

2. 有人可能会提出的一种算法。伪代码应该看起来至少看起来是正确的（例如，混淆或明显可疑的代码不是一个好例子）。如果这是某些学生在尝试解决作业或考试问题时真正想到的一种算法，则可加分。

3. 通过概率较高的合理手动测试策略的算法。手动尝试一些小型测试用例的人应该不太可能发现该缺陷。例如，“手动模拟十二个小型测试用例的QuickCheck”应该不太可能揭示该算法不正确。

4. 优选地，确定性算法。我已经看到许多学生认为“手动尝试一些测试用例”是检查确定性算法是否正确的合理方法，但是我怀疑大多数学生不会认为尝试几个测试用例是验证概率的好方法算法。对于概率算法，通常没有办法判断任何特定输出是否正确。而且您手头不足以对输出分布进行任何有用的统计检验。因此，我宁愿专注于确定性算法，因为它们更清楚地了解了学生的误解。

我想教导证明算法正确的重要性，并且希望使用一些这样的示例来帮助激发正确性的证明。我希望那些相对简单并且可以被大学生使用的例子；需要重型机械或大量数学/算法背景的示例不太有用。另外，我也不想使用“非自然”的算法；虽然构造一些怪异的人工算法来欺骗启发式方法可能很容易，但是如果看起来很不自然，或者构造了明显的后门只是为了欺骗这种启发式方法，那么它可能不会使学生信服。有什么好的例子吗？

我认为一个常见的错误是使用贪婪算法，这并不总是正确的方法，但在大多数测试案例中都可以使用。

例如：硬币面额，和若干，表达作为的总和：■利用尽可能少的硬币越好。 n n d $d_1,\dots,d_k$$n$$n$$d_i$

天真的方法是先使用最大可能的硬币，然后贪婪地产生这样的金额。

例如，对于值的硬币，和 将给予贪婪正确答案为之间的所有数字和 除了编号。5 1 1 14 10 = 6 + 1 + 1 + 1 + 1 = 5 + $6$$5$$1$$1$$14$$10 = 6+1+1+1+1 = 5+5$

我立即想起了R. Backhouse的一个例子（这可能已经写在他的书中）。显然，他分配了一个编程作业，学生必须编写一个Pascal程序来测试两个字符串的相等性。一个学生上交的程序之一是：

issame := (string1.length = string2.length);

if issame then
  for i := 1 to string1.length do
    issame := string1.char[i] = string2.char[i];

write(issame);

现在，我们可以使用以下输入来测试程序：

“大学”“大学” 真；好$\Rightarrow$

“课程”“课程” 是；好$\Rightarrow$

“”“” 是；好$\Rightarrow$

“大学”“课程” 错误；好$\Rightarrow$

“讲座”“课程” 错误；好$\Rightarrow$

“精确”“精确” 错误，可以$\Rightarrow$

所有这些似乎都很有希望：也许程序确实可以工作。但是，使用“ pure”和“ true”进行更仔细的测试会发现错误的输出。实际上，如果字符串具有相同的长度和相同的最后一个字符，则程序会说“ True”！

但是，测试非常彻底：我们使用了长度不同的字符串，长度相等但内容不同的字符串，甚至是相等的字符串。此外，学生甚至测试并执行了每个分支。您不能真的认为测试在这里很粗心-鉴于该程序确实非常简单，可能很难找到足够彻底地进行测试的动力和能量。

另一个可爱的例子是二进制搜索。在TAOCP中，Knuth说：“尽管二进制搜索的基本思想相对简单，但细节可能令人吃惊”。显然，Java的二进制搜索实现中的一个错误十年来未被发现。这是一个整数溢出错误，只有在输入足够大的情况下才会显示出来。Bentley在《Programming Pearls》一书中还介绍了二进制搜索实现的棘手细节。

底线：仅通过测试就很难确定二进制搜索算法是正确的。

我遇到的最好的例子是素数测试：

输入：自然数p，p！= 2
输出：pa prime是否？
算法：计算2 **（p-1）mod p。如果结果= 1，则p是质数，否则p不是质数。

除了很少的反例外，这几乎适用于每个数字，而且实际上需要一台机器在现实的时间内找到反例。第一个反例是341，反例的密度实际上随着p的增加而减小，尽管大约是对数的。

不仅可以使用2作为幂的基础，还可以通过使用其他增加的小质数作为基础来改进算法，以防先前的质数返回1。此外，该方案还有反例，即Carmichael数，虽然很少见

这是谷歌代表按照我参加的一个惯例向我扔的东西。它是用C编码的，但是可以在使用引用的其他语言中使用。很抱歉，必须在[cs.se]上进行编码，但这是唯一的说明。

swap(int& X, int& Y){
    X := X ^ Y
    Y := X ^ Y
    X := X ^ Y
}

即使给定x和y的任何值，该算法也可以使用。但是，如果将其称为swap（x，x），它将无法正常工作。在这种情况下，x最终为0。现在，这可能不满足您的需要，因为您可以以某种方式证明该操作在数学上是正确的，但仍然会忽略这种边缘情况。

一整类算法本来就很难测试：伪随机数生成器。您不能测试单个输出，而必须使用统计手段调查（许多）输出系列。根据测试的内容和方式，您很可能会错过非随机特征。

兰杜（RANDU）是一个著名的例子，它发生了严重错误。它通过了当时可用的审查-无法考虑后续输出的元组的行为。三元组已经显示出许多结构：

基本上，测试并不能涵盖所有用例：尽管RANDU的一维使用（可能多数情况下）很好，但它不支持使用它来采样三维点（以这种方式）。

正确的伪随机采样是一项棘手的事情。幸运的是，那里现在有功能强大的测试套件，例如dieharder，专门用于将我们知道的所有统计信息扔给拟议的生成器。够了吗

^{公平地说，我不知道您可以为PRNG证明什么。}

二维局部最大值

$n \times n$$A$

$(i,j)$$A[i,j]$

$A[i, j+1], A[i, j-1], A[i-1, j], A[i+1, j]$$A$

那么每个加粗的单元格都是局部最大值。每个非空数组至少具有一个局部最大值。

$O(n^2)$

$A$$X$$X$$A$$(i, j)$$X$$(i, j)$$(i', j')$

$A \setminus X$$A$$X$$(i', j')$$A'$

$A'$$A$

$(i', j')$$A'$$A'$$(i', j')$$\diamond$

该算法在递归调用自身$\frac{n}{2}\times\frac{n}{2}$$A'$$(i, j)$

$T(n)$$n\times n$$T(n) = T(n/2) + O(n)$$T(n) = O(n)$

因此，我们证明了以下定理：

$O(n)$$n\times n$

还是我们？

这些是素数示例，因为它们很常见。

（1）SymPy中的原始性。 发行1789年。在著名的网站上进行了错误的测试，直到10 ^ 14之后才失败。尽管此修复程序是正确的，但它只是修补漏洞而不是重新考虑问题。

（2）Perl中的原始性6. Perl6添加了is-prime，它使用了许多具有固定基数的MR测试。有一些已知的反例，但是由于默认的测试数量很大（因此，通过降低性能来掩盖真正的问题），它们的数量很大。这将很快解决。

（3）FLINT中的原始性。 自固定以来，n_isprime（）对于复合材料返回true。基本上与SymPy相同。使用SPRP-2伪素数的Feitsma / Galway数据库到2 ^ 64，我们现在可以测试它们。

（4）Perl的Math :: Primality。 is_aks_prime损坏。此序列似乎与许多AKS实现类似-许多代码要么偶然工作（例如，在第1步中丢失了，最终通过尝试划分完成了整个工作），要么对于较大的示例却不起作用。不幸的是，AKS太慢了，很难测试。

（5）Pari的2.2之前版本为is_prime。 Math :: Pari票。它使用10个随机基进行MR测试（启动时具有固定种子，而不是每次调用时都具有GMP的固定种子）。它将告诉您，每1M个呼叫中有9个是质数。如果选择正确的数字，您可能会使其经常失败，但是数字变得稀疏，因此在实践中不会显示太多。此后，他们改变了算法和API。

这没错，但这是概率测试的经典之作：例如，您给出mpz_probab_prime_p个回合？如果我们给它进行5次回合，那肯定看起来效果很好-数字必须通过210费马基础测试，然后再通过5个预选的Miller-Rabin基础测试。在3892757297131（使用GMP 5.0.1或6.0.0a）之前，您将找不到反例，因此您必须进行大量测试才能找到它。但是在2 ^ 64下有成千上万的反例。因此，您一直在增加数字。多远？有对手吗？正确答案有多重要？您是否将随机基准与固定基准混淆？您知道您将得到什么输入大小吗？

$10^{16}$

这些很难正确测试。我的策略包括明显的单元测试，边缘情况，在其他软件包之前或在其他软件包中看到的失败示例，可能的情况下与已知数据库的测试（例如，如果执行单个base-2 MR测试，则可以减少计算上的不可行测试2 ^ 64个数字以测试大约3200万个数字），最后，许多随机测试使用另一个软件包作为标准。最后一点适用于诸如素数之类的函数，其中有一个相当简单的输入和一个已知的输出，但是很多任务是这样的。我用它来查找我自己的开发代码中的缺陷以及比较包中的偶然性问题。但是鉴于无限的输入空间，我们无法测试所有内容。

至于证明正确性，这是另一个素数示例。BLS75方法和ECPP具有素证的概念。基本上，在他们忙于进行搜索以找到适用于其证明的值之后，他们可以以已知格式输出它们。然后，可以编写一个验证程序，或由其他人编写。与创建相比，它们运行起来非常快，现在（1）这两段代码都不正确（因此，为什么您更喜欢其他程序员作为验证者），或者（2）证明思想背后的数学错误。＃2总是可能的，但是这些通常是由多个人发布和审阅的（在某些情况下，很容易让您逐步了解自己）。

相比之下，AKS，APR-CL，试验划分或确定性Rabin检验之类的方法除“素数”或“复合”外均不产生任何输出。在后一种情况下，我们可能有一个可以验证的因子，但是在前一种情况下，我们只剩下这一点输出了。程序运行正常吗？不知道。

重要的是，不仅要在几个玩具示例上测试软件，还要在算法的每个步骤中都经过一些示例，然后说：“给出此输入，我处于这种状态是否有意义？”

Fisher-Yates-Knuth混排算法是一个（实际的）示例，本网站的一位作者对此发表了评论。

该算法生成给定数组的随机排列，如下所示：

 // To shuffle an array a of n elements (indices 0..n-1):
  for i from n − 1 downto 1 do
       j ← random integer with 0 ≤ j ≤ i
       exchange a[j] and a[i]

$i$$j$$0 \le j \le i$

“天真”算法可以是：

 // To shuffle an array a of n elements (indices 0..n-1):
  for i from n − 1 downto 1 do
       j ← random integer with 0 ≤ j ≤ n-1
       exchange a[j] and a[i]

从所有可用元素中选择要交换的元素。但是，这会产生排列偏差的采样（有些表示过多等）。

实际上，可以使用简单的（或幼稚的）计数分析来提出费舍尔-叶茨-努斯混洗。

$n$$n! = n \times n-1 \times n-2 ..$$n$$n-1$

验证混洗算法是否正确（有偏差）的主要问题是由于统计原因，需要大量样本。我在上面链接的关于编码恐怖的文章准确地解释了这一点（以及实际测试）。

我见过的最好的例子（读：我最受伤害的事情）与collat​​z猜想有关。我当时参加了编程比赛（第一名获得500美元奖金），其中一个问题是找出两个数字达到相同数字所需的最小步数。当然，解决方案是交替使用每个步骤，直到它们都达到以前看到的效果为止。我们给了一个数字范围（我认为它在1到1000000之间），并告诉我们collat​​z猜想已经得到验证，直到2 ^ 64，所以我们得到的所有数字最终都收敛于1。我使用32位整数，但是要执行这些步骤。事实证明，在1到1000000（约17万个）之间存在一个晦涩的数字，这将导致32位整数在适当的时间溢出。实际上，这些数字在2 ^ 31以下非常罕见。我们测试了系统中的巨大数字（大于1000000），以“确保”不会发生溢出。结果是我们只是未测试的一个较小的数字导致了溢出。因为我用“ int”代替“ long”，所以我只获得了300美元的奖金，而不是500美元的奖金。

该背包0/1的问题是，几乎所有的学生认为是贪婪算法解决的。如果您先前曾在贪婪算法起作用的Knapsack问题版本中展示过一些贪婪解决方案，则这种情况会更经常发生。

对于这些问题，我应该在课堂上展示Knapsack 0/1（动态编程）的证明，以消除任何疑问，以及贪婪的问题版本。实际上，这两种证明都不是简单的，学生可能会发现它们很有帮助。此外，在CLRS 3ed第16章第425-427页中对此进行了评论。

问题： 小偷抢商店，可以将最大重量的W放入背包。有n个项目，第i个项目重wi，价值vi。小偷应该带些什么？最大化他的收益？

背包0/1问题：设置相同，但是物品可能不会分成较小的部分，因此小偷可能会决定拿走或离开它（二元选择），但可能不会拿走一小部分。

您可以从学生那里得到一些想法或算法，这些想法或算法遵循与贪婪版本问题相同的想法，即：

• 计算袋子的总容量，并尽可能多地放置最有价值的对象，然后重复此方法，直到不能再放置更多对象为止，因为袋子已经满了，或者没有重量相等的东西放在袋子内。
• 另一种错误的方式是思考：放置较轻的物品，然后按照最高到最低的价格放置这些物品。
• ...

对您有帮助吗？实际上，我们知道硬币问题是背包问题的版本。但是，在背包问题的森林中还有更多示例，例如，关于背包2D的情况（当您想用砍伐的木材制作家具时非常有用，我在我所在城市的本地人那里看到过），这是非常普遍的，贪婪也在这里起作用，但不是。

一个常见的错误是错误地实施改组算法。参见有关维基百科的讨论。

$n!$$n^n$$(n-1)^n$

将统计功能引入标准库的Pythons PEP450可能很有趣。作为拥有在Python标准库中计算方差的函数的理由的一部分，作者Steven D'Aprano写道：

def variance(data):
        # Use the Computational Formula for Variance.
        n = len(data)
        ss = sum(x**2 for x in data) - (sum(data)**2)/n
        return ss/(n-1)

通过临时测试，以上内容似乎是正确的：

>>> data = [1, 2, 4, 5, 8]
>>> variance(data)
  7.5

但是，向每个数据点添加常量不应更改方差：

>>> data = [x+1e12 for x in data]
>>> variance(data)
  0.0

并且方差永远不能为负：

>>> variance(data*100)
  -1239429440.1282566

问题是关于数字以及精度如何丢失。如果要获得最大的精度，则必须以某种方式对操作进行排序。天真的实现会导致不正确的结果，因为不精确度太大。那是我在大学的数字课程所要解决的问题之一。

尽管这可能与您追求的不完全相同，但毫无疑问，它很容易理解和测试一些小情况，而无需任何其他思考就会导致算法错误。

$n$$n^2+n+41$$0<d$$d\text{ divides } n^2+n+41$$d < n^2+n+41$

拟议解决方案：

int f(int n) {
   return 1;
}

$n= 0, 1, 2, \dotsc, 39$$n=40$

这种“尝试一些小情况并从结果中推论算法”的方法在编程比赛中经常出现（尽管不像这里那样极端），其中压力是想出一种算法，该算法必须（a）易于实现，并且（b ）具有快速的运行时间。