Le défi: définir x
de manière à ce que l'expression (x == x+2)
soit évaluée comme vraie.
J'ai marqué la question avec C, mais les réponses dans d'autres langues sont les bienvenues, à condition qu'elles soient créatives ou mettent en valeur un aspect intéressant de la langue.
J'ai l'intention d'accepter une solution C, mais d'autres langues peuvent obtenir mon vote.
- Correct - fonctionne sur les implémentations conformes aux normes. Exception - En supposant une implémentation des types de base, s'il s'agit d'une implémentation courante (en supposant par exemple
int
un complément de 32 bits), tout va bien. - Simple - devrait être petit, utilisez les fonctionnalités de base du langage.
- Intéressant - c'est subjectif, je l'avoue. J'ai quelques exemples de ce que je considère intéressant, mais je ne veux pas donner d'indices. Mise à jour : Éviter le préprocesseur est intéressant.
- Rapide - La première bonne réponse sera acceptée.
Après avoir obtenu 60 réponses (je ne m'attendais pas à une telle préparation), il peut être bon de les résumer.
Les 60 réponses se divisent en 7 groupes, dont 3 peuvent être implémentés en C, le reste en autres langues:
- Le préprocesseur C
#define x 2|0
a été suggéré, mais il y a beaucoup d'autres possibilités. - Point flottant. Les grands nombres, l'infini
ou NaNfonctionnent tous. Pointeur arithmétique. Un pointeur sur une énorme structure provoque l'ajout de 2 à boucler.
Le reste ne fonctionne pas avec C:
- Surcharge d'opérateur - A
+
qui n'ajoute pas ou==
qui retourne toujours vrai. - Faire
x
un appel de fonction (certaines langues le permettent sans lax()
syntaxe). Ensuite, il peut retourner quelque chose à chaque fois. - Un type de données à un bit. Puis
x == x+2 (mod 2)
. - Changer
2
- certaines langues vous permettent de l’affecter0
.
math
arithmetic
c
ugoren
la source
la source
4. Quick
? Vous voulez dire "Celui qui en connaît un et qui a la chance de lire cette question en premier"?add to Set
par la bibliothèque standard, sans+
vous redéfinir , ne rentre pas dans ces 7 catégories, à mon humble avis.Réponses:
Sorties 1.
Lien: http://ideone.com/dL6A5
la source
float x=1./0
est un peu plus court et peut-être plus élégant. Mais de toute façon, c’est sûrement la première bonne réponse.float x=1e20
serait assezFortran IV:
Après cela, chaque constante 2 du programme vaut zéro. Croyez-moi, je l'ai fait (ok, il y a 25 ans)
la source
Cela semble fonctionner:
Fondamentalement, l'expression est étendue à
(2|0 == 2|(0+2))
. C'est un bon exemple de la raison pour laquelle il convient d'utiliser des parenthèses lors de la définition de macros.la source
2|(0+2)
être1
?|
est bitwise OU ;||
est logique OU.Brainfuck
Bien entendu, cela étire un peu "vrai", car dans Brainfuck rien n’est évalué comme quoi que ce soit - vous ne faites que manipuler une bande. Mais si vous ajoutez maintenant votre expression
le programme est équivalent à
(car tout sauf
<>+-[],.
un commentaire). Ce qui ne fait qu’incrémenter la valeur actuelle. La bande est initialisée avec tous les zéros, nous nous retrouvons donc avec un 1 sur la position du curseur, ce qui signifie "vrai": si nous commencions maintenant avec une section conditionnelle[]
, elle entrerait / bouclerait.la source
x
?x
ainsix
est défini commex
.need
rien sauf le+
F#
la source
=
?==
n'est même pas défini par défaut.C
Remarque: peut ne pas fonctionner si
FLT_EVAL_METHOD != 0
(voir les commentaires ci-dessous).la source
INF + 2 == INF
ma réponse, alors que ma réponse utilise un flottant simple précision suffisamment grand pour que 2 soit inférieur à un ULP.∞ + 2 = ∞
c'est quelque chose que tout le monde peut comprendre et ne dépend de rien de spécifique à l'ordinateur, alors que l'ajout de 2 à un nombre concret et qu'il n'a aucun effet est un peu plus surprenant et spécifique à la précision limitée des ordinateurs, et plus intéressant àFLT_EVAL_METHOD == 1
le calcul est fait commedouble
. Recommandez une valeur de PF plus grande, supérieure à lalong double
précision1.0e37f
C #
Pas un shortie, mais un peu élégant.
http://ideone.com/x56Ul
la source
Scala:
{ val x = Set(2); (x == x + 2) }
Haskell: Définissez ℤ / 2ℤ sur
Bool
eans:alors pour tout
x :: Bool
nous auronsx == x + 2
.Mise à jour: Merci pour les idées en commentaire, j'ai mis à jour l'instance en conséquence.
la source
fromInteger = odd
(+)
peut être défini comme(/=)
je crois.()
.Python
la source
__cmp__
class X(int):__cmp__=lambda*x:0
__eq__
class X(int):__eq__=lambda*x:True
class X:__add__=lambda s,o:s
__add__
donné que plusieurs arguments (lambda x,y:
) sont normalement attribués , je sauvegarde certains caractères en utilisant * pour regrouper tous les arguments dans un tuple (lambda *y:
). Voir la documentation pour plus d'informations.GNU C supporte les structures sans membres et de taille 0:
la source
PHP:
Ou:
Sortie:
la source
C'est une idée fausse commune qu'en C, l'espace n'a pas d'importance. Je ne peux pas imaginer que quelqu'un n'ait pas proposé cela dans GNU C:
Impressions
1
.la source
x == x+2
est toujours faux). Mais une fois que vous avez soulevé l'idée, je pense que#define x -2*__LINE__
c'est plus élégant._CAT
est l'identifiant réservé. Tout ce qui commence par un tiret bas et une lettre majuscule est réservé en C.C
C'est plus intéressant sans utiliser de macros et sans abuser de l'infini.
Essayez-le si vous n'y croyez pas!
la source
0
. Non, je n'y crois toujours pas.??\
??\
doit être converti en un seul\
, donc il n'y en a pas??\
. Certains compilateurs modernes donnent toutefois des avertissements par défaut aux trigraphes et aux concaténations de lignes, même s’ils sont activés.Mathematica:
Je pense que cette solution est nouvelle car elle utilise le concept de valeurs Up de Mathematica .
MODIFIER:
J'élargis ma réponse pour expliquer la signification des valeurs supérieures dans Mathematica .
La première ligne redéfinit essentiellement l'addition du symbole
x
. Je pourrais directement stocker une telle définition dans la fonction globale associée au+
symbole, mais une telle redéfinition serait dangereuse car cette redéfinition pourrait se propager de manière imprévisible via les algorithmes intégrés de Mathematica .À la place, en utilisant la balise
x/:
, j’ai associé la définition au symbolex
. Désormais, chaque fois que Mathematica voit le symbolex
, il vérifie s'il est exploité par l'opérateur d'addition+
dans un motif de la formex + 2 + ___
où le symbole___
désigne une éventuelle séquence null d'autres symboles.Cette redéfinition est très spécifique et utilise les capacités étendues de correspondance de motifs de Mathematica . Par exemple, l'expression
x+y+2
retournex+y
, mais l'expressionx+3
retournex+3
; parce que dans le premier cas, le motif pourrait être apparié, mais dans le dernier cas, le motif ne pourrait pas être apparié sans simplification supplémentaire.la source
Javascript:
Testez le violon
la source
Infinity
, ou-Infinity
, et à cause de cela, vous pouvez utiliser le raccourci dex = 1/0
.(99999999999999999 == 99999999999999999+2)
parce que je pense que c'est un peu plus intéressant que(Infinity == Infinity+2)
, comme le dit le PO, "c'est subjectif" :)-1
récursifs . Le langage lui-même était Python, mais cela n'a pas vraiment d'importance dans ce cas.false
; où que vous obteniez cette information sur JS est fausse et ne doit pas faire confiance.schème
la source
(x == x + 2)
ressemble à C, mais signifie une chose totalement différente.(= x 2)
.(define (x a b c d) #t)
:)Réponse évidente:
Quand cela se termine:
la source
while(!(x == x+2)) {}
serait plus dans l'espritVoici une solution pour JavaScript qui ne tire pas parti
Infinity
et les-Infinity
cas bord de plus à virgule flottante. Cela ne fonctionne ni dans Internet Explorer 8 et versions antérieures, ni dans le mode strict opt-in ES5. Je n'appellerais pas lawith
déclaration et les accesseurs particulièrement des fonctionnalités "avancées".Édité pour ajouter: L'astuce ci-dessus est également possible sans utiliser
with
etget
, comme l'a noté Andy E dans Astuces pour jouer au golf en JavaScript et aussi par jncraton sur cette page:la source
x
un appel de fonction, même s'il ressemble à une lecture de variable. Je suppose que l’évaluation va de gauche à droite, mais c’est acceptable car elle est spécifiée dans JS (contrairement à C).Ce qui suit n’est pas conforme aux normes C , mais devrait fonctionner sur n’importe quelle plate-forme 64 bits:
la source
x
serait incrémenté par étapes de 2 ^ 61, doncx + 8
serait égalx
.int
.int
, paschar
.Sauge:
renvoie True
En général pour GF (2 ** n), il est toujours vrai que x = x + 2 pour tout x
Ce n'est pas un bug ou un problème de débordement ou d'infini, c'est en fait correct
la source
Common Lisp
C'est assez facile quand
x
ne doit pas être une valeur réelle.la source
APL (Dyalog)
APL n’a même pas l’infini, c’est juste que les flotteurs ne sont pas assez précis pour faire la différence entre
1.000.000.000.000.000
et1.000.000.000.000.002
. Pour autant que je sache, c'est la seule façon de faire cela dans APL.la source
Perl 6
Je suis surpris de ne pas voir cette solution avant. Quoi qu'il en soit, la solution est la suivante: qu’en
x
est-il0
et2
à la fois?my \x
dans cet exemple, déclare la variable sigilless - cette question demande à proposx
, pas à la manière de Perl$x
. L'?? !!
opérateur est ternaire.Mais...
x
est plusieurs valeurs à la fois.x
est égal à0
et2
à la fois.x + 2
est égal à2
et4
à la fois. Donc, logiquement, ils sont égaux.la source
Python 2.X (Utilisation de la redéfinition des entiers (mis en cache))
J'ai remarqué que toutes les réponses python ont défini des classes qui redéfinissent l'
+
opérateur. Je vais vous répondre avec une démonstration encore plus faible de la flexibilité de python. (Ceci est un extrait spécifique à python2)En python, les entiers sont plus ou moins stockés de cette façon en C:
Autrement dit, une struct avec
size_t
,void *
etlong
objet, dans cet ordre.Une fois que nous utilisons, et le cache donc un entier, on peut utiliser python
ctypes
module pour redéfinir cet entier, de sorte que non seulementx == x+2
, mais2 == 0
Impressions
la source
Perl
Utilisation d'un sous-programme avec des effets secondaires sur une variable de package:
Sortie:
true!
la source
sub x{}
"travaille" aussi .. (au moins dans mon 5.10.1), mais je ne peux pas comprendre pourquoi ..sub x{}
renvoie undef ou une liste vide, les deux étant un zéro numérique. Et x + 2 est analysé comme x (+2).perl -MO=Deparse
révèleprint "true\n" if x() == x(2);
Python
exploiter la précision en virgule flottante rend cela très simple.
Pour le rendre moins spécifique au système nécessite une importation supplémentaire
Cela devrait fonctionner dans d'autres langues aussi. Cela fonctionne car les représentations de 1000000000000000000000.0 et 100000000000000002.0 sont exactement les mêmes pour la machine, en raison de la façon dont les points flottants sont représentés à l'intérieur de la machine. voir http://en.wikipedia.org/wiki/IEEE_floating_point pour plus d'informations.
Cela fonctionnera donc dans n’importe quel langage qui vous permettra d’ajouter des entiers aux flottants et d’en faire le résultat.
la source
Voici une solution pour C ++ basée sur la surcharge des opérateurs. Il s'appuie sur la conversion implicite d'un
enum
versint
.la source
std::boolalpha
au lieu de?:
.Je sais que c'est un défi de code ... mais je l'ai joué au golf. Pardon.
Ruby - 13 caractères - Solution Infinity
retourne vrai
Ruby - 41 caractères - Solutions de surcharge opérationnelle
ou
la source
S'il est possible d'exploiter un peu la question, j'ajouterai du nouveau Java. L’astuce n’est certes pas nouvelle, mais il est peut-être intéressant de noter que cela est possible en Java.
Et les résultats:
la source
Cette solution VBScript fonctionne de manière similaire à ma solution JavaScript. Je n'ai pas encore utilisé de préprocesseur, la solution semble triviale.
la source