Napisz program, który pozornie dodaje cyfry 2 i 2 i wyświetla dane wyjściowe 5. Jest to zawiły zawód.

Twój program nie może wygenerować żadnych błędów. Uważaj na dziury w pamięci! Wejście jest opcjonalne.

Ponowne zdefiniowanie 2 + 2 jako 5 nie jest zbyt kreatywne! Nie myśl o tym podwójnie, spróbuj czegoś innego.

Jawa

Refleksja jest rzeczywiście właściwym sposobem na nadużywanie Javy ... ale musisz sięgnąć głębiej niż tylko ulepszyć niektóre wartości.

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

Wynik:

5

Wyjaśnienie:

Musisz to zmienić jeszcze głębiej, niż zwykle możesz uzyskać dostęp. Należy pamiętać, że jest to zaprojektowane dla Java 6 bez żadnych funkcyjnych parametrów przekazywanych do JVM, które w przeciwnym razie zmieniłyby IntegerCache .

Wewnątrz klasy Integer znajduje się Flyweight of Integers. Jest to tablica liczb całkowitych od −128 do +127. cache[132]jest miejscem, w którym normalnie byłoby 4. Ustaw na 5.

Ostrzeżenie: wykonanie tego w prawdziwym kodzie sprawi, że ludzie będą bardzo niezadowoleni.

Demo kodu na ideone .

Haskell

Uwielbiam, jak możesz rzucać cokolwiek w ghci i to całkowicie się z nim toczy.

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

do

Całkiem tania sztuczka, ale jestem pewien, że złapię większość z was.

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

Wypróbuj tutaj

Przewiń kod w prawo.
Nie jestem pewien w systemie Windows / Linux, ale w OSX, pasek przewijania nie jest widoczny.
W każdym razie jest to dobry powód, aby włączyć „wizualizację przestrzeni” w swoim ulubionym edytorze kodu.

GolfScript

4:echo(2+2);

Wydruki 5.

Oczywiście, GolfScript ma składnię, która jest znacząco różna od innych języków, ten program po prostu wygląda jak coś podstawowego lub C-ish.

4  - Połóż cyfrę 4 na stosie. Zawartość stosu: 4
:echo- Zapisz wartość na górze stosu do zmiennej echa. Zawartość stosu: 4
(  - Zmniejsz wartość na górze stosu o 1. Zawartość stosu: 3
2  - Umieść liczbę 2 na stosie. Zawartość stosu: 3 2
+  - Dodaj dwie liczby na górze stosu. Zawartość stosu: 5
2  - Połóż cyfrę 2 na stosie. Zawartość stosu: 5 2
)  - Zwiększ wartość na górze stosu o 1. Zawartość stosu: 5 3
;  - Usuń górny element ze stosu. Zawartość stosu: 5

GolfScript domyślnie drukuje wszystko, co pozostało na stosie po zakończeniu wykonywania.

Jawa

Zawsze musicie zaokrąglać swoje dwójki, ludzie

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

Wynik:

Variable two = 2.000000000000000
two + two = 5.000000000000000

Wyjaśnienie:

Nie, poważnie, zawsze musisz zaokrąglać swoje deble. 15 nie wystarcza cyfr, aby pokazać, że two()metoda faktycznie produkuje 2.0000000000000004(16 wystarczy, ale).

W nieprzetworzonych reprezentacjach szesnastkowych liczb jest to tylko 1-bitowa różnica (między 4000000000000001i 4000000000000000) ... co wystarcza, aby Math.ceilmetoda zwróciła 5, a nie 4.

BBC BASIC

EDYCJA: Dla Andrei Faulds i Squeamish Ossifrage, bardziej przekonująca wersja z użyciem innego tłumacza: 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

To faktycznie drukuje liczbę 4, ale VDU 23redefiniuje czcionkę dla ASCII 52, aby wyglądała jak 5 zamiast 4. Tryb ekranu 6 został wybrany ze względów estetycznych (znaki o rozsądnym rozmiarze).

Oryginalny obraz przy użyciu emulatora pod adresem http://bbcbasic.co.uk/bbcwin/bbcwin.html . (z nieco innym kodem) można zobaczyć w historii edycji.

Brainfuck

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

Wynik:

5

Wypróbuj tutaj .

Wiem, że może to zabrzmieć trochę zbyt prosto, ale starałem się być kreatywny, jak sugerowano w oryginalnym poście.

Grzmotnąć

Ponieważ jest to konkurs popularności , powinienem użyć długiej metody ...

Dla osób, które nie znają Bash: $((...expr...))to składnia do oceny wyrażeń arytmetycznych. $(bc<<<...expr...)robi to samo, używając bckalkulatora wiersza poleceń.

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...?

Wynik

2+2= 5

Wyjaśnienie

Drugi wiersz łączy v i 2 zamiast ich dodawać, aby uzyskać 22.
Rzeczywiste wyjaśnienie:
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

Pyton

Zainspirowany odpowiedzią Java:

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

Podobnie jak Java, CPython używa tej samej lokalizacji pamięci dla każdej kopii pierwszych kilku małych liczb całkowitych (0-255, jeśli pamięć służy). To wchodzi i bezpośrednio edytuje tę lokalizację pamięci za pośrednictwem ctypes. patchjest tylko zaciemnionym "12-7", ciągiem z len4, czyli eval5.

Bardziej zaciemniona wersja

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")

Powyżej 2 + 2

Jak wspomniano OP, 2 + 2 może być trochę nudne; oto więc czystszy, wieloplatformowy kod o wielu szerokościach do nadużyć.

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

Działa z Python 2.7 ... zignoruj ​​tę linię na końcu. Działa w systemie Windows 64-bit i Ubuntu 32-bit, dwa systemy, do których mam łatwy dostęp.

$ 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)

Nic dziwnego, że możemy przełamać asocjacyjną właściwość dodawania, gdzie ( a + b ) + c = a + ( b + c ), jak widać w pierwszej i drugiej 1+2+3linii, ale w niewytłumaczalny sposób również przełamujemy właściwość przemienną (gdzie a + b = b + a ; 2. i 3. linia). Zastanawiam się, czy interpreter Pythona po prostu ignoruje zbędne nawiasy wokół wyrażeń dodawania.

JavaScript:

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

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

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

Sprawdź to na http://jsfiddle.net/qhRJY/

Zarówno H (duża litera łacińska h), jak i Η (duża litera grecka eta) są ustawione na zakres globalny, ponieważ nie zostały zdefiniowane jako lokalne dla funkcji ze słowem kluczowym var. Choć wyglądają podobnie, w rzeczywistości są to 2 różne zmienne o 2 różnych wartościach. Używając Ctrl + F w przeglądarce, przekonasz się, że Η (eta) pokazuje znacznie mniej niż H (h) na tej stronie.

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

Słabo wykorzystany bit polega na tym, że tak naprawdę nie jest on źle wykorzystany - jeśli dodasz źródło dźwięku 2dB do innego źródła dźwięku 2dB, wówczas wynikowy połączony szum wyniesie 5dB (a jeśli dodasz dwa źródła 30dB, wówczas jego 33dB), ponieważ są mierzone w skali logarytmicznej.

Możesz to zobaczyć na innym kalkulatorze tutaj .

PHP

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

Który produkuje:

2 + 2 = 5

Jest tak, ponieważ w PHP trójskładniki są obliczane od lewej do prawej, więc tak naprawdę jest
(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');
}

DO#

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

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

        Console.WriteLine(x + y);
    }

Dekorowanie kodu JavaScript w sztuce ASCII jest niebezpieczne.

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

     (2 + 2)

Gdy komentarze są usuwane, pozostałe symbole i operatory oceniają na
-~~--~(2 + 2) To korzysta z operatora Bitwise Not (~) w JS, wraz z garstką znaków Minus, które negują wartości po drodze.

Grzmotnąć

#!/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}"

Wynik:

2 + 2 = 5

Dane wyjściowe z każdej catbędą miały domyślną nową linię, ale ostatnia nowa linia jest usuwana przez podstawienie polecenia$( )

Oto kolejna:

#!/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]}"

Tablice Bash są indeksowane zerowo

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

Zależy to od modułu CPAN o nazwie Acme :: NewMath . Z powodu złych nazw plików w module, będzie to działać tylko w systemach plików bez rozróżniania wielkości liter (takich jak Windows lub Mac OS X), ale tutaj obwiniam autora oryginalnego modułu. Acme :: NewMath implementuje matematykę zgodnie z ideologią Ingsoc.

R

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

wynik:

5

kod faktycznie dodaje średnią z [1] do średniej z [4]. Właściwy sposób korzystać z funkcji średnią w badania będzie: mean(c(1,3)) + mean(c(4,0))Jest to w przeciwieństwie do niektórych innych funkcji matematycznych w dziedzinie badań, takich jak sum, maxi min; gdzie sum(1,3), max(1,3)i min(3,1)wszyscy dadzą oczekiwaną odpowiedź.

Jawa

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

wynik:

512.0000000000005

Prawdopodobnie działa w każdym języku, który używa tego samego rodzaju podwójnych.

Befunge

Jest to napisane w Befunge, ale ma wyglądać jak 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

Po uruchomieniu (z poprawnym tłumaczem) program wydrukuje 5.

Wyjaśnienie:

Program Befunge składa się z siatki pojedynczych znaków. Pierwsze polecenie jest tym w lewym górnym rogu, a czytanie poleceń przebiega w prawo. Ale kierunek może się zmienić podczas wykonywania programu.

Uruchamiany jest tylko pierwszy rząd znaków i kolumna znaków rozpoczynająca się vod pierwszego rzędu. Znaki, o których mowa, to:

#- pomiń następne polecenie
>- od tej chwili polecenia są odczytywane po prawej stronie bieżącego polecenia
v- od tej chwili polecenia są odczytywane poniżej bieżącego polecenia
5- Wciśnij 5 na stos
.- Pop i wydrukuj numer u góry stosu
@- Zakończ program
<space>- Nic nie rób

Gdybyś wiedział, że programujesz w Befunge, tak naprawdę nikogo to nie oszuka. Ale jeśli natkniesz się na to i nie zdasz sobie sprawy, że to Befunge, najprawdopodobniej by to zrobiło.

JavaScript

Kod:

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

Wynik:

5

Możesz to przetestować samodzielnie na konsoli lub sprawdzić to skrzypce

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

Drukuje 2 + 2 = 5

Więc a = 2, prawda?

gcc-4.7.3 ocenia parametry funkcji od prawej do lewej. Kiedy a + b jest oceniane, a nadal wynosi 3.

FORTRAN 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

Standardowe nadużywanie commonbloków: kolejność ma znaczenie; Zamieniłem kolejność w bloku podprogramu, więc naprawdę dodaję 1 + 2 + 2.

Pyton

Kod drukuje 5, co jest poprawną odpowiedzią na to zadanie.

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

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

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

Edycja: Oto alternatywna wersja, która dodaje liczby całkowite, a nie dwójkowe.

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

Tylda jest jednostronnym operatorem odwrotnym, który powraca -x-1, więc pierwszym krokiem jest pobranie, -6a następnie użycie innego operatora w printfunkcji get5

Rubin

class Fixnum
    alias plus +

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

puts 2 + 2

Zwiększa to wynik wszystkich dodatków, których pierwszym argumentem jest Fixnum (którym 2 jest, przynajmniej w MRI) o 1.

Skutki uboczne tego są jeszcze gorsze niż wersja Java.

Rubin

Ruby ma środowiska najwyższej klasy. Oznacza to wiele rzeczy. Oznacza to również, że można zrobić wiele rzeczy, które ... może nie powinny.

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

Wynikiem tego jest:

2 + 2 = 
4
2 + 4 = 
6
Ale w 1984 roku ...
2 + 2 = 
5
2 + 4 = 
6

Jeśli chcesz dowiedzieć się więcej na temat radości i niebezpieczeństw związanych z tym, Ruby Conf 2011 Utrzymanie Ruby Rozsądne i przeczytaj pierwszorzędne środowiska z bloga Abstract Heresies.

Schemat

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

DO#

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

Dla kogoś, kto nie jest zaznajomiony, będzie to wyglądać tak, że otrzymuję zakres zaczynający się i kończący na 2. W rzeczywistości zaczyna się od 2 i obejmuje dwie liczby. Więc 2 + 3 = 5.

FA#

Wstawmy fsi następujące oświadczenie:

let ``2+2``= 5

Wynik:

val ( 2+2 ) : int = 5

do

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

5Nie jest zbyt dobrze ukryte, obawiam się. Nie działa z optymalizacją.