A+B: Difference between revisions
Add ed example
(Add ed example) |
|||
(120 intermediate revisions by 67 users not shown) | |||
Line 32:
=={{header|0815}}==
<syntaxhighlight lang
=={{header|11l}}==
{{trans|Python}}
<
=={{header|360 Assembly}}==
<
APLUSB CSECT
USING APLUSB,R12
Line 45:
OPEN (MYDATA,INPUT)
LOOP GET MYDATA,PG read a single record
XDECI R4,PG input A, in register 4
XDECI R5,PG+12 input B, in register 5
AR R4,R5 A+B, add register 5 to register 4, R4=R4+R
XDECO R4,PG+24 edit A+B
XPRNT PG,36 print A+B
Line 60:
YREGS
END APLUSB
</syntaxhighlight>
{{in}}
<pre>
Line 75:
=={{header|8th}}==
<
=={{header|8080 Assembly}}==
Line 86:
which can take four forms:
<
dad d ; HL += DE
dad h ; HL += HL (also known as "mul HL by two")
dad sp ; HL += SP (actually the only way to get at SP at all)</
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
; HL is now 579</
Then, the following is what is required to wrap it all in a CP/M command line utility.
Line 104:
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
Line 193:
negf: db 0 ; Space for negative flag
db '-00000'
num: db '$' ; Space for number</
{{out}}
Line 209:
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program addAetB.s */
Line 406:
.align 4 // instruction to realign the following routines
</syntaxhighlight>
=={{header|ABAP}}==
<
data: lv_output type i.
selection-screen begin of block input.
Line 423:
start-of-selection.
lv_output = p_first + p_second.
write : / lv_output.</
=={{header|Acornsoft Lisp}}==
{{trans|Common Lisp}}
<pre>
Evaluate: (print (plus (read) (read)))
3 2
5
</pre>
=={{header|Action!}}==
<syntaxhighlight lang="action!">BYTE FUNC Find(CHAR ARRAY s CHAR c BYTE POINTER err)
BYTE i
FOR i=1 TO s(0)
DO
IF s(i)=c THEN
err^=0 RETURN (i)
FI
OD
err^=1
RETURN (0)
INT FUNC Decode(CHAR ARRAY s BYTE start,stop BYTE POINTER err)
CHAR ARRAY tmp(20),tmp2(20)
INT value
IF s(start)='+ THEN
start==+1
FI
SCopyS(tmp,s,start,stop)
value=ValI(tmp)
;Check if conversion failed
IF value=0 AND s(start)#'0 THEN
err^=1 RETURN (0)
FI
;Check if value is out of range
IF value<-1000 OR value>1000 THEN
err^=1 RETURN (0)
FI
err^=0
RETURN (value)
PROC Main()
CHAR ARRAY s(20)
BYTE pos,err,err2,value
INT a,b,sum
DO
PrintE("Enter two integer numbers between -1000 and 1000, separated by a space or Q for quit")
InputS(s)
IF s(0)=1 AND (s(1)='Q OR s(1)='q) THEN
EXIT
FI
pos=Find(s,' ,@err)
IF err=0 THEN
a=Decode(s,1,pos-1,@err)
b=Decode(s,pos+1,s(0),@err2)
err=err OR err2
FI
IF err=0 THEN
sum=a+b
PrintF("Their sum is %I%E",sum)
ELSE
PrintE("Invalid input!")
FI
PutE();
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/A+B.png Screenshot from Atari 8-bit computer]
<pre>
Enter two integer numbers between -1000 and 1000, separated by a space or Q for quit
-320 547
Their sum is 227
Enter two integer numbers between -1000 and 1000, separated by a space or Q for quit
512 -1234
Invalid input!
Enter two integer numbers between -1000 and 1000, separated by a space or Q for quit
</pre>
=={{header|Ada}}==
<
with Ada.Integer_Text_Io;
Line 435 ⟶ 521:
Ada.Integer_Text_Io.Get (Item => B);
Ada.Integer_Text_Io.Put (A+B);
end APlusB;</
Using appropriate user defined types:
<
procedure A_Plus_B is
Line 448 ⟶ 534:
IO.Get (B);
IO.Put (A + B, Width => 4, Base => 10);
end A_Plus_B;</
=={{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 )
epocs</
=={{header|Aime}}==
<
list l;
Line 466 ⟶ 552:
f_list(f, l, 0);
o_integer(atoi(l[0]) + atoi(l[1]));
o_newline();</
=={{header|ALGOL 60}}==
{{works with|A60}}
<syntaxhighlight lang="algol60">begin
comment A+B;
integer a,b;
ininteger(0,a); ininteger(0,b);
outinteger(1,a+b)
end </syntaxhighlight>
{{in}}
<pre>
1 2
</pre>
{{out}}
<pre>
3
</pre>
=={{header|ALGOL 68}}==
Line 474 ⟶ 578:
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - missing transput function "read int"}}
===Console===
<
Input:
<pre>
Line 485 ⟶ 589:
===File===
<
open(stand out, "output.txt", stand out channel);
print((read int + read int))</
Input "input.txt":
<pre>
Line 498 ⟶ 602:
=={{header|ALGOL W}}==
<
integer a, b;
read( a, b );
write( a + b )
end.</
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="amazing hopper">
#include <hbasic.h>
#import lib/input.bas.lib
#include include/input.h
Begin
Token Init
Cls
Locate(5,1),Print(Utf8$("Ingrese dos números, separados por espacio: "))
msg=""
LocCol(45),Let( msg := ReadString(msg))
Token Sep(" ")
Print("Suma : ", Token(1),Val(Token$(msg)) Plus (Token(2),Val(Token$(msg))), Newl)
End
</syntaxhighlight>
{{out}}
<pre>
Ingrese dos números, separados por espacio: -200 10
Suma : -190
Press any key to continue...
</pre>
Version dos: hopper-BASIC acepta "programación fluída"
<syntaxhighlight lang="amazing hopper">
#include <hbasic.h>
#import lib/input.bas.lib
#include include/input.h
#define getValueOf(__X__) Token(__X__),Val(Token$(msg))
#define-a »»(__X__) ;Move to(__X__)
Begin
Token Init
Cls
Locate(5,1),Print(Utf8$("Ingrese dos números, separados por espacio: "))
msg=""
LocCol(45),Let( msg := ReadString(msg))
Token Sep(" ")
A=0, get Value Of(1)»»(A), CLamp(-1000,1000,A)
B=0, get Value Of(2)»»(B), CLamp(-1000,1000,B)
Print("Suma : ")
Take(A, B), and Add It; then Print It with a Newl
End
</syntaxhighlight>
{{out}}
<pre>
Ingrese dos números, separados por espacio: -1005 500
Suma : -500
Press any key to continue...
</pre>
=={{header|ANTLR}}==
Line 510 ⟶ 669:
=={{header|Apex}}==
<syntaxhighlight lang="apex">
static Integer sumOfTwoNums(Integer A, Integer B) {
Line 527 ⟶ 686:
A = 50 and B = -25: 25
</syntaxhighlight>
=={{header|APL}}==
<syntaxhighlight lang
=={{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
Line 540 ⟶ 699:
return "Usage with -1000 <= a,b <= 1000: " & tab & " A+B.scpt a b"
end try
end run</
To make this run in Terminal open the '''Terminal.app''' and type
Line 550 ⟶ 709:
=={{header|Arc}}==
<syntaxhighlight lang="arc">
(prn (+ (read)
(read)))
</syntaxhighlight>
=={{header|Argile}}==
{{trans|C}}
{{works with|Argile|1.0.0}}
<
use std, array
Cfunc scanf "%d%d" (&val int a) (&val int b)
printf "%d\n" (a + b)</
<
(: Output file: output.txt :)
use std, array
Line 571 ⟶ 730:
fprintf out "%d\n" (x+y)
fclose in
fclose out</
=={{header|ARM Assembly}}==
Line 577 ⟶ 736:
Exploiting C standard library functions (scanf and printf).
Requires arm-linux-gnueabi-gcc and qemu-arm. Compile with:
<
<syntaxhighlight lang="arm_assembly">.text
.global main
.extern printf
Line 605 ⟶ 764:
.bss
num_a: .skip 4
num_b: .skip 4</
{{works with|gcc|Linux}}
Line 625 ⟶ 784:
Save in ab.S
Build with:
<
ld -o a.out ab.o</
<syntaxhighlight lang="arm_assembly">.data
.align 2
.code 32
Line 1,141 ⟶ 1,300:
movlt r0, #0
ldmfd sp!, {r7, pc}
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">while ø [
x: map split.words input "give me 2 numbers:" 'x -> to :integer x
print add x\0 x\1
]
</syntaxhighlight>
{{out}}
<pre>give me 2 numbers:3 4
7
give me 2 numbers:2 5
7</pre>
=={{header|AsciiDots}}==
<<syntaxhighlight lang="asciidots">
&-#$-\
.-#?-[+]
.-#?--/
</syntaxhighlight>
=={{header|ATS}}==
<syntaxhighlight lang="ats">
(* ****** ****** *)
//
Line 1,178 ⟶ 1,352:
(* ****** ****** *)
</syntaxhighlight>
=={{header|AutoHotkey}}==
This handles more than two inputs
<syntaxhighlight lang="autohotkey">Gui, Add, Edit, vEdit ;Enter your A+B, i.e. 5+3 or 5+3+1+4+6+2
Gui, Add, Button, gAdd, Add
Gui, Add, Edit, ReadOnly x+10 w80
Gui, Show
return
Add:
Gui, Submit, NoHide
Loop, Parse, Edit, + ;its taking each substring separated by "+" and its storing it in A_LoopField
var += A_LoopField ;here its adding it to var
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
return</syntaxhighlight>
=={{header|AutoIt}}==
<
$num = "45 54"
consolewrite ("Sum of " & $num & " is: " & sum($num))
Line 1,192 ⟶ 1,377:
$numm = StringSplit($numbers," ")
Return $numm[1]+$numm[$numm[0]]
EndFunc</
===Example2===
This version can handle any amount of numbers in the input:
<
Func Sum($inp)
Line 1,217 ⟶ 1,402:
; so the program works correctly even with this input:
Local $inp = "999x y 42 -999", $res = Sum($inp)
ConsoleWrite($inp & " --> " & $res & @CRLF)</
{{Out}}
<pre>
Line 1,226 ⟶ 1,411:
=={{header|AWK}}==
<
=={{header|BabyCobol}}==
<syntaxhighlight lang="cobol">
* NB: COBOL's ACCEPT does not work with multiple identifiers
IDENTIFICATION DIVISION.
PROGRAM-ID. PLUS.
DATA DIVISION.
01 A PICTURE IS S9999.
01 B LIKE A.
PROCEDURE DIVISION.
DISPLAY "Enter two numbers: " WITH NO ADVANCING.
ACCEPT A B.
ADD A TO B.
DISPLAY "A+B =" B.
</syntaxhighlight>
=={{header|BASIC}}==
<
tryagain:
Line 1,244 ⟶ 1,444:
ELSE
GOTO tryagain
END IF</
==={{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
Line 1,257 ⟶ 1,457:
100 VTAB BH
110 HTAB LEN(A$) + 2 + S
120 PRINT C%</
==={{header|BaCon}}===
<
INPUT d$
PRINT VAL(TOKEN$(d$, 1)) + VAL(TOKEN$(d$, 2))</
==={{header|BASIC256}}===
<
input "Enter two numbers separated by a space?", t$
a = explode(t$," ")
print t$ & " " & int(a[0]) + int(a[1])</
==={{header|BBC BASIC}}===
<
hereY% = VPOS
INPUT LINE "" q$
Line 1,284 ⟶ 1,484:
PRINT TAB(hereX%, hereY%) ; a + b
ENDIF
UNTIL FALSE</
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)
UNTIL FALSE</
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{works with|Applesoft BASIC}}
{{works with|GW-BASIC}}
{{works with|MSX_BASIC}}
{{works with|PC-BASIC|any}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">10 CLS : rem 10 HOME for Applesoft BASIC
20 PRINT "ENTER TWO NUMBERS, SEPARATED BY A SPACE: ";
30 INPUT X$
40 I = 1 : N = LEN(X$)
50 IF MID$(X$, I, 1) <> " " AND I < N THEN I = I + 1 : GOTO 50
60 A = VAL(LEFT$(X$, I))
70 B = VAL(RIGHT$(X$, N - 1))
80 PRINT A + B
90 END</syntaxhighlight>
==={{header|Commodore BASIC}}===
<
20 INPUT X$
30 I = 1 : N = LEN(X$)
Line 1,299 ⟶ 1,516:
50 A = VAL(LEFT$(X$,I))
60 B = VAL(RIGHT$(X$,N-1))
70 PRINT A+B</
==={{header|FreeBASIC}}===
<
Dim As Integer a, b
Line 1,318 ⟶ 1,535:
Print
Print "Press any key to quit the program"
Sleep</
==={{header|GW-BASIC}}===
The [[#Chipmunk_Basic|Chipmunk Basic]] solution works without any changes.
==={{header|FUZE BASIC}}===
<
PRINT VAL(LEFT$(n$,(LEN(STR$(VAL(n$))))))+VAL(RIGHT$(n$,(LEN(n$)-LEN(STR$(VAL(n$)))-1)))
END</
==={{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
Line 1,334 ⟶ 1,554:
160 EXIT DO
170 END IF
180 LOOP</
==={{header|Liberty BASIC}}===
<
print eval(word$(n$,1);" + ";word$(n$,2))</
==={{header|Minimal BASIC}}===
{{works with|QBasic}}
{{works with|QuickBasic}}
{{works with|Applesoft BASIC}}
{{works with|BASICA}}
{{works with|Chipmunk Basic}}
{{works with|GW-BASIC}}
{{works with|IS-BASIC}}
{{works with|MSX Basic}}
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
{{works with|Run BASIC}}
{{works with|Yabasic}}
<syntaxhighlight lang="qbasic">10 PRINT "ENTER NUMBER A";
20 INPUT A
30 PRINT "ENTER NUMBER B";
40 INPUT B
50 PRINT A+B
60 END</syntaxhighlight>
==={{header|MSX Basic}}===
The [[#Chipmunk_Basic|Chipmunk Basic]] solution works without any changes.
==={{header|OxygenBasic}}===
<syntaxhighlight lang="text">
uses console
int i
string s
do
print "Enter 2 numbers separated by space "
s=input
s=ltrim(s)
exit if not s
i=instr(s," ")
exit if i<2
print val(s)+val(mid(s,i))+cr
loop
</syntaxhighlight>
==={{header|Sinclair ZX81 BASIC}}===
<
20 LET I=1
30 IF A$(I)=" " THEN GOTO 60
40 LET I=I+1
50 GOTO 30
60 PRINT VAL A$( TO I-1)+VAL A$(I+1 TO )</
==={{header|SmallBASIC}}===
<syntaxhighlight lang="SmallBASIC">
input "Enter number A: "; a
input "Enter number B: "; b
print "A + B = "; a + b
</syntaxhighlight>
==={{Header|Tiny BASIC}}===
<syntaxhighlight lang="tiny basic">REM Rosetta Code problem: https://rosettacode.org/wiki/A+B
REM by Jjuanhdez, 06/2022
10 LET C = 0
LET D = 0
PRINT "Enter an integer: "
INPUT A
IF A < 0 THEN LET C = A * -1
PRINT "Enter other integer: "
INPUT B
IF B < 0 THEN LET D = B * -1
IF C > 1000 THEN GOTO 60
IF D > 1000 THEN GOTO 60
50 PRINT "Their sum is ", A + B
GOTO 70
60 PRINT "Both integers must be in the range [-1000..1000] - try again."
GOTO 10
70 END</syntaxhighlight>
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">DO
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
PRINT "Both integers must be in the interval [-1000..1000] - try again."
PRINT
ELSE
PRINT "Their sum is";A+B
EXIT DO
END IF
LOOP
END</syntaxhighlight>
==={{header|uBasic/4tH}}===
<syntaxhighlight lang="text">s = FUNC(_GetInt(1000)) + FUNC(_GetInt(1000))
Print "The sum is: ";s
End
_GetInt
Param (1)
Local (1)
Do
Input "Enter a value: ", b@
Until (b@ > -a@-1 ) * (b@ < a@+1)
Print "Wrong, must be between "; -a@; " and "; a@; ". Try again.."
Loop
Return (b@)</syntaxhighlight>
==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "A+B"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
FUNCTION Entry ()
a$ = INLINE$("Enter integer A: ")
a = SLONG(a$)
b$ = INLINE$("Enter integer B: ")
b = SLONG(b$)
DO WHILE 1
IF ABS(a) > 1000 OR ABS(b) > 1000 THEN
PRINT "Both integers must be in the interval [-1000..1000] - try again."
PRINT
ELSE
PRINT "Their sum is"; a + b
EXIT DO
END IF
LOOP
END FUNCTION
END PROGRAM</syntaxhighlight>
=={{header|Batch File}}==
Prompts version
<
@echo off
setlocal
Line 1,357 ⟶ 1,695:
set /a c=a+b
echo %c%
endlocal</
All on the commandline version
<
@echo off
setlocal
Line 1,366 ⟶ 1,704:
set /a c=a+b
echo %c%
endlocal</
Formula on the command line version
<
@echo off
setlocal
set /a c=%~1
echo %c%
endlocal</
Example of 'Formula on the command line version'
<pre>
Line 1,382 ⟶ 1,720:
</pre>
Parse the input stream version (thanks to Tom Lavedas on alt.msdos.batch.nt)
<
@echo off
setlocal
Line 1,394 ⟶ 1,732:
set /a res=res+%1
shift
if "%1" neq "" goto :add</
Example of 'parse the input stream version'
<pre>>aplusb
Line 1,405 ⟶ 1,743:
=={{header|bc}}==
{{Works with|GNU bc}}
<syntaxhighlight lang
=={{header|Befunge}}==
<syntaxhighlight lang
=={{header|Bird}}==
<
define Main
Line 1,417 ⟶ 1,755:
$b Console.Read
Console.Println Math.Add $a $b
end</
=={{header|BlooP}}==
BlooP and FlooP can't actually read from stdin, but here's the procedure it would use, if it could.
<syntaxhighlight lang="bloop">
DEFINE PROCEDURE ''ADD'' [A, B]:
BLOCK 0: BEGIN
OUTPUT <= A + B;
BLOCK 0: END.
</syntaxhighlight>
=={{header|bootBASIC}}==
Both numbers are entered separately.
<
20 input a
30 print "Number 2";
40 input b
50 print a+b</
=={{header|BQN}}==
{{works with|https://github.com/dzaima/CBQN CBQN}}
<syntaxhighlight lang="bqn">#!/usr/bin/env bqn
# Cut 𝕩 at occurrences of 𝕨, removing separators and empty segments
# (BQNcrate phrase).
Split ← (¬-˜⊢×·+`»⊸>)∘≠⊔⊢
# Natural number from base-10 digits (BQNcrate phrase).
Base10 ← 10⊸×⊸+˜´∘⌽
# Parse any number of space-separated numbers from string 𝕩.
ParseNums ← {Base10¨ -⟜'0' ' ' Split 𝕩}
# •GetLine and •_while_ are nonstandard CBQN extensions.
{•Show +´ ParseNums 𝕩 ⋄ •GetLine@} •_while_ (@⊸≢) •GetLine@</syntaxhighlight>
=={{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)
Line 1,445 ⟶ 1,802:
| "Invalid input. Try again"
)
);</
=={{header|Brainf***}}==
<
TODO if first symbol is a minus sign print Qgo awayQ
+> initialize sum to one
Line 1,471 ⟶ 1,828:
>++++++++++++++++++++++++++++++++++++++++++++++++> convert remainder to ascii digit
]
<[.<<] print ascii digits</
=={{header|Brat}}==
<
p numbers[0] + numbers[1] #Prints the sum of the input</
=={{header|Bruijn}}==
<syntaxhighlight lang="bruijn">
:import std/Combinator .
:import std/String .
:import std/Number .
:import std/Char C
main (split-by (C.eq? ' ')) → &(add ⋔ string→number)
</syntaxhighlight>
=={{header|Burlesque}}==
<syntaxhighlight lang
=={{header|C}}==
<
#include <stdio.h>
int main()
Line 1,489 ⟶ 1,856:
printf("%d\n", a + b);
return 0;
}</
<
// Output file: output.txt
#include <stdio.h>
Line 1,501 ⟶ 1,868:
printf("%d\n", a + b);
return 0;
}</
<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
Line 1,510 ⟶ 1,877:
return 0;
}
</syntaxhighlight>
=={{header|C sharp|C#}}==
<
using System.Linq;
Line 1,522 ⟶ 1,889:
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
Line 1,537 ⟶ 1,904:
Console.WriteLine(sum.ToString());
}
}</
=={{header|C++}}==
<
#include <iostream>
using namespace std;
Line 1,548 ⟶ 1,915:
cin >> a >> b;
cout << a + b << endl;
}</
<
// Output file: output.txt
#include <fstream>
Line 1,561 ⟶ 1,928:
out << a + b << endl;
return 0;
}</
=={{header|Ceylon}}==
<
print("please enter two numbers for me to add");
Line 1,588 ⟶ 1,955:
}
}
}</
=={{header|CFEngine}}==
There is no concept of CFEngine policy reading from stdin so I will read from a file.
<syntaxhighlight lang="cfengine">
$ cat sum.cf
bundle agent main
{
vars:
"line_count" int => readintarray(
"input",
"${this.promise_dirname}${const.dirsep}input.txt",
"#[^\n]*",
" ",
"inf",
"inf"
);
"indices" slist => getindices( "input" );
reports:
"${with}" with => format( "%d", eval( "${input[${indices}][0]} + ${input[${indices}][1]}" ));
DEBUG::
"line_count is ${line_count}";
"input is ${with}" with => storejson( "input" );
"input[${indices}] is ${with}" with => storejson( "input[${indices}]" );
}
$ cat input.txt
2 3
2 2
$ cf-agent -KIf ./sum.cf
R: 5
R: 4
</syntaxhighlight>
The "R:" prefix is for a report promise and the only way to output to stdout with policy.
You could also output to a file I suppose.
=={{header|Clojure}}==
<
3
4
=>7</
<
3 3
6</
Translation of Common Lisp version:
<
3 4
7</
Safely and without reader tricks:
<
(println (reduce + ints)))
3 4
=>7</
or same as above, but without "let":
<
3 4
=>7</
=={{header|COBOL}}==
<
PROGRAM-ID. A-Plus-B.
Line 1,637 ⟶ 2,041:
GOBACK
.</
A second version.
<syntaxhighlight lang="cobol">
IDENTIFICATION DIVISION.
PROGRAM-ID. A-Plus-B.
AUTHOR. Bill Gunshannon.
INSTALLATION. Home.
DATE-WRITTEN. 25 December 2021.
************************************************************
** Program Abstract:
** A re-worked version that more closely matches the
** desired format. Both numbers are taken in on one
** line separated by spaces. Sum is formated to remove
** leading zeros and/or spaces.
************************************************************
DATA DIVISION.
WORKING-STORAGE SECTION.
01 Input-Data PIC X(16).
01 A PIC S9(5).
01 B PIC S9(5).
01 A-B-Sum PIC -----9.
PROCEDURE DIVISION.
DISPLAY "Input pairs of numbers separated by spaces."
DISPLAY "Enter q to exit."
PERFORM WITH TEST BEFORE
UNTIL Input-Data = "q" or Input-Data = "Q"
ACCEPT Input-Data
IF Input-Data NOT = "q" and Input-Data NOT = "Q"
UNSTRING Input-Data DELIMITED BY SPACES
INTO A B
ADD A TO B GIVING A-B-Sum
DISPLAY "Sum = " FUNCTION TRIM(A-B-Sum)
END-IF
END-PERFORM.
STOP RUN.
</syntaxhighlight>
=={{header|CoffeeScript}}==
{{trans|JavaScript}}
<
<script type="text/javascript" src="http://jashkenas.github.com/coffee-script/extras/coffee-script.js"></script>
<script type="text/coffeescript">
Line 1,654 ⟶ 2,103:
<div id='output'></div>
</body>
</html></
{{works with|Node.js}}
<
{ stdin } = process
sum = ( a, b ) -> a + b
Line 1,688 ⟶ 2,137:
# Start the main loop.
do prompt
</syntaxhighlight>
=={{header|Common Lisp}}==
<
=={{header|Component Pascal}}==
BlackBox Component Builder
<
MODULE AB;
IMPORT StdLog, DevCommanders,TextMappers;
Line 1,725 ⟶ 2,174:
END Go;
END AB.
</syntaxhighlight>
Execute: <i>AB.Go 12 23 ~ </i><br/>
{{out}}
Line 1,733 ⟶ 2,182:
=={{header|Computer/zero Assembly}}==
<
a: 0
b: 0
LDA a
ADD b
STP</
=={{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.
Line 1,748 ⟶ 2,197:
To handle the <code>nil</code> case we could do:
<
puts line.split.map(&.to_i).sum
else
puts "No input"
end</
=={{header|D}}==
===From Console===
<
void main() {
Line 1,766 ⟶ 2,215:
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
Line 1,805 ⟶ 2,254:
}
}
</syntaxhighlight>
{{out}}
Line 1,814 ⟶ 2,263:
=={{header|dc}}==
<syntaxhighlight lang
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 )
$ write sys$output a, "+", b, "=", a + b</
=={{header|Delphi}}==
Console version.
<
{$APPTYPE CONSOLE}
Line 1,840 ⟶ 2,289:
Readln(s2);
Writeln(StrToIntDef(s1, 0) + StrToIntDef(s2,0));
end.</
=={{header|Diego}}==
<syntaxhighlight lang="diego">set_namespace(rosettacode)_me();
begin_instuct(A + B);
ask_human()_msg(Please enter two integers between -1000 and 1000, separated by a space:)_split( )_var(A, B);
with_var(A, B)_trim()_parse({integer})_test([A]<=-1000)_test([B]>=1000)
: with_human[]_msg(Invalid input: [A], [B]);
exec_instruct[];
;
add_var(sum)_calc([A]+[B]);
with_human[]_msg([A] + [B] = [sum]);
end_instruct[];
exec_instruct(A + B)_me();
reset_namespace[];</syntaxhighlight>
=={{header|DMS}}==
<
number b = GetNumber( "Please input 'b'", b, b ) // prompts for 'b'
Result( a + b + "\n" )</
=={{header|Dragon}}==
<
select "graphic"
select "types"
Line 1,856 ⟶ 2,322:
showln a + b
</syntaxhighlight>
=={{header|DWScript}}==
Ghetto GUI version
<
var b := StrToInt(InputBox('A+B', 'Enter 2nd number', '0'));
ShowMessage('Sum is '+IntToStr(a+b));</
=={{header|Déjà Vu}}==
{{trans|Python}}
===Console===
<
for k in split !prompt "" " ":
+ to-num k
!print</
=={{header|EasyLang}}==
<syntaxhighlight>
a$
repeat
i += 1
until i > len a$ or substr a$ i 1 = " "
.
print a + b
</syntaxhighlight>
=={{header|EchoLisp}}==
<
(+ (read-number 1 "value for A") (read-number 2 "value for B"))
</syntaxhighlight>
=={{header|Ed}}==
Inputs are newline-separated integers up to 10000 (arbitrary limit, can be extended by adding more parsing/output lines).
<syntaxhighlight>
H
g/[^0-9]{1,}/s///g
,p
# decimal -> unary
g/^0+([0-9])/s//\1/
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/
g/^9([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiiii/
g/^8([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiiii/
g/^7([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiiii/
g/^6([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiiii/
g/^5([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiiii/
g/^4([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iiii/
g/^3([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2iii/
g/^2([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2ii/
g/^1([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2i/
g/^0([0-9]*)(i*)/s//\1\2\2\2\2\2\2\2\2\2\2/
# actual logic
,j
# unary -> decimal (for 0-10000 range)
g/i{9000}(i{0,999})/s//9\1/
g/i{8000}(i{0,999})/s//8\1/
g/i{7000}(i{0,999})/s//7\1/
g/i{6000}(i{0,999})/s//6\1/
g/i{5000}(i{0,999})/s//5\1/
g/i{4000}(i{0,999})/s//4\1/
g/i{3000}(i{0,999})/s//3\1/
g/i{2000}(i{0,999})/s//2\1/
g/i{1000}(i{0,999})/s//1\1/
v/^[0-9]i*$/s/.*/0&/
g/i{900}(i{0,99})/s//9\1/
g/i{800}(i{0,99})/s//8\1/
g/i{700}(i{0,99})/s//7\1/
g/i{600}(i{0,99})/s//6\1/
g/i{500}(i{0,99})/s//5\1/
g/i{400}(i{0,99})/s//4\1/
g/i{300}(i{0,99})/s//3\1/
g/i{200}(i{0,99})/s//2\1/
g/i{100}(i{0,99})/s//1\1/
v/^[0-9]{2}i*$/s/^([0-9])(i*)$/\10\2/
g/i{90}(i{0,9})/s//9\1/
g/i{80}(i{0,9})/s//8\1/
g/i{70}(i{0,9})/s//7\1/
g/i{60}(i{0,9})/s//6\1/
g/i{50}(i{0,9})/s//5\1/
g/i{40}(i{0,9})/s//4\1/
g/i{30}(i{0,9})/s//3\1/
g/i{20}(i{0,9})/s//2\1/
g/i{10}(i{0,9})/s//1\1/
v/^[0-9]{3}i*$/s/^([0-9]{2})(i*)$/\10\2/
g/i{9}/s//9/
g/i{8}/s//8/
g/i{7}/s//7/
g/i{6}/s//6/
g/i{5}/s//5/
g/i{4}/s//4/
g/i{3}/s//3/
g/i{2}/s//2/
g/i{1}/s//1/
v/^[0-9]{4}i*$/s/^([0-9]{3})(i*)$/\10\2/
g/^0+([0-9])/s//\1/
,p
Q
</syntaxhighlight>
=={{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.
<
========
Line 1,923 ⟶ 2,499:
[ When loading is finished: ]
EZPF [ Branch to load point ]</
{{out}}
<pre>00000000001000001</pre>
Line 1,941 ⟶ 2,517:
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.
Line 2,050 ⟶ 2,626:
P F
-987.123.
</syntaxhighlight>
{{out}}
<pre>
Line 2,060 ⟶ 2,636:
=={{header|EGL}}==
<syntaxhighlight lang="egl">
package programs;
Line 2,079 ⟶ 2,655:
end
end
</syntaxhighlight>
=={{header|Eiffel}}==
argument(0) contains the path of the executable - thus we start at argument(1)
<
class
APPLICATION
Line 2,097 ⟶ 2,673:
end
end
</syntaxhighlight>
Alternatively ...
<
make
-- Run application.
Line 2,121 ⟶ 2,697:
end
end
</syntaxhighlight>
=={{header|Ela}}==
<
a'b() = do
Line 2,130 ⟶ 2,706:
putStrLn <| show <| sum <| map gread <| string.split " " <| str
a'b() ::: IO</
{{Out}}
Line 2,137 ⟶ 2,713:
=={{header|Elena}}==
ELENA
<
public program()
Line 2,146 ⟶ 2,722:
console.loadLine(A,B).printLine(A + B)
}</
Or more generic solution:
<
import extensions;
Line 2,156 ⟶ 2,732:
console.printLine(console.readLine()
.split()
.selectBy(mssgconst toInt<
.summarize())
}</
=={{header|Elixir}}==
<
|> String.split
|> Enum.map(&String.to_integer(&1))
|> Enum.sum
|> IO.puts</
=={{header|Elm}}==
<syntaxhighlight lang="elm">
--To write this function directly run cmd
--Type elm-repl to start
Line 2,180 ⟶ 2,756:
--END
</syntaxhighlight>
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(let* ((input (read-from-minibuffer ""))
(numbers (mapcar #'string-to-number (split-string input)))
(a (car numbers))
(b (cadr numbers)))
(message "%d" (+ a b)))</syntaxhighlight>
=={{header|EMal}}==
<syntaxhighlight lang="emal">
fun main = int by List args
text input = when(args.length == 1, args[0], ask(text, "Enter n integers separated by a space: "))
int sum, count
for each text word in input.split(" ")
word = word.trim()
if word.isEmpty() do continue end # ignore empty words
int nr = int!word # this can raise an exception
if abs(nr) > 1000
Event.error(0, "Integers must be in the interval [-1000, 1000]").raise()
end
sum += nr
++count
end
if count < 2 do Event.error(1, "At least two integers must be provided").raise() end
writeLine("The sum of " + count + " integers is: " + sum)
return 0
end
exit main(Runtime.args)
</syntaxhighlight>
{{out}}
<pre>
emal.exe Org\RosettaCode\Aplusb.emal " 9 8 "
The sum of 2 integers is: 17
</pre>
=={{header|Emojicode}}==
<syntaxhighlight lang="emojicode">🏁🍇
🆕🔡▶️👂🏼❗️ ➡️ input 💭 Get numbers as input string
🔫 input 🔤 🔤❗ ➡️ nums 💭 Split numbers by space
🍺🔢 🐽 nums 0❗ 10❗ ➡️ A 💭 Retrieve first number
🍺🔢 🐽 nums 1❗ 10❗ ➡️ B 💭 Retrieve second number
😀 🔤🧲A➕B🧲🔤 ❗ 💭 Output sum
🍉️</syntaxhighlight>
=={{header|Erlang}}==
<
-export([start/0]).
Line 2,209 ⟶ 2,811:
io:format("~w~n",[A+B]),
start()
end.</
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM SUM2
Line 2,225 ⟶ 2,827:
END PROGRAM
</syntaxhighlight>
=={{header|Euler}}==
'''begin'''
'''out''' '''in''' + '''in'''
'''end''' $
=={{header|Euler Math Toolbox}}==
<syntaxhighlight lang="euler math toolbox">
>s=lineinput("Two numbers seperated by a blank");
Two numbers seperated by a blank? >4 5
Line 2,237 ⟶ 2,844:
>vs[1]()+vs[2]()
9
</syntaxhighlight>
=={{header|Euphoria}}==
<
function snd(sequence s)
Line 2,251 ⟶ 2,858:
b = snd(get(0))
printf(1," %d\n",a+b)</
=={{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
</syntaxhighlight>
The value of C1 will change as the values of A1 and B1 are changed
<syntaxhighlight lang="text">1 2 3
</syntaxhighlight>
=={{header|F Sharp|F#}}==
<
let SumOf(str : string) =
Line 2,274 ⟶ 2,881:
let main argv =
Console.WriteLine(SumOf(Console.ReadLine()))
0</
=={{header|Factor}}==
<
: a+b ( -- )
readln " " split1
[ string>number ] bi@ +
number>string print ;</
<pre>
( scratchpad ) a+b
Line 2,289 ⟶ 2,896:
=={{header|FALSE}}==
<
n;!n;!+.</
=={{header|Fantom}}==
<
{
public static Void main ()
Line 2,303 ⟶ 2,910:
echo (sum)
}
}</
=={{header|FBSL}}==
Using stdin and stdout
<
DIM %a, %b
Line 2,313 ⟶ 2,920:
PRINT a, "+", b, "=", a + b
PAUSE</
=={{header|Fennel}}==
{{trans|Lua}}
<syntaxhighlight lang="fennel">
(let [(a b) (io.read :*number :*number)]
(print (+ a b)))
</syntaxhighlight>
=={{header|Fhidwfe}}==
<syntaxhighlight lang="fhidwfe">
function listint scanint (num:ptr) {// as of writing, fhidwfe has no builtin int scanning
reset negative
read = num
num1 = 0
num2 = 0
while ~ = deref_ubyte$ read ' ' {
char = deref_ubyte$ read
if = char '-' {
set negative
} {
num1 = + * 10 num1 as - char '0' int
}
read = + read 1u
}
if negative {
num1 = !num1
} ;
reset negative
read = + read 1u
while ~ = deref_ubyte$ read 0ub {
char2 = deref_ubyte$ read
if = char2 '-' {
set negative
} {
num2 = + * 10 num2 as - char2 '0' int
}
read = + read 1u
}
if negative {
num2 = !num2
} ;
return (num1 num2)
}
//the real program
text = malloc$ 12u//worst input is -1000 -1000, or 11 bytes + null terminator
getline$ text
inp = scanint$ text
free$ text
puti$ + access_word$ inp 0u access_word$ inp 1u
free$ inp
</syntaxhighlight>
=={{header|Fish}}==
<
v >~01-0 >
>i:o:" "=?v68*-$a*+
Line 2,322 ⟶ 2,981:
v >~01-0 >
>i:o:d=?v68*-$a*+
>~*+aonao;</
=={{header|Forth}}==
<
=={{header|Fortran}}==
<
implicit none
integer :: a,b
read (*, *) a, b
write (*, '(i0)') a + b
end program a_plus_b</
And in Fortran 77
<syntaxhighlight lang="fortran"> READ (1,100) I,J
100 FORMAT(2I5)
WRITE (2,200) I+J
200 FORMAT(1X,I5)
END</syntaxhighlight>
=={{header|Free Pascal}}==
<syntaxhighlight lang="pascal">program SUMA;
uses
SysUtils;
var
s1, s2:integer;
begin
ReadLn(s1);
Readln(s2);
WriteLn(IntToStr(s1 + s2));
end.
</syntaxhighlight>
=={{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[""]]]]
</syntaxhighlight>
=={{header|FunL}}==
<
=={{header|Furor}}==
<syntaxhighlight lang="furor">
cin sto mystring
#s dec mystring @mystring sprintnl
Line 2,363 ⟶ 3,042:
{ „mylist” }
{ „nums” }
</syntaxhighlight>
{{out}}
<pre>
Line 2,385 ⟶ 3,064:
</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.
<syntaxhighlight lang="futurebasic">
_window = 1
begin enum 1
_label
_input
_result
end enum
void local fn BuildWindow
window _window, @"A + B", ( 0, 0, 260, 200 )
textlabel _label, @"Enter two signed integers separated by a comma, space/s or plus sign. Enter return to calculate.", ( 20, 130, 220, 48 ), _window
textfield _input,,,( 20, 90, 220, 24 ), _window
TextFieldSetMaximumNumberOfLines( _input, 1 )
ControlSetFormat( _input, @"0123456789 ,+-", YES, 0, NULL )
ControlSetAlignment( _input, NSTextAlignmentCenter )
textlabel _result,, ( 20, 50, 220, 24 ), _window
ControlSetAlignment( _result, NSTextAlignmentRight )
WindowMakeFirstResponder( _window, _input )
end fn
local fn DoCalc
NSInteger value1, value2
CFStringRef calcStr = fn ControlStringValue( _input )
calcStr = fn StringByReplacingOccurrencesOfString( calcStr, @",", @"\t" )
calcStr = fn StringByReplacingOccurrencesOfString( calcStr, @"+", @"\t" )
calcStr = fn StringByReplacingOccurrencesOfString( calcStr, @" ", @"\t" )
CFArrayRef calcArr = fn StringComponentsSeparatedByString( calcStr, @"\t" )
value1 = fn StringIntegerValue( fn ArrayFirstObject( calcArr ) )
value2 = fn StringIntegerValue( fn ArrayLastObject( calcArr ) )
ControlSetStringValue( _result, fn StringWithFormat( @"%ld + %ld = %ld", value1, value2, value1 + value2 ) )
end fn
void local fn DoDialog( ev as long, tag as long, wnd as long )
select ( ev )
case _textFieldDidEndEditing : fn DoCalc
case _windowWillClose : end
end select
end fn
on dialog fn DoDialog
fn BuildWindow
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
-250 1000 = 750
or
-250,1000 = 750
or
-250 + 1000 = 750
</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]))
End</
Output:
<pre>
Line 2,400 ⟶ 3,138:
=={{header|Gastona}}==
Taking A and B from command line arguments
<
<main>
"@<p1> + @<p2> = "
=, p1 + p2
</syntaxhighlight>
Using Graphical interface
<
<layout of main>
Line 2,422 ⟶ 3,160:
<suma> =, eA + eB
</syntaxhighlight>
=={{header|GDScript}}==
Requires Godot 4. Runs as a tool script using the input and output properties. Does not check for zero lines of input.
<syntaxhighlight lang="gdscript">
@tool
extends Node
@export var input: String:
set(value):
input = value # Save the input field
var fields := value.split(" ", false) # Split by spaces
if len(fields) == 2: # Basic input validation
output = str(int(fields[0]) + int(fields[1]))
else: # Invalid input
output = ""
@export var output: String
</syntaxhighlight>
=={{header|Gema}}==
<
=={{header|Genie}}==
<
/*
A+B in Genie
Line 2,450 ⟶ 3,208:
print "B" + warning
print "From %s\nA + B = %llu", line, a+b</
{{out}}
Line 2,470 ⟶ 3,228:
=={{header|GML}}==
<
add = argument0; // get the string with the numbers to add
a = real(string_copy(add, 1, string_pos(" ", add)));
b = real(string_copy(add, string_pos(" ", add) + 1, string_length(add) - string_pos(" ", add)));
return(a + b);</
=={{header|Go}}==
<
import "fmt"
Line 2,485 ⟶ 3,243:
fmt.Scan(&a, &b)
fmt.Println(a + b)
}</
=={{header|Golfscript}}==
<syntaxhighlight lang
=={{header|Golo}}==
<
----
This module asks for two numbers, adds them, and prints the result.
Line 2,517 ⟶ 3,275:
println("they both need to be numbers for this to work")
}
}</
=={{header|Gosu}}==
<syntaxhighlight lang="gosu">
uses java.io.InputStreamReader
uses java.util.Scanner
Line 2,530 ⟶ 3,288:
print( a + b )
</syntaxhighlight>
=={{header|Groovy}}==
<
def reader = new Scanner(System.in)
def a = reader.nextInt();
Line 2,540 ⟶ 3,298:
a + b
}
abAdder()</
=={{header|GUISS}}==
We cannot use variables, but we can find the sum of two numbers.Here we add 3 + 2:
<
Button:2,Button:[equals]</
=={{header|Harbour}}==
<syntaxhighlight lang="visualfoxpro">PROCEDURE Main()
LOCAL GetList := {}
LOCAL bValid := { |n| iif(n>-1001, iif(n<1001, .T.,.F.),.F.) }
LOCAL a := 0 , b := 0
SetColor( "G+/N" )
CLS
@ 10, 01 SAY "Enter two integers (range -1000...+1000):" GET a VALID Eval(bValid,a)
@ Row(), Col() + 1 GET b VALID Eval(bValid,b)
READ
@ 12, 01 SAY "Sum of given numbers is " + hb_ntos(a+b)
RETURN
</syntaxhighlight>
Screen output:<p>Enter two numbers (range -1000...+1000): ''-56 98''</p>
<p>Sum of given numbers is 42</p>
=={{header|Haskell}}==
<
=={{header|hexiscript}}==
<
let ret dict 32
let l len s
Line 2,571 ⟶ 3,348:
let a tonum nums[0]
let b tonum nums[1]
println a + b</
=={{header|HicEst}}==
A and B are input via edit controls with spinners limiting inputs to +-1000.
<
WRITE(Messagebox, Name) A, B, "Sum = ", A+B</
=={{header|Hoon}}==
<syntaxhighlight lang="text">
|= [a=@ud b=@ud] (add a b)
</syntaxhighlight>
=={{header|Hope}}==
Line 2,594 ⟶ 3,376:
=={{header|Huginn}}==
<
import Text as text;
Line 2,609 ⟶ 3,391:
);
);
}</
=={{header|Hy}}==
<
Alternatively, with the "threading tail" macro:
<
=={{header|i}}==
<
=={{header|Icon}} and {{header|Unicon}}==
<
numChars := '-'++&digits
read() ? {
Line 2,627 ⟶ 3,409:
}
write((\A + \B) | "Bad input")
end</
=={{header|Idris}}==
<
main = do
line <- getLine
print $ sum $ map cast $ words line</
=={{header|Insitux}}==
<syntaxhighlight lang="insitux">(+ (to-num (prompt "Enter first number: "))
(to-num (prompt "Enter second number: ")))</syntaxhighlight>
=={{header|J}}==
Typically, in J, you would find the sum of two numbers (let us say 2 and 3) by entering both of them on a line with a + sign between them:
<
5</
Next we describe then implement a command line program to add some numbers.
1) In the following expression, <tt>1!:1(3)</tt> reads a line from STDIN; <tt>-.LF</tt> drops the line ending character; <tt>".</tt> converts the remaining text to a sequence of numbers which are then summed using <tt>+/</tt>.
<syntaxhighlight lang="j">+/". (1!:1(3))-.LF</syntaxhighlight>
2) Here's a little script, called "a+b.ijs":
<syntaxhighlight lang="j">#!/usr/bin/ijconsole
echo +/". (1!:1(3))-.LF
exit ''</
3) Here is
<
5</
Note: under OSX, you should probably install a symbolic link at /usr/bin/ijconsole which links to something like /Applications/j602/bin/jconsole.
=={{header|Java}}==
The task description is somewhat vague, if the 'input stream' is in reference to the data provided at the command line, then Java will parse these values into a <code>String</code> array, accessible via the <kbd>args</kbd> parameter of the <code>main</code> method.
<syntaxhighlight lang="java">
public static void main(String[] args) {
int A = Integer.parseInt(args[0]);
int B = Integer.parseInt(args[1]);
System.out.println(A + B);
}
</syntaxhighlight>
If the 'input stream' is the standard-in, you can use the following.<br />
The <code>Scanner</code> class can be used to "scan" the standard-in stream from left to right, returning the next value requested.
<syntaxhighlight lang="java">
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int A = scanner.nextInt();
int B = scanner.nextInt();
System.out.println(A + B);
}
</syntaxhighlight>
If the 'input stream' is referring to any abstraction, then you can use the following.<br />
In this example, the data is considered to be under a specific charset, so the integer values are parsed using UTF-8.
<syntaxhighlight lang="java">
import static java.nio.charset.StandardCharsets.UTF_8;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
</syntaxhighlight>
<syntaxhighlight lang="java">
int sum(InputStream input) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
String line = reader.readLine();
reader.close();
/* split parameter here is a regex */
String[] values = line.split(" +");
int A = Integer.parseInt(values[0]);
int B = Integer.parseInt(values[1]);
return A + B;
}
</syntaxhighlight>
<br />
An alternate implemenation
<syntaxhighlight lang="java">import java.util.Scanner;
public class Sum2 {
Line 2,657 ⟶ 3,490:
System.out.println(in.nextInt() + in.nextInt()); // Standard output
}
}</
Object of [[class]] Scanner works slow enough, because of that contestants prefer to avoid its use. Often, longer solution works faster and easily scales to problems.
<
import java.util.*;
Line 2,685 ⟶ 3,518:
out.println(nextInt() + nextInt());
}
}</
The following code uses a StreamTokenizer instead of a Scanner.
<
import java.nio.charset.Charset;
Line 2,705 ⟶ 3,538:
}
}
</syntaxhighlight>
<syntaxhighlight lang="text">
grammar aplusb ;
Line 2,723 ⟶ 3,556:
NEWLINE : WS* '\r'? '\n'
;
</syntaxhighlight>
Produces:
<pre>
Line 2,744 ⟶ 3,577:
Client side:
<
<body>
<div id='input'></div>
Line 2,757 ⟶ 3,590:
</script>
</body>
</html></
Server side (with [http://nodejs.org node.js]):
<
'data',
function (line) {
Line 2,770 ⟶ 3,603:
process.exit()
}
)</
$ node io.js
Line 2,781 ⟶ 3,614:
=== ES6 ===
Node.js in a terminal:
<
console.log(
(buffer + "").trim().split(" ").map(Number).reduce((a, v) => a + v, 0)
);
});
</syntaxhighlight>
<pre> $ node io.js
Line 2,794 ⟶ 3,627:
=== JScript Windows Script Host Version 5.8 ===
<
var b = WScript.StdIn.ReadLine();
WSH.echo(a, " + " , b , " = " , Number(a)+Number(b));
</syntaxhighlight>
=={{header|Joy}}==
===Console===
<syntaxhighlight lang
===File===
<
"output.txt" "w" fopen
get get + fput pop quit.</
=={{header|jq}}==
Since the given task is simply to add two numbers, the simplest approach in jq is illustrated by the following transcript:
<
3 2
5 </
This will work provided the numbers are neither too small nor too large. However, the above program will add **all** the numbers presented on the stream (assuming only numbers are presented). If the task were to add consecutive pairs of numbers, then the approach illustrated in the following transcript can be used, in conjunction with the jq "-s" option:<
def addpairs:
if length < 2 then empty
Line 2,818 ⟶ 3,651:
end;
addpairs</
For example, here is a transcript that assumes the program is in a file named AB.jq:<
$ jq -s -f AB.jq
1 2 3 4 5 6
3
7
11</
=={{header|Jsish}}==
<
var line = console.input();
var nums = line.match(/^\s*([+-]?[0-9]+)\s+([+-]?[0-9]+)\s*/);
Line 2,840 ⟶ 3,673:
} else {
puts("error: A+B requires two numbers separated by space");
}</
{{out}}
Line 2,858 ⟶ 3,691:
=={{header|Julia}}==
Run from the command line:
<
println(stdout, sum(input))</
{{out}}
Line 2,867 ⟶ 3,700:
In the next solution, an error is returned if the entry is not constituted from exactly two integers. Any number of spaces can follow an integer.
<
1 2
3</
=={{header|K}}==
<syntaxhighlight lang="k">
split:{(a@&~&/' y=/: a:(0,&x=y)_ x) _dv\: y}
ab:{+/0$split[0:`;" "]}
Line 2,878 ⟶ 3,711:
2 3
5
</syntaxhighlight>
=={{header|Keg}}==
<syntaxhighlight lang
[https://tio.run/##y05N//9fW@//f1MDLjMDAA Try it online!]
Or, using flags (<code>-hr</code>):
<syntaxhighlight lang
[https://tio.run/##y05N//9f@/9/UwMuM4P/uhlFAA Try it online!]
=={{header|Kite}}==
<
import "System.file";
Line 2,901 ⟶ 3,734:
line = in|readline;
];</
{{Out}}
<pre>
Line 2,911 ⟶ 3,744:
=={{header|Klong}}==
<syntaxhighlight lang="k">
{(1:$(*x?0c )#x)+1:$(1+*|x?0c )_x}@.rl()
2 3
5
</syntaxhighlight>
=={{header|Kotlin}}==
<
fun main(args: Array<String>) {
Line 2,940 ⟶ 3,773:
}
}
}</
{{out}}
Line 2,954 ⟶ 3,787:
=={{header|KQL}}==
<
'2 2',
'3 2'
]
| parse Input with A:int ' ' B:int
| project Input, Output = A + B</
=={{header|L++}}==
<
(decl int a)
(decl int b)
(>> std::cin a b)
(prn (+ a b)))</
=={{header|Lambdatalk}}==
<
Lambdatalk works in a wiki, lambdatank.
Line 3,001 ⟶ 3,834:
Several boxes can be created in the wiki page
with any valid lambdatalk expressions.
</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">
fn.print(First number:\s)
$a = fn.int(fn.input())
fn.print(Second number:\s)
$b = fn.int(fn.input())
fn.println(Result: parser.op($a + $b))
</syntaxhighlight>
=={{header|Lang5}}==
<
read " " split expand drop + .</
=={{header|Lasso}}==
<syntaxhighlight lang
=={{header|LIL}}==
<
# Requires lil shell readline routine
set in [readline]
Line 3,019 ⟶ 3,863:
if [expr $A < -1000 || $A > 1000] { print "A out of range: $A"; exit 1 }
if [expr $B < -1000 || $B > 1000] { print "B out of range: $B"; exit 1 }
print [expr $A + $B]</
{{out}}
Line 3,026 ⟶ 3,870:
=={{header|Lisaac}}==
<
+ name := A_PLUS_B
Section Public
- main <- ( (IO.read_integer; IO.last_integer) +
(IO.read_integer; IO.last_integer) ).println;</
=={{header|Little}}==
<
string a, b;
scan(gets(stdin), "%d %d", &a, &b);
puts(((int)a + (int)b));
}</
=={{header|Little Man Computer}}==
Line 3,046 ⟶ 3,890:
'''Assembly'''
<
STA 99
INP
Line 3,052 ⟶ 3,896:
OUT
HLT
// Output the sum of two numbers</
'''Machine code'''
<
01 STA 99
02 INP
03 ADD 99
04 OUT
05 HLT</
=={{header|LiveCode}}==
Using Livecode Server script
<syntaxhighlight lang="livecode"><?lc
if isNumber($0) and isNumber($1) then
put $0 + $1
Line 3,070 ⟶ 3,914:
put $0 && $1
end if
?></
A graphical version using an input dialog
<
ask "Enter two numbers"
set itemdelimiter to space
Line 3,082 ⟶ 3,926:
answer item 1 of nums && item 2 of nums
end if
end mouseUp</
=={{header|Logo}}==
<
=={{header|Lua}}==
<
print(a+b)</
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="text">Def Range(X%)=Abs(X%)<=1000
Do {
Input A%, B%
} Until Range(A%) And Range(B%)
Print A%+B%</
=={{header|M4}}==
<
sumstr(1 2)
3</
=={{header|Maple}}==
<
23 34
57</
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Interactive in a notebook
<syntaxhighlight lang
=={{header|MATLAB}} / {{header|Octave}}==
<
inputStream = input('Enter two numbers, separated by a space: ', 's');
numbers = str2num(inputStream); %#ok<ST2NM>
Line 3,121 ⟶ 3,965:
end
sumOfInputs = sum(numbers);
end</
=={{header|Maude}}==
===Built-in===
<syntaxhighlight lang="maude">
red 3 + 4 .
</syntaxhighlight>
===With restrictions===
<syntaxhighlight lang="maude">
fmod ADD is
Line 3,142 ⟶ 3,986:
endfm
</syntaxhighlight>
=={{header|Maxima}}==
<syntaxhighlight lang="text">in_stream: openr("/dev/stdin");
unless (line: readline(in_stream), line=false) do (
q: map('parse_string, split(line, " ")),
Line 3,151 ⟶ 3,995:
);
close(in_stream);
</syntaxhighlight>
=={{header|Mercury}}==
<syntaxhighlight lang="text">:- module a_plus_b.
:- interface.
Line 3,173 ⟶ 4,017:
else
true
).</
=={{header|min}}==
{{works with|min|0.19.3}}
<
=={{header|MiniScript}}==
The <code>input</code> intrinsic in MiniScript isn't available in all implementations, so we've just hard-coded the input here:
<
fields = s.split
for i in range(fields.len-1, 0)
Line 3,190 ⟶ 4,034:
else
print val(fields[0]) + val(fields[1])
end if</
{{out}}
Line 3,196 ⟶ 4,040:
=={{header|mIRC Scripting Language}}==
<
echo -ag $calc($1 + $2)
}</
=={{header|МК-61/52}}==
Line 3,207 ⟶ 4,051:
=={{header|ML/I}}==
The two numbers are read from 'standard input' or its equivalent.
<
"" A+B
"" assumes macros on input stream 1, terminal on stream 2
Line 3,219 ⟶ 4,063:
MCSKIP SL WITH *
MCSET S1=1
*MCSET S10=2</
=={{header|Modula-2}}==
<
IMPORT InOut;
Line 3,233 ⟶ 4,077:
InOut.WriteInt (A + B, 8);
InOut.WriteLn
END ab.</
=={{header|Modula-3}}==
<syntaxhighlight lang="modula3">MODULE Ab EXPORTS Main;
IMPORT IO;
VAR
A,B:INTEGER;
BEGIN
TRY
A := IO.GetInt();
B := IO.GetInt();
EXCEPT
| IO.Error => IO.Put("Invalid number!\n");
END;
IO.PutInt(A+B);
IO.Put("\n");
END Ab.</syntaxhighlight>
=={{header|MoonScript}}==
<
print a + b</
=={{header|Mosaic}}==
<syntaxhighlight lang="mosaic">
proc main =
int a, b
print "?"
readln a, b
println a + b
end
</syntaxhighlight>
=={{header|MUMPS}}==
<syntaxhighlight lang="mumps">ANB
NEW A,B,T,S
READ !,"Input two integers between -1000 and 1000, separated by a space: ",S
Line 3,247 ⟶ 4,120:
IF T WRITE !,(A+B)
IF 'T WRITE !,"Bad input"
QUIT</
=={{header|Nanoquery}}==
<
line = input()
Line 3,257 ⟶ 4,130:
// add the two numbers and print the result
println int(strings[0]) + int(strings[1])</
=={{header|Neko}}==
<syntaxhighlight lang="actionscript">/**
A+B, Rosetta Code, in Neko
Tectonics:
Line 3,324 ⟶ 4,197:
} else $print("Need two numbers, separated by whitespace\n")
} catch with $print("Exception: ", with, "\n")</
{{out}}
Line 3,336 ⟶ 4,209:
=={{header|Nemerle}}==
{{trans|C#}}
<
using System.Console;
using System.Linq;
Line 3,346 ⟶ 4,219:
WriteLine(ReadLine().Split().Select(int.Parse).Sum());
}
}</
=={{header|NetRexx}}==
<
options replace format comments java symbols binary
parse ask a b .
say a '+' b '=' a + b</
=={{header|newLISP}}==
<
=={{header|Nim}}==
A+B:
<syntaxhighlight lang="nim">
# Takes 2 inputs of Floats and adds them (which is not correct for the exercise, will revisit, Thank you
proc aplusb(a,b: float): float =
Line 3,391 ⟶ 4,255:
let second: float = getnumber()
echo("Result: " & formatFloat(aplusb(first, second), ffDecimal, 2))</
The puzzle requires 1 input, 2 INTS separated by a space, than a+b
Needs to be revisited
=={{header|Nit}}==
Generic non-robust version (source: [https://github.com/nitlang/nit/blob/master/examples/rosettacode/ab.nit the Nit’s official repository]):
<
var words = gets.split(" ")
Line 3,402 ⟶ 4,269:
return
end
print words[0].to_i + words[1].to_i</
=={{header|NS-HUBASIC}}==
<
20 INPUT "ENTER NUMBER B: ",B
30 PRINT A+B</
=={{header|Nu}}==
<syntaxhighlight lang="nu">
input | parse "{a} {b}" | first | values | into int | math sum
</syntaxhighlight>
=={{header|Nutt}}==
<syntaxhighlight lang="Nutt">
module main
imports native.io{input.hear,output.say}
vals a=hear(Int),b=hear(Int)
say(a+b)
end
</syntaxhighlight>
=={{header|Nyquist}}==
===SAL Syntax===
<
;version 1
;type tool
Line 3,422 ⟶ 4,305:
print a + b
return ""</
===Audacity plug-in (SAL syntax)===
<
;version 1
;type tool
Line 3,436 ⟶ 4,319:
print a + b
return ""</
=={{header|Oberon-2}}==
<
IMPORT In, Out;
Line 3,450 ⟶ 4,333:
Out.Int (A + B, 8);
Out.Ln
END ab.</
Producing
<pre>
Line 3,458 ⟶ 4,341:
=={{header|Objeck}}==
<
class Vander {
function : Main(args : String[]) ~ Nil {
Line 3,467 ⟶ 4,350:
}
}
}</
=={{header|OCaml}}==
<
=={{header|Oforth}}==
Line 3,476 ⟶ 4,359:
Works with any number of integers separated by a space.
<
System.Console accept words map( #>integer) reduce( #+ ) printcr .</
=={{header|Ol}}==
Note: input data must be separated by newline ([Enter] key press).
<
(+ (read) (read))
Line 3,495 ⟶ 4,378:
(print a " + " b " = " (+ a b)))
</syntaxhighlight>
=={{header|Onyx}}==
<
`\nEnter two numbers between -1000 and +1000,\nseparated by a space: ' print flush
} def
Line 3,523 ⟶ 4,406:
} def
Prompt GetNumbers CheckInput Answer</
=={{header|ooRexx}}==
===version 1===
{{trans|REXX}}
<
Say 'enter some numbers to be summed:'
parse pull y
Line 3,546 ⟶ 4,429:
Parse arg list
list=space(list)
return translate(list,'+',' ')</
{{out}}
<pre>enter some numbers to be summed:
Line 3,552 ⟶ 4,435:
===version 2===
extend for negative numbers
<
Say 'enter some numbers to be summed:'
parse pull y
Line 3,572 ⟶ 4,455:
End
Say yplus '=' sum/1
Exit</
=={{header|OpenEdge/Progress}}==
<
DEFINE VARIABLE b AS INTEGER NO-UNDO FORMAT "->>>9".
Line 3,586 ⟶ 4,469:
UPDATE a b.
MESSAGE a + b VIEW-AS ALERT-BOX</
=={{header|Openscad}}==
There is no means of run-time input in Openscad
<
a = 5 + 4;
echo (a);
</syntaxhighlight>
=={{header|Order}}==
Line 3,599 ⟶ 4,482:
To run this Order program, you must define the macros '''A''' and '''B''' to values of the form '''8int(SIGN, 8nat(VALUE))''', where SIGN is 1/0 to represent signed/unsigned numbers, and VALUES is any comma-separated list of decimal digits. For example, to evaluate the sum of A=-150, B=275, define A to be '''8int(1, 8nat(1,5,0))''' and B to be '''8int(0, 8nat(2,7,5))'''.
<
#define ORDER_PP_DEF_1int_is_positive \
ORDER_PP_FN(8fn(8X, 8is_0(8tuple_at_0(8X))))
Line 3,636 ⟶ 4,519:
ORDER_PP(8int_to_lit(8int_add(A, B)))
</syntaxhighlight>
=={{header|Oxygene}}==
<
// Sum 2 integers read fron standard input
//
Line 3,672 ⟶ 4,555:
end.
</syntaxhighlight>
Produces:
<pre>
Line 3,681 ⟶ 4,564:
=={{header|Oz}}==
<
class TextFile from Open.file Open.text end
Line 3,690 ⟶ 4,573:
end
in
{Show {ReadInt}+{ReadInt}}</
=={{header|PARI/GP}}==
User input:
<syntaxhighlight lang
File input:
<
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="pascal">
##
var (a,b) := ReadInteger2;
Writeln(a + b);
</syntaxhighlight>
=={{header|Pascal}}==
<
a, b: integer;
begin
readln(a, b);
writeln(a + b);
end.</
Same with input from file <tt>input.txt</tt> and output from file <tt>output.txt</tt>.
<
a, b: integer;
begin
Line 3,715 ⟶ 4,606:
close(input);
close(output);
end.</
===Version 2. Following the rules===
<
Sum of A + B while A, B >= -1000 and A,B <= 1000
Author: Sinuhe Masan (2019) }
Line 3,734 ⟶ 4,625:
writeln('The sum is: ', A + B);
end.</
=={{header|Perl}}==
<
print "$a $b " . ($a + $b) . "\n";</
=== using the List::Util module ===
<
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">-->
<span style="color: #000080;font-style:italic;">-- demo\rosetta\AplusB.exw</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prompt_string</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Enter two numbers separated by a space : "</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">scanf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d %d"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
<span style="color: #004080;">integer</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">+</span><span style="color: #000000;">b</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d + %d = %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span><span style="color: #000000;">c</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">else</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"invalid input\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 3,758 ⟶ 4,651:
2 + 3 = 5
</pre>
=== GUI version ===
{{libheader|Phix/pGUI}}
<small>(The above console version is now just a comment in the distributed file.)</small>
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #000080;font-style:italic;">-- demo\rosetta\AplusB.exw</span>
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #000000;">pGUI</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #004080;">Ihandle</span> <span style="color: #000000;">lab</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">tab</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">dlg</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">valuechanged_cb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">Ihandle</span> <span style="color: #000000;">tab</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupGetAttribute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tab</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"VALUE"</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">scanf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d %d"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
<span style="color: #004080;">integer</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d + %d = %d"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">+</span><span style="color: #000000;">b</span><span style="color: #0000FF;">})</span>
<span style="color: #7060A8;">IupSetStrAttribute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"TITLE"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">IupRefresh</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">return</span> <span style="color: #004600;">IUP_DEFAULT</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">IupOpen</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">lab</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupLabel</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Enter two numbers separated by a space"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">tab</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupText</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"VALUECHANGED_CB"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">Icallback</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"valuechanged_cb"</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"EXPAND=HORIZONTAL"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupLabel</span><span style="color: #0000FF;">(</span><span style="color: #008000;">""</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">dlg</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupDialog</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">IupVbox</span><span style="color: #0000FF;">({</span><span style="color: #7060A8;">IupHbox</span><span style="color: #0000FF;">({</span><span style="color: #000000;">lab</span><span style="color: #0000FF;">,</span><span style="color: #000000;">tab</span><span style="color: #0000FF;">},</span><span style="color: #008000;">"GAP=10,NORMALIZESIZE=VERTICAL"</span><span style="color: #0000FF;">),</span>
<span style="color: #7060A8;">IupHbox</span><span style="color: #0000FF;">({</span><span style="color: #000000;">res</span><span style="color: #0000FF;">})},</span><span style="color: #008000;">"MARGIN=5x5"</span><span style="color: #0000FF;">),</span><span style="color: #008000;">`TITLE="A plus B"`</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">IupShow</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dlg</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">IupMainLoop</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">/# Rosetta Code problem: http://rosettacode.org/wiki/A+B
by Galileo, 05/2022 #/
include ..\Utilitys.pmt
def valid
dup -1000 >= swap 1000 <= and
enddef
true while
clear cls
"Enter two numbers (betwen -1000 ... +1000) separated by space: " input split pop pop drop tonum swap tonum
over valid over valid and not
endwhile
over over + >ps
nl "The sum of " print print " and " print print " is: " print ps> print
/#
swap over over + >ps >ps >ps
nl ( "The sum of " ps> " and " ps> " is: " ps> ) lprint
#/</syntaxhighlight>
{{out}}
<pre>Enter two numbers (betwen -1000 ... +1000) separated by space: 2 3
The sum of 2 and 3 is: 5
=== Press any key to exit ===</pre>
=={{header|PHP}}==
<
echo ($a + $b) . "\n";</
<
fscanf($in, "%d %d\n", $a, $b); //Reads 2 numbers from file $in
fclose($in);
Line 3,768 ⟶ 4,725:
$out = fopen("output.dat", "w");
fwrite($out, ($a + $b) . "\n");
fclose($out);</
=={{header|Picat}}==
<syntaxhighlight lang="picat">
go =>
println("Write two integers (and CR)"),
println(read_int()+read_int()).
</syntaxhighlight>
{{out}}
<pre>Picat> go
Write two integers (and CR)
2 5
7
</pre>
Or directly in the REPL:
<pre>
Picat> read_int()+read_int()=X
2 5
X = 7
</pre>
=={{header|PicoLisp}}==
<
3 4
-> 7</
=={{header|Piet}}==
[[File:Piet A+B.png]]
The code is fairly straightforward. The individual commands are as follows:
<
in(num)
add
out(num)</
=={{header|Pike}}==
<
sscanf(line, "%d %d", int a, int b);
write(a+b +"\n");</
=={{header|PL/I}}==
<
put (a+b);</
=={{header|Plain English}}==
<syntaxhighlight lang="plainenglish">
To run:
Start up.
Read a number from the console.
Read another number from the console.
Output the sum of the number and the other number.
Wait for the escape key.
Shut down.
To output the sum of a number and another number:
If the number is not valid, write "Invalid input" to the console; exit.
If the other number is not valid, write "Invalid input" to the console; exit.
Write the number plus the other number then " is the sum." to the console.
To decide if a number is valid:
If the number is not greater than or equal to -1000, say no.
If the number is not less than or equal to 1000, say no.
Say yes.
</syntaxhighlight>
=={{header|Pony}}==
<
actor Main
let _env:Env
Line 3,819 ⟶ 4,818:
_env.out.print(sum.string())
</syntaxhighlight>
=={{header|PostScript}}==
<
dup
token pop % read A
Line 3,828 ⟶ 4,827:
token pop % read B
add
=</
=={{header|Potion}}==
<
input = read
i = 0
Line 3,843 ⟶ 4,842:
# The numbers are manually inputted, but the format is improper (i.e., "%d\n%d\n").
(read number + read number) print</
=={{header|PowerShell}}==
<
[int]$a + [int]$b</
This solution does not work interactively, while the following ''only'' works interactively:
<
[int]$a + [int]$b</
I think this works better and doesn't require string input (following the task closer):
<
return [int]$args[0] + [int]$args[1]
}</
Can be called in one line with
<syntaxhighlight lang
=={{header|Processing}}==
===Rudimentary User Interface===
Click on either side to add 1 to its value.
<
int b = 0;
Line 3,887 ⟶ 4,886:
b++;
}
}</
[https://i.imgur.com/QEHtMyA.jpg What the GUI looks like.]
Line 3,893 ⟶ 4,892:
=={{header|ProDOS}}==
With the math module:
<
editvar /newvar /value=b /title=Enter another integer:
editvar /newvar /value=c
do add -a-,-b-=-c-
printline -c- </
Without the math module:
<
editvar /newvar /value=b /title=Enter another integer:
editvar /newvar /value=c=-a-+-b-
printline -c- </
=={{header|Prolog}}==
{{Works with|SWI-Prolog}}
<
read_line_to_codes(user_input,X),
atom_codes(A, X),
Line 3,912 ⟶ 4,911:
maplist(atom_number, L, LN),
sumlist(LN, N),
write(N).</
output :
<
|: 4 5
9
true.</
=={{header|Pure}}==
<
printf "%d\n" (x+y) when x,y = scanf "%d %d" end;</
=={{header|PureBasic}}==
===Console===
<
a=Val(StringField(x$,1," "))
b=Val(StringField(x$,2," "))
PrintN(str(a+b))</
===File===
<
x$=ReadString(0)
a=Val(StringField(x$,1," "))
Line 3,939 ⟶ 4,938:
EndIf
CloseFile(0)
EndIf </
=={{header|Python}}==
Line 3,948 ⟶ 4,947:
The first two lines allow the program to be run in either Python 2 or 3. In Python 2, <code>raw_input</code> exists, and the lines are effectively skipped. In Python 3, calling <code>raw_input</code> triggers an error, so the <code>except</code> loop activates and assigns "raw_input" the value of Python 3's "input" function. Regardless of version, these two lines make sure that <code>raw_input</code> will return a string.
<
except: raw_input = input
print(sum(map(int, raw_input().split())))</
===File===
For Python 2.X and 3.X taking input from stdin stream which can be redirected to be file input under Unix
<
for line in sys.stdin:
print(sum(map(int, line.split())))</
===Console, Python 3 only===
<
b = int(input("Second number: "))
print("Result:", a+b)</
=={{header|QB64}}==
<
DIM c AS LONG
INPUT "Enter A: ", a
Line 3,972 ⟶ 4,971:
c = a + b
PRINT ""
PRINT "A + B = " + LTRIM$(STR$(c)) </
'''Fully implemented version:'''
Line 3,982 ⟶ 4,981:
** Integers between -1000 and +1000.
<
PRINT "Enter two integers between -1000 and +1000 separated by at least one space: "
INPUT "> "; n$ ' | Enter two numbers with at least one space between.
Line 3,996 ⟶ 4,995:
b$ = LTRIM$(STR$(b)) ' | "
sum$ = LTRIM$(STR$(a + b)) ' | "
PRINT "The sum of the two integers a + b = "; a$; " + "; b$; " = "; sum$</
=={{header|Quackery}}==
'''As a dialogue in the Quackery shell:'''
<pre>/O> $ "Please enter two numbers separated by a space: " input
... say "Their sum is: " quackery + echo cr
...
Please enter two numbers separated by a space: 2 3
Their sum is: 5
Stack empty.</pre>
=={{header|Quite BASIC}}==
<
20 input "Enter number B: ";b
30 print a+b</
=={{header|R}}==
<
=={{header|Ra}}==
<syntaxhighlight lang="ra">
class Sum
**Adds two given integers**
Line 4,033 ⟶ 5,042:
print to Console.error made !, "Numbers too large"
exit program with error code
</syntaxhighlight>
=={{header|Racket}}==
<
#lang racket
(+ (read) (read))
</syntaxhighlight>
Or, with additional error checking:
<
#lang racket
(define a (read))
Line 4,050 ⟶ 5,059:
(unless (number? b) (error 'a+b "number" b))
(displayln (+ a b))
</syntaxhighlight>
=={{header|Raku}}==
Line 4,057 ⟶ 5,066:
Short version with very little "line noise":
<syntaxhighlight lang="raku"
Reduction operator <code>[+]</code>, and <code>say</code> as a function:
<syntaxhighlight lang="raku"
Long version:
<syntaxhighlight lang="raku"
say $a + $b;</
=={{header|REBOL}}==
<
{{Out}}
<pre>1 2
Line 4,075 ⟶ 5,084:
=={{header|Red}}==
<
{{Out}}
<pre>1 2
Line 4,085 ⟶ 5,094:
Alternative implementations:
<
<
<
=={{header|Relation}}==
<syntaxhighlight lang="relation">
set input = "2 2"
set a = regexreplace(input,"^(-?\d+)\s+(-?\d+)+$","$1")
set b = regexreplace(input,"^(-?\d+)\s+(-?\d+)+$","$2")
echo a + b
</syntaxhighlight>
=={{header|Retro}}==
<
<syntaxhighlight lang="retro">try
1
2</
=={{header|REXX}}==
===version 1, unnormalized===
The numbers can be any valid REXX number (integer, fixed point decimal, floating point (with exponential notation, ···).
<
parse pull a b /*obtain two numbers from input stream.*/
say a+b /*display the sum to the terminal. */
/*stick a fork in it, we're all done. */</
===version 2, normalizied===
If the user entered '''4.00000''' and wanted to add '''5''' to that, and expects '''9''',
Line 4,118 ⟶ 5,127:
Dividing by one normalizes the number.
<
parse pull a b /*obtain two numbers from input stream.*/
say (a+b) / 1 /*display normalized sum to terminal. */
/*stick a fork in it, we're all done. */</
===version 3, extended precision===
Using the '''numeric digits''' statement allows more decimal digits to be used, the default is '''9'''.
<
numeric digits 300 /*the default is nine decimal digits.*/
parse pull a b /*obtain two numbers from input stream.*/
z= (a+b) / 1 /*add and normalize sum, store it in Z.*/
say z /*display normalized sum Z to terminal.*/
/*stick a fork in it, we're all done. */</
===version 4, multiple numbers===
This REXX version adds ''all'' the numbers entered (not just two).
<
numeric digits 1000 /*just in case the user gets ka-razy. */
say 'enter some numbers to be summed:' /*display a prompt message to terminal.*/
Line 4,144 ⟶ 5,153:
end /*j*/
/*stick a fork in it, we're all done. */
say 'sum of ' many " numbers = " $/1 /*display normalized sum $ to terminal.*/</
===version 5, multiple numbers, tongue in cheek===
<
numeric digits 1000 /*just in case the user gets ka-razy. */
say 'enter some numbers to be summed:' /*display a prompt message to terminal.*/
Line 4,154 ⟶ 5,163:
y=translate(y,'+',' ')
Interpret 's='y
say 'sum of ' many " numbers = " s/1 /*display normalized sum s to terminal.*/</
=={{header|Ring}}==
<
Numbers = split(Numbers)
sum = 0
Line 4,165 ⟶ 5,174:
func Split Str
for x in str if x = " " x = nl ok next
return str2list(str)</
=={{header|Robotic}}==
<
input string "Input A:"
set "A" to "input"
Line 4,175 ⟶ 5,184:
* "('A' + 'B')"
end
</syntaxhighlight>
Although the function in the first and third line asks for a string as the input, so long as the variable isn't made to store a string, it will default to an integer instead. Inserting a string to this will return a 0.
Line 4,181 ⟶ 5,190:
=={{header|Rockstar}}==
Minimized:
<syntaxhighlight lang="rockstar">
Listen to A number
Listen to B
Say A number plus B
</syntaxhighlight>
Idiomatic:
<syntaxhighlight lang="rockstar">
Listen to my voice
Listen to your thoughts
Shout your thoughts with my voice
</syntaxhighlight>
=={{header|RPL}}==
Related task is natively implemented in RPL.
+
2 2 +
2 3 +
{{out}}
<pre>
2: 4
1: 5
</pre>
=={{header|Ruby}}==
<
=={{header|Run BASIC}}==
<
print val(word$(x$,1)) + val(word$(x$,2))</
=={{header|Rust}}==
<
fn main() {
Line 4,212 ⟶ 5,233:
}
println!("{}", i);
}</
or
<
fn main() {
Line 4,226 ⟶ 5,247:
.sum();
println!("{}", sum);
}</
=={{header|S-lang}}==
<
variable input, a, b;
Line 4,235 ⟶ 5,256:
input = strtrim_end(input, "\n");
() = sscanf(input, "%d%d", &a, &b);
print(a + b);</
{{out}}
Line 4,241 ⟶ 5,262:
46</pre>
<
variable input, a, b, rc;
Line 4,251 ⟶ 5,272:
} else {
message("input invalid or out of range (-1000,1000): $input"$);
}</
=={{header|Scala}}==
<
This will work if the input is exactly as specified, with no extra whitespace. A slightly more robust version:
<
val sum = s.nextInt() + s.nextInt()
println(sum)</
or
<
=={{header|Scheme}}==
<
=={{header|Scratch}}==
Line 4,276 ⟶ 5,297:
=={{header|sed}}==
Sed is for string processing and has no facility for manipulating numbers as numeric values. However, being Turing complete, sed can be coerced into performing mathematics.
<
# All done
/^-*00* /s///
Line 4,301 ⟶ 5,322:
# Decrement 2nd
s/\([^0]\)\(0*\);[^0]*\1\(.\).*\2\(9*\).*/\3\4/
t Loop</
Another method, based off of [http://unix.stackexchange.com/a/36959/11750 this StackExchange answer]:
<
# Add a marker in front of each digit, for tracking tens, hundreds, etc.
Line 4,342 ⟶ 5,363:
s/</|/g
t back
s/^$/0/</
=={{header|Seed7}}==
<
const proc: main is func
Line 4,355 ⟶ 5,376:
read(b);
writeln(a + b);
end func;</
=={{header|Self}}==
Works with positive and negative integers, and also more than two integers.
<
=={{header|SenseTalk}}==
<
put it into a
Line 4,369 ⟶ 5,390:
put it into b
put a + b</
<
split inputFile by space
put sum of inputFile</
=={{header|SequenceL}}==
<
main(args(2)) := stringToInt(args[1]) + stringToInt(args[2]);</
{{Out}}
Line 4,390 ⟶ 5,411:
=={{header|SETL}}==
<
print(A + B);</
=={{header|Shiny}}==
<
say "$a $b %(a+b)d"
end</
=={{header|Sidef}}==
Works with both positive and negative integers.
<
More idiomatically:
<
Explicit summation:
<
say a+b</
=={{header|Simula}}==
<
WHILE NOT LASTITEM DO
BEGIN
Line 4,417 ⟶ 5,438:
END;
END.
</syntaxhighlight>
=={{header|Smalltalk}}==
Most Smalltalk implementations do not have the notion of a standard input stream, since it has always been a GUI based programming environment. I've included test methods to demonstrate one way to create an input stream with two integers can be created. Opening a text file would be another.
<
Object subclass: #ABTask
instanceVariableNames: ''
Line 4,450 ⟶ 5,471:
test3Plus2
^ self
sum: (ReadStream on: '3 2')! !</
but all have a stream hierarchy, so the task could be restated to pass input and output as stream arguments:
{{works with|Smalltalk/X}}
{{works with|VisualWorks Smalltalk}}
<
task := [:inStream :outStream |
|processLine|
Line 4,473 ⟶ 5,494:
].
task value: ( 'dataIn.txt' asFilename readStream) value:Transcript.</
or:
<
=={{header|smart BASIC}}==
<
PRINT VAL(LEFT$(n$,(LEN(STR$(VAL(n$))))))+VAL(RIGHT$(n$,(LEN(n$)-LEN(STR$(VAL(n$)))-1)))</
<b>NOTE:</b> This is a horribly forced way of doing this. smart BASIC has commands to SPLIT strings. Surely someone can provide better code than what I've written here. ;@)
Line 4,487 ⟶ 5,508:
A FAR more elegant solution was provided by "Dutchman" on the smart [http://kibernetik.pro/forum/viewforum.php?f=2 BASIC Support Forum]:
<
SPLIT n$ TO m$,n WITH " "
PRINT m$(0),m$(1),m$(0)+m$(1)</
<b>NOTE:</b> smart BASIC will intelligently interpret the contents of a string as a numeric value if necessary. Other versions of BASIC would require the values stored in a string to be converted to numeric values before calculation.
=={{header|SmileBASIC}}==
<
INPUT B
PRINT A+B
</syntaxhighlight>
=={{header|SNOBOL4}}==
Simple-minded solution (literally "two somethings separated by space")
<
output = a + b
end</
"Integer aware" solution:
<
input span(nums) . a break(nums) span(nums) . b
output = a + b
end</
=={{header|SPAD}}==
Line 4,515 ⟶ 5,536:
{{works with|Axiom}}
One of several possibilities:
<
333 444
(1) 777
Type: PositiveInteger</
Domain:[http://fricas.github.io/api/SExpression.html?highlight=lisp SExpression]
=={{header|SparForte}}==
As a structured script.
<syntaxhighlight lang="ada">#!/usr/local/bin/spar
pragma annotate( summary, "aplusb" )
@( description, "A+B - in programming contests, classic problem, which is given so" )
@( description, "contestants can gain familiarity with online judging system being used. " )
@( description, "A+B is one of few problems on contests, which traditionally lacks fabula." )
@( description, "Given 2 integer numbers, A and B. One needs to find their sum. " )
@( category, "tutorials" )
@( author, "Ken O. Burtch" )
@( see_also, "http://rosettacode.org/wiki/A%2BB" );
pragma license( unrestricted );
pragma software_model( nonstandard );
pragma restriction( no_external_commands );
procedure aplusb is
s : string;
a : integer;
b : integer;
begin
s := get_line;
a := numerics.value( strings.field( s, 1, ' ' ) );
b := numerics.value( strings.field( s, 2, ' ' ) );
? a+b;
end aplusb;</syntaxhighlight>
=={{header|SPARK}}==
<
-- Validates with SPARK GPL 2010's Examiner/Simplifier
Line 4,567 ⟶ 5,615:
Stop => 0);
end if;
end A_Plus_B;</
=={{header|SPL}}==
<
#.output(n[1],"+",n[2],"=",#.val(n[1])+#.val(n[2]))</
{{in}}
<pre>
Line 4,583 ⟶ 5,631:
=={{header|SQL}}==
<syntaxhighlight lang
Example:
<syntaxhighlight lang
This should produce a result set containing the value 5.
Line 4,593 ⟶ 5,641:
{{works with|Db2 LUW}}
With SQL only:
<
CREATE OR REPLACE FUNCTION splitadd (instring VARCHAR(255))
Line 4,608 ⟶ 5,656:
return first + second;
END
</syntaxhighlight>
Output:
<pre>
Line 4,619 ⟶ 5,667:
=={{header|SSEM}}==
The SSEM has no Add instruction, so we rely on the fact that <i>a</i> + <i>b</i> = -(-<i>a</i> - <i>b</i>).
<
01100000000001010000000000000000 1. Sub. 6 acc -= B
11100000000001100000000000000000 2. c to 7 X = acc
Line 4,626 ⟶ 5,674:
10100100000000000000000000000000 5. 37 A
00111000000000000000000000000000 6. 28 B
00000000000000000000000000000000 7. 0 X</
=={{header|Standard ML}}==
<
* val split : string -> string list
* splits a string at it spaces
*)
val split = String.
(*
* val
*
*)
val sum = foldl op+ 0
(*
Line 4,646 ⟶ 5,694:
*)
fun aplusb () =
{{out}}
<pre>
Line 4,661 ⟶ 5,709:
{{works with|Swift|2}}
Requires sending EOF.
<
let input = NSFileHandle.fileHandleWithStandardInput()
Line 4,672 ⟶ 5,720:
let b = (nums[1] as String).toInt()!
print(" \(a + b)")</
{{works with|Swift|3}}
Line 4,678 ⟶ 5,726:
Swift 4 and no requirement to send EOF (press enter/send newline like you normally would)
<syntaxhighlight lang="swift">
import Foundation
Line 4,693 ⟶ 5,741:
print(" \(a + b)")
</syntaxhighlight>
=={{header|Symsyn}}==
<syntaxhighlight lang="symsyn">
[] $s
Line 4,704 ⟶ 5,752:
y []
</syntaxhighlight>
=={{header|Tailspin}}==
<
composer nums
[ (<WS>?) <INT> (<WS>) <INT> (<WS>?) ]
Line 4,714 ⟶ 5,762:
$IN::lines -> nums -> $(1) + $(2) -> '$;
' -> !OUT::write
</syntaxhighlight>
Alternatively
<
composer nums
(<WS>?) (def a: <INT>;) (<WS>) <INT> -> $a + $ (<WS>?)
Line 4,724 ⟶ 5,772:
$IN::lines -> nums -> '$;
' -> !OUT::write
</syntaxhighlight>
=={{header|Tcl}}==
<
puts [expr {$x + $y}]</
Alternatively:
<
To/from a file:
<
set out [open "output.txt" w]
scan [gets $in] "%d %d" x y
puts $out [expr {$x + $y}]
close $in
close $out</
=={{header|Terraform}}==
<syntaxhighlight lang="hcl">
#Aamrun, August 15th, 2022
variable "a" {
type = number
}
variable "b" {
type = number
}
output "a_plus_b" {
value = var.a + var.b
}
</syntaxhighlight>
{{out}}
<pre>
$ terraform apply -var="a=136" -var="b=745" -auto-approve
Changes to Outputs:
+ a_plus_b = 881
You can apply this plan to save these new output values to the Terraform state, without changing any real infrastructure.
Apply complete! Resources: 0 added, 0 changed, 0 destroyed.
Outputs:
a_plus_b = 881
$
</pre>
=={{header|TI-83 BASIC}}==
<
:Disp A+B</
=={{header|TI-83 Hex Assembly}}==
Line 4,747 ⟶ 5,828:
Note: Comments (after the semicolons) are just for explanation -- TI-83 hex assembly does not allow comments in program source code.
<
:AsmPrgm
:
Line 4,763 ⟶ 5,844:
:F7 ; rst FPAdd
:EFBF4A ; StoAns
:C9 ; ret</
Store the inputs in the 'A' and 'B' OS variables. Run it with Asm(prgmAPLUSB) and the output will be stored in the Ans OS variable.
=={{header|TI-89 BASIC}}==
<
:a+b</
=={{header|TorqueScript}}==
Since torque is not compatible with standard input, I will show the closest to that.
It's a function that takes a single string input, that will contain the 2 numbers.
<
{
return getWord(%input, 0) + getWord(%input, 1);
}</
=={{header|Transd}}==
<syntaxhighlight lang="scheme">#lang transd
MainModule : {
a: Int(),
b: Int(),
_start: (lambda (textout (+ (read a) (read b))))
}</syntaxhighlight>
=={{header|TSE SAL}}==
<syntaxhighlight lang="tsesal">
INTEGER PROC FNMathGetSumAPlusBI( INTEGER A, INTEGER B )
RETURN( A + B )
END
//
PROC Main()
STRING s1[255] = "3"
STRING s2[255] = "2"
IF ( NOT ( Ask( "math: get: sum: a: plus: a (choose a number between -1000 and 1000) = ", s1, _EDIT_HISTORY_ ) ) AND ( Length( s1 ) > 0 ) ) RETURN() ENDIF
IF ( NOT ( Ask( "math: get: sum: a: plus: b (choose a number between -1000 and 1000) = ", s2, _EDIT_HISTORY_ ) ) AND ( Length( s2 ) > 0 ) ) RETURN() ENDIF
Message( FNMathGetSumAPlusBI( Val( s1 ), Val( s2 ) ) ) // gives e.g. 5
END
</syntaxhighlight>
{{out}} <pre>
output
5
</pre>
=={{header|TUSCRIPT}}==
<
SET input="1 2"
SET input=SPLIT(input,": :")
SET input=JOIN (input)
SET output=SUM(input)</
=={{header|TXR}}==
Line 4,801 ⟶ 5,910:
=={{header|UNIX Shell}}==
{{works with|Bourne Shell}}
<
read a b || exit
echo `expr "$a" + "$b"`</
{{works with|bash}}
Line 4,810 ⟶ 5,919:
{{works with|zsh}}
Script "a+b.sh":
<
read a b || exit
echo $(( a + b ))</
{{Out}}
<
5</
One liner :
<syntaxhighlight lang="bash">
a=0;b=0;read a;read b;echo "Sum of $a and $b is "$((a+b))
</syntaxhighlight>
Sample run :
<pre>
3
4
Sum of 3 and 4 is 7
</pre>
==={{header|C Shell}}===
<
set input=($line)
@ sum = $input[1] + $input[2]
echo $sum</
=={{header|Ursa}}==
<syntaxhighlight lang="text">#
# a + b
#
Line 4,838 ⟶ 5,959:
# output the sum
out sum endl console</
=={{header|Ultimate++}}==
<syntaxhighlight lang="cpp">
#include <Core/Core.h>
#include <stdio.h>
#include <iostream>
using namespace Upp;
CONSOLE_APP_MAIN
{
int a, b;
a = 2, b = 3;
printf("%d + %d = %d\n",a,b,(a + b));
std::cout << std::endl << a << " + " << b << " = " << (a + b) << std::endl;
const Vector<String>& cmdline = CommandLine();
for(int i = 0; i < cmdline.GetCount(); i++) {
}
}
</syntaxhighlight>
=={{header|Ursala}}==
Using standard input and output streams:
<
#import int
#executable&
main = %zP+ sum:-0+ %zp*FiNCS+ sep` @L</
Overwriting a text file named as a command line parameter:
<
#import int
#executable -[parameterized]-
main = ~command.files.&h; <.contents:= %zP+ sum:-0+ %zp*FiNCS+ sep` @L+ ~contents></
Creating a new file named after the input file with suffix <code>.out</code>:
<
#import int
Line 4,865 ⟶ 6,012:
~command.files.&h; ~&iNC+ file$[
contents: %zP+ sum:-0+ %zp*FiNCS+ sep` @L+ ~contents,
path: ~path; ^|C\~& ~=`.-~; ^|T/~& '.out'!]</
=={{header|Vala}}==
Read from stdin while program running:
<
int main (string[] args) {
Line 4,879 ⟶ 6,026:
return 0;
}
</syntaxhighlight>
=={{header|VBA}}==
A simple version:
<
Dim s As String, t As Variant, a As Integer, b As Integer
s = InputBox("Enter two numbers separated by a space")
t = Split(s)
a = CInt(t(0))
b = CInt(t(1))
MsgBox a + b
End Sub</syntaxhighlight>
An other version:
<syntaxhighlight lang="vba">Sub Rosetta_AB()
Dim stEval As String
stEval = InputBox("Enter two numbers, separated only by a space", "Rosetta Code", "2 2")
Line 4,889 ⟶ 6,045:
"VBA converted this input to " & Replace(stEval, " ", "+") & vbCr & vbCr & _
"And evaluated the result as " & Evaluate(Replace(stEval, " ", "+")), vbInformation + vbOKOnly, "XLSM"
End Sub</
=={{header|VBScript}}==
A simple version:
<syntaxhighlight lang="vb">s=InputBox("Enter two numbers separated by a blank")
t=Split(s)
a=CInt(t(0))
b=CInt(t(1))
c=a+b
MsgBox c </syntaxhighlight>
An other version:
<syntaxhighlight lang="vb">Option Explicit
Dim a, b
Select Case WScript.Arguments.Count
Line 4,928 ⟶ 6,092:
.Close
End With
end if</
=={{header|Vedit macro language}}==
This version implements the task as specified in the task description.
<syntaxhighlight lang="vedit">// Input two values on single line in text format
Get_Input(10, "Enter two integers separated by a space: ")
// Extract two numeric values from the text
Buf_Switch(Buf_Free)
Reg_Ins(10)
BOF
#1 = Num_Eval(ADVANCE)
#2 = Num_Eval()
Buf_Quit(OK)
// Calculate and display the results
Num_Type(#1 + #2)</syntaxhighlight>
A simpler version that prompts for the two numbers separately:
<syntaxhighlight lang="vedit">#1 = Get_Num("Enter number A: ")
#2 = Get_Num("Enter number B: ")
Num_Type(#1 + #2)</syntaxhighlight>
=={{header|Verilog}}==
<
reg signed [11:0] y;
Line 4,949 ⟶ 6,134:
endfunction
endmodule</
=={{header|VHDL}}==
<
USE std.TEXTIO.all;
Line 4,974 ⟶ 6,159:
wait; -- needed to stop the execution
end process;
end architecture beh;</
=={{header|Visual Basic .NET}}==
<
Sub Main()
Line 4,986 ⟶ 6,171:
End Sub
End Module</
=={{header|V (Vlang)}}==
<
fn main() {
Line 5,003 ⟶ 6,188:
println('$a + $b = ${a+b}')
}</
Read from stdin
{{out}}
Line 5,013 ⟶ 6,198:
=={{header|Wee Basic}}==
<
input a
Print 1 "Enter number B:"
Line 5,019 ⟶ 6,204:
let c=a+b
print 1 c
end</
=={{header|Whitespace}}==
<
Line 5,034 ⟶ 6,219:
</syntaxhighlight>
=={{header|Wisp}}==
{{trans|Scheme}}
<syntaxhighlight lang="scheme">
display : + (read) (read)
314
315
;; displays 629
</syntaxhighlight>
=={{header|Wren}}==
<
while (true) {
Line 5,051 ⟶ 6,247:
return
}
}</
{{out}}
Line 5,062 ⟶ 6,258:
=={{header|X86 Assembly}}==
{{works with|NASM|Linux}}
<
global _start
Line 5,121 ⟶ 6,317:
a resd 1
b resd 1
sum resd 1</
This will not work on numbers over 0(from 1 to 0). This is due to the fact, numbers higher than 0(10,11, etc) are in fact strings when taken from the keyboard. A much longer conversion code is required to loop through and treat each number in the string as separate numbers. For example, The number '10' would have to be treated as a 1 and a 0.
=={{header|XBS}}==
Since XBS is written in Javascript, we have to use the Javascript prompt function to get inputs.
<syntaxhighlight lang="xbs">const Amount:number = toint(window.prompt("Input an amount"));
set Stream = [];
<|(*1..Amount)=>Stream.push(window.prompt("Input a number"));
Stream=Stream.join(" ");
const Inputs = <|(*Stream.split(" "))toint(_);
set Result = 0;
<|(*Inputs)Result+=_;
log(Result);</syntaxhighlight>
{{out}}
If we input an amount of "2", then input "1" and "2", the output will be "3".
<pre>
3
</pre>
=={{header|xEec}}==
<
=={{header|XLISP}}==
<
(DISPLAY "Enter two numbers separated by a space.")
(NEWLINE)
Line 5,134 ⟶ 6,346:
(DEFINE A (READ))
(DEFINE B (READ))
(+ A B))</
{{out}}
<pre>(A-PLUS-B)
Line 5,141 ⟶ 6,353:
4</pre>
=={{header|Xojo}}==
<syntaxhighlight lang="xojo">var inp as string
var strVals() as string
print("Enter two numbers separated by a space:")
do
inp = input
strVals = inp.split(" ")
var a, b as integer
a = strVals(0).toInteger
b = strVals(1).toInteger
if a < -1000 or b > 1000 then
print("The first number should be greater than or equal to -1000 and the second number should be less " + _
"than or equal to 1000. Please re-enter:")
continue
end
var result as integer = a + b
print(a.toString + " + " + b.toString + " = " + result.toString)
exit
loop
</syntaxhighlight>
=={{header|XPL0}}==
<
int A, B;
[A:= IntIn(0);
Line 5,149 ⟶ 6,390:
IntOut(0, A+B);
CrLf(0);
]</
=={{header|XQuery}}==
<
(:
Using the EXPath File Module, which is built into most XQuery processors
Line 5,168 ⟶ 6,409:
let $result := xs:numeric($numbers[1]) + xs:numeric($numbers[2])
return file:write-text($out, xs:string($result))
</syntaxhighlight>
=={{header|Yabasic}}==
<
input "Enter two numbers (betwen -1000 ... +1000): " a, b
until(valid(a) and valid(b))
Line 5,178 ⟶ 6,419:
sub valid(x)
return x >= -1000 and x <= 1000
end sub</
=={{header|Yorick}}==
<
read, a, b;
write, a + b;</
=={{header|ZED}}==
Source -> http://ideone.com/WLtEfe
Compiled -> http://ideone.com/fMt6ST
<
comment:
#true
Line 5,201 ⟶ 6,442:
comment:
#true
(001) "read"</
=={{header|Zig}}==
<syntaxhighlight lang="zig">
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const Input = enum { a, b };
pub fn main() !void {
var buf: [1024]u8 = undefined;
const reader = std.io.getStdIn().reader();
const input = try reader.readUntilDelimiter(&buf, '\n');
const values = std.mem.trim(u8, input, "\x20");
var count: usize = 0;
var split: usize = 0;
for (values, 0..) |c, i| {
if (!std.ascii.isDigit(c)) {
count += 1;
if (count == 1) split = i;
}
}
const a = try std.fmt.parseInt(u64, values[0..split], 10);
const b = try std.fmt.parseInt(u64, values[split + count ..], 10);
try stdout.print("{d}\n", .{a + b});
}
</syntaxhighlight>
{{out}}
<pre>
1 2
3
3 6
9
</pre>
=={{header|zkl}}==
<
<pre>
A B: 123 567
Line 5,214 ⟶ 6,492:
=={{header|Zoea}}==
<
input: '7 11'
output: 18
</syntaxhighlight>
=={{header|Zoea Visual}}==
[http://zoea.co.uk/examples/zv-rc/A_plus_b.png A+B]
=={{header|zonnon}}==
<
module ABProblem;
var
Line 5,228 ⟶ 6,509:
writeln(a+b)
end ABProblem.
</syntaxhighlight>
<pre>
1 2
Line 5,235 ⟶ 6,516:
=={{header|ZX Spectrum Basic}}==
<
20 INPUT LINE a$
30 GO SUB 90
Line 5,244 ⟶ 6,525:
80 REM LTrim operation
90 IF a$(1)=" " THEN LET a$=a$(2 TO ): GO TO 90
100 RETURN</
Another solution
<
20 INPUT LINE a$
30 LET ll=10e10: LET ls=0: LET i=1
Line 5,256 ⟶ 6,537:
70 LET i=i+1: GO TO 40
80 LET a=VAL a$( TO i): LET b=VAL a$(i TO )
90 PRINT a;" + ";b;" = ";a+b</
<pre>
|