Escreva um programa que aparentemente adicione os números 2 e 2 e produz 5. Este é um concurso secreto.

Seu programa não pode gerar erros. Cuidado com os buracos da memória! A entrada é opcional.

Redefinir 2 + 2 como 5 não é muito criativo! Não pense duas vezes, tente outra coisa.

Java

A reflexão é realmente o caminho certo para abusar do Java ... mas você precisa ir mais fundo do que apenas ajustar alguns 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);
    }
}

Resultado:

5

Explicação:

Você precisa alterá-lo ainda mais do que normalmente pode acessar. Observe que isso foi projetado para Java 6 sem parâmetros descolados transmitidos na JVM que, de outra forma, alterariam o IntegerCache .

Dentro da classe Inteiro, há um Flyweight de Inteiros. Essa é uma matriz de números inteiros de -128 a +127. cache[132]é o local onde normalmente seria 4. Defina para 5.

Aviso: fazer isso em código real deixará as pessoas muito infelizes.

Demonstração de código em ideone .

Haskell

Eu simplesmente amo como você pode jogar qualquer coisa no ghci e ele rola totalmente com ele.

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

C

Truque bem barato, mas tenho certeza de que vou prender a maioria de vocês.

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

Experimente aqui

Role o código para a direita.
Não tenho certeza no Windows / Linux, mas no OSX, a barra de rolagem não está visível.
De qualquer forma, esse é um bom motivo para ativar a "visualização de espaço" no seu editor de código favorito.

GolfScript

4:echo(2+2);

Imprime 5.

É claro que o GolfScript possui uma sintaxe muito diferente de outras linguagens; esse programa parece algo básico ou C-ish.

4  - Coloque o número 4 na pilha. Conteúdo da pilha: 4
:echo- Salve o valor na parte superior da pilha no eco variável. Conteúdo da pilha: 4
(  - Diminua o valor na parte superior da pilha por 1. Conteúdo da pilha: 3
2  - Coloque o número 2 na parte superior da pilha. Conteúdo da pilha: 3 2
+  - Adicione os dois números na parte superior da pilha. Conteúdo da pilha: 5
2  - Coloque o número 2 em cima da pilha. Conteúdo da pilha: 5 2
)  - Aumente o valor na parte superior da pilha em 1. Conteúdo da pilha: 5 3
;  - Remova o elemento superior da pilha. Conteúdo da pilha: 5

Por padrão, o GolfScript imprime tudo o que resta na pilha após a conclusão da execução.

Java

Sempre tem que arredondar suas duplas, pessoal

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

Resultado:

Variable two = 2.000000000000000
two + two = 5.000000000000000

Explicação:

Não, sério, você sempre tem que arredondar suas duplas. 15 não são dígitos suficientes para mostrar que o two()método realmente produz 2.0000000000000004(16 são suficientes).

Nas representações hexadecimais brutas dos números, é apenas uma diferença de 1 bit (entre 4000000000000001e 4000000000000000) ... o suficiente para fazer o Math.ceilmétodo retornar 5, não 4.

BBC BASIC

EDIT: Para Andrea Faulds e Squeamish Ossifrage, uma versão mais convincente usando um 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

Na verdade, ele imprime o número 4, mas VDU 23redefine a fonte do ASCII 52 para que pareça um 5 em vez de um 4. O modo de tela 6 foi selecionado por razões estéticas (caracteres de tamanho razoável).

A imagem original usando o emulador em http://bbcbasic.co.uk/bbcwin/bbcwin.html . (com código ligeiramente diferente) pode ser visto no histórico de edições.

Brainfuck

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

Resultado:

5

Experimente aqui .

Sei que isso pode parecer um pouco simples, mas tentei ser criativo, conforme sugerido na postagem original.

Bater

Uma vez que este é um concurso de popularidade , acho que devo usar um método muito complicado ...

Para pessoas que não conhecem o Bash: $((...expr...))é uma sintaxe para avaliar expressões aritméticas. $(bc<<<...expr...)faz o mesmo usando a bccalculadora da linha 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...?

Resultado

2+2= 5

Explicação

A segunda linha concatena v e 2 em vez de adicioná-los, para fazer 22.
Explicação 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ão

Inspirado pela resposta Java:

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

Como Java, o CPython usa o mesmo local de memória para qualquer cópia dos primeiros números inteiros pequenos (0 a 255, se a memória servir). Isso entra e edita diretamente esse local de memória via ctypes. patché apenas um ofuscado "12-7", uma string com len4, que evalé 5.

Uma versão mais 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")

Além de 2 + 2

Como o OP mencionou, 2 + 2 pode ser meio chato; então aqui está um código mais limpo, multiplataforma e com várias larguras para abuso arbitrário.

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

Correndo com o Python 2.7 ... ignore essa linha no final. Funciona no Windows de 64 bits e no Ubuntu de 32 bits, os dois sistemas aos quais tenho acesso fácil.

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

Sem surpresa, podemos quebrar a propriedade associativa de adição, onde ( a + b ) + c = a + ( b + c ), como visto nas 1+2+3linhas 1 e 2 , mas inexplicavelmente também quebramos a propriedade comutativa (onde a + b = b + a ; 2ª e 3ª linhas). Gostaria de saber se o interpretador Python simplesmente ignora parênteses supérfluos em torno de expressões de adição.

JavaScript:

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

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

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

Verifique em http://jsfiddle.net/qhRJY/

H (letra maiúscula em latim h) e Η (letra maiúscula em grego eta) são configurados para o escopo global porque não foram definidos como locais para as funções com a palavra-chave var. Embora pareçam semelhantes, na verdade são 2 variáveis ​​diferentes com 2 valores diferentes. Usando Ctrl + F no seu navegador, você verá que Η (eta) aparece significativamente menos que H (h) nesta 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) );

O bit secreto é que não é realmente secreto - se você adicionar uma fonte de som de 2dB a outra fonte de som de 2dB, o ruído combinado resultante será de 5dB (e se você adicionar duas fontes de 30dB, então seus 33dB), conforme são medidos em uma escala de log.

Você pode vê-lo em uma calculadora diferente aqui .

PHP

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

Qual produz:

2 + 2 = 5

Isso ocorre porque, no PHP, os ternários são calculados da esquerda para a direita, então é realmente
(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);
    }

É perigoso decorar seu Javascript com arte ASCII.

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

     (2 + 2)

Quando os comentários são removidos, os símbolos e operadores restantes avaliam como
-~~--~(2 + 2) Isso faz uso do operador Bitwise Not (~) em JS, junto com um punhado de sinais de menos que negarão os valores ao longo do caminho.

Bater

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

Resultado:

2 + 2 = 5

A saída de cada catum terá uma nova linha implícita, mas a nova linha final é removida pela substituição de comando$( )

Aqui está outro:

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

Matrizes Bash são zero indexadas

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 do módulo CPAN chamado Acme :: NewMath . Devido a nomes de arquivos incorretos no módulo, isso funcionará apenas em sistemas de arquivos que não diferenciam maiúsculas de minúsculas (como no Windows ou Mac OS X), mas eu culpo o autor do módulo original aqui. Acme :: NewMath implementa matemática de acordo com a ideologia Ingsoc.

R

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

resultado:

5

o código realmente adiciona a média de [1] à média de [4]. A maneira correta de usar a função de média em R seria: mean(c(1,3)) + mean(c(4,0))Isso é diferente de algumas outras funções matemáticas em R, tais como sum, max, e min; onde sum(1,3), max(1,3)e min(3,1)que todos dar a resposta esperada.

Java

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

resultado:

512.0000000000005

Provavelmente funciona em qualquer idioma que use o mesmo tipo de duplas.

Befunge

Isso está escrito no Befunge, mas foi projetado para se parecer com 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: [email protected]

Quando executado (com o intérprete correto), o programa será impresso 5.

Explicação:

Um programa Befunge é composto de uma grade de comandos de caracteres únicos. O primeiro comando é aquele no canto superior esquerdo e a leitura dos comandos prossegue para a direita. Mas a direção pode mudar durante a execução do programa.

Somente a primeira linha de caracteres e a coluna de caracteres iniciando com o vna primeira linha são executadas. Os caracteres em questão:

#- pulam o próximo comando
>- A partir de agora, os comandos são lidos à direita do comando atual
v- A partir de agora, os comandos são lidos abaixo do comando atual
5- Pressione 5 na pilha
.- Pop e imprima o número no topo da pilha
@- Finalize o programa
<space>- Não faça nada

Se você soubesse que estava programando no Befunge, isso não enganaria ninguém. Mas se você se deparar com isso e não perceber que é o Befunge, provavelmente seria.

Javascript

Código:

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

Resultado:

5

Você pode testá-lo no seu console ou verificar 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

Então a = 2, certo?

O gcc-4.7.3 avalia os parâmetros de função da direita para a esquerda. Quando a + b é avaliado, a ainda é 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 de commonblocos padrão : a ordem é importante; Troquei a ordem no bloco na sub-rotina, então estou realmente adicionando 1 + 2 + 2.

Pitão

O código imprime 5, que é a resposta correta para esta tarefa.

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

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

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

Edit: Aqui está a versão alternativa, que adiciona números inteiros, e não a dois.

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

Tilde é um operador inverso unário que retorna -x-1; portanto, o primeiro passo é obter -6e, em seguida, com outro operador na printfunção get5

Rubi

class Fixnum
    alias plus +

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

puts 2 + 2

Isso aumenta o resultado de todas as adições cujo primeiro argumento é um Fixnum (que 2 é, pelo menos na RM) em 1.

Os efeitos colaterais disso são ainda piores que a versão Java.

Rubi

Ruby tem ambientes de primeira classe. Isso significa muitas coisas. Isso também significa que muitas coisas podem ser feitas que ... talvez não devam.

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

A saída disso é:

2 + 2 = 
4
2 + 4 = 
6
Mas em 1984 ...
2 + 2 = 
5
2 + 4 = 
6

Se você quiser entender mais sobre as alegrias e os perigos disso, Ruby Conf 2011 Mantendo o Ruby Razoável e leia Ambientes de primeira classe no blog Abstract Heresies.

Esquema

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

C #

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

Para alguém não familiar, parece que estou recebendo um intervalo começando e terminando em 2. Na realidade, ele começa em 2 e passa por dois números. Então 2 + 3 = 5.

F #

Vamos colocar na seguinte declaração fsi:

let ``2+2``= 5

Resultado:

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

O 5medo não está muito bem escondido. Não funciona com otimização.