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|AsciiDots}}==

&-#$-\

.-#?-[+]

.-#?--/

 

=={{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}}===

uses console

int i

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}}===

Print "The sum is: ";s

End

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}}==

BlooP and FlooP can't actually read from stdin, but here's the procedure it would use, if it could.

DEFINE PROCEDURE ''ADD'' [A, B]:

BLOCK 0: BEGIN

OUTPUT <= A + B;

BLOCK 0: END.

 

=={{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}}==

.

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}}==

public program()

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

 

Or more generic solution:

import extensions;

 

console.printLine(console.readLine()

.split()

.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

 

 

=={{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}}==

_window = 1

begin enum 1

 

HandleEvents

{{output}}

<pre>

-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]))

 

Output:

<pre>

=={{header|Gastona}}==

Taking A and B from command line arguments

 

<main>

"@<p1> + @<p2> = "

=, p1 + p2

Using Graphical interface

 

<layout of main>

<suma> =, eA + eB

 

=={{header|Gema}}==

 

=={{header|Genie}}==

/*

A+B in Genie

print "B" + warning

 

 

{{out}}

 

=={{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)));

 

=={{header|Go}}==

 

import "fmt"

fmt.Scan(&a, &b)

fmt.Println(a + b)

 

=={{header|Golfscript}}==

 

=={{header|Golo}}==

----

This module asks for two numbers, adds them, and prints the result.

println("they both need to be numbers for this to work")

}

 

=={{header|Gosu}}==

uses java.io.InputStreamReader

uses java.util.Scanner

 

print( a + b )

 

=={{header|Groovy}}==

def reader = new Scanner(System.in)

def a = reader.nextInt();

a + b

}

 

=={{header|GUISS}}==

We cannot use variables, but we can find the sum of two numbers.Here we add 3 + 2:

 

=={{header|Harbour}}==

LOCAL GetList := {}

LOCAL bValid := { |n| iif(n>-1001, iif(n<1001, .T.,.F.),.F.) }

 

RETURN

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

let a tonum nums[0]

let b tonum nums[1]

 

=={{header|HicEst}}==

A and B are input via edit controls with spinners limiting inputs to +-1000.

 

=={{header|Hoon}}==

|= [a=@ud b=@ud] (add a b)

 

=={{header|Hope}}==

 

=={{header|Huginn}}==

import Text as text;

 

);

);

 

=={{header|Hy}}==

Alternatively, with the "threading tail" macro:

 

=={{header|i}}==

 

=={{header|Icon}} and {{header|Unicon}}==

numChars := '-'++&digits

read() ? {

}

write((\A + \B) | "Bad input")

 

=={{header|Idris}}==

main = do

line <- getLine

 

=={{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:

echo +/". (1!:1(3))-.LF

 

=={{header|Java}}==

 

public class Sum2 {

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.*;

 

out.println(nextInt() + nextInt());

}

 

The following code uses a StreamTokenizer instead of a Scanner.

 

import java.nio.charset.Charset;

 

}

}

 

 

grammar aplusb ;

 

NEWLINE : WS* '\r'? '\n'

;

Produces:

<pre>

Client side:

 

<body>

<div id='input'></div>

</script>

</body>

 

Server side (with [http://nodejs.org node.js]):

 

'data',

function (line) {

process.exit()

}

 

$ node io.js

=== ES6 ===

Node.js in a terminal:

console.log(

(buffer + "").trim().split(" ").map(Number).reduce((a, v) => a + v, 0)

);

});

 

<pre> $ node io.js

 

=== JScript Windows Script Host Version 5.8 ===

var b = WScript.StdIn.ReadLine();

WSH.echo(a, " + " , b , " = " , Number(a)+Number(b));

 

=={{header|Joy}}==

===Console===

===File===

"output.txt" "w" fopen

 

=={{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

def addpairs:

if length < 2 then empty

end;

 

$ jq -s -f AB.jq

1 2 3 4 5 6

3

7

 

=={{header|Jsish}}==

var line = console.input();

var nums = line.match(/^\s*([+-]?[0-9]+)\s+([+-]?[0-9]+)\s*/);

} else {

puts("error: A+B requires two numbers separated by space");

 

{{out}}

=={{header|Julia}}==

Run from the command line:

 

{{out}}

 

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

 

=={{header|K}}==

split:{(a@&~&/' y=/: a:(0,&x=y)_ x) _dv\: y}

ab:{+/0$split[0:`;" "]}

2 3

5

 

=={{header|Keg}}==

[https://tio.run/##y05N//9fW@//f1MDLjMDAA Try it online!]

 

Or, using flags (<code>-hr</code>):

[https://tio.run/##y05N//9f@/9/UwMuM4P/uhlFAA Try it online!]

 

=={{header|Kite}}==

 

import "System.file";

 

line = in|readline;

{{Out}}

<pre>

 

=={{header|Klong}}==

{(1:$(*x?0c )#x)+1:$(1+*|x?0c )_x}@.rl()

2 3

5

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

}

}

 

{{out}}

 

=={{header|KQL}}==

'2 2',

'3 2'

]

| parse Input with A:int ' ' B:int

 

=={{header|L++}}==

(decl int a)

(decl int b)

(>> std::cin a b)

 

=={{header|Lambdatalk}}==

Lambdatalk works in a wiki, lambdatank.

 

Several boxes can be created in the wiki page

with any valid lambdatalk expressions.

 

=={{header|Lang5}}==

 

 

=={{header|Lasso}}==

 

=={{header|LIL}}==

# Requires lil shell readline routine

set in [readline]

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 }

 

{{out}}

 

=={{header|Lisaac}}==

+ name := A_PLUS_B

 

Section Public

- main <- ( (IO.read_integer; IO.last_integer) +

 

=={{header|Little}}==

string a, b;

scan(gets(stdin), "%d %d", &a, &b);

puts(((int)a + (int)b));

 

=={{header|Little Man Computer}}==

 

'''Assembly'''

STA 99

INP

OUT

HLT

 

'''Machine code'''

01 STA 99

02 INP

03 ADD 99

04 OUT

 

=={{header|LiveCode}}==

Using Livecode Server script

if isNumber($0) and isNumber($1) then

put $0 + $1

put $0 && $1

end if

 

A graphical version using an input dialog

ask "Enter two numbers"

set itemdelimiter to space

answer item 1 of nums && item 2 of nums

end if

 

=={{header|Logo}}==

 

=={{header|Lua}}==

 

=={{header|M2000 Interpreter}}==

Do {

Input A%, B%

} Until Range(A%) And Range(B%)

 

=={{header|M4}}==

 

sumstr(1 2)

 

=={{header|Maple}}==

23 34

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Interactive in a notebook

 

=={{header|MATLAB}} / {{header|Octave}}==

inputStream = input('Enter two numbers, separated by a space: ', 's');

numbers = str2num(inputStream); %#ok<ST2NM>

end

sumOfInputs = sum(numbers);

 

=={{header|Maude}}==

===Built-in===

red 3 + 4 .

===With restrictions===

fmod ADD is

 

endfm

 

=={{header|Maxima}}==

unless (line: readline(in_stream), line=false) do (

q: map('parse_string, split(line, " ")),

);

close(in_stream);

 

=={{header|Mercury}}==

:- interface.

 

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)

else

print val(fields[0]) + val(fields[1])

 

{{out}}

 

=={{header|mIRC Scripting Language}}==

echo -ag $calc($1 + $2)

 

=={{header|МК-61/52}}==

=={{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

MCSKIP SL WITH *

MCSET S1=1

 

=={{header|Modula-2}}==

 

IMPORT InOut;

InOut.WriteInt (A + B, 8);

InOut.WriteLn

 

=={{header|Modula-3}}==

 

IMPORT IO;

IO.PutInt(A+B);

IO.Put("\n");

 

=={{header|MoonScript}}==

 

=={{header|MUMPS}}==

NEW A,B,T,S

READ !,"Input two integers between -1000 and 1000, separated by a space: ",S

IF T WRITE !,(A+B)

IF 'T WRITE !,"Bad input"

 

=={{header|Nanoquery}}==

line = input()

// add the two numbers and print the result

 

=={{header|Neko}}==

A+B, Rosetta Code, in Neko

Tectonics:

} else $print("Need two numbers, separated by whitespace\n")

 

 

{{out}}

=={{header|Nemerle}}==

{{trans|C#}}

using System.Console;

using System.Linq;

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

}

 

=={{header|NetRexx}}==

 

options replace format comments java symbols binary

 

parse ask a b .

 

=={{header|newLISP}}==

 

=={{header|Nim}}==

A+B:

# Takes 2 inputs of Floats and adds them (which is not correct for the exercise, will revisit, Thank you

 

let second: float = getnumber()

 

 

The puzzle requires 1 input, 2 INTS separated by a space, than a+b

=={{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(" ")

return

end

 

=={{header|NS-HUBASIC}}==

20 INPUT "ENTER NUMBER B: ",B

 

=={{header|Nyquist}}==

===SAL Syntax===

;version 1

;type tool

print a + b

 

===Audacity plug-in (SAL syntax)===

;version 1

;type tool

print a + b

 

 

=={{header|Oberon-2}}==

 

IMPORT In, Out;

Out.Int (A + B, 8);

Out.Ln

Producing

<pre>

 

=={{header|Objeck}}==

class Vander {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|OCaml}}==

 

=={{header|Oforth}}==

Works with any number of integers separated by a space.

 

 

 

=={{header|Ol}}==

Note: input data must be separated by newline ([Enter] key press).

 

(+ (read) (read))

 

 

(print a " + " b " = " (+ a b)))

 

=={{header|Onyx}}==

 

`\nEnter two numbers between -1000 and +1000,\nseparated by a space: ' print flush

} def

} def

 

 

=={{header|ooRexx}}==

===version 1===

{{trans|REXX}}

Say 'enter some numbers to be summed:'

parse pull y

Parse arg list

list=space(list)

{{out}}

<pre>enter some numbers to be summed:

===version 2===

extend for negative numbers

Say 'enter some numbers to be summed:'

parse pull y

End

Say yplus '=' sum/1

 

=={{header|OpenEdge/Progress}}==

DEFINE VARIABLE b AS INTEGER NO-UNDO FORMAT "->>>9".

 

UPDATE a b.

 

 

=={{header|Openscad}}==

There is no means of run-time input in Openscad

a = 5 + 4;

echo (a);

 

=={{header|Order}}==

 

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))))

 

ORDER_PP(8int_to_lit(8int_add(A, B)))

 

=={{header|Oxygene}}==

// Sum 2 integers read fron standard input

//

end.

Produces:

<pre>

 

=={{header|Oz}}==

class TextFile from Open.file Open.text end

 

end

in

 

=={{header|PARI/GP}}==

User input:

File input:

 

=={{header|Pascal}}==

a, b: integer;

begin

readln(a, b);

writeln(a + b);

Same with input from file <tt>input.txt</tt> and output from file <tt>output.txt</tt>.

a, b: integer;

begin

close(input);

close(output);

===Version 2. Following the rules===

Sum of A + B while A, B >= -1000 and A,B <= 1000

Author: Sinuhe Masan (2019) }

writeln('The sum is: ', A + B);

 

 

=={{header|Perl}}==

 

=== using the List::Util module ===

 

=={{header|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: #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>

{{out}}

<pre>

</pre>

=== GUI version ===

<small>(The above console version is now just a comment in the distributed file.)</small>

<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: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{header|Phixmonti}}==

by Galileo, 05/2022 #/

 

 

over over + >ps

{{out}}

<pre>Enter two numbers (betwen -1000 ... +1000) separated by space: 2 3

 

=={{header|PHP}}==

fscanf($in, "%d %d\n", $a, $b); //Reads 2 numbers from file $in

fclose($in);

$out = fopen("output.dat", "w");

fwrite($out, ($a + $b) . "\n");

 

=={{header|Picat}}==

go =>

println("Write two integers (and CR)"),

println(read_int()+read_int()).

 

{{out}}

 

=={{header|PicoLisp}}==

3 4

 

=={{header|Piet}}==

[[File:Piet A+B.png]]

The code is fairly straightforward. The individual commands are as follows:

in(num)

add

 

=={{header|Pike}}==

sscanf(line, "%d %d", int a, int b);

 

=={{header|PL/I}}==

 

=={{header|Pony}}==

actor Main

let _env:Env

_env.out.print(sum.string())

 

 

=={{header|PostScript}}==

dup

token pop % read A

token pop % read B

add

 

=={{header|Potion}}==

input = read

i = 0

 

# The numbers are manually inputted, but the format is improper (i.e., "%d\n%d\n").

 

=={{header|PowerShell}}==

This solution does not work interactively, while the following ''only'' works interactively:

 

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

 

=={{header|Processing}}==

===Rudimentary User Interface===

Click on either side to add 1 to its value.

int b = 0;

 

b++;

}

 

[https://i.imgur.com/QEHtMyA.jpg What the GUI looks like.]

=={{header|ProDOS}}==

With the math module:

editvar /newvar /value=b /title=Enter another integer:

editvar /newvar /value=c

do add -a-,-b-=-c-

Without the math module:

editvar /newvar /value=b /title=Enter another integer:

editvar /newvar /value=c=-a-+-b-

 

=={{header|Prolog}}==

{{Works with|SWI-Prolog}}

read_line_to_codes(user_input,X),

atom_codes(A, X),

maplist(atom_number, L, LN),

sumlist(LN, N),

output :

|: 4 5

9

 

=={{header|Pure}}==

 

=={{header|PureBasic}}==

===Console===

a=Val(StringField(x$,1," "))

b=Val(StringField(x$,2," "))

===File===

x$=ReadString(0)

a=Val(StringField(x$,1," "))

EndIf

CloseFile(0)

 

=={{header|Python}}==

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

 

 

===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:

 

===Console, Python 3 only===

b = int(input("Second number: "))

 

=={{header|QB64}}==

DIM c AS LONG

INPUT "Enter A: ", a

c = a + b

PRINT ""

 

'''Fully implemented version:'''

** 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.

b$ = LTRIM$(STR$(b)) ' | "

sum$ = LTRIM$(STR$(a + b)) ' | "

 

=={{header|Quackery}}==

 

=={{header|Quite BASIC}}==

20 input "Enter number B: ";b

 

=={{header|R}}==

 

=={{header|Ra}}==

class Sum

**Adds two given integers**

print to Console.error made !, "Numbers too large"

exit program with error code

 

=={{header|Racket}}==

 

#lang racket

(+ (read) (read))

 

Or, with additional error checking:

#lang racket

(define a (read))

(unless (number? b) (error 'a+b "number" b))

(displayln (+ a b))

 

=={{header|Raku}}==

 

Short version with very little "line noise":

Reduction operator <code>[+]</code>, and <code>say</code> as a function:

Long version:

 

=={{header|REBOL}}==

{{Out}}

<pre>1 2

 

=={{header|Red}}==

{{Out}}

<pre>1 2

 

Alternative implementations:

 

=={{header|Relation}}==

set input = "2 2"

set a = regexreplace(input,"^(-?\d+)\s+(-?\d+)+$","$1")

set b = regexreplace(input,"^(-?\d+)\s+(-?\d+)+$","$2")

echo a + b

 

=={{header|Retro}}==

1

 

=={{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. */

===version 2, normalizied===

If the user entered &nbsp; '''4.00000''' &nbsp; and wanted to add &nbsp; '''5''' &nbsp; to that, and expects &nbsp; '''9''',

 

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. */

 

===version 3, extended precision===

Using the &nbsp; '''numeric digits''' &nbsp; statement allows more decimal digits to be used, the default is &nbsp; '''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.*/

 

===version 4, multiple numbers===

This REXX version adds &nbsp; ''all'' &nbsp; the numbers entered &nbsp; (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.*/

end /*j*/

/*stick a fork in it, we're all done. */

 

===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.*/

y=translate(y,'+',' ')

Interpret 's='y

 

=={{header|Ring}}==

Numbers = split(Numbers)

sum = 0

func Split Str

for x in str if x = " " x = nl ok next

 

=={{header|Robotic}}==

input string "Input A:"

set "A" to "input"

* "('A' + 'B')"

end

 

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.

=={{header|Rockstar}}==

Minimized:

Listen to A number

Listen to B

Say A number plus B

Idiomatic:

Listen to my voice

Listen to your thoughts

Shout your thoughts with my voice

 

=={{header|Ruby}}==

 

=={{header|Run BASIC}}==

 

=={{header|Rust}}==

 

fn main() {

}

println!("{}", i);

 

or

 

 

fn main() {

.sum();

println!("{}", sum);

 

=={{header|S-lang}}==

variable input, a, b;

 

input = strtrim_end(input, "\n");

() = sscanf(input, "%d%d", &a, &b);

 

{{out}}

46</pre>

 

variable input, a, b, rc;

 

} 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()

 

or

 

 

=={{header|Scheme}}==

 

=={{header|Scratch}}==

=={{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///

# Decrement 2nd

s/\([^0]\)\(0*\);[^0]*\1\(.\).*\2\(9*\).*/\3\4/

 

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.

s/</|/g

t back

 

=={{header|Seed7}}==

 

const proc: main is func

read(b);

writeln(a + b);

 

=={{header|Self}}==

Works with positive and negative integers, and also more than two integers.

 

 

=={{header|SenseTalk}}==

put it into a

 

put it into b

 

split inputFile by space

 

=={{header|SequenceL}}==

 

 

{{Out}}

 

=={{header|SETL}}==

 

=={{header|Shiny}}==

say "$a $b %(a+b)d"

 

=={{header|Sidef}}==

Works with both positive and negative integers.

 

More idiomatically:

 

Explicit summation:

 

=={{header|Simula}}==

WHILE NOT LASTITEM DO

BEGIN

END;

END.

 

=={{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: ''

test3Plus2

^ self

 

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|

].

 

or:

 

=={{header|smart BASIC}}==

 

<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. ;@)

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 " "

 

<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

 

=={{header|SNOBOL4}}==

Simple-minded solution (literally "two somethings separated by space")

output = a + b

"Integer aware" solution:

input span(nums) . a break(nums) span(nums) . b

output = a + b

 

=={{header|SPAD}}==

{{works with|Axiom}}

One of several possibilities:

333 444

 

(1) 777

 

Domain:[http://fricas.github.io/api/SExpression.html?highlight=lisp SExpression]

 

=={{header|SPARK}}==

-- Validates with SPARK GPL 2010's Examiner/Simplifier

 

Stop => 0);

end if;

 

=={{header|SPL}}==

{{in}}

<pre>

 

=={{header|SQL}}==

Example:

This should produce a result set containing the value 5.

 

{{works with|Db2 LUW}}

With SQL only:

 

CREATE OR REPLACE FUNCTION splitadd (instring VARCHAR(255))

return first + second;

END

Output:

<pre>

=={{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

10100100000000000000000000000000 5. 37 A

00111000000000000000000000000000 6. 28 B

 

=={{header|Standard ML}}==

* val split : string -> string list

* splits a string at it spaces

in

(sum o List.mapPartial Int.fromString o split) input

{{out}}

<pre>

{{works with|Swift|2}}

Requires sending EOF.

 

let input = NSFileHandle.fileHandleWithStandardInput()

let b = (nums[1] as String).toInt()!

 

 

{{works with|Swift|3}}

Swift 4 and no requirement to send EOF (press enter/send newline like you normally would)

 

import Foundation

 

 

print(" \(a + b)")

 

=={{header|Symsyn}}==

 

[] $s

y []

 

 

=={{header|Tailspin}}==

composer nums

[ (<WS>?) <INT> (<WS>) <INT> (<WS>?) ]

$IN::lines -> nums -> $(1) + $(2) -> '$;

' -> !OUT::write

 

Alternatively

composer nums

(<WS>?) (def a: <INT>;) (<WS>) <INT> -> $a + $ (<WS>?)

$IN::lines -> nums -> '$;

' -> !OUT::write

 

=={{header|Tcl}}==

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

 

=={{header|TI-83 BASIC}}==

 

=={{header|TI-83 Hex Assembly}}==

Note: Comments (after the semicolons) are just for explanation -- TI-83 hex assembly does not allow comments in program source code.

 

:AsmPrgm

:

:F7 ; rst FPAdd

:EFBF4A ; StoAns

 

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}}==

 

=={{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}}==

 

MainModule : {

b: Int(),

_start: (lambda (textout (+ (read a) (read b))))

 

=={{header|TSE SAL}}==

INTEGER PROC FNMathGetSumAPlusBI( INTEGER A, INTEGER B )

RETURN( A + B )

Message( FNMathGetSumAPlusBI( Val( s1 ), Val( s2 ) ) ) // gives e.g. 5

END

{{out}} <pre>

output

 

=={{header|TUSCRIPT}}==

SET input="1 2"

SET input=SPLIT(input,": :")

SET input=JOIN (input)

 

=={{header|TXR}}==

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

read a b || exit

 

{{works with|bash}}

{{works with|zsh}}

Script "a+b.sh":

read a b || exit

{{Out}}

 

One liner :

 

a=0;b=0;read a;read b;echo "Sum of $a and $b is "$((a+b))

Sample run :

<pre>

 

==={{header|C Shell}}===

set input=($line)

@ sum = $input[1] + $input[2]

 

=={{header|Ursa}}==

# a + b

#

 

# output the sum

 

=={{header|Ultimate++}}==

 

#include <Core/Core.h>

#include <stdio.h>

 

 

 

 

=={{header|Ursala}}==

Using standard input and output streams:

#import int

 

#executable&

 

Overwriting a text file named as a command line parameter:

#import int

 

#executable -[parameterized]-

 

Creating a new file named after the input file with suffix <code>.out</code>:

#import int

 

~command.files.&h; ~&iNC+ file$[

contents: %zP+ sum:-0+ %zp*FiNCS+ sep` @L+ ~contents,

 

=={{header|Vala}}==

Read from stdin while program running:

 

int main (string[] args) {

return 0;

}

 

=={{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")

b = CInt(t(1))

MsgBox a + b

An other version:

Dim stEval As String

stEval = InputBox("Enter two numbers, separated only by a space", "Rosetta Code", "2 2")

"VBA converted this input to " & Replace(stEval, " ", "+") & vbCr & vbCr & _

"And evaluated the result as " & Evaluate(Replace(stEval, " ", "+")), vbInformation + vbOKOnly, "XLSM"

 

=={{header|VBScript}}==

A simple version:

t=Split(s)

a=CInt(t(0))

b=CInt(t(1))

c=a+b

An other version:

Dim a, b

Select Case WScript.Arguments.Count

.Close

End With

 

=={{header|Verilog}}==

 

reg signed [11:0] y;

endfunction

 

=={{header|VHDL}}==

USE std.TEXTIO.all;

 

wait; -- needed to stop the execution

end process;

 

=={{header|Visual Basic .NET}}==

 

Sub Main()

End Sub

 

 

 

fn main() {

println('$a + $b = ${a+b}')

Read from stdin

{{out}}

 

=={{header|Wee Basic}}==

input a

Print 1 "Enter number B:"

let c=a+b

print 1 c

 

=={{header|Whitespace}}==

 

 

 

=={{header|Wisp}}==

{{trans|Scheme}}

display : + (read) (read)

 

315

;; displays 629

 

=={{header|Wren}}==

 

while (true) {

return

}

 

{{out}}

=={{header|X86 Assembly}}==

{{works with|NASM|Linux}}

global _start

a resd 1

b 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.

set Stream = [];

<|(*1..Amount)=>Stream.push(window.prompt("Input a number"));

set Result = 0;

<|(*Inputs)Result+=_;

{{out}}

If we input an amount of "2", then input "1" and "2", the output will be "3".

 

=={{header|xEec}}==

 

=={{header|XLISP}}==

(DISPLAY "Enter two numbers separated by a space.")

(NEWLINE)

(DEFINE A (READ))

(DEFINE B (READ))

{{out}}

<pre>(A-PLUS-B)

 

=={{header|Xojo}}==

var strVals() as string

 

exit

loop

 

=={{header|XPL0}}==

int A, B;

[A:= IntIn(0);

IntOut(0, A+B);

CrLf(0);

 

=={{header|XQuery}}==

(:

Using the EXPath File Module, which is built into most XQuery processors

let $result := xs:numeric($numbers[1]) + xs:numeric($numbers[2])

return file:write-text($out, xs:string($result))

 

=={{header|Yabasic}}==

input "Enter two numbers (betwen -1000 ... +1000): " a, b

until(valid(a) and valid(b))

sub valid(x)

return x >= -1000 and x <= 1000

 

=={{header|Yorick}}==

read, a, b;

 

=={{header|ZED}}==

Source -> http://ideone.com/WLtEfe

Compiled -> http://ideone.com/fMt6ST

comment:

#true

comment:

#true

 

=={{header|zkl}}==

<pre>

A B: 123 567

 

=={{header|Zoea}}==

input: '7 11'

output: 18

 

=={{header|Zoea Visual}}==

 

=={{header|zonnon}}==

module ABProblem;

var

writeln(a+b)

end ABProblem.

<pre>

1 2

 

=={{header|ZX Spectrum Basic}}==

20 INPUT LINE a$

30 GO SUB 90

80 REM LTrim operation

90 IF a$(1)=" " THEN LET a$=a$(2 TO ): GO TO 90

 

Another solution

 

20 INPUT LINE a$

30 LET ll=10e10: LET ls=0: LET i=1

70 LET i=i+1: GO TO 40

80 LET a=VAL a$( TO i): LET b=VAL a$(i TO )

 

<pre>