When does (x == x+2)?

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

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

Outputs 1.

Link: http://ideone.com/dL6A5

Answer 2

Fortran IV:

2=0

After this every constant 2 in the program is zero. Trust me, I have done this (ok, 25 years ago)

Answer 3

This seems to work:

#define x 2|0

Basically, the expression is expanded to (2|0 == 2|(0+2)). It is a good example of why one should use parentheses when defining macros.

Answer 4

Brainfuck

x

This does of course stretch "evaluate to true" a bit, because in Brainfuck nothing actually evaluates to anything – you only manipulate a tape. But if you now append your expression

x
(x == x+2)

the program is equivalent to

+

(because everything but <>+-[],. is a comment). Which does nothing but increment the value where we are now. The tape is initialised with all zeros, so we end up with a 1 on the cursor position, which means "true": if we now started a conditional section with [], it would enter/loop.

Answer 5

F#

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

Answer 6

C

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

Note: may not work if FLT_EVAL_METHOD != 0 (see comments below).

Answer 7

C#

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

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

Not a shortie, but somewhat elegant.

http://ideone.com/x56Ul

Answer 8

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

---

Haskell: Define ℤ/2ℤ on Booleans:

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

then for any x :: Bool we'll have x == x + 2.

Update: Thanks for the ideas in comment, I updated the instance accordingly.

Answer 9

Python

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

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

Answer 10

GNU C supports structures with no members and size 0:

struct {} *x = 0;

Answer 11

PHP:

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

Or:

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

Output:

bool(true)

Answer 12

It's a common misconception that in C, whitespace doesn't matter. I can't imagine somebody hasn't come up with this in 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;
}

Prints 1.

Answer 13

C

It's more interesting without using macros and without abusing infinity.

/////////////////////////////////////
// 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);

Try it if you don't believe it!

Answer 14

Mathematica:

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

I think this solution is novel because it uses Mathematica's concept of Up Values.

EDIT:

I am expanding my answer to explain what Up Values mean in Mathematica.

The first line essentially redefines addition for the symbol x. I could directly store such a definition in the global function that is associated with the + symbol, but such a redefinition would be hazardous because the redefinition may propagate unpredictably through Mathematica's built-in algorithms.

Instead, using the tag x/:, I associated the definition with the symbol x. Now whenever Mathematica sees the symbol x, it checks to see whether it is being operated on by the addition operator + in a pattern of the form x + 2 + ___ where the symbol ___ means a possible null sequence of other symbols.

This redefinition is very specific and utilizes Mathematica's extensive pattern matching capabilities. For example, the expression x+y+2 returns x+y, but the expression x+3 returns x+3; because in the former case, the pattern could be matched, but in the latter case, the pattern could not be matched without additional simplification.

Answer 15

Javascript:

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

Test Fiddle

Answer 16

scheme

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

Answer 17

Here is a solution for JavaScript that does not exploit the Infinity and -Infinity edge cases of floating-point addition. This works neither in Internet Explorer 8 and below nor in the opt-in ES5 strict mode. I would not call the with statement and getters particularly "advanced" features.

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

Edited to add: The above trick is also possible without using with and get, as noted by Andy E in Tips for golfing in JavaScript and also by jncraton on this page:

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

Answer 18

Obvious answer:

When this terminates:

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

Answer 19

The following is not standards compliant C, but should work on just about any 64-bit platform:

int (*x)[0x2000000000000000];

Answer 20

Sage:

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

returns True

In general for GF(2**n) it's always true that x=x+2 for any x

This is not a bug or an issue with overflow or infinity, it's actually correct

Answer 21

Common Lisp

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

It's pretty easy when x doesn't have to be an actual value.

Answer 22

APL (Dyalog)

X←1e15
X=X+2

APL does not even have infinity, it's just that the floats aren't precise enough to tell the difference between 1.000.000.000.000.000 and 1.000.000.000.000.002. This is, as far as I know, the only way to do this in APL.

Answer 23

Perl 6

I'm surprised to not see this solution before. Anyway, the solution is - what if x is 0 and 2 at once? my \x in this example declares sigilless variable - this question asks about x, not Perl-style $x. The ?? !! is ternary operator.

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

But...

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

x is multiple values at once. x is equal to 0 and 2 at once. x + 2 is equal to 2 and 4 at once. So, logically they're equal.

Answer 24

Python 2.X (Using redefinition of (cached) integers)

I've noticed all of the python answers have defined classes that redefine the + operator. I'll answer with an even more low-level demonstration of python's flexibility. (This is a python2-specific snippet)

In python, integers are stored more or less this way in C:

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

That is, a struct with a size_t, void *, and long object, in that order.
Once we use, and therefore cache an integer, we can use python's ctypes module to redefine that integer, so that not only does x == x+2, but 2 == 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

Prints

True
True

Answer 25

Perl

using a subroutine with side-effects on a package variable:

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

Output: true!

Answer 26

Python

exploiting floating point precision makes this very simple.

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

To make it less system specific requires an extra import

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

This should work in other languages too. This works because the reprensentation of 100000000000000000.0 and 100000000000000002.0 are exactly the same for the machine, because of the way floating points are represented inside the machine. see http://en.wikipedia.org/wiki/IEEE_floating_point for more information.

So this will basically work in any language that allows you to add integers to floats and have the result of this be a float.

Answer 27

Here is a solution for C++ based on operator overloading. It relies on implicit conversion from an enum to 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;
}

Answer 28

I know it's a code challenge... but I golfed it. Sorry.

Ruby - 13 characters - Infinity solution

x=1e17;x==x+2

returns true

Ruby - 41 characters - Op Overloading solutions

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

or

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

Answer 29

If it is ok to exploit the question a little bit, then I will add some new Java. The trick is for sure not new, but perhaps interesting that this is possible in 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));
}

And the results:

(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

Answer 30

Java

double x = Double.POSITIVE_INFINITY; // Double.NEGATIVE_INFINITY also works
System.out.println(x == x + 2);      // prints true

Answer 31

Common Lisp

(let ((x   42)
      (x+2 42))
  (= x x+2))
;=> true

Answer 32

This VBScript solution works similarly to my JavaScript solution. I did not use a preprocessor yet the solution seems 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

Answer 33

Ada

procedure test() is
  type x_type is mod 2;
  var x: x_type := 0; -- 0 or 1
begin
  if x /= x + 2 then
    put('Error');
  else
    put('Equal!');
  end if;
end test;

This is similar to Sage. We use a 1 bit integer which is allowed to wrap. We could also use a floating point, obviously.

Answer 34

Bash (0 character)

According to the rule, it looks like I can suggest my 0 character definition of x in bash, since without any definition, I have:

if (x==x+2); then echo "true"; fi

Output

true

Is it fair?

Answer 35

C#

I didn't see any rule stating x had to be a number:

class Program {
    public static Program operator +(Program x, int y) {
        return x;
    }

    static void Main(string[] args) {
        var x = new Program();
        Console.WriteLine(x == x + 2);
    }
}

I defined x in such a way, but I also defined the + operator for the object stored in x.

http://ideone.com/ylNyM

Answer 36

JavaScript

Here's a way do it without exploiting Infinity:

x = {
    value: 0,
    valueOf: function () {
        this.value += 2;
        return this.value;
    }
};

alert(x == x+2);

Answer 37

C

If you evaluate x == x+2 directly you will get a false, but I think it is interesting because it makes usage of a different language feature.

#include <stdio.h>

typedef struct {
  int bit:1;
} bitpack;

#define x a.bit
#define y b.bit

main() 
{
  bitpack a, b;
  y = x + 2;
  if (x==y) 
    printf("true\n");
  else 
    printf("false\n");
}

Answer 38

C

let the computer find a value for x

int main()
{
  float x=0;
  while(x!=x+2)x+=2;
  printf("%f\n",x);
}

Answer 39

Haskell

Prelude> instance Num Bool where (+) _ _ = True
Prelude> let x = True
Prelude> (x==x+2)
True

You could call that cheating but I assume that's what this is about :D

To make it work with more than just bool:

import Prelude hiding ((==),(+))
infixl 9 ==
(==) _ _ = True
(+) _ _ = True

Answer 40

GAP

gap> x:=[];
[  ]
gap> x=x+2;
true

Here x is an empty array.

gap> x:=Z(2);
Z(2)^0
gap> x=x+2;
true

Here x is a generator of GF(2).

gap> x:=Integers;
Integers
gap> x=x+2;
true

Here x is the set of integers.

Answer 41

JavaScript

x=Math.log(0)
x==x+2

Prints

True

Answer 42

Tcl, 22 chars.

proc (x args return\ 1

Answer 43

J

x =: 1

There is no == operator in J, sox==x+2 would actually mean x=(=(x+2)). Unary = is an operator, that will return 1 acting on any number, and as binary it is just an equality. So 1=(=(1+2)) => 1=(=3) => 1=1 => 1.

Answer 44

SWI-Prolog

In query mode:

?- X = X+2, X == X+2.
X = X+2.

You just need to "assign" X = X + 2, then X == X + 2 will be true. Why make things so complicated?

---

Real explanation

In Prolog, x is an atom, so it is not possible to make x == x + 2 returns true. Variables in Prolog must start with an uppercase letter or underscore.

Therefore, my solution will define (uppercase) X so that X == X+2.

In Prolog, == compares 2 terms according to standard order of terms. Therefore, we only need to unify (= operator) X and X+2 before doing the comparison.

Note that the unification X = X+2 unifies X with the infinite term X = (((...)+2)+2)+2, much like how the unification X = f(X) unifies X with the infinite term X = f(f(f(...))).

In Prolog, when a query succeeds, it will return true if there is no variable, or it will return the variable binding which satisfies the query. This explains the output X = X+2.

Answer 45

PHP

<?php
  $x = 1e17;
  echo $x==$x+2;

Works in many other languages as well.

Answer 46

Ruby

def x;1.0/0;end
puts (x == x+2) #=> true

Answer 47

Scala

case object x {
  def +(n:Int) = this
}
//defined module x

x == x + 2
//res0: Boolean = true

Answer 48

Java:

Float x = Float.MAX_VALUE;
System.out.println(x == (x + 2));

It prints "true"

System.out.println(x); 

prints 3.4028235E38

System.out.println(x+2); 

prints 3.4028235E38

I think this is caused by the loss of precision.

Answer 49

In my opinion, x must have a data type of just ONE BIT.

Since C99, there is the data type _Bool ; So this should probably work:

_Bool x;
x = 0;
if (x == x + 2) ...

Answer 50

Python

>>> x=1e999
>>> x==x+2
True

Answer 51

Haskell

f x = (x == x + 2)
    where x + 2 = x

Calling f with any argument (whose type is in the Eq typeclass) will evaluate to True.

Answer 52

Missing GolfScript?

0:2;
Then e.g. 15 2+ -> 15

Answer 53

JavaScript

var x = Infinity;

So if you add anything to infinity it will remain infinity.

Answer 54

Trying to come up with something that doesn't fall under one of the existing seven groups is tough:

def x
  rand(1..3)
end

puts x==x+2

33% of the time, it's right all the time...

Answer 55

$x == $х+2 for infinite pairs of numbers. Let's try it out.

PHP

$х = 1;
$x = 3;

if ($x == $х+2)
    echo "LOL it works. Sort of black magic?";

Nah, it's not black magic. Truth is that one x is Kha, that as Wikipedia states, it looks the same as the Latin letter X, in both uppercase and lowercase, both roman and italic forms.

There's actually no difference between them, so even if there are two different variables, rules are not broken, since I assumed that a x is a Kha.

Answer 56

C

Defining x as 1==-2

#include<stdio.h>
#define x 1==-2

main()
{
  printf("%d", (x==x+2) ) ;
}

Answer 57

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 58

ECMAScript (also known as JavaScript):

x=1e17

Answer 59

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 60

Python 2.7, 46 chars

I see a lot of Python answers abusing real number limitations, I'm surprised no one's submitted this disgusting Python hack yet.

x=True;True=False;
if True is (x==x+2): print x

Returns:

True

Answer 61

C#

Using infinity

Double x = Double.PositiveInfinity;
Console.WriteLine(String.Format("Result: {0}", x == x + 2));

Also works with

Double x = Double.NegativeInfinity

(this is actually the same as 1.0 / 0.0 approach)

Answer 62

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 63

Python:

>>> x=float('inf')
>>> x==x+2
True

Answer 64

Haskell

f x = x == (x+2) where (==)=(<)

Always returns True, except when x is 1/0.

Answer 65

Pascal

Here's a solution that takes a different approach (not the usual infinity trick).

Program xplus2;

Var value: integer;

Function x: integer;
Begin
   value := value-2;
   x := value;
End;

Begin
   If x=x+2 then
      Writeln('They are the same')
   else
      WriteLn('They are different');
End.

Works with 2+x too.

Answer 66

Mathematica

x=∞

Mathematica is perfectly happy to reason (within reason) with infinity, and knows that ∞ and ∞+2 are the same!

Answer 67

ForceLang

def x set y -2+y
io.write x=x+2

Answer 68

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 69

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 70

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 71

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 72

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 73

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 74

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 75

JavaScript

var x = {y: 0, toString: function() {return (this.y+=2)}};
console.log(x == x+2); // true

When you add number to an object you indirectly call toString method of this object. toString method returns number... Right side becomes number, then == operator converts x to primitive by using it's toString method.

Interesting article about related idea: Fake operator overloading in JavaScript.

Answer 76

Python (18)

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

Gives True in interactive mode.

Answer 77

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.

Answer 78

Javascript

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

This doesn't work in strict mode, nor without a global variable (i.e window). Tested in Firefox 38.

Answer 79

Ruby

With some monkey patching, everything is possible.

class Fixnum
    def ==(obj)
        # Check if difference between self and obj is 0, -2 or +2
        "#{self-obj}"=~/0|\-?2/ ? true : false
    end
end

As I can't use self==obj || self==obj+2 || self==obj-2, as that would cause a StackError, I first transform them into Strings, then check if the difference matches "0", "-2" or "2"

Test cases

# Make sure `x` is from type Fixnum
x=0

p (x==x+2) # => true
p (x+2==x) # => true
p (x==x)   # => true
p (x==x+1) # => false
p (x==x+3) # => false

Answer 80

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 81

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 82

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 83

Processing

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

The output will be true

Not very creative, but yeah.

Answer 84

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 85

Python

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

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

Answer 86

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 87

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 88

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 89

Python

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

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

Answer 90

q/k

Pretty trivial using infinity (or null):

q)x:0w

x=x+2
1b

Answer 91

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 92

Sage

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

Answer 93

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 94

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 95

Coffeescript, 18 chars

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

Answer 96

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 97

JavaScript

!!("x==x+2") // true

Answer 98

 cout << bool(x == x+2);

! is not needed at all