Scrivi un programma che apparentemente aggiunge i numeri 2 e 2 e le uscite 5. Questo è un concorso subdolo.

Il tuo programma non può generare errori. Fai attenzione ai buchi della memoria! L'ingresso è facoltativo.

Ridefinire 2 + 2 come 5 non è molto creativo! Non pensarci due volte, prova qualcos'altro.

Giava

La riflessione è davvero il modo giusto per abusare di Java ... ma devi andare più in profondità che modificare solo alcuni valori.

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

Produzione:

5

Spiegazione:

Devi cambiarlo ancora più in profondità di quanto puoi accedere in genere. Si noti che questo è progettato per Java 6 senza parametri funky passati sulla JVM che altrimenti cambierebbe IntegerCache .

Nel profondo della classe Integer è presente un Peso mosca di numeri interi. Questa è una matrice di numeri interi da -128 a +127. cache[132]è il punto in cui 4 sarebbe normalmente. Impostalo su 5.

Attenzione: farlo nel vero codice renderà le persone molto infelici.

Demo del codice su ideone .

Haskell

Adoro il modo in cui puoi lanciare qualsiasi cosa su Ghci e tutto ruota con esso.

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

C

Un trucco abbastanza economico ma sono sicuro che intrappolerò la maggior parte di voi.

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

Provalo qui

Scorri il codice verso destra.
Non sono sicuro su Windows / Linux ma su OSX, la barra di scorrimento non è visibile.
Comunque, questo è un buon motivo per abilitare la "visualizzazione dello spazio" sul tuo editor di codice preferito.

GolfScript

4:echo(2+2);

Stampe 5.

Naturalmente GolfScript ha una sintassi che è nettamente diversa dalle altre lingue, questo programma sembra essere qualcosa di semplice o di C-ish.

4  - Metti il ​​numero 4 in pila. Contenuto dello stack: 4
:echo- Salva il valore nella parte superiore dello stack nell'eco della variabile. Contenuto dello stack: 4
(  - Diminuisci il valore nella parte superiore dello stack di 1. Contenuto dello stack: 3
2  - Metti il ​​numero 2 in cima allo stack. Contenuto dello stack: 3 2
+  - Aggiungi i due numeri in cima allo stack. Contenuto dello stack: 5
2  - Metti il ​​numero 2 in cima allo stack. Contenuto dello stack: 5 2
)  - Incrementa il valore nella parte superiore dello stack di 1. Contenuto dello stack: 5 3
;  - Rimuovi l'elemento superiore dallo stack. Contenuto dello stack: 5

Per impostazione predefinita, GolfScript stamperà qualsiasi cosa rimasta nello stack al termine dell'esecuzione.

Giava

Devi sempre arrotondare il doppio, gente

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

Produzione:

Variable two = 2.000000000000000
two + two = 5.000000000000000

Spiegazione:

No, sul serio, devi sempre arrotondare il doppio. 15 non sono abbastanza cifre per mostrare che il two()metodo produce effettivamente 2.0000000000000004(16 è abbastanza, però).

Nelle rappresentazioni esadecimali dei numeri, è solo una differenza di 1 bit (tra 4000000000000001e 4000000000000000) ... che è sufficiente per rendere il Math.ceilmetodo restituito 5, non 4.

BBC BASIC

EDIT: per Andrea Faulds e Squeamish Ossifrage, una versione più convincente che utilizza un interprete diverso: 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

Questo in realtà stampa il numero 4, ma VDU 23ridefinisce il carattere per ASCII 52 in modo che appaia come un 5 anziché un 4. La modalità schermo 6 è stata selezionata per motivi estetici (caratteri di dimensioni ragionevoli).

L'immagine originale utilizzando l'emulatore su http://bbcbasic.co.uk/bbcwin/bbcwin.html . (con un codice leggermente diverso) può essere visto nella cronologia delle modifiche.

Brainfuck

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

Produzione:

5

Provalo qui .

So che potrebbe sembrare un po 'troppo semplice, ma ho cercato di essere creativo, come suggerito nel post originale.

bash

Dal momento che questo è un concorso di popolarità , suppongo che dovrei usare un metodo prolisso ...

Per le persone che non conoscono Bash: $((...expr...))è una sintassi per valutare le espressioni aritmetiche. $(bc<<<...expr...)fa lo stesso usando il bccalcolatore della riga di comando.

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

Produzione

2+2= 5

Spiegazione

La seconda riga concatena v e 2 invece di aggiungerli, per fare 22.
Spiegazione effettiva:
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

Pitone

Ispirato dalla risposta Java:

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

Come Java, CPython utilizza la stessa posizione di memoria per qualsiasi copia dei primi piccoli numeri interi (0-255 se la memoria serve). Questo accede e modifica direttamente la posizione della memoria tramite ctypes. patchè solo un offuscato "12-7", una stringa con len4, che evalè a 5.

Una versione più offuscata

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

Oltre 2 + 2

Come menzionato in OP, 2 + 2 può essere un po 'noioso; quindi ecco un codice più pulito, multipiattaforma e multi-larghezza per abuso sfrenato.

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

In esecuzione con Python 2.7 ... ignora quella riga alla fine. Funziona in Windows 64-bit e Ubuntu 32-bit, i due sistemi a cui ho un facile accesso.

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

Non sorprende che possiamo rompere la proprietà associativa di addizione, dove ( a + b ) + c = a + ( b + c ), come si vede nella 1a e 2a 1+2+3riga, ma inspiegabilmente rompiamo anche la proprietà commutativa (dove a + b = b + a ; 2a e 3a riga). Mi chiedo se l'interprete Python ignori semplicemente le parentesi superflue attorno alle espressioni di addizione.

JavaScript:

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

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

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

Controllalo su http://jsfiddle.net/qhRJY/

Sia H (maiuscola latina h) che Η (maiuscola greca eta) sono impostati nell'ambito globale perché non sono stati definiti locali per le funzioni con la parola chiave var. Mentre sembrano simili, in realtà sono 2 variabili diverse con 2 valori diversi. Usando Ctrl + F nel tuo browser scoprirai che Η (eta) appare significativamente meno di H (h) in questa pagina.

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

Il bit subdolo è che in realtà non è subdolo - se aggiungi una sorgente sonora da 2 dB a un'altra sorgente sonora da 2 dB, il rumore combinato risultante sarà di 5 dB (e se aggiungi due sorgenti da 30 dB, quindi i suoi 33 dB) in quanto misurati su una scala logaritmica.

Puoi vederlo su un altro calcolatore qui .

PHP

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

Che produce:

2 + 2 = 5

Questo perché in PHP, i ternari sono calcolati da sinistra a destra, quindi in realtà lo è
(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);
    }

È pericoloso decorare il tuo Javascript con l'arte ASCII.

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

     (2 + 2)

Quando i commenti vengono rimossi, i simboli e gli operatori rimanenti valutano
-~~--~(2 + 2) Questo fa uso dell'operatore Bitwise Not (~) in JS, insieme a una manciata di segni Meno che annulleranno i valori lungo la strada.

bash

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

Produzione:

2 + 2 = 5

L'output di ciascuno catavrà una nuova riga implicita, ma la nuova riga finale viene rimossa dalla sostituzione del comando$( )

Eccone un altro:

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

Le matrici di Bash sono indicizzate zero

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

Dipende dal modulo CPAN chiamato Acme :: NewMath . A causa di nomi di file errati nel modulo, questo funzionerà solo su file system senza distinzione tra maiuscole e minuscole (come su Windows o Mac OS X), ma qui biasimo l'autore del modulo originale. Acme :: NewMath implementa la matematica secondo l'ideologia Ingsoc.

R

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

produzione:

5

il codice aggiunge effettivamente la media di [1] alla media di [4]. Il modo corretto di utilizzare la funzione medio in R sarebbe: mean(c(1,3)) + mean(c(4,0))Questo è diverso da alcune altre funzioni matematiche in R, come sum, maxe min; dove sum(1,3), max(1,3)e min(3,1)darebbe tutti la risposta prevista.

Giava

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

produzione:

512.0000000000005

Probabilmente funziona in qualsiasi lingua che utilizza lo stesso tipo di doppio.

Befunge

Questo è scritto in Befunge, ma è progettato per assomigliare a 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

Quando eseguito (con l'interprete corretto) il programma stamperà 5.

Spiegazione:

Un programma Befunge è costituito da una griglia di comandi a carattere singolo. Il primo comando è quello nell'angolo in alto a sinistra e la lettura dei comandi procede verso destra. Ma la direzione può cambiare durante l'esecuzione del programma. Vengono eseguite

solo la prima riga di caratteri e la colonna di caratteri che iniziano con il vnella prima riga. I caratteri in questione fanno:

#- salta il comando successivo
>- D'ora in poi, i comandi vengono letti a destra del comando corrente
v- D'ora in poi, i comandi vengono letti sotto il comando corrente
5- Premi 5 nello stack
.- Pop e stampa il numero in cima alla pila
@- Termina il programma
<space>- Non fare nulla

Se sapessi che stavi programmando in Befunge, questo non avrebbe davvero ingannato nessuno. Ma se ti sei imbattuto in questo e non ti rendessi conto che era Befunge, molto probabilmente lo farebbe.

JavaScript

Codice:

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

Produzione:

5

Puoi provarlo tu stesso sulla tua console o controllare questo violino

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

Stampa 2 + 2 = 5

Quindi a = 2, giusto?

gcc-4.7.3 valuta i parametri della funzione da destra a sinistra. Quando viene valutato a + b, a è ancora 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

Abuso standard di commonblocchi: l'ordine conta; Ho scambiato l'ordine nel blocco nella subroutine, quindi sto davvero aggiungendo 1 + 2 + 2.

Pitone

Il codice stampa 5, che è la risposta corretta per questa attività.

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

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

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

Modifica: ecco una versione alternativa che aggiunge numeri interi, non a due stringenti.

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

Tilde è un operatore inverso unario che ritorna -x-1, quindi il primo passo è ottenere -6e poi con un altro operatore in printfunzione ottenere5

Rubino

class Fixnum
    alias plus +

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

puts 2 + 2

Ciò aumenta il risultato di tutte le aggiunte il cui primo argomento è Fixnum (che 2 è, almeno in MRI) di 1.

Gli effetti collaterali di questo sono persino peggiori della versione Java.

Rubino

Ruby ha ambienti di prima classe. Questo significa molte cose. Significa anche che si possono fare molte cose che ... forse non dovrebbero.

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

L'output di questo è:

2 + 2 = 
4
2 + 4 = 
6
Ma nel 1984 ...
2 + 2 = 
5
2 + 4 = 
6

Se vuoi saperne di più sulle gioie e sui pericoli di questo, Ruby Conf 2011 Mantenere Ruby ragionevole e leggere ambienti di prima classe dal blog di Abstract Heresies.

schema

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

C #

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

A qualcuno che non ha familiarità, sembrerà che stia ottenendo un intervallo che inizia e termina a 2. In realtà, inizia a 2 e va per due numeri. Quindi 2 + 3 = 5.

F #

Mettiamo in fsi la seguente dichiarazione:

let ``2+2``= 5

Produzione:

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

Non 5è troppo ben nascosto, temo. Non funziona con l'ottimizzazione.