Напишите программу, которая, казалось бы, добавляет числа 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 целых чисел. Это массив целых чисел от −128 до +127. cache[132]это место, где обычно 4. Установите это к 5.

Предупреждение: выполнение этого в реальном коде сделает людей очень несчастными.

Демонстрация кода на ideone .

Haskell

Я просто люблю, как вы можете бросить что-нибудь в GHCI, и это полностью катится с этим.

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

С

Довольно дешевый трюк, но я уверен, что поймаю большинство из вас.

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

Попробуй здесь

Прокрутите код вправо.
Я не уверен в Windows / Linux, но в OSX полоса прокрутки не видна.
В любом случае, это хорошая причина включить «визуализацию пространства» в вашем любимом редакторе кода.

GolfScript

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 достаточно).

В необработанных шестнадцатеричных представлениях чисел разница только в 1 бит (между 4000000000000001и 4000000000000000) ... этого достаточно, чтобы Math.ceilметод возвращал 5, а не 4.

BBC BASIC

РЕДАКТИРОВАТЬ: Для Андреа Фолдс и 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 . (с немного другим кодом) можно увидеть в истории редактирования.

Brainfuck

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

Выход:

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, который evalдо 5.

Более запутанная версия

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

Как уже упоминалось, 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-bit и Ubuntu 32-bit, две системы, к которым у меня есть легкий доступ.

$ 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-й 1+2+3строках, но необъяснимым образом мы также нарушаем коммутативное свойство (где a + b = b + a ; 2-я и 3-я строки). Интересно, интерпретатор 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. Хотя они выглядят одинаково, на самом деле это две разные переменные с двумя разными значениями. Используя 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) );

Подбитый бит состоит в том, что он фактически не скрыт - если вы добавляете источник звука 2 дБ к другому источнику звука 2 дБ, тогда результирующий объединенный шум будет 5 дБ (и если вы добавите два источника 30 дБ, то его 33 дБ), поскольку они измеряются в логарифмическом масштабе.

Вы можете увидеть это на другом калькуляторе здесь .

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);
    }

Опасно украшать ваш Javascript искусством ASCII.

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

     (2 + 2)

Когда комментарии удаляются, оставшиеся символы и операторы оцениваются как.
-~~--~(2 + 2) В нем используется оператор Bitwise Not (~) в 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 имеют нулевую индексацию

Perl

# 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...";
}

Это зависит от CPAN модуля с именем Acme :: NewMath . Из-за неправильных имен файлов в модуле это будет работать только в нечувствительных к регистру файловых системах (например, в Windows или Mac OS X), но я обвиняю автора оригинального модуля здесь. Acme :: NewMath реализует математику в соответствии с идеологией Ingsoc.

р

# 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

Так а = 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)

Тильда - это унарный обратный оператор, который возвращает -x-1, поэтому первый шаг - это получить-6 а затем с другим оператором в printфункции получить5

Рубин

class Fixnum
    alias plus +

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

puts 2 + 2

Это увеличивает результат всех добавлений, первый аргумент которых является Fixnum (который 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 Keeping Ruby Reasonable и прочтите первоклассные среды из блога Abstract Heresies.

Схема

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

C #

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

Для кого-то незнакомого это будет выглядеть так, как будто я получаю диапазон, начинающийся и заканчивающийся на 2. На самом деле, он начинается с 2 и идет для двух чисел. Так что 2 + 3 = 5.

F #

Давайте поместим в ФСИ следующее утверждение:

let ``2+2``= 5

Выход:

val ( 2+2 ) : int = 5

С

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Не слишком хорошо скрыты, я боюсь. Не работает с оптимизацией.