O desafio: defina de x
forma 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.
- 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
int
o complemento de 32 bits 2) esteja OK. - Simples - deve ser pequeno, use os recursos básicos da linguagem.
- Interessante - é subjetivo, admito. Tenho alguns exemplos para o que considero interessante, mas não quero dar dicas. Atualização : Evitar o pré-processador é interessante.
- 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:
- O pré-processador C.
#define x 2|0
foi sugerido, mas existem muitas outras possibilidades. - Ponto flutuante. Grandes números, infinito
ou NaN,todos funcionam. Ponteiro aritmético. Um ponteiro para uma estrutura enorme causa a adição de 2 para contornar.
O resto não funciona com C:
- Sobrecarga de operador - Um
+
que não adiciona ou==
que sempre retorna verdadeiro. - Fazendo
x
uma chamada de função (alguns idiomas permitem isso sem ax()
sintaxe). Em seguida, ele pode retornar outra coisa a cada vez. - Um tipo de dados de um bit. Então
x == x+2 (mod 2)
. - Mudando
2
- algum idioma permite atribuir0
a ele.
math
arithmetic
c
ugoren
fonte
fonte
4. Quick
? Você quer dizer "Quem conhece um e tem a sorte de ler esta pergunta primeiro"?add to Set
pela biblioteca padrão, sem+
se redefinir , não se encaixa nessas 7 categorias, IMHO.Respostas:
Saídas 1.
Link: http://ideone.com/dL6A5
fonte
float x=1./0
é um pouco mais curto e talvez mais elegante. Mas, enfim, essa certamente é a primeira boa resposta.float x=1e20
seria suficienteFortran IV:
Depois disso, todas as constantes 2 do programa são zero. Confie em mim, eu fiz isso (ok, há 25 anos)
fonte
Isso parece funcionar:
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.fonte
2|(0+2)
ser1
?|
é bit a bit OR ;||
é OR lógico.Brainfuck
É 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
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.fonte
x
?x
então aquix
é definido comox
.need
nada exceto o+
F #
fonte
=
?==
nem é definido por padrão.C
Nota: pode não funcionar se
FLT_EVAL_METHOD != 0
(veja os comentários abaixo).fonte
INF + 2 == INF
, enquanto a minha resposta usa um único flutuador de precisão que é grande o suficiente para que 2 seja menor que um ULP.∞ + 2 = ∞
é algo que qualquer um pode entender e não depende de nada específico do computador, enquanto adicionar 2 a um número concreto e não ter nenhum efeito é um pouco mais surpreendente e específico da precisão limitada de computadores e IMHO mais interessanteFLT_EVAL_METHOD == 1
a matemática é feita comodouble
. Recomendar a um valor FP maior certeza superar até mesmolong double
de precisão como1.0e37f
C #
Não é um shortie, mas um pouco elegante.
http://ideone.com/x56Ul
fonte
Scala:
{ val x = Set(2); (x == x + 2) }
Haskell: Defina ℤ / 2ℤ no eans
Bool
:então, para qualquer um
x :: Bool
que tivermosx == x + 2
.Atualização: obrigado pelas ideias em comentário, atualizei a instância de acordo.
fonte
fromInteger = odd
(+)
pode ser definido como(/=)
eu acredito.()
.Pitão
fonte
__cmp__
comoclass X(int):__cmp__=lambda*x:0
(ou__eq__
embora ligeiramente mais longoclass X(int):__eq__=lambda*x:True
class X:__add__=lambda s,o:s
__add__
normalmente são fornecidos vários argumentos (lambda x,y:
), eu salvo alguns caracteres usando * para compactar todos os argumentos em uma tupla (lambda *y:
). Veja os documentos para mais informações.O GNU C suporta estruturas sem membros e tamanho 0:
fonte
PHP:
Ou:
Resultado:
fonte
É 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:
Imprime
1
.fonte
x == x+2
ainda é falso). Mas depois que você traz a ideia, acho que#define x -2*__LINE__
é mais elegante._CAT
é um identificador reservado. Qualquer coisa que começa com sublinhado e letra maiúscula é reservado em C.C
É mais interessante sem usar macros e sem abusar do infinito.
Experimente se você não acredita!
fonte
0
. Não, ainda não acredito nisso.??\
??\
deve ser convertido em um único\
, portanto não existe??\
. Alguns compiladores modernos, no entanto, emitem avisos por padrão para trigrafs e concatenações de linha, mesmo se ativados.Mathematica:
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ímbolox
. Agora, sempre que o Mathematica vê o símbolox
, ele verifica se está sendo operado pelo operador de adição+
em um padrão da forma emx + 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+2
retornax+y
, mas a expressãox+3
retornax+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.fonte
Javascript:
Test Fiddle
fonte
Infinity
, ou-Infinity
, e por causa disso, pode usar o atalho dex = 1/0
.(99999999999999999 == 99999999999999999+2)
porque eu acho que é um pouco mais interessante do que(Infinity == Infinity+2)
, embora, como o OP diz, "é subjetiva" :)-1
e recorrente . A linguagem em si era Python, mas isso realmente não importa nesse caso.false
; onde quer que você esteja obtendo informações sobre JS, está errado e não deve ser confiável.esquema
fonte
(x == x + 2)
parece com o C, mas significa uma coisa totalmente diferente.(= x 2)
.(define (x a b c d) #t)
:)Resposta óbvia:
Quando isso termina:
fonte
while(!(x == x+2)) {}
que seria mais em espíritoAqui está uma solução para JavaScript que não explorar as
Infinity
e-Infinity
ponta 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 awith
declaração e os getters de recursos particularmente "avançados".Editado para adicionar: O truque acima também é possível sem o uso
with
eget
, como observado por Andy E em Dicas para jogar golfe em JavaScript e também por jncraton nesta página:fonte
x
uma chamada de função, embora pareça uma leitura variável. Eu assumo a ordem de avaliação da esquerda para a direita, mas tudo bem, pois é especificado em JS (ao contrário de C).O seguinte não é compatível com os padrões C , mas deve funcionar em praticamente qualquer plataforma de 64 bits:
fonte
x
seria incrementado nas etapas de 2 ^ 61, entãox + 8
seria igualx
.int
.int
, nãochar
.Sábio:
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
fonte
Lisp comum
É muito fácil quando
x
não precisa ser um valor real.fonte
APL (Dyalog)
O APL nem sequer tem infinito, apenas os flutuadores não são precisos o suficiente para diferenciar entre
1.000.000.000.000.000
e1.000.000.000.000.002
. Esta é, até onde eu sei, a única maneira de fazer isso no APL.fonte
Perl 6
Estou surpreso por não ver essa solução antes. Enfim, a solução é - e se
x
for0
e de2
uma só vez?my \x
neste exemplo declara variável sigilless - esta pergunta é sobrex
, não no estilo Perl$x
. O?? !!
operador é ternário.Mas...
x
é vários valores de uma vez.x
é igual a0
e de2
uma só vez.x + 2
é igual a2
e de4
uma só vez. Então, logicamente eles são iguais.fonte
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:
Isto é, uma estrutura com um
size_t
,void *
elong
objeto, nessa ordem.Depois que usamos e, portanto, armazenamos em cache um número inteiro, podemos usar o
ctypes
módulo python para redefinir esse número inteiro, para que não apenas o façax == x+2
, mas2 == 0
Impressões
fonte
Perl
usando uma sub-rotina com efeitos colaterais em uma variável de pacote:
Resultado:
true!
fonte
sub x{}
"funciona" bem .. (pelo menos na minha 5.10.1), mas eu não consigo descobrir por que ..sub x{}
retorna undef ou uma lista vazia, os quais são um zero numérico. E x + 2 é analisado como x (+2).perl -MO=Deparse
revelaprint "true\n" if x() == x(2);
Pitão
explorar a precisão do ponto flutuante torna isso muito simples.
Para torná-lo menos específico do sistema, é necessária uma importação extra
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.
fonte
Aqui está uma solução para C ++ baseada na sobrecarga do operador. Ele se baseia na conversão implícita de um
enum
para umint
.fonte
std::boolalpha
vez de?:
.Eu sei que é um desafio de código ... mas eu joguei. Desculpa.
Ruby - 13 caracteres - solução Infinity
retorna verdadeiro
Ruby - 41 caracteres - Soluções de sobrecarga de operação
ou
fonte
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.
E os resultados:
fonte
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.
fonte