Schreiben Sie ein Programm, das scheinbar die Zahlen 2 und 2 addiert und 5 ausgibt.

Ihr Programm kann keine Fehler ausgeben. Achten Sie auf Erinnerungslöcher! Die Eingabe ist optional.

2 + 2 als 5 neu zu definieren ist nicht sehr kreativ! Denken Sie nicht doppelt, probieren Sie etwas anderes.

Java

Reflexion ist in der Tat der richtige Weg, um Java zu missbrauchen ... aber Sie müssen tiefer gehen, als nur einige Werte zu optimieren.

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

Ausgabe:

5

Erläuterung:

Sie müssen es noch tiefer ändern, als Sie normalerweise zugreifen können. Beachten Sie, dass dies für Java 6 entwickelt wurde und keine funky Parameter an die JVM übergeben wurden, die andernfalls den IntegerCache ändern würden .

Tief in der Integer-Klasse befindet sich ein Flyweight of Integer. Dies ist ein Array von Ganzzahlen von –128 bis +127. cache[132]ist der Punkt, an dem 4 normalerweise sein würde. Stellen Sie es auf 5.

Warnung: Wenn Sie dies in echtem Code tun, werden die Leute sehr unglücklich.

Code Demo auf Ideone .

Haskell

Ich liebe es einfach, wie man alles auf ghci wirft und es total mitrollt.

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

C

Ziemlich billiger Trick, aber ich bin sicher, ich werde die meisten von Ihnen fangen.

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

Probieren Sie es hier aus

Scrollen Sie den Code nach rechts.
Ich bin mir unter Windows / Linux nicht sicher, aber unter OSX ist die Bildlaufleiste nicht sichtbar.
Auf jeden Fall ist dies ein guter Grund, die "Raumvisualisierung" in Ihrem bevorzugten Code-Editor zu aktivieren.

GolfScript

4:echo(2+2);

Druckt 5.

Natürlich hat GolfScript eine Syntax, die sich deutlich von anderen Sprachen unterscheidet. Dieses Programm sieht einfach so aus wie Basic oder C-ish.

4  - Legen Sie die Nummer 4 auf den Stapel. Stapelinhalt: 4
:echo- Speichern Sie den Wert oben im Stapel im Variablenecho. Stapelinhalt: 4
(  - Verringern Sie den Wert oben auf dem Stapel um 1. Stapelinhalt: 3
2  - Legen Sie die Zahl 2 oben auf den Stapel. Stapelinhalt: 3 2
+  - Addieren Sie die beiden Zahlen oben auf dem Stapel. Stapelinhalt: 5
2  - Legen Sie die Nummer 2 oben auf den Stapel. Stapelinhalt: 5 2
)  - Erhöhen Sie den Wert am oberen Rand des Stapels um 1. Stapelinhalt: 5 3
;  - Entfernen Sie das obere Element vom Stapel. Stapelinhalt: 5

GolfScript druckt standardmäßig alles, was nach Abschluss der Ausführung noch auf dem Stapel ist.

Java

Müssen immer Ihre Doppel runden, Leute

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

Ausgabe:

Variable two = 2.000000000000000
two + two = 5.000000000000000

Erläuterung:

Nein, im Ernst, Sie müssen immer Ihre Doppel runden. 15 sind nicht genug Ziffern, um zu zeigen, dass die two()Methode tatsächlich produziert 2.0000000000000004(16 sind jedoch genug).

In den rohen Hex-Darstellungen der Zahlen ist es nur ein 1-Bit-Unterschied (zwischen 4000000000000001und 4000000000000000) ..., der ausreicht, damit die Math.ceilMethode 5 und nicht 4 zurückgibt.

BBC BASIC

EDIT: Für Andrea Faulds und Squeamish Ossifrage eine überzeugendere Version mit einem anderen Interpreter: 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

Dies gibt tatsächlich die Zahl 4 aus, VDU 23definiert jedoch die Schriftart für ASCII 52 neu, sodass sie wie eine 5 anstelle einer 4 aussieht. Der Bildschirmmodus 6 wurde aus ästhetischen Gründen ausgewählt (Zeichen mit einer angemessenen Größe).

Das Originalbild mit dem Emulator unter http://bbcbasic.co.uk/bbcwin/bbcwin.html . (mit etwas anderem Code) ist im Bearbeitungsverlauf zu sehen.

Brainfuck

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

Ausgabe:

5

Probieren Sie es hier aus .

Ich weiß, dass dies ein wenig zu einfach klingt, aber ich habe versucht, kreativ zu sein, wie im ursprünglichen Beitrag vorgeschlagen.

Bash

Da dies ein Beliebtheitswettbewerb ist , sollte ich eine langwierige Methode anwenden ...

Für Leute, die Bash nicht kennen: $((...expr...))ist eine Syntax zum Auswerten von arithmetischen Ausdrücken. $(bc<<<...expr...)tut dasselbe mit dem bcKommandozeilenrechner.

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

Ausgabe

2+2= 5

Erläuterung

Die zweite Zeile verkettet v und 2, anstatt sie zu addieren, um 22.
Tatsächliche Erklärung:
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

Inspiriert von der Java-Antwort:

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

Wie Java verwendet CPython denselben Speicherort für jede Kopie der ersten kleinen Ganzzahlen (0-255, wenn der Speicher belegt ist). Dies geht in und bearbeitet diesen Speicherplatz direkt über ctypes. patchist nur eine verschleierte "12-7"Zeichenfolge mit len4, was eval5 entspricht.

Eine verschleierte Version

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

Jenseits von 2 + 2

Wie OP erwähnt, kann 2 + 2 ein bisschen langweilig sein; Hier ist also ein sauberer, plattformübergreifender Code mit mehreren Breiten für mutwilligen Missbrauch.

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

Läuft mit Python 2.7 ... ignoriere diese Zeile am Ende. Funktioniert unter Windows 64-Bit und Ubuntu 32-Bit, die beiden Systeme, auf die ich einfachen Zugriff habe.

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

Es ist nicht überraschend, dass wir die assoziative Eigenschaft der Addition brechen können, wobei ( a + b ) + c = a + ( b + c ), wie in der 1. und 2. 1+2+3Zeile gezeigt, aber unerklärlicherweise auch die kommutative Eigenschaft (wobei a + b) = b + a ; 2. und 3. Zeile). Ich frage mich, ob der Python-Interpreter überflüssige Klammern um Additionsausdrücke einfach ignoriert.

JavaScript:

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

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

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

Überprüfen Sie es auf http://jsfiddle.net/qhRJY/

Sowohl H (lateinisches Großbuchstaben h) als auch Η (griechisches Großbuchstaben eta) werden auf den globalen Gültigkeitsbereich festgelegt, da sie für die Funktionen mit dem Schlüsselwort var nicht als lokal definiert wurden. Während sie ähnlich aussehen, sind sie tatsächlich 2 verschiedene Variablen mit 2 verschiedenen Werten. Wenn Sie Strg + F in Ihrem Browser verwenden, werden Sie feststellen, dass Η (eta) auf dieser Seite deutlich weniger als H (h) anzeigt.

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

Das unterschwellige Bit ist, dass es nicht tatsächlich unterschwellig ist - wenn Sie eine 2-dB-Tonquelle zu einer anderen 2-dB-Tonquelle hinzufügen, ergibt sich ein kombiniertes Rauschen von 5 dB (und wenn Sie zwei 30-dB-Quellen hinzufügen, dann sind es 33 dB), wie sie auf einer logarithmischen Skala gemessen werden.

Sie können es hier auf einem anderen Rechner sehen .

PHP

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

Welches produziert:

2 + 2 = 5

Dies liegt daran, dass in PHP die Ternären von links nach rechts berechnet werden, also tatsächlich
(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 ist gefährlich, Ihr Javascript mit ASCII-Kunst zu dekorieren.

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

     (2 + 2)

Wenn die Kommentare entfernt werden, werden die verbleibenden Symbole und Operatoren zu ausgewertet.
-~~--~(2 + 2) Dies verwendet den bitweisen Nicht-Operator (~) in JS zusammen mit einigen Minuszeichen, die die Werte auf dem Weg negieren.

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

Ausgabe:

2 + 2 = 5

Die Ausgabe von jedem cathat eine implizite neue Zeile, aber die letzte neue Zeile wird durch die Befehlsersetzung entfernt$( )

Hier ist ein anderes:

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

Bash-Arrays sind mit Nullen indiziert

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

Dies hängt vom CPAN-Modul namens Acme :: NewMath ab . Aufgrund falscher Dateinamen im Modul funktioniert dies nur bei Dateisystemen, bei denen die Groß- und Kleinschreibung nicht berücksichtigt wird (wie unter Windows oder Mac OS X), aber ich beschuldige hier den Autor des ursprünglichen Moduls. Acme :: NewMath implementiert Mathematik gemäß der Ingsoc-Ideologie.

R

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

Ausgabe:

5

Der Code addiert den Mittelwert von [1] zum Mittelwert von [4]. Der richtige Weg , um die mittlere Funktion in R zu verwenden wäre: mean(c(1,3)) + mean(c(4,0))Dies ist im Gegensatz zu einigen anderen mathematischen Funktionen in R, wie sum, max, und min; wo sum(1,3), max(1,3)und min(3,1)würden alle die erwartete Antwort geben.

Java

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

Ausgabe:

512.0000000000005

Funktioniert wahrscheinlich in jeder Sprache, die die gleiche Art von Double verwendet.

Befunge

Dies ist in Befunge geschrieben, sieht aber wie Python aus.

#>>>>>>>>>>>>>>>>>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]

Beim Ausführen (mit dem richtigen Interpreter) wird das Programm gedruckt 5.

Erläuterung:

Ein Befunge-Programm besteht aus einem Raster von Einzelzeichenbefehlen. Der erste Befehl befindet sich in der oberen linken Ecke, und das Lesen der Befehle erfolgt nach rechts. Die Richtung kann sich jedoch während der Programmausführung ändern.

Es werden nur die erste Zeichenreihe und die mit vder ersten Zeile beginnende Zeichenreihe ausgeführt. Die fraglichen Zeichen tun Folgendes :

#- Den nächsten Befehl überspringen
>- Von nun an werden Befehle rechts neben dem aktuellen Befehl
vgelesen - Von nun an werden Befehle unter dem aktuellen Befehl gelesen
5- 5 auf den Stapel schieben
.- Die Nummer einfügen und ausdrucken ganz oben auf dem Stapel
@- Programm
<space>beenden - Nichts unternehmen

Wenn Sie wüssten, dass Sie in Befunge programmieren, würde dies niemanden wirklich täuschen. Aber wenn Sie darauf gestoßen sind und nicht bemerkt haben, dass es sich um Befunge handelt, wird dies höchstwahrscheinlich der Fall sein.

JavaScript

Code:

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

Ausgabe:

5

Sie können es selbst auf Ihrer Konsole testen oder diese Geige überprüfen

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

Es wird 2 + 2 = 5 ausgegeben

Also a = 2, richtig?

gcc-4.7.3 wertet die Funktionsparameter von rechts nach links aus. Wenn a + b ausgewertet wird, ist a immer noch 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

Standardmissbrauch von commonBlöcken: Ordnungsangelegenheiten; Ich habe die Reihenfolge im Block im Unterprogramm vertauscht, also füge ich wirklich hinzu 1 + 2 + 2.

Python

Der Code gibt 5 aus, was die richtige Antwort für diese Aufgabe ist.

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

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

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

Bearbeiten: Hier ist eine alternative Version, in der ganze Zahlen hinzugefügt werden, nicht zwei.

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

Tilde ist ein unärer inverser Operator, der zurückkehrt -x-1. Der erste Schritt besteht also darin, einen -6anderen Operator abzurufen und dann die printFunktion zu erhalten5

Rubin

class Fixnum
    alias plus +

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

puts 2 + 2

Dies erhöht das Ergebnis aller Zusätze, deren erstes Argument ein Fixnum ist (welches 2 ist, zumindest in der MRT), um 1.

Die Nebenwirkungen sind noch schlimmer als bei der Java-Version.

Rubin

Ruby hat erstklassige Umgebungen. Das bedeutet viele Dinge. Es bedeutet auch, dass viele Dinge getan werden können, die vielleicht nicht getan werden sollten.

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

Die Ausgabe davon ist:

2 + 2 = 
4
2 + 4 = 
6
Aber im Jahr 1984 ...
2 + 2 = 
5
2 + 4 = 
6

Wenn Sie mehr über die Freuden und Gefahren verstehen möchten, lesen Sie Ruby Conf 2011 Keeping Ruby Reasonable und erstklassige Umgebungen im Abstract Heresies-Blog.

Planen

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

C #

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

Für jemanden, der nicht vertraut ist, sieht es so aus, als würde ein Bereich bei 2 beginnen und enden. In Wirklichkeit beginnt er bei 2 und gilt für zwei Zahlen. Also 2 + 3 = 5.

F #

Lassen Sie uns folgende Anweisung in fsi einfügen:

let ``2+2``= 5

Ausgabe:

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

Das 5ist leider nicht so gut versteckt. Funktioniert nicht mit Optimierung.