La sfida: definire xin modo tale che l'espressione (x == x+2)valuti come vera.

Ho taggato la domanda con C, ma le risposte in altre lingue sono benvenute, purché siano creative o evidenzino un aspetto interessante della lingua.

Intendo accettare una soluzione C, ma altre lingue possono ottenere il mio voto.

1. Corretto: funziona su implementazioni conformi agli standard. Eccezione: assumere un'implementazione dei tipi di base, se si tratta di un'implementazione comune (ad esempio supponendo che intil complemento a 32 bit 2) sia OK.
2. Semplice: dovrebbe essere piccolo, utilizzare le funzioni linguistiche di base.
3. Interessante - è soggettivo, lo ammetto. Ho alcuni esempi di ciò che considero interessante, ma non voglio dare suggerimenti. Aggiornamento : evitare il preprocessore è interessante.
4. Veloce: verrà accettata la prima buona risposta.

Dopo aver ottenuto 60 risposte (non mi sarei mai aspettato una simile previsione), potrebbe essere utile riassumerle.

Le 60 risposte si dividono in 7 gruppi, 3 dei quali possono essere implementati in C, il resto in altre lingue:

1. Il preprocessore C. #define x 2|0è stato suggerito, ma ci sono molte altre possibilità.
2. Virgola mobile. Grandi numeri, infinito o NaN funzionano tutti.

3. Puntatore aritmetico. Un puntatore a un'enorme struttura provoca l'aggiunta di 2 da avvolgere.

   Il resto non funziona con C:

4. Sovraccarico dell'operatore - A +che non viene aggiunto o ==che restituisce sempre true.
5. Effettuare xuna chiamata di funzione (alcune lingue lo consentono senza la x()sintassi). Quindi può restituire qualcos'altro ogni volta.
6. Un tipo di dati a un bit. Poi x == x+2 (mod 2).
7. Modifica 2: alcune lingue ti consentono di assegnarle 0.

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

Uscite 1.

Link: http://ideone.com/dL6A5

Fortran IV:

2=0

Dopodiché ogni costante 2 nel programma è zero. Fidati di me, l'ho fatto (ok, 25 anni fa)

Questo sembra funzionare:

#define x 2|0

Fondamentalmente, l'espressione viene espansa in (2|0 == 2|(0+2)). È un buon esempio del perché si dovrebbero usare le parentesi quando si definiscono le macro.

Brainfuck

x

Questo ovviamente allunga un po '"valuta come vero", perché in Brainfuck nulla in realtà valuta nulla: manipoli solo un nastro. Ma se ora aggiungi la tua espressione

x
(x == x+2)

il programma è equivalente a

+

(perché tutto tranne che <>+-[],.un commento). Che non fa altro che incrementare il valore dove siamo ora. Il nastro è inizializzato con tutti gli zeri, quindi finiamo con un 1 sulla posizione del cursore, che significa "vero": se ora avessimo iniziato una sezione condizionale con [], entrerebbe in / loop.

F #

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

C

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

Nota: potrebbe non funzionare se FLT_EVAL_METHOD != 0(vedi commenti sotto).

C #

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

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

Non uno short ma un po 'elegante.

http://ideone.com/x56Ul

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

Haskell: Definisci ℤ / 2ℤ sugli Boolean:

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

quindi per qualsiasi x :: Boolavremox == x + 2 .

Aggiornamento: grazie per le idee nel commento, ho aggiornato l'istanza di conseguenza.

Pitone

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

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

GNU C supporta strutture senza membri e dimensioni 0:

struct {} *x = 0;

PHP:

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

O:

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

Produzione:

bool (true)

È un'idea sbagliata comune che in C lo spazio bianco non abbia importanza. Non riesco a immaginare che qualcuno non l'abbia inventato in GNU C:

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

Stampe 1.

C

È più interessante senza usare le macro e senza abusare dell'infinito.

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

Provalo se non ci credi!

Matematica:

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

Penso che questa soluzione sia nuova perché utilizza il concetto di Up Values ​​di Mathematica .

MODIFICARE:

Sto espandendo la mia risposta per spiegare cosa significano Up Values ​​in Mathematica .

La prima riga essenzialmente ridefinisce l'aggiunta per il simbolo x. Potrei archiviare direttamente tale definizione nella funzione globale associata al +simbolo, ma una tale ridefinizione sarebbe pericolosa perché la ridefinizione potrebbe propagarsi in modo imprevedibile attraverso gli algoritmi integrati di Mathematica .

Invece, usando il tag x/:, ho associato la definizione al simbolo x. Ora, ogni volta che Mathematica vede il simbolo x, controlla se viene operato dall'operatore addizione +in uno schema della forma in x + 2 + ___cui il simbolo ___indica una possibile sequenza nulla di altri simboli.

Questa ridefinizione è molto specifica e utilizza le ampie capacità di abbinamento dei modelli di Mathematica . Ad esempio, l'espressione x+y+2ritorna x+y, ma l'espressione x+3ritorna x+3; perché nel primo caso, il modello potrebbe essere abbinato, ma nel secondo caso, il modello non potrebbe essere abbinato senza ulteriore semplificazione.

Javascript:

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

Test Fiddle

schema

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

Risposta ovvia:

Quando questo termina:

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

Qui è una soluzione per JavaScript che non sfrutta le Infinitye -Infinitybordi casi di virgola mobile aggiunta. Questo non funziona né in Internet Explorer 8 e versioni precedenti né nella modalità rigorosa ES5 di opt-in. Non definirei l' withaffermazione e le funzioni particolarmente "avanzate".

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

Modificato per aggiungere: il trucco sopra è possibile anche senza usare withe get, come notato da Andy E in Suggerimenti per giocare a golf in JavaScript e anche da jncraton in questa pagina:

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

Quanto segue non è conforme agli standard C , ma dovrebbe funzionare praticamente su qualsiasi piattaforma a 64 bit:

int (*x)[0x2000000000000000];

Saggio:

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

restituisce True

In generale per GF (2 ** n) è sempre vero che x = x + 2 per qualsiasi x

Questo non è un bug o un problema con overflow o infinito, in realtà è corretto

Lisp comune

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

È abbastanza facile quando xnon deve essere un valore reale.

APL (Dyalog)

X←1e15
X=X+2

APL non ha nemmeno l'infinito, è solo che i float non sono abbastanza precisi da dire la differenza tra 1.000.000.000.000.000e 1.000.000.000.000.002. Questo è, per quanto ne so, l'unico modo per farlo in APL.

Perl 6

Sono sorpreso di non aver visto questa soluzione prima. Comunque, la soluzione è: cosa succede se lo xè 0e 2subito? my \xin questo esempio dichiara la variabile sigilless - questa domanda pone x, non in stile Perl $x. È un ?? !!operatore ternario.

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

Ma...

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

xsono più valori contemporaneamente. xè uguale 0e 2immediato. x + 2è uguale 2e 4immediato. Quindi, logicamente sono uguali.

Python 2.X (Uso della ridefinizione di numeri interi (memorizzati nella cache)

Ho notato che tutte le risposte di Python hanno classi definite che ridefiniscono il + operatore. Risponderò con una dimostrazione ancora più di basso livello della flessibilità di Python. (Questo è uno snippet specifico di python2)

In Python, gli interi sono memorizzati più o meno in questo modo in C:

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

Cioè, una struttura con una size_t, void *e longoggetto, in questo ordine.
Una volta che usiamo, e quindi memorizziamo nella cache un numero intero, possiamo usare il ctypesmodulo di Python per ridefinire quel numero intero, in modo che non solo lo faccia x == x+2, ma2 == 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

stampe

True
True

Perl

usando una subroutine con effetti collaterali su una variabile del pacchetto:

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

Produzione: true!

Pitone

lo sfruttamento della precisione in virgola mobile rende tutto molto semplice.

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

Per renderlo meno specifico del sistema è necessaria un'importazione extra

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

Questo dovrebbe funzionare anche in altre lingue. Questo funziona perché le rappresentazioni di 100000000000000000.0 e 100000000000000002.0 sono esattamente le stesse per la macchina, a causa del modo in cui i punti fluttuanti sono rappresentati all'interno della macchina. vedi http://en.wikipedia.org/wiki/IEEE_floating_point per ulteriori informazioni.

Quindi questo funzionerà fondamentalmente in qualsiasi lingua che ti consenta di aggiungere numeri interi ai float e avere il risultato di essere un float.

Ecco una soluzione per C ++ basata sul sovraccarico dell'operatore. Si basa sulla conversione implicita da an enuma an 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;
}

So che è una sfida del codice ... ma l'ho giocata a golf. Scusate.

Rubino - 13 personaggi - Soluzione infinita

x=1e17;x==x+2

ritorna vero

Rubino - 41 caratteri - Op Soluzioni di sovraccarico

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

o

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

Se va bene sfruttare un po 'la domanda, aggiungerò un po' di nuovo Java. Il trucco non è certo nuovo, ma forse interessante che ciò sia possibile in Java.

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

E i risultati:

(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

Questa soluzione VBScript funziona in modo simile alla mia soluzione JavaScript. Non ho usato un preprocessore, ma la soluzione sembra banale.

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

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