用您选择的语言编写一个程序，该程序似乎可以成功找到Fermat的Last Theorem的反例。也就是说，找到整数a，b，c > 0和n > 2使得a ⁿ + b ⁿ = c ⁿ。

当然，除非安德鲁·威尔斯（Andrew Wiles）的证明有缺陷，否则您无法真正做到。我的意思是假的，依靠

• 整数溢出
• 浮点舍入误差
• 未定义的行为
• 具有加法，求幂或等式的异常定义的数据类型
• 编译器/解释器错误
• 或类似的规定。

你可以硬编码部分或全部变量a，b，c，或n，或做循环寻找他们喜欢的for a = 1 to MAX。

这不是代码高尔夫；这是寻找聪明而精妙的解决方案的竞赛。

Ĵ

实际上，费马确实犯了一个大错：如果a为1，则对于任何b，c或n都是错误的：

   1^3 + 4^3 = 5^3
1
   1^4 + 5^4 = 11^4
1
   1^9 + 3^9 = 42^9
1

也许也许，费马的优先权规则并非严格由右至左。

TI基本

1782^12+1841^12=1922^12

输出（真）

1

爪哇

这个费马家伙一定在睡觉。我得到了数百个方程的解。我只是将Excel公式转换为Java程序。

public class FermatNoMore {
    public static void main(String[] args) {
        for (int n = 3; n < 6; n++)
            for (int a = 1; a < 1000; a++)
                for (int b = 1; b < 1000; b++)
                    for (int c = 1; c < 1000; c++)
                        if ((a ^ n + b ^ n) == (c ^ n))
                            System.out.println(String.format("%d^%d + %d^%d = %d^%d", a, n, b, n, c, n));
    }
}

该^运营商实际上意味着XOR在Java中，而不是在典型的纯文本幂

C ++

#include <cstdlib>
#include <iostream>

unsigned long pow(int a, int p) {
  unsigned long ret = a;

  for (int i = 1; i < p; ++i)
    ret *= a;

  return ret;
}

bool fermat(int n) {
  // surely we can find a counterexample with 0 < a,b,c < 256;
  unsigned char a = 1, b = 1, c = 1;

  // don't give up until we've found a counterexample
  while (true) {
    if (pow(a, n) + pow(b, n) == pow(c, n)) {
      // found one!
      return true;
    }

    // make sure we iterate through all positive combinations of a,b,c
    if (!++a) {
      a = 1;
      if (!++b) {
        b = 1;
        if (!++c)
          c = 1;
      }
    }
  }

  return false;
}

int main(int argc, char** argv) {
  if (fermat(std::atoi(argv[1])))
   std::cout << "Found a counterexample to Fermat's Last Theorem" << std::endl;
}

编译clang++ -O3 -o fermat fermat.cpp，通过以下测试Ubuntu clang version 3.4.1-1~exp1 (branches/release_34) (based on LLVM 3.4.1)：

./fermat 3
Found a counterexample to Fermat's Last Theorem

我们显然发现a，b，c> 0，因此a ³ + b ³ = c ³（这也适用于n = 4、5、6 ...）。

虽然打印a，b和c可能会有点困难...

爪哇

看起来该定理适用于n = 3，但我发现了针对n = 4的反例：

public class Fermat {
    public static int p4(final int x) {
        return x * x * x * x;
    }

    public static void main(final String... args) {
        System.out.println(p4(64) + p4(496) == p4(528));
    }
}

输出：

true

说明：

即使数字看起来很小，当升至四次方时它们也会溢出。在现实中，64 ⁴ + 496 ⁴ = 528 ⁴ - 2 ³⁴，但2 ³⁴限制为int（32个比特）时变为0。

蟒蛇

import math
print math.pow(18014398509481984,3) + math.pow(1, 3) \
      == math.pow(18014398509481983,3)

谁说c必须大于a和b？

高尔夫脚本

# Save the number read from STDIN in variable N and format for output.

:N"n="\+

{
  [{100rand)}3*] # Push an array of three randomly selected integers from 1 to 100.
  .{N?}/         # Compute x**N for each of the three x.
  +=!            # Check if the sum of the topmost two results equals the third.
}{;}while        # If it doesn't, discard the array and try again.

# Moar output formatting.

~]["a=""\nb=""\nc="""]]zip

这种方法找到了很多不同的解决方案。例如：

$ golfscript fermat.gs <<< 3
n=3
a=43
b=51
c=82

这个怎么运作

第一行应以a开头~以解释输入。代替数字3，变量N包含字符串3\n。
在2 3 ?计算^3时，2 N ?将ASCII码为2的字符的索引压入N（-1为未找到）。
这种方式，43 N ?和82 N ?按压-1和51 N ?按压0（51的ASCII字符代码3）。
由于-1 + 0 = -1，条件得到满足并且(43,51,82)是“解决方案”。

C

当然，你们所有人都在寻找反例，您不断得到整数溢出。另外，通过迭代c也确实很慢。这是一个更好的方法！

#include <stdio.h>
#include <math.h>

int main(void) {
  double a, b, c;
  for (a = 2; a < 1e100; a *= 2) {
    for (b = 2; b < 1e100; b *= 2) {
      c = pow(pow(a, 3) + pow(b, 3), 1.0/3);
      if (c == floor(c)) {
        printf("%f^3 + %f^3 == %f^3\n", a, b, c);
      }
    }
  }
  return 0;
}

double 在范围上可能很棒，但是仍然缺乏精确度...

C

我们都讨厌整数溢出，因此我们将使用一个小的指数n和一些浮点转换。但是定理仍然不成立a = b = c = 2139095040。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

int a, b, c;
int n;

int disprove(int a, int b, int c, int n)
{
    // Integers are so prone to overflow, so we'll reinforce them with this innocent typecast.
    float safe_a = *((float *)&a);
    float safe_b = *((float *)&b);
    float safe_c = *((float *)&c);

    return pow(safe_a, n) + pow(safe_b, n) == pow(safe_c, n);
}

int main(void)
{
    srand(time(NULL));

    a = b = c = 2139095040;
    n = rand() % 100 + 3;

    printf("Disproved for %d, %d, %d, %d: %s\n", a, b, c, n, disprove(a, b, c, n) ? "yes" : "no");
}

输出：

Disproved for 2139095040, 2139095040, 2139095040, 42: yes

Disproved for 2139095040, 2139095040, 2139095040, 90: yes

在IEEE 754中，数字2139095040或0x7F800000表示单精度浮点类型中的正无穷大。所有pow(...)调用都将返回+ Infinity，并且+ Infinity等于+ Infinity。一个更简单的任务是通过使用0x7F800001（Quiet NaN）来反驳勾股定理，根据标准，该0x7F800001不等于自身。

Java脚本

var a, b, c, MAX_ITER = 16;
var n = 42;
var total = 0, error = 0;

for(a = 1 ; a <= MAX_ITER ; a++) {
  for(b = 1 ; b <= MAX_ITER ; b++) {
    for(c = 1 ; c <= MAX_ITER ; c++) {
      total++;
      if(Math.pow(a, n) + Math.pow(b, n) == Math.pow(c, n)) {
        error++;
        console.log(a, b, c);
      }
    }
  }
}

console.log("After " + total + " calculations,");
console.log("I got " + error + " errors but Fermat ain't one.");

你知道42是魔术。

> node 32696.js
After 2176 calculations,
I got 96 errors but Fermat ain't one.

而且威尔斯不是一个。

Javascript Number不够大。

T-SQL

为了反驳这个费马小子定理，我们只需要找到一个反例。看来，他超级懒惰，只尝试了很小的排列。实际上，他甚至都没有尝试。我在0 <a，b，c <15和2 <e <15中找到了一个反例。对不起，我是一名高尔夫球手，所以以后我将取消对该代码的处理！

with T(e)as(select 1e union all select (e+1) from T where e<14)select isnull(max(1),0)FROM T a,T b,T c,T e where e.e>2 and power(a.e,e.e)+power(b.e,e.e)=power(c.e,e.e)

返回1，表示我们找到了一个反例！

诀窍是，尽管第一个e看起来像是别名，但实际上是一种将e的数据类型从int更改为等效于double的浮点类型的偷偷摸摸的方法。到14时，我们已经超出了浮点数的精度，因此我们可以将其加1，并且仍然不会丢失任何内容。最小化是一个很好的借口，可以解释我在rcte中看似愚蠢的列别名双重声明。如果我不这样做的话，它很可能在我们到达14 ^ 14之前就溢出了。

的JavaScript

看来这个家伙已经没事了。如果您问我，请上毒品。给定约束，找不到定理成立的值集。

var a = 1,
    b = 1,
    c = 1,
    n = 3,
    lhs = (a^n + b^n),
    rhs = c^n;

alert(lhs === rhs);

与Java中一样，^运算符是JavaScript中按位XOR运算符。计算数字幂的正确方法是使用Math.pow。

另一个BASIC反例

10 a = 858339
20 b = 2162359
30 c = 2162380
40 IF (a^10 + b^10) = c^10 THEN
50   PRINT "Fermat disproved!"
60 ENDIF