Ecrivez un programme qui ajoute apparemment les nombres 2 et 2 et les sorties 5. Ceci est un concours sournois.

Votre programme ne peut générer aucune erreur. Attention aux trous de mémoire! La saisie est facultative.

Redéfinir 2 + 2 en tant que 5 n'est pas très créatif! Ne le double pas, essaie autre chose.

Java

La réflexion est en effet le bon choix pour abuser de Java ... mais vous devez aller plus loin que de peaufiner certaines valeurs.

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

Sortie:

5

Explication:

Vous devez le modifier encore plus profondément que ce à quoi vous pouvez généralement accéder. Notez que ceci est conçu pour Java 6 sans aucun paramètre génial transmis sur la machine virtuelle Java qui pourrait autrement changer IntegerCache .

Au cœur de la classe Integer se trouve un Flyweight of Integers. C'est un tableau d'entiers de −128 à +127. cache[132]est l'endroit où 4 serait normalement. Réglez-le sur 5.

Avertissement: Faire cela dans un code réel rendra les gens très malheureux.

Code démo sur ideone .

Haskell

J'adore la façon dont on peut jeter n'importe quoi sur ghci et ça roule totalement avec ça.

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

C

Très bon truc mais je suis sûr que je vais piéger la plupart d'entre vous.

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

Essayez-le ici

Faites défiler le code à droite.
Je ne suis pas sûr sous Windows / Linux mais sous OSX, la barre de défilement n'est pas visible.
Quoi qu'il en soit, c'est une bonne raison d'activer la "visualisation d'espace" sur votre éditeur de code préféré.

GolfScript

4:echo(2+2);

Impressions 5.

Bien sûr, la syntaxe de GolfScript est très différente de celle des autres langages. Ce programme a juste l’air de ressembler à quelque chose de fondamental ou de C-ish.

4  - Mettez le chiffre 4 sur la pile. Contenu de la pile: 4
:echo- Enregistrez la valeur située en haut de la pile dans la variable echo. Contenu de la pile: 4
(  - Décrémentez de 1 la valeur située en haut de la pile. Contenu de la pile: 3
2  - Placez le chiffre 2 au-dessus de la pile. Contenu de la pile: 3 2
+  - Ajoutez les deux nombres en haut de la pile. Contenu de la pile: 5
2  - Placez le chiffre 2 en haut de la pile. Contenu de la pile: 5 2
)  - Incrémentez la valeur du haut de la pile de 1. Contenu de la pile: 5 3
;  - Supprimez l’élément supérieur de la pile. Contenu de la pile: 5

Par défaut, GolfScript imprimera tout ce qui reste sur la pile à la fin de l'exécution.

Java

Il faut toujours arrondir les doubles

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

Sortie:

Variable two = 2.000000000000000
two + two = 5.000000000000000

Explication:

Non, sérieusement, vous devez toujours arrondir vos doubles. 15 n'est pas suffisant pour indiquer que la two()méthode produit réellement 2.0000000000000004(16 suffisent cependant).

Dans les représentations hexadécimales brutes des nombres, il n'y a qu'une différence de 1 bit (entre 4000000000000001et 4000000000000000) ... ce qui suffit pour que la Math.ceilméthode retourne 5, pas 4.

BBC BASIC

EDIT: Pour Andrea Faulds et Squeamish Ossifrage, une version plus convaincante utilisant un interprète différent: 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

Ceci affiche en fait le numéro 4, mais VDU 23redéfinit la police pour ASCII 52 de sorte qu’elle ressemble à un 5 au lieu de 4. Le mode d’écran 6 a été sélectionné pour des raisons esthétiques (caractères d’une taille raisonnable).

L'image originale utilisant l'émulateur à l' adresse http://bbcbasic.co.uk/bbcwin/bbcwin.html . (avec un code légèrement différent) peut être vu dans l'historique d'édition.

Brainfuck

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

Sortie:

5

Essayez ici .

Je sais que cela peut sembler un peu simple, mais j'ai essayé d'être créatif, comme suggéré dans le post original.

Frapper

Comme il s’agit d’un concours de popularité , j’imagine que je devrais utiliser une méthode assez longue ...

Pour les personnes qui ne connaissent pas Bash: $((...expr...))est une syntaxe permettant d'évaluer les expressions arithmétiques. $(bc<<<...expr...)fait la même chose en utilisant la bccalculatrice en ligne de commande.

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

Sortie

2+2= 5

Explication

La deuxième ligne concatène v et 2 au lieu de les ajouter, ce qui donne 22.
Explication réelle:
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

Python

Inspiré par la réponse Java:

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

Comme Java, CPython utilise le même emplacement de mémoire pour toutes les copies des premiers petits nombres entiers (0 à 255 si la mémoire le permet). Cela entre et édite directement cet emplacement mémoire via ctypes. patchest simplement une "12-7"chaîne obscurcie , une chaîne de len4, qui evalest à 5.

Une version plus obscure

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

Au-delà de 2 + 2

Comme OP mentionné, 2 + 2 peut être un peu ennuyeux; voici donc du code plus propre, multiplateforme et multi-largeurs pour abus abusif.

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

Courir avec Python 2.7 ... ignore cette ligne à la fin. Fonctionne sous Windows 64 bits et Ubuntu 32 bits, les deux systèmes auxquels j'ai facilement accès.

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

Sans surprise, nous pouvons casser la propriété associative d’addition, où ( a + b ) + c = a + ( b + c ), comme on le voit dans les première et deuxième 1+2+3lignes, mais inexplicablement, nous cassons aussi la propriété commutative (où a + b = b + a ; 2e et 3e lignes). Je me demande si l'interpréteur Python ignore simplement les parenthèses superflues entourant les expressions d'addition.

JavaScript:

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

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

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

Vérifiez-le à http://jsfiddle.net/qhRJY/

H (lettre latine majuscule h) et Η (lettre grecque capitale eta) sont définis sur la portée globale car ils n'étaient pas définis comme locaux par rapport aux fonctions avec le mot clé var. Bien qu'elles se ressemblent, ce sont en fait deux variables différentes avec deux valeurs différentes. En utilisant Ctrl + F dans votre navigateur, vous constaterez que Η (eta) apparaît nettement moins que H (h) sur cette page.

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

Le bit sous-jacent est qu’il n’est pas vraiment sous-jacent - si vous ajoutez une source sonore de 2 dB à une autre source sonore de 2 dB, le bruit résultant sera alors de 5 dB (et si vous ajoutez deux sources de 30 dB, puis de 33 dB), car elles sont mesurées sur une échelle logarithmique.

Vous pouvez le voir sur une autre calculatrice ici .

PHP

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

Qui produit:

2 + 2 = 5

En effet, en PHP, les ternaires sont calculés de gauche à droite, il est donc réellement
(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);
    }

Il est dangereux de décorer votre Javascript avec de l'art ASCII.

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

     (2 + 2)

Lorsque les commentaires sont supprimés, les symboles et les opérateurs restants sont évalués comme
-~~--~(2 + 2) suit: Cette option utilise l'opérateur Bitwise Not (~) dans JS, ainsi qu'une poignée de signes moins qui annuleront les valeurs en cours de route.

Frapper

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

Sortie:

2 + 2 = 5

La sortie de chacun cataura un retour à la ligne implicite, mais le retour à la ligne final est supprimé par la substitution de commande$( )

Voici un autre:

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

Les tableaux Bash sont indexés à zéro

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

Cela dépend du module CPAN appelé Acme :: NewMath . En raison de noms de fichier incorrects dans le module, cela ne fonctionnera que sur des systèmes de fichiers insensibles à la casse (comme sous Windows ou Mac OS X), mais je blâme ici l'auteur du module d'origine. Acme :: NewMath implémente les mathématiques selon l'idéologie Ingsoc.

R

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

sortie:

5

le code ajoute en fait la moyenne de [1] à la moyenne de [4]. La bonne façon d'utiliser la fonction moyenne dans R serait la suivante: mean(c(1,3)) + mean(c(4,0))Ceci est différent des autres fonctions mathématiques dans R, tels que sum, maxet min; où sum(1,3), max(1,3)et min(3,1)donnerait tous la réponse attendue.

Java

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

sortie:

512.0000000000005

Fonctionne probablement dans toutes les langues utilisant le même type de doublons.

Befunge

Ceci est écrit en Befunge, mais est conçu pour ressembler à 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]

Lorsqu'il est exécuté (avec l'interprète correct), le programme sera imprimé 5.

Explication:

Un programme Befunge est constitué d'une grille de commandes à un seul caractère. La première commande est celle qui se trouve dans le coin supérieur gauche et la lecture des commandes se poursuit vers la droite. Mais la direction peut changer pendant l'exécution du programme.

Seules la première ligne de caractères et la colonne de caractères commençant par le vdans la première ligne sont exécutées. Les caractères en question font:

#- ignorer la commande suivante
>- Les commandes sont désormais lues à droite de la commande en cours
v- Les commandes sont désormais lues sous la commande en cours
5- Poussez 5 dans la pile
.- Pop et imprimez le numéro en haut de la pile
@- Terminez le programme
<space>- Ne faites rien

Si vous saviez que vous programmez à Befunge, cela ne trompera personne. Mais si vous rencontriez cela et ne réalisiez pas que c'était Befunge, ce serait probablement le cas.

JavaScript

Code:

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

Sortie:

5

Vous pouvez le tester vous-même sur votre console ou consulter ce violon

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

Il imprime 2 + 2 = 5

Donc a = 2, non?

gcc-4.7.3 évalue les paramètres de la fonction de droite à gauche. Quand a + b est évalué, a est toujours 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

Abus standard de commonblocs: l'ordre compte; J'ai échangé la commande dans le bloc du sous-programme alors j'ajoute vraiment 1 + 2 + 2.

Python

Le code affiche 5, ce qui est la réponse correcte pour cette tâche.

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

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

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

Edit: Voici une version alternative qui ajoute des entiers, pas des deux stringifiés.

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

Tilde est un opérateur inverse unaire qui revient -x-1, donc la première étape consiste à obtenir -6puis avec un autre opérateur dans la printfonction get5

Rubis

class Fixnum
    alias plus +

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

puts 2 + 2

Cela augmente de 1 le résultat de tous les ajouts dont le premier argument est un Fixnum (dont 2 correspond au moins à l'IRM).

Les effets secondaires sont encore pires que ceux de la version Java.

Rubis

Ruby a des environnements de première classe. Cela signifie beaucoup de choses. Cela signifie également que beaucoup de choses peuvent être faites ... peut-être que non.

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

La sortie de ceci est:

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

Si vous voulez en savoir plus sur les joies et les dangers de cette expérience , Ruby Conf 2011 Gardez Ruby raisonnable et lisez les environnements de première classe du blog Abstract Heresies.

Schème

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

C #

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

Pour ceux qui ne sont pas familiers, cela donne l’impression que la plage commence et se termine à 2. En réalité, elle commence à 2 et comprend deux chiffres. Donc 2 + 3 = 5.

F#

Mettons dans la déclaration suivante fsi:

let ``2+2``= 5

Sortie:

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

Le 5n'est pas trop bien caché, j'ai peur. Ne fonctionne pas avec l'optimisation.