[Question]
  [
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
 
 
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/4029/edit).
Closed 1 year ago.
The community reviewed whether to reopen this question 1 year ago and left it closed:
> 
> Original close reason(s) were not resolved
> 
> 
> 
[Improve this question](/posts/4029/edit) 
There have been many "Do \_\_ without *\_*\_" challenges before, but I hope that this is one of the most challenging.
## The Challenge
You are to write a program that takes two natural numbers (whole numbers > 0) from STDIN, and prints the sum of the two numbers to STDOUT. The challenge is that you must use as few `+` and `-` signs as possible. You are not allowed to use any sum-like or negation functions.
**Examples** 
input
```
123
468
```
output
```
591
```
input
```
702
720
```
output
```
1422
```
**Tie Breaker:**
If two programs have the same number of `+` and `-` characters, the winner is the person with fewer `/` `*` `(` `)` `=` `.` `,` and `0-9` characters.
**Not Allowed:** Languages in which the standard addition/subtraction and increment/decrement operators are symbols other than `+` or `-` are not allowed. This means that Whitespace the language is not allowed.
  
[Answer]
# R (24 characters)
```
length(sequence(scan()))
```
What this does:
* `scan` reads input from STDIN (or a file)
* `sequence` generates integer sequences starting from 1 and concatenates the sequences. For example, `sequence(c(2, 3))` results in the vector `1 2 1 2 3`
* `length` calculates the number of elements in the concatenated vector
Example 1:
```
> length(sequence(scan()))
1: 123
2: 468
3:
Read 2 items
[1] 591
```
Example 2:
```
> length(sequence(scan()))
1: 702
2: 720
3:
Read 2 items
[1] 1422
```
[Answer]
## Perl (no +/-, no tie-breakers, 29 chars)
```
s!!xx!;s!x!$"x<>!eg;say y!!!c
```
As a bonus, you can make the code sum more than two numbers by adding more `x`s to the `s!!xx!`.
Alternatively, here are two 21-char solutions with 1 and 3 tie-breakers respectively
```
say length$"x<>.$"x<>
say log exp(<>)*exp<>
```
Note: These solutions use the `say` function, available since Perl 5.10.0 with the `-E` command line switch or with `use 5.010`. See the [edit history of this answer](https://codegolf.stackexchange.com/posts/4047/revisions) for versions that work on older perls.
---
How does the solution with no tie-breakers work?
* `s!!xx!` is a [regexp replacement operator](http://perldoc.perl.org/perlop.html#s/PATTERN/REPLACEMENT/msixpodualgcer), operating by default on the `$_` variable, which replaces the empty string with the string `xx`. (Usually `/` is used as the regexp delimiter in Perl, but really almost any character can be used. I chose `!` since it's not a tie-breaker.) This is just a fancy way of prepending `"xx"` to `$_` — or, since `$_` starts out empty (undefined, actually), it's really a way to write `$_ = "xx"` without using the equals sign (and with one character less, too).
* `s!x!$"x<>!eg` is another regexp replacement, this time replacing each `x` in `$_` with the value of the expression `$" x <>`. (The `g` switch specifies global replacement, `e` specifies that the replacement is to be evaluated as Perl code instead of being used as a literal string.) `$"` is a [special variable](http://perldoc.perl.org/perlvar.html#$LIST_SEPARATOR) whose default value happens to be a single space; using it instead of `" "` saves one char. (Any other variable known to have a one-character value, such as `$&` or `$/`, would work equally well here, except that using `$/` would cost me a tie-breaker.) The `<>` [line input operator](http://perldoc.perl.org/perlop.html#I%2fO-Operators), in scalar context, reads one line from standard input and returns it. The `x` before it is the Perl [string repetition operator](http://perldoc.perl.org/perlop.html#Multiplicative-Operators), and is really the core of this solution: it returns its left operand (a single space character) repeated the number of times given by its right operand (the line we just read as input).
* `y!!!c` is just an obscure way to (ab)use the [transliteration operator](http://perldoc.perl.org/perlop.html#tr/SEARCHLIST/REPLACEMENTLIST/cdsr) to count the characters in a string (`$_` by default, again). I could've just written `say length`, but the obfuscated version is one character shorter. :)
[Answer]
## D
```
main(){
    int a,b;
    readf("%d %d",&a,&b);
    while(b){a^=b;b=((a^b)&b)<<1;}
    write(a);
}
```
bit twiddling for the win
as a bonus the compiled code doesn't contain a add operation (can't speak for the readf call though)
[Answer]
# Python 2, 43 bytes
```
print len('%s%s'%(input()*'?',input()*'!'))
```
[Answer]
# [Seed](https://github.com/TryItOnline/seed), ~~3904~~ ~~3846~~ 11 bytes, 0 +/-, 10 tie breakers
```
4 141745954
```
[Answer]
C (32bit only)
```
int main(int ac, char *av) {
    scanf("%d\n%d", &ac, &av);
    return printf("%d\n", &av[ac]);
}
```
Pointer arithmetic is just as good.  
How does it match the requirements?  
\* No `+` or `-`  
\* No `/`, `=`, `.`, `0`-`9`  
\* Only 3 pairs of parenthesis, which seems to me minimal (you need `main`, `scanf`, `printf`).  
\* One `*` (the pointer approach requires it).  
\* Four `,` (could save one by defining normal variables, not `ac,av`)
[Answer]
## C++ 0 +/-, 3 tie-breakers
```
#include <vector>
#include <iostream>
#define WAX (
#define WANE )
#define SPOT .
int main WAX WANE {
    unsigned x;
    unsigned y;
    std::cin >> x >> y;
    std::vector<int> v WAX x WANE;
    std::vector<int> u WAX y WANE;
    for WAX auto n : u WANE {
        v SPOT push_back WAX n WANE;
    }
    std::cout << v SPOT size WAX WANE;
}
```
[Answer]
### GolfScript
No +/- or tie-breakers:
```
# Twiddle some bits to get a few small integers
[]!~abs:two~abs:three!:zero~:minusone;
~[two base minusone%\two base minusone%]zip
zero:c;
{
    # Stack holds [x y] or [x] with implicit y is zero
    # Half adder using x y c: want to end up with sum on stack and carry back in c
    [~c zero]three<zero$
    ~^^\
    $~;:c;;
}%
[~c]minusone%two base
```
Much simpler version with two tie-breaker characters, using the same list-concatenation trick that other people are using:
```
~[\]{,~}%,
```
I'm assuming that GolfScript isn't disqualified for having `)` as an increment operator, as I'm not actually using it.
[Answer]
# Haskell, 0+2
```
import Monad
main = join $ fmap print $ fmap length $ fmap f $ fmap lines getContents
f x = join $ flip replicate [] `fmap` fmap read x
```
This uses no `+` or `-` characters, and only two `=` from the set of tie breaker characters, one of which is mandatory for binding `main`. The sum is done by concatenating lists of the appropriate lengths.
[Answer]
I didn't see anyone do it the Electrical Engineering way, so here's my take (in ruby):
```
def please_sum(a, b)
    return (a&b !=0)? please_sum( ((a&b)<<1) , a^b ):a^b
end
```
It is a little bit ugly, but it gets the job done. The two values are compared by a bitwise `AND`. If they don't have any bits in common, there is no "carry" into the next binary column, so the addition can be completed by bitwise `XOR`ing them. If there is a carry, you have to add the carry to the bitwise `XOR`. Here's a little ruby script I used to make sure my digital logic was not too rusty:
```
100.times do
    a=rand 10
    b=rand 10
    c=please_sum(a,b)
    puts "#{a}+#{b}=#{c}"
    end
```
Cheers!
[Answer]
**EDIT** This was posted BEFORE the rules changed to disallow `sum`...
The R language: No calls to `+` or `-`... And 9 tie-breaker characters!
```
sum(as.numeric(readLines(n=2)))
```
Example:
```
> sum(as.numeric(readLines(n=2)))
123
456
[1] 579
```
The `[1] 579` is the answer 579 (the `[1]` is to keep track of where in the result vector your are since in R all values are vectors - in this case of length 1)
Note that R has `+` operators just like most languages - it just so happens that it has `sum` too that sums up a bunch of vectors.
In this case, `readLines` returns a string vector of length 2. I then coerce it to numeric (doubles) and sum it up...
Just to show some other features of R:
```
> 11:20 # Generate a sequence
 [1] 11 12 13 14 15 16 17 18 19 20
> sum(1:10, 101:110, pi)
[1] 1113.142
```
[Answer]
# The R language
New rules, new answer, same language. No calls to `+` or `-`
**UPDATE** Using `scan`, it drops to 11 tie-breaker characters (and 27 characters in all).
```
as.numeric(scan())%*%c(1,1)
```
Original: 13 tie-breaker characters!
```
as.numeric(readLines(n=2)) %*% c(1,1)
```
Example:
```
> as.numeric(readLines(n=2)) %*% c(1,1)
123
456
     [,1]
[1,]  579
```
This time the result is achieved by matrix multiplication. The answer is displayed as a 1x1 matrix.
[Answer]
# Haskell, 0 `+`/`-`, ~~6~~ 2 tie-breakers (`=`)
## (does not use the string/list concatenation trick)
```
main = interact f
f x = show $ log $ product $ map exp $ map read $ lines x
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 4 bytes, 0 `+`/`-`
```
F>
```
[Try it online!](https://tio.run/##yy9OTMpM/f/fze7/f3MjAy4gBgA "05AB1E – Try It Online")
Apologies if I misunderstood this challenge, but I was
surprised there was no 05AB1E answer. Shortest answer in
this language I could come up with that doesn't use + or
the built in sum function.
Explanation:
```
 F   #Loop A many times
  >  #Increment B
     #(Implicit output)
```
*-2 Bytes thanks to Grimy.*
[Answer]
# Excel, ~~(25, 8) (22, 6)~~ 13, 4 tie-breakers
Inputs are `A1`, `A2`.
```
=2*MEDIAN(A:A
^^^      ^
```
Because `MEDIAN` is shorter than `AVERAGE` and `AGGREGATE`.
[Answer]
# [Python 3](https://docs.python.org/3/), 64 62 bytes
Without relying on hidden summations in other functions.
```
x=int(input());y=int(input())
while y:x,y=x^y,(x&y)*2
print(x)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v8I2M69EIzOvoLREQ1PTuhKFy1WekZmTqlBpVaFTaVsRV6mjUaFWqallxFVQBFJWofn/v7ERl4kJAA "Python 3 – Try It Online")
[Answer]
**Javascript, 56**
```
p=prompt;alert(Array(~~p()).concat(Array(~~p())).length)
```
Thanks to @JiminP on the ~~ tip! I'm going for least bytes, so the 1 byte saving on the p=prompt; is still worth it. I understand your argument about tie-breaker chars, but to be honest wouldn't you rather the least bytes :-p
**Version, 69**
```
i=parseInt;p=prompt;alert(Array(i(p())).concat(Array(i(p()))).length)
```
Thanks to some feedback from @Ilmari and @JiminP, I've shaved 13 bytes off my original solution.
*Originally, 82*
```
i=parseInt;p=prompt;a=Array(i(p()));a.push.apply(a, Array(i(p())));alert(a.length)
```
[Answer]
## C
```
b[500];i;j;main(){scanf("%d%d",&i,&j);printf("%d\n",sprintf(b,"%*s%*s",i,"",j,""));
```
[Answer]
## Javascript (17 tie-breaker characters)
```
eval('걢갽거걲걯걭거건갨걡갽거걲걯걭거건갨걹갽걦걵걮걣건걩걯걮갨걡갩걻걣갽걮걥걷갠걕걩걮건갸걁걲걲걡걹갨걡갩갻걦걯걲갨걩갠걩걮갠걣갩걩걦갨걩갽갽걾걾걩갩걸갮거걵걳걨갨갱갩걽갬걸갽걛걝갩갩갻걹갨걡갩갻걹갨걢갩갻걡걬걥걲건갨걸갮걬걥걮걧건걨갩갻'['split']('')['map'](function(_){return String['fromCharCode'](_['charCodeAt'](~~[])^0xac00)})['join'](''))
```
:P ("Obfuscated" to reduce number of tie-breaker characters. Internally, it's
`b=prompt(a=prompt(y=function(a){c=new Uint8Array(a);for(i in c)if(i==~~i)x.push(1)},x=[]));y(a);y(b);alert(x.length);`
.)
[Answer]
## APL (no +/-, no tie breakers, 8 or 10 characters)
This entry is similar to the other ones that concatenate sequences generated from the input and find the length... but it's in APL, which can appear confusing even for a small problem like this. I used [Dyalog APL](http://www.dyalog.com), which offers a free educational license.
Code:
```
⍴⊃⍪⌿⍳¨⎕⎕
```
From right to left:
* Each quote-quad ( `⎕` ) requests input from the user and evaluates it.
* The each operator ( `¨` ) applies the index generator function ( `⍳` ) to each of the items in the array to its right.
* This flattens the resulting array of arrays into one array. The input array is reduced to a flat list by the reduction operator ( `/` ), which folds the array using the concatenation function ( `,` ). For the sake of this challenge, the one-dimensional reduction operator ( `⌿` ) is used, along with the concatenation operator along the first axis ( `⍪` ).
* As a result of using the reduction operator, the array is *enclosed*, which is like placing it in the bag; all we see on the outside is a bag, not its contents. The disclose operator ( `⊃` ) gives us the contents of the enclosed array (the bag).
* Finally, the shape-of function ( `⍴` ) gives us the lengths of the dimensions of an array. In this case, we have a one-dimensional array, so we obtain the number of items in the array, which is our result.
If we need to explicitly output the result, we can do so like this:
```
⎕←⍴⊃⍪⌿⍳¨⎕⎕
```
Comparable Python code, with corresponding APL symbols above:
```
import operator
⎕←     ⍴    ⌿        ⍪                 ¨              ⍳                ⎕        ⎕         ⊃
print (len (reduce (operator.__add__, [map (lambda n: range (1, n+1), [input(), input()])][0])))
```
I'd like to know if there's a shorter version possible in APL - another, simpler version I came up with that has more tie breakers (although still at 8 characters) is: `⍴(⍳⎕),⍳⎕`.
[Answer]
# [Befunge-93](https://github.com/catseye/Befunge-93), 0 `+-` characters, 0 tiebreakers, 33 bytes
```
"e:"%"X:"%::%p"h:"%"Y:"%::%p&&  @
```
[Try it online!](https://tio.run/##S0pNK81LT/3/XynVSklVKQJIWFmpFihlgHiRUJ6amoKCw///5gZGCuZGBgA)
### Explanation
Like @negative seven's Befunge answer, we generate `+` and `.` at runtime and put them onto the field to be executed. However, Befunge-93 does not include the `y` instruction, so we abuse the `%` modulo operator instead.
```
"e:"%                                            # Calculate 101 ('e') mod 58 (':') to get 43 ('+')
     "X:"%                                       # Calculate 88 ('X') mod 58 to get 30
          ::%                                    # Calculate 30 mod 30 to get 0
             p                                   # Put character 43 ('+') at position (30, 0)
              "h:"%                              # Calculate 104 ('h') mod 58 to get 46 ('.')
                   "Y:"%                         # Calculate 89 ('Y') mod 58 to get 31
                        ::%                      # Calculate 31 mod 31 to get 0
                           p                     # Put character 46 ('.') at position (31, 0)
                            &&                   # Get two numbers from STDIN
                              (changed to '+')   # Add the numbers together
                               (changed to '.')  # Output the result
                                @                # End the program
```
[Answer]
# Scala 2.12, 20 bytes, 0 +/- signs
```
readInt\u002breadInt
```
The unicode literal is just turned into a `+` before compilation
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `as`, 0 bytes
[Try it Online!](http://lyxal.pythonanywhere.com?flags=as&code=&inputs=12%0A24&header=&footer=)
The `a` flag takes newline separated inputs as a list, and the `s` flag sums the top of the stack.
# Non-trivial `a`, ~~4~~ 2 bytes
*-2 bytes because I realized the challenge guarantees 2 number input.*
```
ṁd
```
[Try it Online!](http://lyxal.pythonanywhere.com/?flags=a&code=%E1%B9%81d&inputs=12%0A24&header=&footer=)
Explanation:
```
    # 'a' flag - take newline separated inputs as a list
ṁ   # Mean of inputs
 d  # Multiply by 2
    # Implicit output
```
Effectively calculates `((a + b) / 2) * 2`, which is equivalent to `a + b`. The previous version worked for any amount of numbers, but it turns out the challenge specifies taking 2 numbers as input, so this works fine.
[Answer]
## Shell, 52
```
read a
read b
(seq 1 $a;seq 1 $b)|wc|awk '{print$1}'
```
This is basically the [same answer](https://stackoverflow.com/a/4765078/149391) I gave for another problem.
[Answer]
## C
```
a,b;A(int a,int b){return a&b?A(a^b,(a&b)<<1):a^b;}
main(){scanf("%d%d",&a,&b);printf("%d\n",A(a,b));}
```
[Answer]
**C#**
It's not the shortest by any stretch:
```
private static int getIntFromBitArray(BitArray bitArray)
{
    int[] array = new int[1];
    bitArray.CopyTo(array, 0);
    return array[0];
}
private static BitArray getBitArrayFromInt32(Int32 a)
{
    byte[] bytes = BitConverter.GetBytes(a);
    return new BitArray(bytes);
}
static void Main(string[] args)
{
    BitArray first = getBitArrayFromInt32(int.Parse(Console.ReadLine()));
    BitArray second = getBitArrayFromInt32(int.Parse(Console.ReadLine()));
    BitArray result = new BitArray(32);
    bool carry = false;
    for (int i = 0; i < result.Length; i++)
    {
        if (first[i] && second[i] && carry)
        {
            result[i] = true;
        }
        else if (first[i] && second[i])
        {
            result[i] = false;
            carry = true;
        }
        else if (carry && (first[i] || second[i]))
        {
            result[i] = false;
            carry = true;
        }
        else
        {
            result[i] = carry || first[i] || second[i];
            carry = false;
        }
    }
    Console.WriteLine(getIntFromBitArray(result));
}
```
[Answer]
# J, ~~15~~ 7 chars, 1 tie breaker, incomplete program
This is my J attempt. It is not a full program, because I have not yet figured out how to write one. Just put that line in a script to get the function `p` that can be used for adding an arbitrary amount of numbers. It is a monad and takes a list of numbers to add (such as `p 1 2 3 4`):
```
p=:#@#~
```
The idea is very simple. The function is written in tacit aka pointless style. Here is a pointed definition:
```
p=:3 :'##~y'
```
Read from right to left. In the tacit version, `@` composes the parts of the function. (like a ∘ in mathematics [(f∘g)(x) = f(g(x)])
* `y` is the parameter of `p`.
* `~` makes a verb reflexive. For some verb `m`, `m~ a` is equal to `a m a`.
* `#` (copy, `a#b`): Each element in `a` is replicated `i` times, where `i` is the element at the same index as the current element of `a` of `b`. Thus, `#~` replicates an item `n` `n` times.
* `#` (count, `#b`): Counts the number of elements in `b`.
Conclusion: J is awsome and less readable than Perl (that makes it even more awsome)
## Edits
* 15 -> 7 using `#` instead of `i.`. Yeah! Less chars than golfscript.
## More of a program
This one queries for input, but it still isn't a full program: (13 chars, 3 breakers)
```
##~".1!:1<#a:
```
[Answer]
# C#,
Program works on 1 line; separated on multiple lines to avoid horizontal scrolling. 
```
using C=System.Console;
class A{
static void Main(){
int a,b,x,y;
a=int.Parse(C.ReadLine());
b=int.Parse(C.ReadLine());
do{x=a&b;y=a^b;a=x<<1;b=y;}while(x>0);
C.WriteLine(y);
}}
```
[Answer]
# C++, () only for `main`
```
#include <iostream>
int main()
{
    unsigned int a, b;
    std::cin >> a;
    std::cin >> b;
    unsigned int p = a ^ b;
    unsigned int g = a & b;
    unsigned int gg {g | p & g << 1};
    unsigned int pp {p & p << 1};
    unsigned int ggg {gg | pp & gg << 2};
    unsigned int ppp {pp | pp << 2};
    unsigned int gggg {ggg | ppp & ggg << 4};
    unsigned int pppp {ppp & ppp << 4};
    unsigned int ggggg {gggg | pppp & gggg << 8};
    unsigned int ppppp {pppp | pppp << 8};
    unsigned int gggggg {ggggg | ppppp & ggggg << 16};
    unsigned int result {a ^ b ^ gggggg << 1};
    std::cout << result;
}
```
Assumes 32-bit unsigned ints. Very ugly code to remove tiebreak characters. Emulates a Kogge-Stone adder.
[Answer]
# Octave/MATLAB, 37 bytes
```
f=@()e^(input(''));disp(log(f()*f()))
```
[Try it online!](https://tio.run/##y08uSSxL/f8/zdZBQzM1TiMzr6C0RENdXVPTOiWzuEAjJz9dI01DUwuINTX//zcx4jI2BgA "Octave – Try It Online")
]