Escriba un programa que aparentemente agregue los números 2 y 2 y produzca 5. Este es un concurso oculto.

Su programa no puede generar ningún error. ¡Cuidado con los agujeros de memoria! La entrada es opcional.

¡Redefinir 2 + 2 como 5 no es muy creativo! No lo pienses dos veces, prueba con otra cosa.

Java

La reflexión es, de hecho, la forma correcta de abusar de Java ... pero necesita profundizar más que simplemente ajustar algunos valores.

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

Salida:

5

Explicación:

Debe cambiarlo aún más de lo que normalmente puede acceder. Tenga en cuenta que esto está diseñado para Java 6 sin que se pasen parámetros originales en la JVM que de otro modo cambiarían IntegerCache .

En lo profundo de la clase Integer hay un Flyweight of Integers. Esta es una matriz de enteros de −128 a +127. cache[132]es el lugar donde normalmente estaría 4. Ajústelo a 5.

Advertencia: Hacer esto en código real hará que la gente sea muy infeliz.

Código de demostración en ideone .

Haskell

Me encanta cómo puedes arrojarle algo a ghci y todo funciona.

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

C

Truco bastante barato, pero estoy seguro de que atraparé a la mayoría de ustedes.

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

Pruébalo aquí

Desplaza el código a la derecha.
No estoy seguro en Windows / Linux pero en OSX, la barra de desplazamiento no está visible.
De todos modos, esta es una buena razón para habilitar la "visualización del espacio" en su editor de código favorito.

GolfScript

4:echo(2+2);

Impresiones 5.

Por supuesto, GolfScript tiene una sintaxis que es marcadamente diferente a la de otros lenguajes, este programa simplemente parece algo Básico o C-ish.

4  - Pon el número 4 en la pila. Contenido de la pila: 4
:echo: guarde el valor en la parte superior de la pila en el eco variable. Contenido de la pila: 4
(  - Disminuya el valor en la parte superior de la pila en 1. Contenido de la pila: 3
2  - Ponga el número 2 en la parte superior de la pila. Contenido de la pila: 3 2
+  - Agregue los dos números en la parte superior de la pila. Contenido de la pila: 5
2  - Pon el número 2 en la parte superior de la pila. Contenido de la pila: 5 2
)  - Incremente el valor en la parte superior de la pila en 1. Contenido de la pila: 5 3
;  - Retire el elemento superior de la pila. Contenido de la pila: 5

GolfScript imprimirá por defecto todo lo que quede en la pila una vez que haya finalizado la ejecución.

Java

Siempre tienen que redondear sus dobles, amigos

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

Salida:

Variable two = 2.000000000000000
two + two = 5.000000000000000

Explicación:

No, en serio, siempre tienes que redondear tus dobles. 15 no son suficientes dígitos para mostrar que el two()método realmente produce 2.0000000000000004(16 es suficiente, sin embargo).

En las representaciones hexadecimales sin procesar de los números, es solo una diferencia de 1 bit (entre 4000000000000001y 4000000000000000) ... que es suficiente para hacer que el Math.ceilmétodo devuelva 5, no 4.

BBC BASIC

EDITAR: Para Andrea Faulds y Squeamish Ossifrage, una versión más convincente con un intérprete diferente: 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

Esto realmente imprime el número 4, pero VDU 23redefine la fuente para ASCII 52 para que parezca un 5 en lugar de un 4. Se seleccionó el modo de pantalla 6 por razones estéticas (caracteres de un tamaño razonable).

La imagen original con el emulador en http://bbcbasic.co.uk/bbcwin/bbcwin.html . (con un código ligeramente diferente) se puede ver en el historial de edición.

Brainfuck

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

Salida:

5

Probarlo aquí .

Sé que esto puede sonar un poco simple, pero traté de ser creativo, como se sugiere en la publicación original.

Golpetazo

Dado que este es un concurso de popularidad , creo que debería usar un método de largo aliento ...

Para las personas que no conocen Bash: $((...expr...))es una sintaxis para evaluar expresiones aritméticas. $(bc<<<...expr...)hace lo mismo usando la bccalculadora de línea de comandos.

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

Salida

2+2= 5

Explicación

La segunda línea concatena v y 2 en lugar de agregarlos, para hacer 22.
Explicación real:
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

Pitón

Inspirado por la respuesta de Java:

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

Al igual que Java, CPython usa la misma ubicación de memoria para cualquier copia de los primeros enteros pequeños (0-255 si la memoria sirve). Esto entra y edita directamente esa ubicación de memoria a través de ctypes. patches solo un ofuscado "12-7", una cadena con len4, que evales 5.

Una versión más ofuscada

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

Más allá de 2 + 2

Como OP mencionó, 2 + 2 puede ser un poco aburrido; Así que aquí hay un código más limpio, multiplataforma y de ancho múltiple para el abuso sin sentido.

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

Ejecutando con Python 2.7 ... ignore esa línea al final. Funciona en Windows de 64 bits y Ubuntu de 32 bits, los dos sistemas a los que tengo fácil acceso.

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

Como era de esperar, podemos romper la propiedad asociativa de la suma, donde ( a + b ) + c = a + ( b + c ), como se ve en las 1+2+3líneas 1 y 2 , pero inexplicablemente también rompemos la propiedad conmutativa (donde a + b = b + a ; 2da y 3ra líneas). Me pregunto si el intérprete de Python ignora los paréntesis superfluos alrededor de las expresiones de suma.

JavaScript:

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

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

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

Compruébelo en http://jsfiddle.net/qhRJY/

Tanto H (letra latina mayúscula h) como Η (letra mayúscula griega eta) se establecen en el ámbito global porque no se definieron como locales para las funciones con la palabra clave var. Si bien se ven similares, en realidad son 2 variables diferentes con 2 valores diferentes. Usando Ctrl + F en su navegador, encontrará que Η (eta) aparece significativamente menos que H (h) en esta página.

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

El bit oculto es que no está realmente oculto: si agrega una fuente de sonido de 2dB a otra fuente de sonido de 2dB, el ruido combinado resultante será de 5dB (y si agrega dos fuentes de 30dB, entonces es de 33dB) ya que se miden en una escala de registro.

Puedes verlo en una calculadora diferente aquí .

PHP

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

Que produce:

2 + 2 = 5

Esto se debe a que en PHP, los ternaries se calculan de izquierda a derecha, por lo que en realidad es
(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);
    }

Es peligroso decorar tu Javascript con arte ASCII.

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

     (2 + 2)

Cuando se eliminan los comentarios, los símbolos y operadores restantes se evalúan como
-~~--~(2 + 2) Esto hace uso del operador Bitwise Not (~) en JS, junto con un puñado de signos Menos que negarán los valores en el camino.

Golpetazo

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

Salida:

2 + 2 = 5

La salida de cada uno cattendrá una nueva línea implícita, pero la nueva línea final se elimina mediante la sustitución del comando$( )

Aquí está otro:

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

Las matrices de bash están indexadas a cero

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

Depende del módulo CPAN llamado Acme :: NewMath . Debido a nombres de archivo incorrectos en el módulo, esto solo funcionará en sistemas de archivos que no distinguen entre mayúsculas y minúsculas (como en Windows o Mac OS X), pero culpo al autor del módulo original aquí. Acme :: NewMath implementa las matemáticas de acuerdo con la ideología Ingsoc.

R

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

salida:

5

el código en realidad agrega la media de [1] a la media de [4]. La forma correcta de utilizar la función de media en R sería: mean(c(1,3)) + mean(c(4,0))Esto es a diferencia de algunas otras funciones matemáticas en I, tales como sum, max, y min; donde sum(1,3), max(1,3)y min(3,1)todos darían la respuesta esperada.

Java

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

salida:

512.0000000000005

Probablemente funciona en cualquier idioma que use el mismo tipo de dobles.

Befunge

Esto está escrito en Befunge, pero está diseñado para parecerse 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

Cuando se ejecuta (con el intérprete correcto) se imprimirá el programa 5.

Explicación:

Un programa Befunge se compone de una cuadrícula de comandos de un solo carácter. El primer comando es el que está en la esquina superior izquierda, y la lectura de los comandos continúa a la derecha. Pero la dirección puede cambiar durante la ejecución del programa.

Solo vse ejecutan la primera fila de caracteres y la columna de caracteres que comienza con la primera fila. Los caracteres en cuestión lo hacen:

#- omita el siguiente comando
>- De ahora en adelante, los comandos se leen a la derecha del comando actual
v- De ahora en adelante, los comandos se leen debajo del comando actual
5- Presione 5 en la pila
.- Pop e imprima el número en la parte superior de la pila
@- Finalice el programa
<space>- No haga nada

Si supieras que estás programando en Befunge, esto realmente no engañaría a nadie. Pero si te encuentras con esto y no te das cuenta de que era Befunge, lo más probable es que lo haga.

JavaScript

Código:

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

Salida:

5

Puede probarlo usted mismo en su consola o consultar este Fiddle

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

Imprime 2 + 2 = 5

Entonces a = 2, ¿verdad?

gcc-4.7.3 evalúa los parámetros de la función de derecha a izquierda. Cuando se evalúa a + b, a sigue siendo 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 estándar de commonbloques: el orden importa; Cambié el orden en el bloque en la subrutina, así que realmente estoy agregando 1 + 2 + 2.

Pitón

El código imprime 5, que es la respuesta correcta para esta tarea.

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

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

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

Editar: Aquí hay una versión alternativa que agrega enteros, no dos en cadena.

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

Tilde es un operador inverso unario que regresa -x-1, por lo que el primer paso es obtener -6y luego con otro operador en la printfunción obtener5

Rubí

class Fixnum
    alias plus +

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

puts 2 + 2

Esto aumenta el resultado de todas las adiciones cuyo primer argumento es un Fixnum (que 2 es, al menos en MRI) en 1.

Los efectos secundarios de esto son incluso peores que la versión de Java.

Rubí

Ruby tiene ambientes de primera clase. Esto significa muchas cosas. También significa que se pueden hacer muchas cosas que ... tal vez no deberían.

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

El resultado de esto es:

2 + 2 = 
4 4
2 + 4 = 
6 6
Pero en 1984 ...
2 + 2 = 
5 5
2 + 4 = 
6 6

Si desea comprender más sobre las alegrías y los peligros de esto, Ruby Conf 2011 Mantener a Ruby Razonable y lea entornos de primera clase del blog Abstract Heresies.

Esquema

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

C#

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

Para alguien no familiar, esto parecerá que estoy obteniendo un rango que comienza y termina en 2. En realidad, comienza en 2 y va por dos números. Entonces 2 + 3 = 5.

F#

Pongamos en fsi la siguiente declaración:

let ``2+2``= 5

Salida:

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

El 5no está muy bien escondido, me temo. No funciona con optimización.