A+B: Difference between revisions

=={{header|0815}}==

=={{header|11l}}==

{{trans|Python}}

=={{header|360 Assembly}}==

APLUSB CSECT

USING APLUSB,R12

YREGS

END APLUSB

{{in}}

<pre>

=={{header|8th}}==

=={{header|8080 Assembly}}==

which can take four forms:

dad d ; HL += DE

dad h ; HL += HL (also known as "mul HL by two")

Merely doing A+B, with 16-bit numbers so that <math>(-1000 \le A,B \le +1000)</math> will fit,

would look like this:

lxi d,456

dad d

Then, the following is what is required to wrap it all in a CP/M command line utility.

fits exactly in one CP/M block.

fcb2n: equ 6Ch+1 ; "Filename" in second FCB

puts: equ 9 ; CP/M call to write string to console

negf: db 0 ; Space for negative flag

db '-00000'

{{out}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program addAetB.s */

.align 4 // instruction to realign the following routines

=={{header|ABAP}}==

data: lv_output type i.

selection-screen begin of block input.

start-of-selection.

lv_output = p_first + p_second.

=={{header|Action!}}==

BYTE i

FOR i=1 TO s(0)

PutE();

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/A+B.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

with Ada.Integer_Text_Io;

Ada.Integer_Text_Io.Get (Item => B);

Ada.Integer_Text_Io.Put (A+B);

Using appropriate user defined types:

procedure A_Plus_B is

IO.Get (B);

IO.Put (A + B, Width => 4, Base => 10);

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

local f := trim( io.read() ) split " "; # read a line and split into fields

local a := tonumber( f[ 1 ] );

local b := tonumber( f[ 2 ] );

print( a + b )

=={{header|Aime}}==

list l;

f_list(f, l, 0);

o_integer(atoi(l[0]) + atoi(l[1]));

=={{header|ALGOL 60}}==

{{works with|A60}}

comment A+B;

integer a,b;

ininteger(0,a); ininteger(0,b);

outinteger(1,a+b)

{{in}}

<pre>

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - missing transput function "read int"}}

===Console===

Input:

<pre>

===File===

open(stand out, "output.txt", stand out channel);

Input "input.txt":

<pre>

=={{header|ALGOL W}}==

integer a, b;

read( a, b );

write( a + b )

=={{header|Amazing Hopper}}==

#include <hbasic.h>

Print("Suma : ", Token(1),Val(Token$(msg)) Plus (Token(2),Val(Token$(msg))), Newl)

End

{{out}}

<pre>

Version dos: hopper-BASIC acepta "programación fluída"

#include <hbasic.h>

Take(A, B), and Add It; then Print It with a Newl

End

{{out}}

<pre>

=={{header|Apex}}==

static Integer sumOfTwoNums(Integer A, Integer B) {

A = 50 and B = -25: 25

=={{header|APL}}==

=={{header|AppleScript}}==

Open the '''AppleScript Editor''' and save this as '''A+B.scpt''' on your Desktop

try

return ((first item of argv) as integer) + (second item of argv) as integer

return "Usage with -1000 <= a,b <= 1000: " & tab & " A+B.scpt a b"

end try

To make this run in Terminal open the '''Terminal.app''' and type

=={{header|Arc}}==

(prn (+ (read)

(read)))

=={{header|Argile}}==

{{trans|C}}

{{works with|Argile|1.0.0}}

use std, array

Cfunc scanf "%d%d" (&val int a) (&val int b)

(: Output file: output.txt :)

use std, array

fprintf out "%d\n" (x+y)

fclose in

=={{header|ARM Assembly}}==

Exploiting C standard library functions (scanf and printf).

Requires arm-linux-gnueabi-gcc and qemu-arm. Compile with:

.global main

.extern printf

.bss

num_a: .skip 4

{{works with|gcc|Linux}}

Save in ab.S

Build with:

.align 2

.code 32

movlt r0, #0

ldmfd sp!, {r7, pc}

=={{header|Arturo}}==

x: map split.words input "give me 2 numbers:" 'x -> to :integer x

print add x\0 x\1

]

{{out}}

=={{header|ATS}}==

(* ****** ****** *)

//

(* ****** ****** *)

=={{header|AutoHotkey}}==

This handles more than two inputs

Gui, Add, Button, gAdd, Add

Gui, Add, Edit, ReadOnly x+10 w80

GuiControl, Text, Edit2, %var% ;here it displays var in the second edit control

var := 0 ;here it makes sure var is 0 so it won't contain the value from the previous addition

=={{header|AutoIt}}==

$num = "45 54"

consolewrite ("Sum of " & $num & " is: " & sum($num))

$numm = StringSplit($numbers," ")

Return $numm[1]+$numm[$numm[0]]

===Example2===

This version can handle any amount of numbers in the input:

Func Sum($inp)

; so the program works correctly even with this input:

Local $inp = "999x y 42 -999", $res = Sum($inp)

{{Out}}

<pre>

=={{header|AWK}}==

=={{header|BASIC}}==

tryagain:

ELSE

GOTO tryagain

==={{header|Applesoft BASIC}}===

20 INPUT ""; A$ : I$ = A$ : VTAB BH : A = PEEK(40) + PEEK(41) * 256 : FOR S = 0 TO 39 : IF PEEK(A + S) = 160 THEN NEXT S : S = 0

40 IF LEN(I$) THEN IF MID$(I$, LEN(I$), 1) = " " THEN I$ = MID$(I$, 1, LEN(I$) - 1) : GOTO 40RTRIM

100 VTAB BH

110 HTAB LEN(A$) + 2 + S

==={{header|BaCon}}===

INPUT d$

==={{header|BASIC256}}===

input "Enter two numbers separated by a space?", t$

a = explode(t$," ")

==={{header|BBC BASIC}}===

hereY% = VPOS

INPUT LINE "" q$

PRINT TAB(hereX%, hereY%) ; a + b

ENDIF

That seems overly complicated. What's wrong with:

INPUT LINE "" q$

space% = INSTR(q$," ")

PRINT VAL LEFT$(q$,space%-1) + VAL MID$(q$,space%+1)

==={{header|Commodore BASIC}}===

20 INPUT X$

30 I = 1 : N = LEN(X$)

50 A = VAL(LEFT$(X$,I))

60 B = VAL(RIGHT$(X$,N-1))

==={{header|FreeBASIC}}===

Dim As Integer a, b

Print

Print "Press any key to quit the program"

==={{header|FUZE BASIC}}===

PRINT VAL(LEFT$(n$,(LEN(STR$(VAL(n$))))))+VAL(RIGHT$(n$,(LEN(n$)-LEN(STR$(VAL(n$)))-1)))

==={{header|IS-BASIC}}===

110 INPUT PROMPT "Ener two integers separated by a comma: ":A,B

120 IF ABS(A)>1000 OR ABS(B)>1000 OR IP(A)<>A OR IP(B)<>B THEN

160 EXIT DO

170 END IF

==={{header|Liberty BASIC}}===

==={{header|OxygenBasic}}===

print val(s)+val(mid(s,i))+cr

loop

==={{header|Sinclair ZX81 BASIC}}===

20 LET I=1

30 IF A$(I)=" " THEN GOTO 60

40 LET I=I+1

50 GOTO 30

==={{Header|Tiny BASIC}}===

REM by Jjuanhdez, 06/2022

60 PRINT "Both integers must be in the range [-1000..1000] - try again."

GOTO 10

==={{header|True BASIC}}===

INPUT PROMPT "Enter two integers separated by a comma: ": A, B

IF ABS(A)>1000 OR ABS(B)>1000 OR IP(A)<>A OR IP(B)<>B THEN

END IF

LOOP

==={{header|uBasic/4tH}}===

<lang>s = FUNC(_GetInt(1000)) + FUNC(_GetInt(1000))

Print "Wrong, must be between "; -a@; " and "; a@; ". Try again.."

Loop

=={{header|Batch File}}==

Prompts version

@echo off

setlocal

set /a c=a+b

echo %c%

All on the commandline version

@echo off

setlocal

set /a c=a+b

echo %c%

Formula on the command line version

@echo off

setlocal

set /a c=%~1

echo %c%

Example of 'Formula on the command line version'

<pre>

</pre>

Parse the input stream version (thanks to Tom Lavedas on alt.msdos.batch.nt)

@echo off

setlocal

set /a res=res+%1

shift

Example of 'parse the input stream version'

<pre>>aplusb

=={{header|bc}}==

{{Works with|GNU bc}}

=={{header|Befunge}}==

=={{header|Bird}}==

define Main

$b Console.Read

Console.Println Math.Add $a $b

=={{header|BlooP}}==

=={{header|bootBASIC}}==

Both numbers are entered separately.

20 input a

30 print "Number 2";

40 input b

=={{header|BQN}}==

{{works with|https://github.com/dzaima/CBQN CBQN}}

# Cut 𝕩 at occurrences of 𝕨, removing separators and empty segments

# •GetLine and •_while_ are nonstandard CBQN extensions.

=={{header|Bracmat}}==

<code>filter</code> is a pattern that checks that input is a non-fractional number not less than -1000 and not greater than 1000. The filter is applied to each input.

$ ( put$"Enter two integer numbers between -1000 and 1000:"

& (filter=~/#%:~<-1000:~>1000)

| "Invalid input. Try again"

)

=={{header|Brainf***}}==

TODO if first symbol is a minus sign print Qgo awayQ

+> initialize sum to one

>++++++++++++++++++++++++++++++++++++++++++++++++> convert remainder to ascii digit

]

=={{header|Brat}}==

=={{header|Burlesque}}==

=={{header|C}}==

#include <stdio.h>

int main()

printf("%d\n", a + b);

return 0;

// Output file: output.txt

#include <stdio.h>

printf("%d\n", a + b);

return 0;

#include <stdio.h>

#include <stdlib.h>

return 0;

}

=={{header|C sharp|C#}}==

using System.Linq;

Console.WriteLine(Console.ReadLine().Split().Select(int.Parse).Sum());

}

Another way (not recommended since it does not work with more than two numbers):

class Program

Console.WriteLine(sum.ToString());

}

=={{header|C++}}==

#include <iostream>

using namespace std;

cin >> a >> b;

cout << a + b << endl;

// Output file: output.txt

#include <fstream>

out << a + b << endl;

return 0;

=={{header|Ceylon}}==

print("please enter two numbers for me to add");

}

}

=={{header|Clojure}}==

3

4

3 3

Translation of Common Lisp version:

3 4

Safely and without reader tricks:

(println (reduce + ints)))

3 4

or same as above, but without "let":

3 4

=={{header|COBOL}}==

PROGRAM-ID. A-Plus-B.

GOBACK

A second version.

IDENTIFICATION DIVISION.

STOP RUN.

=={{header|CoffeeScript}}==

{{trans|JavaScript}}

<script type="text/javascript" src="http://jashkenas.github.com/coffee-script/extras/coffee-script.js"></script>

<script type="text/coffeescript">

<div id='output'></div>

</body>

{{works with|Node.js}}

{ stdin } = process

sum = ( a, b ) -> a + b

# Start the main loop.

do prompt

=={{header|Common Lisp}}==

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE AB;

IMPORT StdLog, DevCommanders,TextMappers;

END Go;

END AB.

Execute: <i>AB.Go 12 23 ~ </i><br/>

{{out}}

=={{header|Computer/zero Assembly}}==

a: 0

b: 0

LDA a

ADD b

=={{header|Crystal}}==

The <code>not_nil!</code> call on <code>gets</code> is needed because <code>gets</code> might return <code>nil</code> and the compiler forces us to deal with it.

To handle the <code>nil</code> case we could do:

puts line.split.map(&.to_i).sum

else

puts "No input"

=={{header|D}}==

===From Console===

void main() {

writeln(to!int(r[0]) + to!int(r[1]));

{{out}}

<pre>30</pre>

===From File===

import std.stdio, std.file;

immutable ab = "sum_input.txt".slurp!(int, int)("%d %d")[0];

"sum_output.txt".File("w").writeln(ab[0] + ab[1]);

=={{header|Dart}}==

// a little helper function that checks if the string only contains

}

}

{{out}}

=={{header|dc}}==

The question mark ''?'' reads and executes a line of input. The user must enter a dc program that pushes two numbers to the stack, such as ''2 3'' or ''5 _1''. (The user must use underscore ''_'' for negative numbers.)

=={{header|DCL}}==

$ a = f$element( 0, " ", line )

$ b = f$element( 1, " ", line )

=={{header|Delphi}}==

Console version.

{$APPTYPE CONSOLE}

Readln(s2);

Writeln(StrToIntDef(s1, 0) + StrToIntDef(s2,0));

=={{header|Diego}}==

begin_instuct(A + B);

exec_instruct(A + B)_me();

=={{header|DMS}}==

number b = GetNumber( "Please input 'b'", b, b ) // prompts for 'b'

=={{header|Dragon}}==

select "graphic"

select "types"

showln a + b

=={{header|DWScript}}==

Ghetto GUI version

var b := StrToInt(InputBox('A+B', 'Enter 2nd number', '0'));

=={{header|Déjà Vu}}==

{{trans|Python}}

===Console===

for k in split !prompt "" " ":

+ to-num k

=={{header|EasyLang}}==

b = number substr a$ i -1

print a + b

=={{header|EchoLisp}}==

(+ (read-number 1 "value for A") (read-number 2 "value for B"))

=={{header|EDSAC order code}}==

The EDSAC does not support input of data while a program is running, so A and B are pre-set to 37 and 28. Other values can of course be substituted: note the slightly idiosyncratic format in which integer data is written (the least significant bit set using an alphabetic character). The result of the computation is displayed in binary in the first address of storage tank 3.

========

[ When loading is finished: ]

{{out}}

<pre>00000000001000001</pre>

3. Dismiss the message, make the file with the two integers the active file, and click Reset. The simulator will continue, read the integers, and print them together with their sum.

[A + B for Rosetta Code.

Read two integers and find their sum.

P F

-987.123.

{{out}}

<pre>

=={{header|EGL}}==

package programs;

end

end

=={{header|Eiffel}}==

argument(0) contains the path of the executable - thus we start at argument(1)

class

APPLICATION

end

end

Alternatively ...

make

-- Run application.

end

end

=={{header|Ela}}==

a'b() = do

putStrLn <| show <| sum <| map gread <| string.split " " <| str

{{Out}}

=={{header|Elena}}==

ELENA 5.0 :

public program()

console.loadLine(A,B).printLine(A + B)

Or more generic solution:

import extensions;

.selectBy(mssgconst toInt<convertorOp>[1])

.summarize())

=={{header|Elixir}}==

|> String.split

|> Enum.map(&String.to_integer(&1))

|> Enum.sum

=={{header|Elm}}==

--To write this function directly run cmd

--Type elm-repl to start

--END

=={{header|Emacs Lisp}}==

(numbers (mapcar #'string-to-number (split-string input)))

(a (car numbers))

(b (cadr numbers)))

=={{header|Emojicode}}==

🆕🔡▶️👂🏼❗️ ➡️ input 💭 Get numbers as input string

🔫 input 🔤 🔤❗ ➡️ nums 💭 Split numbers by space

🍺🔢 🐽 nums 1❗ 10❗ ➡️ B 💭 Retrieve second number

😀 🔤🧲A➕B🧲🔤 ❗ 💭 Output sum

=={{header|Erlang}}==

-export([start/0]).

io:format("~w~n",[A+B]),

start()

=={{header|ERRE}}==

PROGRAM SUM2

END PROGRAM

=={{header|Euler Math Toolbox}}==

>s=lineinput("Two numbers seperated by a blank");

Two numbers seperated by a blank? >4 5

>vs[1]()+vs[2]()

9

=={{header|Euphoria}}==

function snd(sequence s)

b = snd(get(0))

=={{header|Excel}}==

Take any 3 columns of any row or rows. Let's say A1,B1 and C1 are taken. In C1 type in :

=A1+B1

The value of C1 will change as the values of A1 and B1 are changed

<lang>1 2 3

=={{header|F Sharp|F#}}==

let SumOf(str : string) =

let main argv =

Console.WriteLine(SumOf(Console.ReadLine()))

=={{header|Factor}}==

: a+b ( -- )

readln " " split1

[ string>number ] bi@ +

<pre>

( scratchpad ) a+b

=={{header|FALSE}}==

=={{header|Fantom}}==

{

public static Void main ()

echo (sum)

}

=={{header|FBSL}}==

Using stdin and stdout

DIM %a, %b

PRINT a, "+", b, "=", a + b

=={{header|Fhidwfe}}==

function listint scanint (num:ptr) {// as of writing, fhidwfe has no builtin int scanning

reset negative

puti$ + access_word$ inp 0u access_word$ inp 1u

free$ inp

=={{header|Fish}}==

v >~01-0 >

>i:o:" "=?v68*-$a*+

v >~01-0 >

>i:o:d=?v68*-$a*+

=={{header|Forth}}==

=={{header|Fortran}}==

implicit none

integer :: a,b

read (*, *) a, b

write (*, '(i0)') a + b

And in Fortran 77

100 FORMAT(2I5)

WRITE (2,200) I+J

200 FORMAT(1X,I5)

=={{header|Free Pascal}}==

uses

SysUtils;

WriteLn(IntToStr(s1 + s2));

end.

=={{header|Frink}}==

This program handles arbitrarily-large integers, or even floating-point or rational numbers or complex numbers (as long as they're not internally separated with spaces, of course, which are the delimiters for this task.) It can even handle units of measure (with no embedded spaces) such as "3.3meter 2feet" and does the right thing when summing those units. It can handle any number of arbitrary whitespace characters separating the numbers. It also works whether the input is user-interactive, or input comes from stdin or a pipe. (It will bring up a user dialog for input when run in a graphical environment.)

sum[eval[split[%r/\s+/, input[""]]]]

=={{header|FunL}}==

=={{header|Furor}}==

cin sto mystring

#s dec mystring @mystring sprintnl

{ „mylist” }

{ „nums” }

{{out}}

<pre>

=={{header|FutureBasic}}==

The input statement was removed from FB several years ago. However, it's trivial to write our own input field which compiles as a stand-alone Macintosh application.

_window = 1

begin enum 1

HandleEvents

{{output}}

<pre>

=={{header|Gambas}}==

Dim sInput As String = InputBox("Input 2 numbers seperated by a space", "A + B")

Print Split(sInput, " ")[0] & " + " & Split(sInput, " ")[1] & " = " & Str(Val(Split(sInput, " ")[0]) + Val(Split(sInput, " ")[1]))

Output:

<pre>

=={{header|Gastona}}==

Taking A and B from command line arguments

<main>