O desafio: defina de xforma que a expressão (x == x+2)seja avaliada como verdadeira.

Marquei a pergunta com C, mas as respostas em outros idiomas são bem-vindas, desde que sejam criativas ou destacem um aspecto interessante do idioma.

Pretendo aceitar uma solução C, mas outros idiomas podem obter meu voto.

1. Correto - funciona em implementações compatíveis com padrão. Exceção - supor que uma implementação dos tipos básicos, se for uma implementação comum (por exemplo, supondo que into complemento de 32 bits 2) esteja OK.
2. Simples - deve ser pequeno, use os recursos básicos da linguagem.
3. Interessante - é subjetivo, admito. Tenho alguns exemplos para o que considero interessante, mas não quero dar dicas. Atualização : Evitar o pré-processador é interessante.
4. Rápido - A primeira boa resposta será aceita.

Depois de obter 60 respostas (nunca esperei essa antecipação), pode ser bom resumi-las.

As 60 respostas se dividem em 7 grupos, 3 dos quais podem ser implementados em C, o restante em outros idiomas:

1. O pré-processador C. #define x 2|0foi sugerido, mas existem muitas outras possibilidades.
2. Ponto flutuante. Grandes números, infinito ou NaN, todos funcionam.

3. Ponteiro aritmético. Um ponteiro para uma estrutura enorme causa a adição de 2 para contornar.

   O resto não funciona com C:

4. Sobrecarga de operador - Um +que não adiciona ou ==que sempre retorna verdadeiro.
5. Fazendo xuma chamada de função (alguns idiomas permitem isso sem a x()sintaxe). Em seguida, ele pode retornar outra coisa a cada vez.
6. Um tipo de dados de um bit. Então x == x+2 (mod 2).
7. Mudando 2- algum idioma permite atribuir 0a ele.

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

Saídas 1.

Link: http://ideone.com/dL6A5

Fortran IV:

2=0

Depois disso, todas as constantes 2 do programa são zero. Confie em mim, eu fiz isso (ok, há 25 anos)

Isso parece funcionar:

#define x 2|0

Basicamente, a expressão é expandida para (2|0 == 2|(0+2)). É um bom exemplo de por que se deve usar parênteses ao definir macros.

Brainfuck

x

É claro que isso se alonga um pouco "avalia como verdadeiro", porque no Brainfuck nada avalia de fato - você apenas manipula uma fita. Mas se você agora anexar sua expressão

x
(x == x+2)

o programa é equivalente a

+

(porque tudo, mas <>+-[],.é um comentário). O que não faz nada além de incrementar o valor onde estamos agora. A fita é inicializada com todos os zeros, então terminamos com um 1 na posição do cursor, que significa "true": se agora começássemos uma seção condicional com [], ela entraria / faria um loop.

F #

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

C

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

Nota: pode não funcionar se FLT_EVAL_METHOD != 0(veja os comentários abaixo).

C #

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

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

Não é um shortie, mas um pouco elegante.

http://ideone.com/x56Ul

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

Haskell: Defina ℤ / 2ℤ no eans Bool:

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

então, para qualquer um x :: Boolque tivermos x == x + 2.

Atualização: obrigado pelas ideias em comentário, atualizei a instância de acordo.

Pitão

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

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

O GNU C suporta estruturas sem membros e tamanho 0:

struct {} *x = 0;

PHP:

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

Ou:

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

Resultado:

bool (true)

É um equívoco comum que, em C, espaço em branco não importe. Não posso imaginar que alguém não tenha sugerido isso no 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;
}

Imprime 1.

C

É mais interessante sem usar macros e sem abusar do 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);

Experimente se você não acredita!

Mathematica:

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

Eu acho que essa solução é nova porque usa o conceito de Up Values do Mathematica .

EDITAR:

Estou expandindo minha resposta para explicar o que Up Values ​​significa no Mathematica .

A primeira linha redefine essencialmente a adição do símbolo x. Eu poderia armazenar diretamente essa definição na função global associada ao +símbolo, mas essa redefinição seria perigosa porque a redefinição pode se propagar imprevisivelmente através dos algoritmos internos do Mathematica .

Em vez disso, usando a tag x/:, associei a definição ao símbolo x. Agora, sempre que o Mathematica vê o símbolo x, ele verifica se está sendo operado pelo operador de adição +em um padrão da forma em x + 2 + ___que o símbolo ___significa uma possível sequência nula de outros símbolos.

Essa redefinição é muito específica e utiliza os extensos recursos de correspondência de padrões do Mathematica . Por exemplo, a expressão x+y+2retorna x+y, mas a expressão x+3retorna x+3; porque no primeiro caso, o padrão poderia ser correspondido, mas no último caso, o padrão não poderia ser correspondido sem simplificação adicional.

Javascript:

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

Test Fiddle

esquema

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

Resposta óbvia:

Quando isso termina:

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

Aqui está uma solução para JavaScript que não explorar as Infinitye -Infinityponta casos de adição de ponto flutuante. Isso não funciona no Internet Explorer 8 e abaixo, nem no modo estrito de ativação do ES5. Eu não chamaria a withdeclaração e os getters de recursos particularmente "avançados".

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

Editado para adicionar: O truque acima também é possível sem o uso withe get, como observado por Andy E em Dicas para jogar golfe em JavaScript e também por jncraton nesta página:

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

O seguinte não é compatível com os padrões C , mas deve funcionar em praticamente qualquer plataforma de 64 bits:

int (*x)[0x2000000000000000];

Sábio:

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

retorna True

Em geral, para GF (2 ** n), é sempre verdade que x = x + 2 para qualquer x

Este não é um bug ou um problema com estouro ou infinito, está realmente correto

Lisp comum

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

É muito fácil quando xnão precisa ser um valor real.

APL (Dyalog)

X←1e15
X=X+2

O APL nem sequer tem infinito, apenas os flutuadores não são precisos o suficiente para diferenciar entre 1.000.000.000.000.000e 1.000.000.000.000.002. Esta é, até onde eu sei, a única maneira de fazer isso no APL.

Perl 6

Estou surpreso por não ver essa solução antes. Enfim, a solução é - e se xfor 0e de 2uma só vez? my \xneste exemplo declara variável sigilless - esta pergunta é sobre x, não no estilo Perl $x. O ?? !!operador é ternário.

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

Mas...

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

xé vários valores de uma vez. xé igual a 0e de 2uma só vez. x + 2é igual a 2e de 4uma só vez. Então, logicamente eles são iguais.

Python 2.X (Usando redefinição de números inteiros (em cache))

Notei que todas as respostas python definiram classes que redefinem o +operador. Responderei com uma demonstração ainda mais de baixo nível da flexibilidade do python. (Este é um trecho específico do python2)

Em python, números inteiros são armazenados mais ou menos dessa maneira em C:

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

Isto é, uma estrutura com um size_t, void *e longobjeto, nessa ordem.
Depois que usamos e, portanto, armazenamos em cache um número inteiro, podemos usar o ctypesmódulo python para redefinir esse número inteiro, para que não apenas o faça x == x+2, mas2 == 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

Impressões

True
True

Perl

usando uma sub-rotina com efeitos colaterais em uma variável de pacote:

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

Resultado: true!

Pitão

explorar a precisão do ponto flutuante torna isso muito simples.

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

Para torná-lo menos específico do sistema, é necessária uma importação extra

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

Isso deve funcionar em outros idiomas também. Isso funciona porque as representações 100000000000000000.0 e 1000000000000000000.0 são exatamente iguais para a máquina, devido à maneira como os pontos flutuantes são representados dentro da máquina. consulte http://en.wikipedia.org/wiki/IEEE_floating_point para obter mais informações.

Portanto, isso funcionará basicamente em qualquer idioma que permita adicionar números inteiros a flutuadores e fazer com que o resultado seja flutuante.

Aqui está uma solução para C ++ baseada na sobrecarga do operador. Ele se baseia na conversão implícita de um enumpara um 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;
}

Eu sei que é um desafio de código ... mas eu joguei. Desculpa.

Ruby - 13 caracteres - solução Infinity

x=1e17;x==x+2

retorna verdadeiro

Ruby - 41 caracteres - Soluções de sobrecarga de operação

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

ou

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

Se for bom explorar a questão um pouco, adicionarei um novo Java. O truque certamente não é novo, mas talvez interessante seja possível em 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 os 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 solução VBScript funciona de maneira semelhante à minha solução JavaScript. Eu não usei um pré-processador, mas a solução 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