编写一个看似将数字2和2相加并输出5的程序。

您的程序无法输出任何错误。当心内存孔！输入是可选的。

将2 + 2重新定义为5 不是很有创意！不要三思而后行，尝试其他方法。

爪哇

反思确实是滥用Java的正确方法……但是您需要更深入，而不仅仅是调整一些价值。

import java.lang.reflect.Field;

public class Main {
    public static void main(String[] args) throws Exception {
        Class cache = Integer.class.getDeclaredClasses()[0];
        Field c = cache.getDeclaredField("cache");
        c.setAccessible(true);
        Integer[] array = (Integer[]) c.get(cache);
        array[132] = array[133];

        System.out.printf("%d",2 + 2);
    }
}

输出：

5

说明：

您需要对其进行比通常可以访问的更深的更改。请注意，这是为Java 6设计的，没有在JVM上传递的时髦参数，否则这些参数会更改IntegerCache。

在Integer类的最深处是Flyweight of Integers。这是从-128到+127的整数数组。 cache[132]通常是4。设置为5。

警告：用真实代码执行此操作会使人非常不高兴。

ideone上的代码演示。

哈斯克尔

我只是喜欢您如何在ghci上扔任何东西，它随它而生。

λ> let 2+2=5 in 2+2
5

C

很便宜的把戏，但我敢肯定我会困住你们中的大多数。

int main() {
    int a = 2 + 2;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     a++;
    printf("%d",a);
    return 0;
}

在这里尝试

将代码向右滚动。
我不确定在Windows / Linux上，但是在OSX上，滚动条不可见。
无论如何，这是在您喜欢的代码编辑器上启用“空间可视化”的一个很好的理由。

高尔夫脚本

4:echo(2+2);

印刷品5。

当然，GolfScript具有与其他语言明显不同的语法，该程序看起来就像是Basic或C-ish。

4  -将数字4放在堆栈上。堆栈内容：4-
:echo将堆栈顶部的值保存到变量echo中。堆栈内容：4-
(  将堆栈顶部的值减1。堆栈内容：3-
2  将数字2放在堆栈顶部。堆栈内容：3 2-
+  在堆栈顶部添加两个数字。堆栈内容：5-
2  将数字2放在堆栈顶部。堆栈内容：5 2-
)  将堆栈顶部的值增加1。堆栈内容：5 3-
;  从堆栈中删除顶部元素。堆栈内容：5

默认情况下，GolfScript将在执行完成后打印堆栈上剩余的所有内容。

爪哇

伙计们，总是要打双打

public class TwoPlusTwo {
  public static void main(String... args) {
    double two = two();
    System.out.format("Variable two = %.15f%n", two);
    double four = Math.ceil(two + two); // round just in case
    System.out.format("two + two = %.15f%n", four);
  }

  // 20 * .1 = 2
  private static double two() {
    double two = 0;
    for(int i = 0; i < 20; i++) {
      two += .1;
    }
    return two;
  }
}

输出：

Variable two = 2.000000000000000
two + two = 5.000000000000000

说明：

不，说真的，您总是必须双打。15位数字不足以显示该two()方法实际产生的值2.0000000000000004（不过16位就足够了）。

在数字的原始十六进制表示形式中，4000000000000001和之间仅相差1位4000000000000000...足以使Math.ceil方法返回5，而不是4。

英国广播公司

编辑：对于Andrea Faulds和Squeamish Ossifrage，使用其他解释器的更令人信服的版本：http : //sourceforge.net/projects/napoleonbrandy/

  MODE 6
  VDU 23,52,254,192,252,6,6,198,124,0
  PRINT
  PRINT "2+2=";2+2
  PRINT "2+3=";2+3

实际上，这会打印数字4，但是会VDU 23重新定义ASCII 52的字体，以使其看起来像5而不是4。出于美观的原因，选择了屏幕模式6（字符大小合理）。

使用模拟器的原始图像位于http://bbcbasic.co.uk/bbcwin/bbcwin.html。（代码略有不同）可以在编辑历史记录中看到。

脑干

+++++           +++++
    +               +    
    +     +         +     +++++
+++++    +++    +++++     
+         +     +         +++++
+               +
+++++           +++++.

输出：

5

在这里尝试。

我知道这听起来有些简单，但正如原始文章中所建议的那样，我试图发挥创造力。

重击

由于这是一场人气竞赛，我想我应该使用一种漫长的方法...

对于不了解Bash的人：$((...expr...))是一种用于评估算术表达式的语法。$(bc<<<...expr...)使用bc命令行计算器执行相同的操作。

v=2                     #v is 2
v+=2                    #v is 4
v=$(($v*5))             #v is 20
v=$(($v-16))            #v is 4
v=$(bc<<<"sqrt($v)+2")  #v is 4 (sqrt(4) is 2)
v=$(bc<<<"$v/4+3")      #v is 4 (4/4 = 1)
echo '2+2=' $v          #So v is 4...?

输出量

2+2= 5

说明

第二行将v和2连接起来而不是将它们相加，得到22。
实际说明：
v=2 #v is 2 v+=2 #v is 22 v=$(($v*5)) #v is 110 v=$(($v-16)) #v is 94 v=$(bc<<<"sqrt($v)+2") #v is 11 (by default, bc rounds to integers) v=$(bc<<<"$v/4+3") #v is 5 (11/4 is 2 with rounding) echo '2+2=' $v #TADAAAM

蟒蛇

受Java答案启发：

>>> patch = '\x312\x2D7'
>>> import ctypes;ctypes.c_int8.from_address(id(len(patch))+8).value=eval(patch)
>>> 2 + 2
5

与Java一样，CPython将相同的内存位置用于前几个小整数的任何副本（如果有内存，则为0-255）。这将进入并通过直接编辑该内存位置ctypes。 patch只是一个模糊"12-7"的字符串，带有len4 的字符串，等于eval5。

更加混淆的版本

exec("\x66\x72\x6f\x6d\x20c\x74\x79\x70e\x73\x20\x69\x6d\x70\
\x6f\x72\x74\x20c\x5f\x69\x6e\x748\x20a\x73\x20x\x3bf\x72\x6f\
\x6d\x20\x73\x74\x72\x75c\x74\x20\x69\x6d\x70\x6f\x72\x74\x20\
ca\x6cc\x73\x69\x7ae\x20a\x73\x20x0\x3bx\x2ef\x72\x6f\x6d\x5f\
a\x64\x64\x72e\x73\x73\x28\x69\x64\x284\x29\x2bx0\x28\x27\x50\
\x50\x27\x29\x29\x2e\x76a\x6c\x75e\x3d5")

超越2 + 2

如OP所述，2 + 2可能很无聊；因此，这里有一些更干净，跨平台，多宽度的代码，可以肆意滥用。

from __future__ import division, print_function
import struct
import ctypes
import random

# Py 2.7 PyIntObject:
# - PyObject_HEAD
#     - PyObject_HEAD_EXTRA [usually nothing unless compiled with DEBUG]
#     - (Py_ssize_t) ob_refcnt
#     - (_typeobject) *ob_type
# - (long) ob_ival

# two platform-sized (32/64-bit) ints (ob_refcnt and *ob_type from above)
offset = struct.calcsize('PP')

num = 60
nums = list(range(num))
addresses = [id(x) + offset for x in nums]
random.shuffle(nums)

for a, n in zip(addresses, nums):
    ctypes.c_ssize_t.from_address(a).value = n

print('2 + 2 =', 2+2)
print('9 - 4 =', 9-4)
print('5 * 6 =', 5*6)
print('1 / 0 =\n', 1/0)
print('(1 + 2) + 3 = ', (1+2)+3)
print('1 + (2 + 3) = ', 1+(2+3))
print('(2 + 3) + 1 = ', (2+3)+1)
print('2 + (3 + 1) = ', 2+(3+1))

使用Python 2.7运行...最后忽略该行。我可以轻松访问Windows 64位和Ubuntu 32位两个系统。

$ python awful.py 
2 + 2 = 24
9 - 4 = 49
5 * 6 = 55
1 / 0 = 0.76

(1 + 2) + 3 =  50
1 + (2 + 3) =  68
(2 + 3) + 1 =  50
2 + (3 + 1) =  61
Segmentation fault (core dumped)

毫不奇怪，我们可以破坏加法的关联性质，其中（a + b）+ c = a +（b + c），如第一1+2+3行和第二行所示，但莫名其妙地，我们也破坏了交换性质（其中a + b = b + a；第二和第三行）。我想知道Python解释器是否只是忽略加法表达式周围的多余括号。

JavaScript：

g = function () {
  H = 3
  return H + H
}

f = function () {
  Η = 2
  return Η + H
}

// 3 + 3 = 6
alert(g())
// 2 + 2 = 5
alert(f())

在http://jsfiddle.net/qhRJY/上进行检查

H（拉丁文大写字母h）和Η（希腊文大写字母eta）都被设置为全局范围，因为它们未使用var关键字定义为函数的局部变量。虽然它们看起来很相似，但实际上是2个不同的变量，具有2个不同的值。在浏览器中使用Ctrl + F，您会发现Η（eta）在此页面上的显示明显小于H（h）。

的JavaScript

function addDecibels(){return (10*Math.log10([].reduce.call(arguments,(p,c)=>p+Math.pow(10,c/10),0))).toFixed(1);}

alert( addDecibels(2,2) );

不足的地方是它实际上并没有被使用-如果您将2dB的声源添加到另一个2dB的声源，则最终的组合噪声将为5dB（如果您添加两个30dB的声源，则其噪声为33dB），因为它们是以对数刻度测量的。

您可以在这里在其他计算器上看到它。

的PHP

echo '2 + 2 = ' . (2 + 2 === 4 ? 4 : 2 + 2 === 5 ? 5 : 'dunno');

产生：

2 + 2 = 5

这是因为在PHP中，三元数是从左到右计算的，因此实际上
(2 + 2 === 4 ? 4 : 2 + 2 === 5) // 2 + 2 is == 4, and 4 == true, therefore echo 5 ? 5 : 'dunno';

的JavaScript

var total = 2 + 2;

if(total = 5)
{
    alert('I guess 2 + 2 = 5');
}
else
{
    alert('The universe is sane, 2 + 2 = 4');
}

C＃

    static void Main(string[] args)
    {
        var x = 2;
        var y = 2;

        if (1 == 0) ;
        {
            ++x;
        }

        Console.WriteLine(x + y);
    }

用ASCII艺术装饰Javascript是很危险的。

  -~// JS  \\~-
 ~-// Maths \\-~
-~// Madness \\~-

     (2 + 2)

删除注释后，其余符号和运算符的计算结果为。
-~~--~(2 + 2) 这利用了JS中的按位非运算符（〜）以及少数的减号，这些负号将一路取反。

重击

#!/bin/bash

# strings of length 2
x="ab"
y="cd"

# add lengths by concatenation
c="$(cat<<<$x; cat<<<$y)"

# display the lengths of the parts and the sum
echo "${#x} + ${#y} = ${#c}"

输出：

2 + 2 = 5

每个命令的输出cat都有一个隐式换行符，但是最后的换行符被命令替换剥离$( )

这是另一个：

#!/bin/bash

# Create an array of ascending integers
a=({1..10})

# Use the sum to index into the array
s="2 + 2"
i=$(($s))
echo "$s = ${a[$i]}"

Bash数组的索引为零

佩尔

# Generic includes
use strict;
use warnings;
use 5.010;
use Acme::NewMath;

# Ok, time to begin the real program.
if (2 + 2 == 5) {
    say 5;
}
else {
    say "Dunno...";
}

这取决于名为Acme :: NewMath的 CPAN模块。由于模块中的文件名错误，因此仅适用于不区分大小写的文件系统（例如，在Windows或Mac OS X上），但是我在这里怪罪了原始模块的作者。Acme :: NewMath根据Ingsoc意识形态实现数学。

[R

# add the mean of [1,3] to the mean of [4,0] (2 + 2)
mean(1,3) + mean(4,0)

输出：

5

该代码实际上将[1]的平均值与[4]的平均值相加。使用R中的平均功能将是正确的方法： mean(c(1,3)) + mean(c(4,0))这不像R中一些其他的数学函数，比如sum，max和min; 其中sum(1,3)，max(1,3)和min(3,1)都会给出预期的答案。

爪哇

public class Five {
    public static void main(final String... args) {
        System.out.println(256.0000000000002 + 256.0000000000002);
    }
}

输出：

512.0000000000005

可能适用于使用相同双打的任何语言。

Befunge

这是用Befunge编写的，但看起来像Python。

#>>>>>>>>>>>>>>>>>v
# Calculate 2 + 2 v
#>>>>>>>>>>>>>>>>>v
def add(v,w):
    return v+w
 # I rewrote this 5 times and it still doesn't work

print add(2,2) #... Still not working

# email: MarkSmith@example.com

运行（使用正确的解释器）时，程序将打印5。

说明：

Befunge程序由单字符命令网格组成。第一个命令是左上角的命令，命令的读取向右进行。但是方向可以在程序执行期间改变。

仅运行第一行字符，以及第一行中以开头的字符v列。有问题的字符会执行以下操作：

#-跳过下一个命令
>-从现在开始，命令将在当前命令的右侧读取
v-从现在开始，命令将在当前命令的下方读取
5-将5压入堆栈
.-弹出并打印数字在堆栈的顶部
@-结束程序
<space>-不执行任何操作

如果您知道自己正在使用Befunge进行编程，那真的不会欺骗任何人。但是，如果您遇到此问题，但没有意识到这是Befunge，则很有可能会做到。

的JavaScript

码：

var a = 3;
а = 2;
a + а;

输出：

5

您可以在控制台上自行测试或检查此小提琴

C（Linux，gcc 4.7.3）

#include <stdio.h>

int main(void)
{
    int a=3, b=2;

    printf("%d + %d = %d", --a, b, a+b);  
}

打印2 + 2 = 5

所以a = 2对吧？

gcc-4.7.3从右到左评估函数参数。当评估a + b时，a仍为3。

福特77

       program BadSum
       integer i,a,j
       common i,a
       a = 1
       i = 2
       call addtwo(j) 
       print *,j
       end

       subroutine addtwo(j)
       integer a,i,j
       common a,i
c since a = 1 & i = 2, then 2 + 1 + 1 = 2 + 2 = 4
       j = i + a + a
       end

common块的标准滥用：订单很重要；我在子程序的块中交换了顺序，所以我真的添加了1 + 2 + 2。

蟒蛇

代码打印5，这是此任务的正确答案。

def int(a):
    return ~eval(a)

def add(a,b):
    return int(a)+int(b)

print ~add("2","2")

编辑：这是添加整数，而不是字符串化的二进制数的替代版本。

def int(a): return ~eval(`a`)
def add(a,b): return int(a)+int(b)
print ~add(2,2)

Tilde是返回的一元逆运算符-x-1，因此第一步是获取-6，然后在print函数get中使用另一个运算符5

红宝石

class Fixnum
    alias plus +

    def + (other)
        plus(other).succ
    end
end

puts 2 + 2

这会将所有第一个自变量为Fixnum（至少在MRI中为2）的加法运算的结果加1。

这样做的副作用甚至比Java版本还要糟。

红宝石

Ruby具有一流的环境。这意味着很多事情。这也意味着可以做很多事情……也许不应该。

def mal(&block)
    block.call
    for v in block.binding.eval("local_variables");
      block.binding.eval('if ' + v.to_s + ' == 4 then ' + v.to_s + ' = 5 end')
    end 
end

a = 2 + 2;
b = 2 + 4;
puts "2 + 2 = ", a
puts "2 + 4 = ", b

mal do
  puts "But in 1984..."
end

puts "2 + 2 = ", a
puts "2 + 4 = ", b

输出为：

2 + 2 = 
4
2 + 4 = 
6
但是在1984年...
2 + 2 = 
5
2 + 4 = 
6

如果您想更多地了解这种乐趣和危险，请参阅Ruby Conf 2011保持Ruby合理，并从Abstract Heresies博客中阅读一流的环境。

方案

(define 2+2 5)
2+2 ;=> 5

C＃

var c = Enumerable.Range(2, 2).Sum();

对于不熟悉的人来说，这看起来像是我在2范围开始和结束的范围。实际上，它是从2开始并具有两个数字。所以2 + 3 = 5

F＃

让我们在fsi中输入以下语句：

let ``2+2``= 5

输出：

val ( 2+2 ) : int = 5

C

int main() {
        char __func_version__[] = "5";  // For source control
        char b[]="2", a=2;
        printf("%d + %s = %s\n", a, b, a+b);
        return 0;
}

该5是不太好隐藏的，我害怕。不适用于优化。