的背景

因此，我们都知道像这样的经典证明：

A = B
A²= AB
A² -称b²= AB -称b²
（AB）（A + B）= B（AB）
（A + B）= B
B + B =
2B = B
2 = 1（呵呵！）
中当然，错误是您不能被0除。由于a = b，a-b = 0，所以存在被0除的隐藏除法。

挑战

您必须复制此证明。首先，声明两个相等的整数a和b（不管它们叫什么）。然后将aMod和bMod声明为a和b的可修改版本，并分别最初等于a和b。您必须将它们都乘以a，然后从两者中减去b * b。然后必须除以a-b，然后除以b（或a）才能得到。然后，打印出aMod和bMod之间带有等号。

人手不足

当然，由于您声明a和b相等，所以a-b = 0，然后除以0会导致错误。因此，您必须创造性地伪造它。另外，由于您要复制证明，因此打印时aMod和bMod上所有操作的结果均不得相等。他们不必精确地等于2和1，只要两个数字不相等即可。

这是一个例子：

#include <iostream>
#define subtract(a, b) a - b

using namespace std;
int main()
{
    int a = 4, b = 4;
    int a_2 = a, b_2 = b;

    a_2 *= a;
    b_2 *= b;

    a_2 -= b * b;
    b_2 -= b * b;

    a_2 = a_2 / subtract(a, b);
    b_2 = b_2 / subtract(-b, -a); // a - b == (-b) - (-a)

    a_2 /= a;
    b_2 /= a;

    cout << a_2 << " = " << b_2 << " because I did the same operations on both of them.";

    return 0;
}

也许不是最好的，但它说明了这一点。

奖金不足

除了打印等号外，您还可以仅打印两个变量（aMod和bMod），然后使用代码来比较两个变量是否相等，但实际上它们是相等的（并打印某种形式的true）。

请记住，这是一场人气竞赛，因此最多的获胜者。
此外，名为Mathematics 2.0的新数学版本已利用标准漏洞自动使证明无效。

的JavaScript

var a=3,b=3,a2=3,b2=3
[a2,b2]=[a2*a,b2*a]
[a2,b2]=[a2-b*b,b2-b*b]
[a2,b2]=[a2/(a-b),b2/(a-b)]
console.log([a2/a,b2/a])

输出：

[1, NaN]

注意0/0 = NaN

暗示

尝试添加一些分号。
这个程序实际上是var a=3,b=3,a2=3,b2=3[a2,b2]=...=[a2/(a-b),b2/(a-b)];console.log([a2/a,b2/a])。
NaN是[3/0,undefined/0]/3。

Python 2

我很确定这是显而易见的，因为每个人都知道Python，但这是我的尝试：

a=b=1
x,y=a*a,a*b
x,y=x-b*b,y-b*b
x,y=a+b/a-b,b
x,y=x/a,y/a
print(x==y)

它输出True。

暗示：

检查我的部门。

红宝石

def calculate a,
  b = a
  left, right = a, b
  left, right = [left, right].map { |x| x * a     }
  left, right = [left, right].map { |x| x - b*b   }
  left, right = [left, right].map { |x| x / a - b }
  left, right = [left, right].map { |x| x / b     }
  puts $/=[left, right].join(' = ')
end

calculate 3,
STDOUT.write($/)

乙二酮

暗示：

，

说明：

以逗号结尾的两行会导致程序的行为与实际不同。如果没有逗号，则该方法采用单个参数a，设置为b等于a，对每个证明执行从证明的转换（由于括号缺失，它不除以0），然后输出结果（输入为3 ，则输出“ -1 = -1”。但是，尾随逗号b = a成为方法签名的一部分，这意味着它声明了一个默认值的第二个参数。的结果STDOUT.write($/)为1（由于$/已将其预定义为换行符，因此它写入STDOUT的字节数。）因此a为3，b为1，导致方程式开始为“ 3 = 1”。垃圾了。

高尔夫脚本

警告：该程序有点作弊，因为它不会打印aMod和bMod

1nt main(){
  int a = 2, b = 2;
  int aMod,bMod;
//The next line should throw and error, but why doesn't it??/
  aMod = (a*a - b*b) / (a-b);
//The next line should throw and error, but why doesn't it??/
  bMod = (b*a - b*b) / (a-b);
//The if should fail, but it works??/
  if(aMod == bMod)
    printf("1");
  return 0;
};

尝试一下 在这里！

发生什么了？

您可能注意到的第一件事是“禁止的三部曲”。但是请记住，这是GolfScript，而不是C！另外，可能注意到它实际上并没有说“ int main（）”，而是说“ 1nt main（）”。在GolfScript中，“ 1”表示将1压入堆栈，而“ nt main”则作为两个未初始化的变量进行处理，它们什么都不做。两个括号首先将1加到堆栈的顶部，然后减去1，从本质上抵消了它们的位置。方括号表示一个被压入堆栈的块，然后分号立即将其弹出。因此，最后，我们只保留了原始的“ 1”，并在GolfScript程序的末尾打印了堆栈。这个答案的灵感来自于这一个。

序言

areEqual(A, B) :-
    Amod = A,
    Bmod = B,

    Amod = Amod * A,
    Bmod = Bmod * B,

    Amod = Amod - B*B,
    Bmod = Bmod - B*B,

    Amod = Amod / (A-B),
    Bmod = Bmod / (A-B),

    Amod = Amod / A,
    Bmod = Bmod / A,

    Amod == Bmod.

输出when会areEqual(4,4)被调用（或其他真正的数字）：

false

为什么？

在Prolog中，运算符“ =”不是情感；这是“统一”。因此Amod = Amod * A失败是因为Amod已经统一A，因而不可能统一Amod * A。然后Prolog立即停止执行当前规则并返回false。

的JavaScript

//Very badly written code!
//No! It is "poetic" code!
while(true){break;}{ 
let scrollMaxX = 3, screenX = 3;
var scrollBarWithBeerMax = scrollMaxX, Yscroll = screenX; for(var i = 0; i<1; i++){}}

scrollBarWithBeerMax *= scrollMaxX;
Yscroll *= screenX;

scrollBarWithBeerMax -= screenX * screenX;
Yscroll -= screenX * screenX;

scrollBarWithBeerMax /= (scrollMaxX - screenX);
Yscroll /= (scrollMaxX - screenX);

alert(scrollBarWithBeerMax + ' = ' + Yscroll);

输出：
http //jsbin.com/furino/2/edit?js， JsBin似乎无法执行此代码。而是使用浏览器控制台。

为什么？

scrollMaxX和screenX已经是现有变量。它们内置在浏览器中。因此，结果可能会有所不同。let关键字仅临时更改其值。

另一个JavaScript语言：它不完全遵循规则，仅在变量相等或不相等时才输出。

var a = 2;
var b = 2;

var a_duplicate = a;
var b_duplicate = b;

a_duplicate*=a
b_duplicate*=b;

a_duplicate-=b*b;
b_duplicate-=b*b;

a_duplicate/=(a-b);
b_duplicate/=(a-b);

alert(a_duplicate==b_duplicate);

为什么？

NaN不等于IEEE浮动规范中的NaN。感谢Alex Van Liew指出这不仅适用于Javascript。

扇形

a := 3
b := 3
duplicates := [a:b]
duplicates = duplicates.map {it * a}
duplicates = duplicates.map {it - b*b}
duplicates = duplicates.map {it / a-b}
echo(duplicates.join("") |Int a_2, Int b_2 ->Str| {"" +  a_2 + " = " + b_2})

输出：

-3 = 3

为什么？

[a：b]是地图，而不是列表。不太偷偷摸摸，我知道:(

C

经典证明谬误需要经典的C语法误解。不幸的是，我遇到了一些“仅高级”开发人员，他们确信C会因为类似于此代码的结果而损坏。如果您知道C的工作原理，它就会变得很明显，但是如果您看到了代码并假定它是另一种语言，则可能不是。

a,b,LHS,RHS;
main(){
    a=2; b=2;
    LHS=a; RHS=b;

    //multiply both sides by a
    LHS,RHS *= a; 
    //subtract b squared from both sides
    LHS,RHS -= b*b; 
    //assert that it factors correctly
    if (LHS,RHS != (a+b)*(a-b), b*(a-b)) printf("ERROR!\n");
    //'hard' division, just to be sure the compiler doesn't remove it
    LHS,RHS /=! (a-b);
    //assert that a+a really is b+b
    if (a+a != b+b) printf("ERROR!\n");
    //now just divide them by b
    printf("%d = %d ? ", LHS/b, RHS/b);
    if (RHS = LHS) 
        printf("true!");
    else
        printf("false!");
}

当然，当更惯用地将#include <stdio.h>int放在声明前面时，它的效果会不尽如人意。