Die Herausforderung: Definieren Sie xso, dass der Ausdruck (x == x+2)als wahr bewertet wird.

Ich habe die Frage mit C markiert, aber Antworten in anderen Sprachen sind willkommen, sofern sie kreativ sind oder einen interessanten Aspekt der Sprache hervorheben.

Ich beabsichtige, eine C-Lösung zu akzeptieren, aber andere Sprachen können meine Stimme bekommen.

1. Richtig - Funktioniert bei standardkonformen Implementierungen. Ausnahme - vorausgesetzt, eine Implementierung der intBasistypen ist in Ordnung , wenn es sich um eine allgemeine Implementierung handelt (z. B. vorausgesetzt, es handelt sich um das 32-Bit-2-Komplement).
2. Einfach - sollte klein sein, grundlegende Sprachfunktionen verwenden.
3. Interessant - es ist subjektiv, gebe ich zu. Ich habe einige Beispiele für das, was ich für interessant halte, aber ich möchte keine Hinweise geben. Update : Das Vermeiden des Präprozessors ist interessant.
4. Schnell - Die erste gute Antwort wird akzeptiert.

Nach 60 Antworten (mit einer solchen Erwartung hätte ich nie gerechnet) kann es gut sein, sie zusammenzufassen.

Die 60 Antworten sind in 7 Gruppen unterteilt, von denen 3 in C implementiert werden können, der Rest in anderen Sprachen:

1. Der C-Präprozessor. #define x 2|0wurde vorgeschlagen, aber es gibt viele andere Möglichkeiten.
2. Gleitkomma. Große Zahlen, Unendlich oder NaN funktionieren.

3. Zeigerarithmetik. Ein Zeiger auf eine riesige Struktur bewirkt, dass 2 hinzugefügt wird.

   Der Rest funktioniert nicht mit C:

4. Überladen von Operatoren - Ein +, das nicht hinzugefügt wird, oder ein ==, das immer true zurückgibt.
5. Macht xeinen Funktionsaufruf ( in einigen Sprachen erlauben es , ohne die x()Syntax). Dann kann es jedes Mal etwas anderes zurückgeben.
6. Ein Ein-Bit-Datentyp. Dann x == x+2 (mod 2).
7. Ändern 2- in einigen Sprachen können Sie es zuweisen 0.

main()
{
double x=1.0/0.0;
printf("%d",x==x+2);
}

Ausgänge 1.

Link: http://ideone.com/dL6A5

Fortran IV:

2=0

Danach ist jede Konstante 2 im Programm Null. Vertrau mir, ich habe das getan (ok, vor 25 Jahren)

Das scheint zu funktionieren:

#define x 2|0

Grundsätzlich wird der Ausdruck zu erweitert (2|0 == 2|(0+2)). Es ist ein gutes Beispiel dafür, warum man beim Definieren von Makros Klammern verwenden sollte.

Brainfuck

x

Dabei wird natürlich ein wenig gedehnt, um "wahr zu bewerten", da in Brainfuck nichts tatsächlich zu etwas bewertet wird - Sie manipulieren nur ein Band. Aber wenn Sie jetzt Ihren Ausdruck anhängen

x
(x == x+2)

Das Programm ist äquivalent zu

+

(weil alles aber <>+-[],.ein Kommentar ist). Was nichts anderes tut, als den Wert zu erhöhen, wo wir jetzt sind. Das Band wird mit allen Nullen initialisiert, so dass wir an der Cursorposition eine 1 haben, was "wahr" bedeutet: Wenn wir jetzt einen bedingten Abschnitt mit []starten, würde er / loop eingeben.

F #

let (==) _ _ = true
let x = 0
x == (x + 2) //true

C

int main() { float x = 1e10; printf("%d\n", x == x + 2); }

Hinweis: funktioniert möglicherweise nicht, wenn FLT_EVAL_METHOD != 0(siehe Kommentare unten).

C #

class T {
  static int _x;
  static int X { get { return _x -= 2; } }

  static void Main() { Console.WriteLine(X == X + 2); }
}

Kein Shortie, aber etwas elegant.

http://ideone.com/x56Ul

Scala: { val x = Set(2); (x == x + 2) }

Haskell: Definiere ℤ / 2ℤ auf Booleans:

instance Num Bool where
    (+) = (/=)
    (-) = (+)
    (*) = (&&)
    negate = id
    abs    = id
    signum = id
    fromInteger = odd

dann für alle, die x :: Boolwir haben x == x + 2.

Update: Danke für die Ideen im Kommentar, ich habe die Instanz entsprechend aktualisiert.

Python

class X(int):__add__=lambda*y:0
x=X()

# Then (x == x+2) == True

GNU C unterstützt Strukturen ohne Mitglieder und Größe 0:

struct {} *x = 0;

PHP:

$x = true;
var_dump($x == $x+2);

Oder:

var_dump(!($x==$x+2));

Ausgabe:

bool (wahr)

Es ist ein weit verbreitetes Missverständnis, dass in C Leerzeichen keine Rolle spielen. Ich kann mir nicht vorstellen, dass jemand in GNU C nicht darauf gekommen ist:

#include <stdio.h>
#define CAT_IMPL(c, d) (c ## d)
#define CAT(c, d) CAT_IMPL(c, d)
#define x CAT(a, __LINE__)

int main()
{
    int a9 = 2, a10 = 0;
    printf("%d\n", x ==
        x + 2);
    return 0;
}

Druckt 1.

C

Es ist interessanter, ohne Makros zu verwenden und ohne die Unendlichkeit zu missbrauchen.

/////////////////////////////////////
// At the beginning                 /
// We assume truth!                 /

int truth = 1;
int x = 42;

/////////////////////////////////////
// Can the truth really be changed??/
truth = (x == x + 2);

/////////////////////////////////////
// The truth cannot be changed!     /
printf("%d",truth);

Probieren Sie es aus, wenn Sie es nicht glauben!

Mathematica:

x /: x + 2 := x
x == x + 2

Ich denke, diese Lösung ist neu, weil sie das Konzept von Mathematica von Up Values ​​verwendet.

BEARBEITEN:

Ich erweitere meine Antwort, um zu erklären, was Up Values ​​in Mathematica bedeuten .

Die erste Zeile definiert die Addition für das Symbol im Wesentlichen neu x. Ich könnte eine solche Definition direkt in der globalen Funktion speichern, die dem +Symbol zugeordnet ist, aber eine solche Neudefinition wäre gefährlich, da sich die Neudefinition möglicherweise unvorhersehbar über die in Mathematica integrierten Algorithmen ausbreitet .

Stattdessen habe x/:ich mithilfe des Tags die Definition mit dem Symbol verknüpft x. Immer wenn Mathematica das Symbol sieht x, prüft es, ob es vom Additionsoperator +in einem Muster der Form x + 2 + ___bearbeitet wird, in der das Symbol ___eine mögliche Nullsequenz anderer Symbole bedeutet.

Diese Neudefinition ist sehr spezifisch und nutzt die umfangreichen Mustervergleichsfunktionen von Mathematica . Beispielsweise gibt der Ausdruck x+y+2zurück x+y, aber der Ausdruck gibt x+3zurück x+3; denn im ersteren Fall könnte das Muster angepasst werden, im letzteren Fall könnte das Muster ohne zusätzliche Vereinfachung nicht angepasst werden.

Javascript:

var x = 99999999999999999;
alert(x == x+2);​

Testen Sie Fiddle

planen

(define == =)
(define (x a b c d) #t)
(x == x + 2)
;=> #t

Offensichtliche Antwort:

Wenn dies endet:

while (x != x+2) { }
printf("Now");

Hier ist eine Lösung für JavaScript, die die Infinityund -InfinityRandfälle der Gleitkommazugabe nicht ausnutzt . Dies funktioniert weder in Internet Explorer 8 und darunter noch im strengen Opt-In ES5-Modus. Ich würde die withAussage und Getter nicht als besonders "erweiterte" Funktionen bezeichnen.

with ({ $: 0, get x() {return 2 * this.$--;} }) {
    console.log(x == x+2);
}

Bearbeitet, um hinzuzufügen: Der obige Trick ist auch ohne Verwendung von withund möglich get, wie von Andy E in Tipps zum Golfen in JavaScript und auch von jncraton auf dieser Seite angegeben:

var x = { $: 0, valueOf: function(){return 2 * x.$++;} };
console.log(x == x+2);

Das Folgende entspricht nicht den Standards C , sollte jedoch auf nahezu jeder 64-Bit-Plattform funktionieren:

int (*x)[0x2000000000000000];

Salbei:

x=Mod(0,2)
x==x+2

gibt True zurück

Im Allgemeinen gilt für GF (2 ** n) immer x = x + 2 für ein beliebiges x

Dies ist kein Fehler oder ein Problem mit Überlauf oder Unendlich, es ist tatsächlich korrekt

Common Lisp

* (defmacro x (&rest r) t)
X
* (x == x+2)
T

Es ist ziemlich einfach, wenn xes kein tatsächlicher Wert sein muss.

APL (Dyalog)

X←1e15
X=X+2

APL hat nicht einmal unendlich, es ist nur so, dass die Schwimmer nicht genau genug sind, um den Unterschied zwischen 1.000.000.000.000.000und zu erkennen 1.000.000.000.000.002. Dies ist meines Wissens die einzige Möglichkeit, dies in APL zu tun.

Perl 6

Ich bin überrascht, diese Lösung vorher nicht zu sehen. Wie auch immer, die Lösung ist - was ist, wenn xist 0und 2auf einmal? my \xIn diesem Beispiel wird eine sigilless-Variable deklariert. Bei dieser Frage xgeht es nicht um den Perl-Stil $x. Der ?? !!ist ein ternärer Operator.

$ perl6 -e 'my \x = 0|2; say x == x + 2 ?? "YES" !! "NO"'
YES

Aber...

$ perl6 -e 'my \x = 0|2; say x == x + 3 ?? "YES" !! "NO"'
NO

xist mehrere Werte gleichzeitig. xist gleich 0und 2auf einmal. x + 2ist gleich 2und 4auf einmal. Also logischerweise sind sie gleich.

Python 2.X (Verwenden der Neudefinition von (zwischengespeicherten) Ganzzahlen)

Ich habe bemerkt, dass alle Python-Antworten Klassen definiert haben, die das neu definieren + Operator . Ich werde mit einer noch einfacheren Demonstration der Flexibilität von Python antworten. (Dies ist ein Python2-spezifisches Snippet)

In Python werden Ganzzahlen in C mehr oder weniger auf diese Weise gespeichert:

typedef struct {            // NOTE: Macros have been expanded
    Py_ssize_t ob_refcnt;
    PyTypeObject *ob_type;
    long ob_ival;
} PyIntObject;

Das heißt, eine Struktur mit einem size_t, void *und longObjekt, in dieser Reihenfolge.
Sobald wir eine Ganzzahl verwenden und daher zwischenspeichern, können wir das Python- ctypesModul verwenden, um diese Ganzzahl neu zu definieren, sodass dies nicht nur der Fall ist x == x+2, sondern2 == 0

import ctypes
two = 2 # This will help us access the address of "2" so that we may change the value

# Recall that the object value is the third variable in the struct. Therefore,
# to change the value, we must offset the address we use by the "sizeof" a 
# size_t and a void pointer
offset = ctypes.sizeof(ctypes.c_size_t) + ctypes.sizeof(ctypes.c_voidp)

# Now we access the ob_ival by creating a C-int from the address of 
# our "two" variable, offset by our offset value.
# Note that id(variable) returns the address of the variable.
ob_ival = ctypes.c_int.from_address(id(two)+offset)

#Now we change the value at that address by changing the value of our int.
ob_ival.value = 0

# Now for the output
x = 1
print x == x+2
print 2 == 0

Druckt

True
True

Perl

Verwenden eines Unterprogramms mit Nebenwirkungen auf eine Paketvariable:

sub x () { $v -= 2 }
print "true!\n" if x == x + 2;

Ausgabe: true!

Python

Die Ausnutzung der Gleitkommapräzision macht dies sehr einfach.

>>> x = 100000000000000000.0
>>> (x == x+2)
True

Um es weniger systemspezifisch zu machen, ist ein zusätzlicher Import erforderlich

>>> import sys
>>> x = float(sys.maxint + 1)
>>> (x == x+2)
True

Dies sollte auch in anderen Sprachen funktionieren. Dies funktioniert, weil die Repräsentation von 100000000000000000.0 und 100000000000000002.0 für die Maschine aufgrund der Art und Weise, wie Gleitkommazahlen innerhalb der Maschine dargestellt werden, genau gleich ist. Weitere Informationen finden Sie unter http://en.wikipedia.org/wiki/IEEE_floating_point .

Dies funktioniert also grundsätzlich in jeder Sprache, in der Sie Ganzzahlen zu Floats hinzufügen können und das Ergebnis ist ein Float.

Hier ist eine Lösung für C ++ basierend auf der Überladung von Operatoren. Es beruht auf der impliziten Konvertierung von einem enumin einen int.

#include <iostream>

enum X {};
bool operator==(X x, int y)
{
    return true;
}

int main()
{
    X x;
    std::cout << std::boolalpha << (x == x+2) << std::endl;
    return 0;
}

Ich weiß, es ist eine Code-Herausforderung ... aber ich habe es gespielt. Es tut uns leid.

Ruby - 13 Zeichen - Infinity-Lösung

x=1e17;x==x+2

gibt true zurück

Ruby - 41 Zeichen - Op Überladungslösungen

class Fixnum;def + y;0 end end;x=0;x==x+2

oder

class A;def self.+ y;A end end;x=A;x==x+2

Wenn es in Ordnung ist, die Frage ein wenig auszunutzen, füge ich ein neues Java hinzu. Der Trick ist sicher nicht neu, aber vielleicht interessant, dass dies in Java möglich ist.

static void pleaseDoNotDoThis() throws Exception {
    Field field = Boolean.class.getField("FALSE");
    field.setAccessible(true);
    Field modifiersField = Field.class.getDeclaredField("modifiers");
    modifiersField.setAccessible(true);
    modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
    field.set(null, true);
}

public static void main(String args[]) throws Exception {
    pleaseDoNotDoThis();
    doit(1);
    doit("NO");
    doit(null);
    doit(Math.PI);
}

static void doit(long x) {
    System.out.format("(x == x + 2) = (%d == %d) = %s\n", x, x+2, (x == x + 2));
}

static void doit(String x) {
    System.out.format("(x == x + 2) = (%s == %s) = %s\n", x, x+2, (x == x + 2));
}

static void doit(double x) {
    System.out.format("(x == x + 2) = (%f == %f) = %s\n", x, x+2, (x == x + 2));
}

Und die Ergebnisse:

(x == x + 2) = (1 == 3) = true
(x == x + 2) = (NO == NO2) = true
(x == x + 2) = (null == null2) = true
(x == x + 2) = (3,141593 == 5,141593) = true
(x == x + 2) = (Infinity == Infinity) = true

Diese VBScript-Lösung funktioniert ähnlich wie meine JavaScript-Lösung. Ich habe noch keinen Präprozessor verwendet, aber die Lösung scheint trivial zu sein.

y = 0
Function x
x = y
y = -2
End Function

If x = x + 2 Then
    WScript.Echo "True"
Else
    WScript.Echo "False"
End If