[Question]
  [
**Problem:**
Your goal is to add two input numbers without using any of the following math operators: `+,-,*,/`.
Additionally, you can't use any built-in functions that are designed to replace those math operators.
**Scoring:**
Smallest code (in number of bytes) wins.
**Update**
> 
> Most of the programs i've seen either concatenate two arrays containing their numbers, or make `first number` of a character, append `second number` characters, then count them all.
> 
> 
> Shortest array counter: [APL with 8 chars, by Tobia](https://codegolf.stackexchange.com/a/21087/)
> 
> 
> Shortest array concatenation: [Golfscript with 4 chars, by Doorknob](https://codegolf.stackexchange.com/a/21017/)
> 
> 
> Shortest logarithmic solution: [TI-89 Basic with 19 chars, by Quincunx](https://codegolf.stackexchange.com/a/21464/9498)
> 
> 
> Integration solution: [Mathematica with 45 chars, by Michael Stern](https://codegolf.stackexchange.com/a/21018/9498)
> 
> 
> Coolest, in my opinion: [bitwise operators in javascript, by dave](https://codegolf.stackexchange.com/a/21025/)
> 
> 
> 
  
[Answer]
## Javascript (25)
```
while(y)x^=y,y=(y&x^y)<<1
```
This adds two variables x and y, using only bitwise operations, and stores the result in x. 
This works with negative numbers, too.
[Answer]
## C - 38 bytes
```
main(){return printf("%*c%*c",3,0,4);}
```
---
I do cheat a bit here, the OP said to not use any *math* operators. 
The `*` in the `printf()` format means that the field width used to print the character is taken from an argument of `printf()`, in this case, 3 and 4. The return value of `printf()` is the number of characters printed. So it's printing one `' '` with a field-width of 3, and one with a field-width of 4, makes 3 + 4 characters in total.
The return value is the added numbers in the `printf()` call.
[Answer]
# Python - 49 bytes
Assuming input by placement in variables `x` and `y`.
```
from math import*
print log(log((e**e**x)**e**y))
```
This **61 byte** solution is a full program:
```
from math import*
print log(log((e**e**input())**e**input()))
```
Considering that you did not ban exponentiation, I had to post this. When you simplify the expression using properties of logarithms, you simply get `print input() + input()`.
This supports both negative and floating point numbers.
Note: I followed [gnibbler's advice](http://meta.codegolf.stackexchange.com/questions/1003/is-it-better-to-post-one-answer-or-two#comment3694_1026) and split this answer into three. This is [the Mathematica solution](https://codegolf.stackexchange.com/a/21462/9498), and this is [the TI-89 Basic solution](https://codegolf.stackexchange.com/a/21464/9498).
[Answer]
## JavaScript [25 bytes]
```
~eval([1,~x,~y].join(''))
```
[Answer]
# GolfScript, ~~6~~ 4 characters/bytes
Input in the form of `10, 5` (=> `15`).
```
~,+,
```
The `+` is array concatenation, not addition.
How it works is that `,` is used to create an array of the length that the number is (`0,1,...,n-2,n-1`). This is done for both numbers, then the arrays are concatenated. `,` is used again for a different purpose, to find the length of the resulting array.
Now, **here's the trick**. I really like this one because it abuses the input format. It *looks* like it's just inputting an array, but really, since the input is being executed as GolfScript code, the first `,` is already done for me! (The old 6-character version was `~,\,+,` with input format `10 5`, which I shaved 2 chars off by eliminating the `\,` (swap-array)).
**Old version (12)**:
Creates a function `f`.
```
{n*\n*+,}:f;
```
The `*` and `+` are string repetition and concatenation respectively, not arithmetic functions.
Explanation: `n` creates a one-character string (a newline). This is then repeated `a` times, then the same thing is done with `b`. The strings are concatenated, and then `,` is used for string length.
[Answer]
## Mathematica, 21 bytes
There are a number of ways to do this in Mathematica. One, use the Accumulate function and toss everything but the final number in the output. As with my other solution below, I assume the input numbers are in the variables `a` and `b`. 21 bytes.
```
Last@Accumulate@{a, b}
```
More fun, though it is 45 characters, use the numbers to define a line and integrate under it.
```
Integrate[Fit[{{0, a}, {2, b}}, {x, 1}, x], {x, 0, 2}]
```
As a bonus, both solutions work for all complex numbers, not just positive integers as seems to be the case for some other solutions here.
[Answer]
## C, 29 27 Bytes
Using pointer arithmetic:
```
f(x,y)char*x;{return&x[y];}
```
`x` is defined as a pointer, but the caller should pass an integer.
An anonymous user suggested the following - also 27 bytes, but parameters are integers:
```
f(x,y){return&x[(char*)y];}
```
[Answer]
# Brainf\*ck, 9 36
```
,>,[-<+>]
```
```
++[->,[->>[>]+[<]<]<]>>>[<[->+<]>>]<
```
This works without using simple addition; it goes through and lays a trail of 1's and then counts them up
Note: The `+` and `-` are merely single increments and nothing can be done in brainf\*ck without them. They aren't really addition/subtraction so I believe this still counts.
[Answer]
# J (6)
You didn't say we couldn't use the succ function:
```
>:@[&0
```
Usage:
```
   9>:@[&0(8)
17
```
It just does 9 repetitions of `>:` on 8.
The list concatenation approach works, too: `#@,&(#&0)`. And - I know it's against the rules - I can't let this answer go without the most J-ish solution: `*&.^` (multiplication under exponentiation).
[Answer]
## Postscript, 41
We define function with expression 41 bytes long as:
```
/a{0 moveto 0 rmoveto currentpoint pop}def
```
Then we call it e.g. as:
```
gs -q -dBATCH -c '/a{0 moveto 0 rmoveto currentpoint pop}def' -c '10 15 a ='
```
Which gives
```
25.0
```
It easily handles negatives and floats, unlike most competitors:-)
[Answer]
bash, 20 chars
```
(seq 10;seq 4)|wc -l
```
[Answer]
# Smalltalk (now seriously), 123 118 105(\*)
Sorry for answering twice, but consider this a serious answer, while the other one was more like humor. The following is actually executed right at this very moment in all of our machines (in hardware, though). Strange that it came to no one else's mind...
By combining two half-adders, and doing all bits of the words in parallel, we get (inputs a,b; output in s) readable version:
```
  s := a bitXor: b.            
  c := (a & b)<<1.             
                              
  [c ~= 0] whileTrue:[        
     cn := s & c.
     s := s bitXor: c.
     c := cn<<1.
     c := c & 16rFFFFFFFF.
     s := s & 16rFFFFFFFF.
  ].
  s           
```
The loop is for carry propagation.
The masks ensure that signed integers are handled (without them, only unsigned numbers are possibe).
They also define the word length, the above being for 32bit operation. If you prefer 68bit addition, change to 16rFFFFFFFFFFFFFFFFF.
golf version (123 chars) (avoids the long mask by reusing in m):
```
[:a :b||s c n m|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&m:=16rFFFFFFFF.s:=s&m].s]
```
(\*) By using -1 instead of 16rFFFFFFFF, we can golf better, but the code no longer works for arbitrary precision numbers, only for machine-word sized smallIntegers (the representation for largeIntegers is not defined in the Ansi standard):
```
[:a :b||s c n|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&-1.s:=s&-1].s]
```
this brings the code size down to 105 chars.
[Answer]
# APL, 8 and 12
Nothing new here, the array counting version:
```
{≢∊⍳¨⍺⍵}
```
and the log ○ log version:
```
{⍟⍟(**⍺)**⍵}
```
I just thought they looked cool in APL!
```
{≢     }       count
  ∊            all the elements in
   ⍳¨          the (two) sequences of naturals from 1 up to
     ⍺⍵        both arguments
```
 
```
{⍟⍟        }   the double logarithm of
   (**⍺)       the double exponential of ⍺
        *      raised to
         *⍵    the exponential of ⍵
```
[Answer]
# sed, 359 bytes (without the fancy formatting)
Sorry for the late answer, and probably the longest answer here by far. But I wanted to see if this is possible with sed:
```
                       s/([^ ]+) ([^ ]+)/\1:0::\2:/
                       :d /^([^:]+):\1::([^:]+):/tx
                       s/(:[^:]*)9([_:])/\1_\2/g;td
s/(:[^:]*)8(_*:)/\19\2/g;s/(:[^:]*)7(_*:)/\18\2/g;s/(:[^:]*)6(_*:)/\17\2/g
s/(:[^:]*)5(_*:)/\16\2/g;s/(:[^:]*)4(_*:)/\15\2/g;s/(:[^:]*)3(_*:)/\14\2/g
s/(:[^:]*)2(_*:)/\13\2/g;s/(:[^:]*)1(_*:)/\12\2/g;s/(:[^:]*)0(_*:)/\11\2/g
                       s/:(_+:)/:1\1/g; y/_/0/; # #
                       bd;  :x  s/.*::([^:]+):/\1/;
                       # # # # # # #  # # # # # # #
```
This is similar to <https://codegolf.stackexchange.com/a/38087/11259>, which simply increments numbers in a string. But instead it does the increment operations in a loop.
Input is taken from STDIN in the form "x y". That is first transformed to "x:0::y:". Then we increment all numbers that come after ":" characters, until we get "x:x::(x+y):". Then we finally return (x+y).
# Output
```
$ printf "%s\n" "0 0" "0 1" "1 0" "9 999" "999 9" "12345 67890" "123 1000000000000000000000"  | sed -rf add.sed
0
1
1
1008
1008
80235
1000000000000000000123
$
```
Note that this only works for the natural numbers. However (in theory at least) it works for arbitrarily large integers. Because we are doing x increment operations on y, ordering can make a big difference to speed: x < y will be faster than x > y.
[Answer]
# [Dash](https://wiki.debian.org/Shell), 18 bytes
```
time -f%e sleep $@
```
Requires GNU time 1.7 or higher. Output is to STDERR.
[Try it online!](https://tio.run/##S0kszvj/vyQzN1VBN001VaE4JzW1QEHF4f///4b/jQA "Dash – Try It Online")
Note that this will not work in **B**​ash, since its builtin time command differs from GNU time.
At the cost of one additional byte, `\time` can be used instead of `time` to force Bash to use the external command.
[Answer]
# Smalltalk, 21 13
All of the following only work on positive integers. See the ***other Smalltalk*** answer for a serious one.
### version1
shifting to a large integer and asking it for its high bit index (bad, ST indexing is 1-based, so I need an additional right shift):
```
(((1<<a)<<b)>>1)highBit
```
### version2
similar, and even a bit shorter (due to Smalltalk precedence rules, and no right shift needed):
```
1<<a<<b log:2 
```
### version3
another variation of the "collection-concatenating-asking size" theme,  
given two numbers a and b,
```
((Array new:a),(Array new:b)) size
```
using Intervals as collection, we get a more memory friendly version ;-) in 21 chars:
```
((1to:a),(1to:b))size
```
not recommended for heavy number crunching, though.
### version4
For your amusement, if you want to trade time for memory, try:
```
Time secondsToRun:[
   Delay waitForSeconds:a.
   Delay waitForSeconds:b.
]
```
which is usually accurate enough (but no guarantee ;-)))
### version5
write to a file and ask it for its size
```
(
    [
        't' asFilename 
            writingFileDo:[:s |
                a timesRepeat:[ 'x' printOn:s ].
                b timesRepeat:[ 'x' printOn:s ]];
            fileSize 
    ] ensure:[
        't' asFilename delete
    ]
) print
```
[Answer]
## Javascript (67)
There is probably much better
```
a=Array;p=Number;r=prompt;alert(a(p(r())).concat(a(p(r()))).length)
```
[Answer]
Ruby, 18 chars 
```
a.times{b=b.next}
```
And two more verbose variants, 29 chars 
```
[*1..a].concat([*1..b]).size
```
Another version, 32 chars 
```
(''.rjust(a)<<''.rjust(b)).size
```
[Answer]
# Ruby 39
```
f=->a,b{[*1..a].concat([*1..b]).length}
```
[Answer]
# C# - on the fly code generation
Yeah, there is actually an addition in there, but not the + operator and not even a framework function which does adding, instead we generate a method on the fly that does the adding.
```
public static int Add(int i1, int i2)
{
    var dm = new DynamicMethod("add", typeof(int), new[] { typeof(int), typeof(int) });
    var ilg = dm.GetILGenerator();
    ilg.Emit(OpCodes.Ldarg_0);
    ilg.Emit(OpCodes.Ldarg_1);
    ilg.Emit(OpCodes.Add);
    ilg.Emit(OpCodes.Ret);
    var del = (Func<int, int, int>)dm.CreateDelegate(typeof(Func<int, int, int>));
    return del(i1, i2);
}
```
[Answer]
# K, 2 bytes
```
#&
```
Usage example:
```
  #&7 212
219
```
Apply the "where" operator (monadic `&`) to the numbers in an input list (possibly taking liberty with the input format). This will produce a list containing the first number of zeroes followed by the second number of ones:
```
  &3 2
0 0 0 1 1
```
Normally this operator is used as a "gather" to produce a list of the indices of the nonzero elements of a boolean list, but the generalized form comes in handy occasionally.
Then simply take the count of that list (monadic `#`).
If my interpretation of the input requirements is unacceptable, the following slightly longer solution does the same trick:
```
{#&x,y}
```
[Answer]
## R 36
```
function(x,y)length(rep(1:2,c(x,y)))
```
where `rep` builds a vector of `x` ones followed by `y` twos.
[Answer]
# TI Basic 89 - 19 bytes
Run this in your TI-89 (Home screen or programming app):
```
ln(ln((e^e^x)^e^y))
```
This uses log rules to compute `x+y`, just like in [this solution](https://codegolf.stackexchange.com/a/21033/9498). As a bonus, it works for decimal and integer numbers. It works for all real numbers. If the logarithm rules are still valid with complex exponents, then this works for complex numbers too. However, my calculator spits out junk when I try to insert complex exponents.
[Answer]
Thanks to [Michael Stern for teaching me Mathematica notation](https://codegolf.stackexchange.com/questions/20996/add-without-addition-or-any-of-the-4-basic-arithmetic-operators/21033?noredirect=1#comment42342_21033).
# Mathematica - ~~21~~ 20 bytes
```
Log@Log[(E^E^x)^E^y]
```
This uses the same approach as [this solution](https://codegolf.stackexchange.com/a/21033/9498), but it is in Mathematica to make it shorter. This works for negative and floating point numbers as well as integers in `x` and `y`.
Simplifying the expression using log rules yields `x+y`, but this is valid since it uses exponentiation, not one of the 4 basic operators.
[Answer]
# C# - string arithmetics
We convert both numbers to strings, do the addition with string cutting (with carry and everything, you know), then parse back to integer. Tested with i1, i2 in 0..200, works like a charm. Find an addition in this one!
```
public static int Add(int i1, int i2)
{
    var s1 = new string(i1.ToString().Reverse().ToArray());
    var s2 = new string(i2.ToString().Reverse().ToArray());
    var nums = "01234567890123456789";
    var c = '0';
    var ret = new StringBuilder();
    while (s1.Length > 0 || s2.Length > 0 || c != '0')
    {
        var c1 = s1.Length > 0 ? s1[0] : '0';
        var c2 = s2.Length > 0 ? s2[0] : '0';
        var s = nums;
        s = s.Substring(int.Parse(c1.ToString()));
        s = s.Substring(int.Parse(c2.ToString()));
        s = s.Substring(int.Parse(c.ToString()));
        ret.Append(s[0]);
        if (s1.Length > 0)
            s1 = s1.Substring(1);
        if (s2.Length > 0)
            s2 = s2.Substring(1);
        c = s.Length <= 10 ? '1' : '0';
    }
    return int.Parse(new string(ret.ToString().ToCharArray().Reverse().ToArray()));
}
```
[Answer]
# C (79)
```
void main(){int a,b;scanf("%d%d",&a,&b);printf("%d",printf("%*c%*c",a,0,b,0));}
```
[Answer]
# Python -- 22 characters
```
len(range(x)+range(y))
```
[Answer]
**APL: 2**
```
1⊥
```
This converts the numbers from base 1, so (n\*1^1)+(m\*1^2) which is exactly n+m.
Can be tried on [TryApl.org](http://TryApl.org)
[Answer]
## TI-BASIC, 10
Adds `X` and `Y`
```
ln(ln(e^(e^(X))^e^(Y
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 29 bytes
```
AQW!qG0=k.&GH=HxGH=k.<k1=Gk)H
```
[Try it online!](https://tio.run/##K6gsyfj/3zEwXLHQ3cA2W0/N3cPWowJIZOvZZBvaumdrevz/r2FooGOsCQA "Pyth – Try It Online")
My first submission here!
This compiles to:
```
assign('Q',eval_input())     # Q
assign('[G,H]',Q)            #A
while Pnot(equal(G,0)):      #  W!qG0
  assign('k',bitand(G,H))    #       =k.&GH
  assign('H',index(G,H))     #             =HxGH  (index in this case is XOR)
  assign('k',leftshift(k,1)) #                  =k.<k1
  assign('G',k)              #                        =Gk)
imp_print(H)                 #                            H
```
]