41
\$\begingroup\$

Input: Two integers. Preferably decimal integers, but other forms of numbers can be used. These can be given to the code in standard input, as arguments to the program or function, or as a list.

Output: Their sum. Use the same format for output integers as input integers. For example, the input 5 16 would lead to the output 21.

Restrictions: No standard loopholes please. This is , answer in lowest amount of bytes wins.

Notes: This should be fairly trivial, however I'm interested to see how it can be implemented. The answer can be a complete program or a function, but please identify which one it is.

Test cases:

1 2 -> 3
14 15 -> 29
7 9 -> 16
-1 8 -> 7
8 -9 -> -1
-8 -9 -> -17

Or as CSV:

a,b,c
1,2,3
14,15,29
7,9,16
-1,8,7
8,-9,-1
-8,-9,-17

Leaderboard

var QUESTION_ID=84260,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

\$\endgroup\$
  • 26
    \$\begingroup\$ This is quite trivial, but not really simpler than, e.g., the Hello World catalog. Given that the ability to add integers is one of our two requirements for programming languages, I'd say it's worthwhile to have if properly specified. \$\endgroup\$ – Dennis Jul 2 '16 at 0:48
  • 1
    \$\begingroup\$ Can the answer take input with preceding zeros as default? e.g. 5 16 is inputted as 005 016 \$\endgroup\$ – FinW Dec 4 '16 at 11:56
  • \$\begingroup\$ @FinW Sure. As long as they don't get interpreted as octal. \$\endgroup\$ – dkudriavtsev Dec 4 '16 at 20:47

180 Answers 180

1
\$\begingroup\$

7, 8 bytes, 22 characters

1717023740344172360303

Try it online!

This program is encoded on disk as (xxd hexdump):

00000000: 3cf0 9f81 c87a 7830                      <....zx0

7 doesn't really support numbers natively, and thus it's hard to define what a number is for the purpose of a function submission. As such, this is a full program, reading from stdin, outputting to stdout (which explains where much of the length comes from).

This program doesn't support negative numbers, because 7 can't input those using numeric I/O (although it can output them). As such, supporting negative numbers would require the use of character input (and a decimal→integer parser), which would make the program much, much more complex.

Explanation

1717023740344172360303
 7 7   7                Stack element separators
1 1 023                 Initial stack
        40344172360303  Initial program (also stored on the stack)
(Implicit: run the initial program, but leave it on the stack)
        4               Swap with blank element between
         0              Escape top stack element, append it to element below

So at this point, we've effectively swapped the program below the 023 element, escaping that element in the process. The 023 is a program in a domain-specific I/O language; and putting the program as the second stack element means that we can discard it (the second stack element is the only one that can be discarded).

          3             Do I/O using top element, discard second element
    0                   Set I/O format: numeric in decimal
     23                 Input via repeating the third stack element

We now have only two stack elements; 1 at the bottom, and the first input in unary just above it (because we repeated the second-last stack element, which was 1, and thus will have a number of 1s).

           4            Swap with blank element between
            4           Swap with blank element between
             172360     Append an escaped representation of "23" to TOS
                   3    Do I/O using top element, discard second element
               23       Input via repeating the third stack element

So now our stack consists of the first input (in unary) directly below the second stack element (in unary).

                    0   Escape top element, appending it to the element below
                     3  Do I/O using top element, and exit

The 3 command exits the program as we're out of stack, but not before it outputs the number we calculated. The number in question will consist of a number of 7s equal to the first number input, followed by a number of 1s equal to the second number input (these are the unescaped and escaped representations of the same command). Numeric I/O treats 1 and 7 as equivalent, and having a value of +1; thus, the unary number gets translated into decimal and output.

\$\endgroup\$
1
\$\begingroup\$

Burlesque - 4 bytes

ps++

ps   parse
  ++ sum

Try it online.

\$\endgroup\$
  • \$\begingroup\$ How does this work? Can you link to an interactive demo and / or provide instructions on how to execute it? \$\endgroup\$ – Οurous Nov 18 '18 at 21:57
  • 1
    \$\begingroup\$ ps parses the input into a list and ++ computes the sum of a list. I added a link to the online interpreter. \$\endgroup\$ – mroman Nov 18 '18 at 22:10
1
\$\begingroup\$

Aheui (esotope), 15 bytes(5 characters)

방방다망히

Try it online!


Meet Aheui(아희), A Korean alphabet-based esoteric programming language.

\$\endgroup\$
1
\$\begingroup\$

RUST, 29 bytes

Save 5 bytes thank to ASCII-only

Try this on line

fn s(a:i32,b:i32)->i32{a+b}

ASCII-only also beat my solution here

\$\endgroup\$
  • 1
    \$\begingroup\$ 8, also you have unneeded spaces anyway \$\endgroup\$ – ASCII-only Jan 29 at 7:48
  • \$\begingroup\$ @ASCII-only Thank you a lot for your solution. \$\endgroup\$ – chau giang Jan 29 at 8:00
  • \$\begingroup\$ You forgot to rename the function \$\endgroup\$ – ASCII-only Jan 29 at 8:02
  • 1
    \$\begingroup\$ lol, now it's 27 bytes not 29 \$\endgroup\$ – ASCII-only Jan 29 at 8:10
  • \$\begingroup\$ @ASCII-only, thank you, I just updated it, I count all bytes with my eyes so maybe I was wrong \$\endgroup\$ – chau giang Jan 29 at 8:12
1
\$\begingroup\$

BitCycle, 49 bytes

?Av
?v<>  \Cv
~=B/Av
 ^+  <
+ B\^v /~v
   >  /! <

Try it online!

Made so much more complicated by the signed numbers, otherwise it could just be:

?!
?^

This takes input and outputs as signed unary, though the -U flag is used to translate to decimal.

Explanation:

?Av  From input 1
?v<  And input 2
~=B  Push positive numbers into the top B collector
 ^
+ B  Invert bits of negative numbers and push into the bottom B collector
   >   \   Filter one bit from each collector
  B/Av     And the rest go into the A collector
  +  <     And then back into the B collectors
  B\^      If both positive and negative, then both bits are destroyed
   >   /   Otherwise they reflect off the > and go right of each of the \/
   >   \Cv    Collect the remainder of negative bits in the C collector

              Invert the bits and output
      v /~v   Send one of the 0s to output to represent a negative number
   >   /! <   Positive remainders go straight to output
\$\endgroup\$
1
\$\begingroup\$

Intel 8080 machine code, Altair 8800, 22 bytes

This will add two integers of nearly any size (16, 32, 64-bit, etc) using an Intel 8080 8-bit CPU (c. 1974). This is implemented as a full program, running on a MITS Altair 8800.

Code listing and programming instructions:

Step    Switches 0-7    Control Switch  Instruction Comment
1                       RESET
2       00 001 110      DEPOSIT         MVI  C, 2   ; loop counter set to word size
3       00 000 010      DEPOSIT NEXT                ; value is 2
4       00 010 001      "               LXI  D, 16H ; load address of first term into E:D
5       00 010 110      "                           ; at memory address 16H
6       00 000 000      "          
7       00 100 001      "               LXI  H, 18H ; load address of second term into H:L
8       00 011 000      "                           ; memory address 16H + word size = 18H
9       00 000 000      "          
10      10 101 111      "               XRA  A      ; clear accumulator
11      00 011 010      "               LOOP:LDAX D ; load [E:D] into A
12      10 001 110      "               ADC  M      ; add [H:L] + previous carry, to A
13      00 010 010      "               STAX D      ; store result in A to [E:D]
14      00 001 101      "               DCR  C      ; decrement loop counter
15      11 001 010      "               JZ   DONE   ; if counter is zero, end addition
16      00 010 101      "                           ; jump to step 23
17      00 000 000      "       
18      00 010 011      "               INX  D      ; first term next byte
19      00 100 011      "               INX  H      ; second term next byte
20      11 000 011      "               JMP  LOOP   ; restart loop
21      00 001 001      "                           ; jump to step 11
22      00 000 000      "           
23      01 110 110      "               DONE:HLT    ; halt CPU
24      00 001 110      "                           ; Term 1 low byte (14) 
25      00 000 000      "                           ; Term 1 high byte (0)
26      00 001 111      "                           ; Term 2 low byte (15)         
27      00 000 000      "                           ; Term 2 high byte (0)    
31                      RESET                       ; Reset program counter to beginning
32                      RUN
33                      STOP            
34      00 010 110      EXAMINE                     ; low byte of output displayed on D7-D0
35                      EXAMINE NEXT                ; high byte of output displayed on D7-D0

Try it online!

If entered correctly, RAM contents should look like:

0000    0e 02 11 16 00 21 18 00 af 1a 8e 12 0d ca 15 00 
0010    13 23 c3 09 00 76 0e 00 0f 00

I/O:

The above program adds two 16-bit integers, located in memory address 16H and 18H. This could accept larger integers, for example 32-bit integers by changing steps 3 and 8 to values 4 and 20H respectively, and then input would be in 16H and 20H. Numbers are represented in memory as little endian.

Output is displayed on lights D7-D0.

Example: 14 + 15 = 29 = 00 011 101

enter image description here

Example: 1234 + 4321 = 5555 = 00 010 101, 10 110 011

enter image description here

enter image description here

\$\endgroup\$
0
\$\begingroup\$

hashmap (Yes, the name starts with a lowercase letter.), 3 bytes

hh+
h   Take input
 h  Take input
  + Get the sum
\$\endgroup\$
0
\$\begingroup\$

C, 25 Bytes

p(a,b){printf("%d",a+b);}

Usage

p(a,b){printf("%d",a+b);}
main(c,v)char**v;{p(atoi(*++v),atoi(*++v));}

Or, if you want a full program: (+29 chars)

main(c,v)char**v;{printf("%d",atoi(*++v)+atoi(*++v));}

Take 2 arguments and outputs the results in STDOUT

\$\endgroup\$
  • \$\begingroup\$ You dont need to print it, a simple return will suffice. \$\endgroup\$ – Karl Napf Oct 27 '16 at 15:22
0
\$\begingroup\$

hashmap (non-competing)

Non-competing because I had to add a couple of new commands in.

i" "ĥdĐ+

Explanation:

i" "ĥdĐ+
i        Take input
 " "     Push space
    ĥ    Split the input by space
     dĐ  Convert the list to a double then flatten the list
       + Add them together
\$\endgroup\$
0
\$\begingroup\$

Maple, 3 bytes

`+`

Usage:

> `+`(1,2)
  3
\$\endgroup\$
0
\$\begingroup\$

Gema, 13 characters

* *=@add{*;*}

Sample run:

bash-4.3$ gema '* *=@add{*;*}' <<< '5 16'
21
\$\endgroup\$
0
\$\begingroup\$

golflua, 12 characters

\f(a,b)~a+b$

Sample run:

> \f(a,b)~a+b$ 
> w(f(5,16))
21
\$\endgroup\$
0
\$\begingroup\$

MoonScript, 10 characters

(a,b)->a+b

Sample run:

bash-4.3$ .luarocks/moon <(echo 'print ((a,b)->a+b)(5,16)')
21
\$\endgroup\$
0
\$\begingroup\$

SQF, 19

Using the function-as-a-file format:

params["x","y"];x+y

Call as: [X, Y] call NAME_OF_COMPILED_FUNCTION

\$\endgroup\$
0
\$\begingroup\$

S.I.L.O.S 38

readIO 
a = i
readIO 
a + i
printInt a


For documentation see the repo https://github.com/rjhunjhunwala/S.I.L.O.S Fee free to try this code online!

\$\endgroup\$
  • \$\begingroup\$ Perhaps you meant printInt instead of prinInt \$\endgroup\$ – Leaky Nun Aug 26 '16 at 15:29
  • \$\begingroup\$ How does it work? \$\endgroup\$ – Leaky Nun Aug 26 '16 at 15:39
  • \$\begingroup\$ @LeakyNun whoopsmy bad, fixing now \$\endgroup\$ – Rohan Jhunjhunwala Aug 26 '16 at 16:16
  • \$\begingroup\$ 2 bytes off \$\endgroup\$ – Leaky Nun Aug 26 '16 at 16:20
  • \$\begingroup\$ @LeakyNun thanks, you showed me a feature I didn't even know my language had! I though readIO must have a prompt after it! \$\endgroup\$ – Rohan Jhunjhunwala Aug 26 '16 at 16:21
0
\$\begingroup\$

Batch, 52 Bytes

set/p x=
set/p y=
set/a z=%x%+%y%
echo %z%
pause>nul

This is the lowest byte number you will have while still making the program work. I did the challenge by making a program, not just what the operation was. This method will allow you to input any number and then any other number, including negatives, and the program will output a number.

\$\endgroup\$
  • \$\begingroup\$ Is this a full program? I don't know batch but it looks like the numbers get inputted by editing the program rather than a prompt of some kind \$\endgroup\$ – Blue Jul 6 '16 at 16:32
  • \$\begingroup\$ Hey Nitrate. Welcome to PPCG. A few problems with this post: this is code-golf, which means you need to shorten your code to as short as possible. You don't have to take input like this - you could possibly take it as command line arguments to shorten it. Nice to see you here, m9. \$\endgroup\$ – Addison Crump Jul 6 '16 at 22:44
  • \$\begingroup\$ @muddyfish The /p switch allows you to set a variable equal to a line of input entered by the user. \$\endgroup\$ – Dennis Oct 18 '16 at 15:36
0
\$\begingroup\$

RubyGolf, 15 bytes

p gets.i+gets.i

code is so short it hit the character limit. ugh.

New language created by me, interpreter going up soon. non competing.

\$\endgroup\$
0
\$\begingroup\$

Y, 5 bytes

{α+β}

Anonymous function returning the sum of it first and second argument.

\$\endgroup\$
0
\$\begingroup\$

JavaScript, 27 bytes

function s(a,b){return a+b}

I thought this needed a semi-colon after the return statement, but when typing it into the Chrome Console, it works fine without.

\$\endgroup\$
  • \$\begingroup\$ a=>b=>a+b, but then it will be a duplicate \$\endgroup\$ – TuxCrafting Oct 27 '16 at 18:27
  • \$\begingroup\$ Also (a,b)=>a+b is better, but still, duplicate \$\endgroup\$ – Yotam Salmon Oct 30 '16 at 21:27
0
\$\begingroup\$

2 cases:

Pyth, 5 bytes

Input format: n1, n2

code: +hQeQ

Pyth, 1 byte

Input format: n1+n2

code: Q

(But I'm not sure if the second is called "cheating" :-P)

\$\endgroup\$
0
\$\begingroup\$

Java, 91 bytes

interface M{static void main(String[]a){System.out.print(new Long(a[0])+new Long(a[1]));}}

Usage: java M <num1> <num2>

Tips appreciated.

\$\endgroup\$
  • 1
    \$\begingroup\$ (a,b)->a+b as a lambda expression \$\endgroup\$ – Pavel Jan 9 '17 at 9:23
  • 1
    \$\begingroup\$ @Pavel Or a->b->a+b to save 1 more byte. \$\endgroup\$ – Kevin Cruijssen Sep 26 '17 at 15:07
0
\$\begingroup\$

PHP, 5 bytes

bcadd

PHP has the BC-Math library for arbitrary length integers.
bcadd adds the numbers represented by the two string operands.

A full program would need 21 bytes:

<?=$argv[1]+$argv[2];

alright 20 bytes with array_sum (assuming that the file name does not start with a digit).

\$\endgroup\$
0
\$\begingroup\$

Carrot, 5 bytes, non-competing

$^F+$

Try it online! (no permalink)

Input numbers are separated by a newline like so:

x
y

$ in c^rrot mode (the code before the first ^) pops the first value from the input array. So now the stack contains x. After that, this value is converted to a number using F. Then we add it with $, the next value in the input array, ie y. Output is implicit, so this outputs x+y.

An alternative at the cost of 1 byte would be:

#^A + 

note the trailing space

# takes all of the input (separated by a space), and converts it to an Array by splitting on s. Then encounter a +, which is given a as its argument, meaning that all the elements of the array will be summed up.

\$\endgroup\$
0
\$\begingroup\$

Billiards, 7 characters = 11 bytes, non-competing

Language made after the challenge.

↧ # Takes an input
↧ # Takes another input
+ # Adds them together
P # Outputs as an integer

Alternatively, for the same number of bytes:

↧↧ # Takes two inputs
+/ # Adds them together; the '/' deflects the second input into the '+'
P  # Output as an integer
\$\endgroup\$
0
\$\begingroup\$

Scala, 17 Bytes

x:Int=>y:Int=>x+y
\$\endgroup\$
0
\$\begingroup\$

REXX, 15 bytes

arg a b
say a+b
\$\endgroup\$
0
\$\begingroup\$

J, 4 bytes

I've defined a function f and set it to the built-in addition operator.

f=:+
\$\endgroup\$
0
\$\begingroup\$

AHK, 15 bytes

1+=%2%
Send,%1%

1 and 2 are, by default, the first two arguments passed in to a program. Sometimes you have to escape them with percent signs so it doesn't confuse the variable 1 with the number one.

\$\endgroup\$
0
\$\begingroup\$

Visual Basic.NET, 39 bytes

Function F(x,y)
Return x+y
End Function

Without Option Strict On (which you definitely want for any real coding), no data types are required (As type).

With Option Strict On:

Function F(x As Integer,y As Integer) As Integer
Return x+y
End Function
\$\endgroup\$
0
\$\begingroup\$

Decimal, 12 bytes

81D81D41D301

Explanation:

81D   ; builtin - read INT from STDIN, push to stack
81D   ; builtin - read INT from STDIN, push to stack
41D   ; math +, pop values used, push result
301   ; print from stack to STDOUT
\$\endgroup\$
  • \$\begingroup\$ TIO link coming as soon as the latest Decimal version is pulled to TIO. \$\endgroup\$ – MD XF Jun 4 '17 at 21:33

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.