Write a program that makes 2 + 2 = 5

I would like to post on there but it's protected from people with low reputation... Maybe someone here appreciates my solution in C:

  #include <stdio.h>
  
  int main(int argc, char* argv[]){
  	int arr[1];
  	int a = 2;
  	int b = 2;
  	arr[1] = 3;
  	printf("%d", a+b);
  
  	return 0;
  }

Here's mine :

    $ cat test.c
    #include <stdio.h>
    
    int main() {
        int a = 3;
        int b = 3;
    
        // aren't we supposed to add 2 and 2 ??/
        a = 2;
        b = 2;
    
        printf("%d\n", a + b);
    
        return 0;
    }
    $ gcc -W -Wall -trigraphs test2.c 2>/dev/null
    $ ./a.out
    5
    $

That Java one is particularly amusing, as most programmers otherwise familiar with the language would never know about the integer cache (and their reaction upon discovering that there is one would probably be the same as mine - WTF?)

Edit: I had a feeling I'd heard of an "integer cache" somewhere else" in a WTF-eliciting context... http://thedailywtf.com/Articles/The-Integer-Cache.aspx !

UB abuse in C/C++ Linux x86-64 (works with gcc/clang/icc with any optimization level):

  #include <stdio.h>

  int main() {
    double x;
    printf("Input any number:\n> ");

    if (scanf("%lf", &x) == 1) {
      printf("Is 2 + 2 really equals %g? Let's try!\n", x);
      printf("2 + 2 = %g\n", 2 + 2);
    } else {
      printf("Invalid input!\n");
    }
  }

  Input any number:
  > 5
  Is 2 + 2 really equals 5? Let's try!
  2 + 2 = 5

JavaScript ;)

http://codegolf.stackexchange.com/a/29944/12328

Here's a Ruby solution that really does modify the + operation:

  class Fixnum
    alias_method :old_plus, :+
    def +(*args)
      old_plus(*args).old_plus(1)
    end
  end

  2 + 2 #=> 5

  public class Main {
   	public static void main (String [] args) {
  		System.out.println("‮5=2+2‭"); // prints ‬4=2+2
  	}
  }

C:

    #include <stdio.h>
    #include <stdbool.h>
    #include <stdlib.h>

    int nums[5] = {1, 0, 1, 0, 1};
    static int cur;

    int main(int argc, char **argv) {
        for(int i = 1; nums[i] != 5 && i < 10; i++) {
            cur = i;
            if(i/4 == 1) {
                printf("2 + 2 <= %d = %s\n", cur, 2 + 2 <= i ? "true" : "false");
                printf("2 + 2 == %d = %s\n", cur, 2 + 2 == i ? "true" : "false");
                printf("\n");
            }
        }
    }

It's finicky and I believe depends on register allocation, but when I compile it using whatever version of gcc-mp-4.9 I have installed from MacPorts at -O3, it outputs, among other things:

    2 + 2 == 5 = true

Because I can't post on stackoverflow either, here's my variant in C (requires glibc, and a deprecated function at that).

  #include <printf.h>
  #include <stdio.h>
  #include <string.h>

  int d_cb(FILE *stream, const struct printf_info *info, const void *const* args) {
    int num = (*(int*)(((int**)args)[0])), numw = info->width;
    char str[10], numn = num|numw, *out = str;
    num = num < 0 ? *out++ = '-', -num : numn;
    do { *out++ = '0' + num % 10; num /= 10; } while(num);
    fwrite(str, out - str, 1, stream);
    return 0;
  }

  void init() {
    register_printf_function('d', d_cb, 0);
  }

  int main() {
    init();
    printf("2+4 = %d, 2+2 = %1d\n", 2+4, 2+2);
    return 0;
  }

Here's the Perl 6 solution:

  multi infix:<+>(2, 2) { 5 }
  say 2 + 2;  # 5

Ruby solution (don't have enough rep to post to codegolf):

  def mad_addr(a,b)
    a == b && a == 2 ? (a.object_id + b.object_id)/a : a + b
  end

I just learned the object_id of 2 is 5 while doing this exercise, and I would like to continue learning more about how Ruby works. So if you have feedback, criticisms, or other ideas regarding this solution please feel free to share :)

[edit: added missing `=`]

Asking: Isn't the only true solution the one using Decibels for Addition? Because everyone else either just redefines or overwrites a value. Also addition of decibels cannot be disproofed as fake.

You know, this would be possible in C and C++ if you add some code at the start of main() that unprotects the executable section, goes through it and modifies each "load 4 in register X" instruction to "load 5", then forks a process that attaches itself as a debugger to the executable to monitor every add and change the result to 5 if it's 4.

Lua:

    local debug = require "debug" -- in case 5.2
    debug.setmetatable(1, {__tostring=function(n)
      return ("%g"):format(n+1)
    end})

    print(2+2)

How about the opposite? Make 2+3=4, here in C.

    add2And3(int *a, int *b)
    {
       *a = 3;
       *b = 2;
       printf("%d", *a + *b);  //4
    }
    void main()
    {
       int storage;
       add2And3(&storage, &storage);
    }

  #!/bin/bash
  tty
  if [[ $? -ne 0 ]] ; then
      # command returned nonzero
      echo "not a tty"
  else
      # command returned zero
      n=$?
      ((n=$n+2))
      ((n=$n+2))
      echo "0+2+2=$n";
  fi

Haskell:

  let 2 + 2 = 5

Simple solution in R:

   > '%+%' <- get( '+')
   > '+' <- function( e1, e2) 1 %+% e1 %+% e2
   > 2+2
   [1] 5

Combining a couple ideas, here's a Go solution

http://play.golang.org/p/XnPglbkLW4

You have to add 1 to either the first or the second 2 or to the sum of the two.

#lang racket (define (add-bizzare x y) (round (+ (+ x 0.4) (+ y 0.4))))

My first thought in Clojure.

  (let [+ (partial + 1)]                                                                                                                                                                                
        (+ 2 2))

The JavaScript answer from @user1886419 is a great joke. lol

Julia

  !(a::Int) = !bool(a)
  !0 + 2 + 2

  ##> 5

why not just overload the + operator in C++?

I'm surprised no one has suggested this yet. In python

>Write a program that seemingly adds the numbers 2 and 2

a=2+2

>and outputs 5.

print(5)

Yeah, I know that isn't the intent here, but, following the wording of the contest rules exactly...