When does (x == x+2)? [closed]

Question

The challenge: Define x in such a way that the expression (x == x+2) would evaluate to true.

I tagged the question with C, but answers in other languages are welcome, as long as they're creative or highlight an interesting aspect of the language.

I intend to accept a C solution, but other languages can get my vote.

1. Correct - works on standard-compliant implementations. Exception - assuming an implementation of the basic types, if it's a common implementation (e.g. assuming int is 32bit 2's complement) is OK.
2. Simple - should be small, use basic language features.
3. Interesting - it's subjective, I admit. I have some examples for what I consider interesting, but I don't want to give hints. Update: Avoiding the preprocessor is interesting.
4. Quick - The first good answer will be accepted.

After getting 60 answers (I never expected such prticipation), It may be good to summarize them.

The 60 answers divide into 7 groups, 3 of which can be implemented in C, the rest in other languages:

1. The C preprocessor. #define x 2|0 was suggested, but there are many other possibilities.
2. Floating point. Large numbers, infinity or NaN all work.

3. Pointer arithmetic. A pointer to a huge struct causes adding 2 to wrap around.

   The rest don't work with C:

4. Operator overloading - A + that doesn't add or a == that always returns true.
5. Making x a function call (some languages allow it without the x() syntax). Then it can return something else each time.
6. A one-bit data type. Then x == x+2 (mod 2).
7. Changing 2 - some language let you assign 0 to it.

Answer 1

Scheme / Unicode

(let
  ((２ 0) (x 9))
  (= x (+ x ２)))

I knew there had to be a Unicode character that looks like a 2 - and that there would be a language or interpreter lenient enough to accept it as a variable name.

Answer 2

ECMAScript (also known as JavaScript):

x=1e17

Answer 3

Haskell, denotational semantics

x = undefined

As most of you probably know, undefined :: a can be cast to any type - or in other words, every type contains a special value undefined, also called ⊥ (pronounced "bottom"). We say that ⊥ is less defined than any other inhabitant of that type, and while its a little too in-depth for this post, ⊥ can also be seen as a computation that never finishes.

Let's import Data.Function.

In there, there is a function called fix, which according to the Haskell docs finds the least-defined fixpoint of f, by repeatedly applying the function to itself. Let's recap:

We need to find a value x, for which x = x + 2, or, equivalently x = (+2) x. Lets factor (+2) into a function called f. We get x = f x, which is precisely the definition of a fixed point for the function f. Since we don't know x yet, we need a function that knows how to calculate a fixpoint, like fix; x is our placeholder for said fixpoint (x = fix f), so our whole equation becomes fix f = f (fix f).

This is just the definition of fix, so fix indeed finds a fixed point for a given function!

What I'm trying to say is: To solve OP's problem, all we need to do is pipe fix (+2) through ghci. When we do that however, we see nothing, as ghci gets caught in an infinite loop. But since I said that infinite loops can be seen as ⊥, we arrive at the fact that x = ⊥, which by the way turns out to be the only solution to OP's question (who would have guessed).

Answer 4

PHP

$isi = 1.0E+17;
var_dump($isi == $isi + 2);

---

$isi = 1e18;
var_dump($isi == $isi + 2);

---

$isi = 4.2E+20;
var_dump($isi == $isi + 2);

---

$isi = 9.2233720368548E+18;
var_dump($isi == $isi + 2);

---

$isi = 5.0E+19;
var_dump($isi == $isi + 2);

---

$isi = 6.0822444802213E+18;
var_dump($isi == $isi + 2);

---

$isi = 0x5468792130ABCDEF;
var_dump($isi == $isi + 2);

---

$isi = 6082244480221302255;
var_dump($isi == $isi + 2);

Answer 5

the answer is infinity or - infinity because infinity+2=infinity you can't find any other number that it's bigger than itself+ a number

Answer 6

Ruby

1.9.3p125 :006 > x = Float::INFINITY  # or x = -Float::INFINITY
 => Infinity 
1.9.3p125 :007 > x == x +2
 => true 



1.9.3p125 :015 > x =Float::MAX
 => 1.7976931348623157e+308 
1.9.3p125 :016 > x == x +2
 => true 

Answer 7

In Scala, just override the "+" operator (really a function):

scala> class X { def +(a:Int)=this }
defined class X

scala> val x = new X
x: X = X@26e7127

scala> x == x+2
res3: Boolean = true

scala> 

Answer 8

Ruby

That's surely cheating, but hey ...

#/usr/bin/env

class Fixnum
  def +(y)
    if self == 42
       self
    else
       self + y
    end
  end
end

Then for x being exactly 42 ... /me => [ ]

Answer 9

Javascript

Most compact, correct that I could figure.

x=1/0;x==x+2

I also tried futzin around with toString() and clever output variance with casting, but while the results were correct sequentially, the == would never be true.

Answer 10

C++

I'm aware there have been a couple of similarly themed solutions, but here's mine nonetheless:

#include <iostream>

struct Plus {
  int x;
  Plus(int _x):x(_x){}
  Plus operator+(int _x) {
    return Plus(this->x + _x);
  }
  bool operator==(Plus _x) {
    return true;
  }
};

int main() {
  Plus x(0);
  std::cout << bool(x == x + 2); 
}

Answer 11

Python

I'm always looking for an excuse to use a class for golfing Python... alas, this isn't golf.

class foo:__add__=lambda a,b:a
x=foo()

Here, x+2 is x, though 2+x blows up with an error (I'd have to implement __radd__). I could have hacked equality testing instead, but I'd still need to implement __add__.

Answer 12

Python

Any language with floats - no need to go all the way to infinity

x=9e9**9
x==x+2

Answer 13

q/k

Pretty trivial using infinity (or null):

q)x:0w

x=x+2
1b

Answer 14

Processing

float x=1e30;
print(x==x+2);

The output will be true

Not very creative, but yeah.

Answer 15

Python

class X():
 def __eq__(a,b):
  return True
 def __add__(a,b):
  return True
x = X()
print x==x+2

$ python x.py 
True

Answer 16

Sage

sage: print oo
+Infinity
sage: oo+2==oo
True

Answer 17

Groovy

Integer.metaClass.plus = { Integer y -> delegate }
def x = 0
assert x == x+2

The plus method is overridden to return the first number :-D

Answer 18

C (GCC at least)

Using pointer arithmetic on an struct of size 0

#include <stdio.h>
typedef struct {} empty;

main(){
    empty *x;
    printf("%d\n", x==x+2);
}

Answer 19

Coffeescript, 18 chars

x=1/0;alert x==x+2

Answer 20

Lua, used in various products including World of Warcraft, Wireshark, Nmap, Adobe Photoshop Lightroom, and the Nspire line of Texas Instruments graphing calculators, supports operator overloading (using "metamethods") for tables (associative arrays). This code works in both Lua 5.1 and 5.2:

local x = setmetatable({}, {
  __add = function(a, b)
    return a
  end
})

print(x == x + 2) -- true

Answer 21

GolfScript

In Golfscript, you can redefine +, 2, or = in order to make the statement true for any value of x! Any of the following lines would suffice:

{;}:+; #Redefine + to ignore the second summand
0:2;; #Redefine 2 to be 0
{;;1}:=; #Redine = to always return true

Then:

10:x; #Any x would work
x x 2+ = #x==x+2
-> 1

If you want the answer in the exactly format of the question, we can do some other nonsense:

{0}:(:x:=:+:2; #redefine all the characters in the expression to 0
{];1}:); #redefine ) to pop everything off the stack and then return 1

So then:

(x == x+2)  #That doesn't look like GolfScript!
-> 1

Answer 22

Little know fact about Haskell is it doesn't always do divide by 0 errors.

let x=1/0 in x==x+2

This is because when you add 2 to infinity, it doesn't get bigger. It is weird that such a mathematical language would just deal with infinity so nonchalantly.

Answer 23

Rebol

Version of the Perl answer by memowe:

v: 0
x: does [v: v - 2]

With above defined you can now test in Rebol console...

>> x == (x + 2)
== true

>> equal? x x + 2
== true

And a Rebol version of Joshua Taylor Common Lisp answer:

x: 42
x+2: 42

In console...

>> x == x+2  
== true

Answer 24

Groovy

x = Float.MAX_VALUE
assert x==x+2

Float.MAX_VALUE = 3.4028235E38
Float.MAX_VALUE + 2 = 3.4028234663852886E38
Which the == determines is close enough.

Answer 25

C++ / C-sharp

Here's another one depending on the definition of an infinite double according to the IEEE standard (http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlf101a.doc%2Fxlfopg%2Ffpieee.htm).

int main()
{
   double x = 0x7FF0000000000000; // Positive infinity
   cout << (x == x + 2 ? "true" : "false");
   
   return 0;
}

In C# this could be written more readably as

 double x = double.PositiveInfinity;

Answer 26

C++

Had some fun with operator overloading

#include <iostream>

class Tautology
{
  public:
    const Tautology& operator+(int n)
    {
        // Anything to make x + 2 compile
        return *this;
    }
    
    bool operator==(const Tautology& t)
    {
        // Any tautology equals any other
        return true;
    }
};

int main()
{
   Tautology x;
   std::cout << (x == x + 2 ? "true" : "false");
   
   return 0;
}

Answer 27

JavaScript

Exploiting the big number / infinity approach as shortly as possible.

12 chars:

9e99==9e99+2 // true

10 chars

1/0==1/0+2 // true

Answer 28

Python

>>> x=99999999999999999999999999999999999.
>>> x==x+2
True

Note the . at the end, which makes x a floating point number.

Answer 29

Python (18)

>>> x=True;[x][x==2+x]
True

Gives True in interactive mode.

Answer 30

J

   x=:!123
   x=x+2
1

This is also reliant on the floating point trick: !123x=2+!123x returns 0(= actually is the comparison operator, so no trickery there)

Or, maybe even better:

   x=:_
   x=x+2
1

simply sets x to infinity.