El desafío: definir xde tal manera que la expresión (x == x+2)se evalúe como verdadera.

Etiqueté la pregunta con C, pero las respuestas en otros idiomas son bienvenidas, siempre que sean creativas o resalten un aspecto interesante del lenguaje.

Tengo la intención de aceptar una solución C, pero otros idiomas pueden obtener mi voto.

1. Correcto: funciona en implementaciones que cumplen con los estándares. Excepción: asumir una implementación de los tipos básicos, si es una implementación común (por ejemplo, suponiendo que intes un complemento de 32 bits 2) está bien.
2. Simple: debe ser pequeño, usar funciones básicas del lenguaje.
3. Interesante, es subjetivo, lo admito. Tengo algunos ejemplos de lo que considero interesante, pero no quiero dar pistas. Actualización : Evitar el preprocesador es interesante.
4. Rápido: se aceptará la primera buena respuesta.

Después de obtener 60 respuestas (nunca esperé tal anticipación), puede ser bueno resumirlas.

Las 60 respuestas se dividen en 7 grupos, 3 de los cuales se pueden implementar en C, el resto en otros idiomas:

1. El preprocesador C. #define x 2|0fue sugerido, pero hay muchas otras posibilidades.
2. Punto flotante. Grandes números, infinito o NaN, todo funciona.

3. Puntero aritmético. Un puntero a una estructura enorme hace que se agregue 2 para ajustarse.

   El resto no funciona con C:

4. Sobrecarga del operador: una +que no agrega o una ==que siempre devuelve verdadero.
5. Realizar xuna llamada de función (algunos idiomas lo permiten sin la x()sintaxis). Entonces puede devolver algo más cada vez.
6. Un tipo de datos de un bit. Entonces x == x+2 (mod 2).
7. Cambio 2: algunos idiomas le permiten asignarlo 0.

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

Salidas 1.

Enlace: http://ideone.com/dL6A5

Fortran IV:

2=0

Después de esto, cada constante 2 en el programa es cero. Confía en mí, he hecho esto (ok, hace 25 años)

Esto parece funcionar:

#define x 2|0

Básicamente, la expresión se expande a (2|0 == 2|(0+2)). Es un buen ejemplo de por qué uno debería usar paréntesis al definir macros.

Brainfuck

x

Esto, por supuesto, estira un poco "evaluar a verdadero" un poco, porque en Brainfuck nada realmente se evalúa a nada, solo se manipula una cinta. Pero si ahora agregas tu expresión

x
(x == x+2)

el programa es equivalente a

+

(porque todo menos <>+-[],.es un comentario). Lo que no hace más que incrementar el valor donde estamos ahora. La cinta se inicializa con todos los ceros, por lo que terminamos con un 1 en la posición del cursor, lo que significa "verdadero": si ahora comenzamos una sección condicional [], entraría / loop.

F#

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

C

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

Nota: puede no funcionar si FLT_EVAL_METHOD != 0(ver comentarios más abajo).

C#

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

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

No es un shortie, pero algo elegante.

http://ideone.com/x56Ul

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

Haskell: Define ℤ / 2ℤ en Booleans:

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

entonces para cualquiera x :: Booltendremos x == x + 2.

Actualización: Gracias por las ideas en el comentario, actualicé la instancia en consecuencia.

Pitón

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

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

GNU C admite estructuras sin miembros y tamaño 0:

struct {} *x = 0;

PHP:

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

O:

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

Salida:

bool (verdadero)

Es un error común pensar que en C, el espacio en blanco no importa. No puedo imaginar que a alguien no se le haya ocurrido esto en 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;
}

Impresiones 1.

C

Es más interesante sin usar macros y sin abusar del 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);

¡Pruébalo si no lo crees!

Mathematica:

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

Creo que esta solución es nueva porque usa el concepto de valores ascendentes de Mathematica .

EDITAR:

Estoy ampliando mi respuesta para explicar qué significan los valores ascendentes en Mathematica .

La primera línea esencialmente redefine la suma del símbolo x. Podría almacenar directamente tal definición en la función global asociada con el +símbolo, pero dicha redefinición sería peligrosa porque la redefinición puede propagarse de manera impredecible a través de los algoritmos integrados de Mathematica .

En cambio, usando la etiqueta x/:, asocié la definición con el símbolo x. Ahora, cuando Mathematica ve el símbolo x, verifica si está siendo operado por el operador de suma +en un patrón de la forma x + 2 + ___en que el símbolo ___significa una posible secuencia nula de otros símbolos.

Esta redefinición es muy específica y utiliza las amplias capacidades de coincidencia de patrones de Mathematica . Por ejemplo, la expresión x+y+2regresa x+y, pero la expresión x+3regresa x+3; porque en el primer caso, el patrón podría coincidir, pero en el último caso, el patrón no podría coincidir sin una simplificación adicional.

Javascript:

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

Violín de prueba

esquema

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

Respuesta obvia:

Cuando esto termina:

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

Aquí es una solución para JavaScript que no explota a las Infinityy -Infinitylos bordes de los casos, además de coma flotante. Esto no funciona ni en Internet Explorer 8 ni en versiones posteriores, ni en el modo estricto opt-in ES5. No llamaría a la withdeclaración y a los captadores características particularmente "avanzadas".

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

Editado para agregar: el truco anterior también es posible sin usar withy get, como lo señaló Andy E en Consejos para jugar al golf en JavaScript y también por jncraton en esta página:

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

Lo siguiente no cumple con los estándares C , pero debería funcionar en casi cualquier plataforma de 64 bits:

int (*x)[0x2000000000000000];

Sabio:

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

devuelve True

En general para GF (2 ** n) siempre es cierto que x = x + 2 para cualquier x

Esto no es un error o un problema con desbordamiento o infinito, en realidad es correcto

Lisp común

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

Es bastante fácil cuando xno tiene que ser un valor real.

APL (Dyalog)

X←1e15
X=X+2

APL ni siquiera tiene infinito, es solo que los flotadores no son lo suficientemente precisos como para diferenciar entre 1.000.000.000.000.000y 1.000.000.000.000.002. Esta es, hasta donde yo sé, la única forma de hacer esto en APL.

Perl 6

Me sorprende no ver esta solución antes. De todos modos, la solución es: ¿qué xpasa si es 0y 2a la vez? my \xEn este ejemplo, se declara la variable sin sigilo: esta pregunta se refiere xal estilo Perl, no al estilo Perl $x. El ?? !!operador es ternario.

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

Pero...

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

xson múltiples valores a la vez. xes igual 0y 2a la vez. x + 2es igual 2y 4a la vez. Entonces, lógicamente son iguales.

Python 2.X (Usando la redefinición de enteros (en caché))

He notado que todas las respuestas de Python tienen clases definidas que redefinen el +operador. Contestaré con una demostración aún más baja de la flexibilidad de Python. (Este es un fragmento específico de python2)

En python, los enteros se almacenan más o menos de esta manera en C:

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

Es decir, una estructura con una size_t, void *y longobjeto, en ese orden.
Una vez que usamos, y por lo tanto almacenamos en caché un entero, podemos usar el ctypesmódulo de Python para redefinir ese entero, de modo que no solo lo haga x == x+2, sino2 == 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

Huellas dactilares

True
True

Perl

usando una subrutina con efectos secundarios en una variable de paquete:

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

Salida: true!

Pitón

explotar la precisión de coma flotante lo hace muy simple.

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

Para hacerlo menos específico del sistema, se requiere una importación adicional

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

Esto también debería funcionar en otros idiomas. Esto funciona porque la representación de 100000000000000000.0 y 100000000000000002.0 son exactamente iguales para la máquina, debido a la forma en que se representan los puntos flotantes dentro de la máquina. ver http://en.wikipedia.org/wiki/IEEE_floating_point para más información.

Entonces, esto básicamente funcionará en cualquier idioma que le permita agregar enteros a flotantes y que el resultado sea flotante.

Aquí hay una solución para C ++ basada en la sobrecarga del operador. Se basa en la conversión implícita de 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;
}

Sé que es un desafío de código ... pero lo jugué. Lo siento.

Ruby - 13 caracteres - Solución infinita

x=1e17;x==x+2

devuelve verdadero

Ruby - 41 caracteres - Soluciones de sobrecarga de operaciones

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

Si está bien explotar un poco la pregunta, entonces agregaré algunos nuevos Java. El truco es seguro que no es nuevo, pero quizás sea interesante que esto sea posible en 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));
}

Y los resultados:

(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

Esta solución VBScript funciona de manera similar a mi solución JavaScript. No utilicé un preprocesador pero la solución parece trivial.

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

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