A+B: Difference between revisions

 

=={{header|0815}}==

 

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

{{trans|Python}}

 

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

APLUSB CSECT

USING APLUSB,R12

 

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

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

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program addAetB.s */

 

=={{header|ABAP}}==

data: lv_output type i.

selection-screen begin of block input.

lv_output = p_first + p_second.

write : / lv_output.</syntaxhighlight>

 

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

BYTE i

FOR i=1 TO s(0)

 

=={{header|Ada}}==

 

with Ada.Integer_Text_Io;

end APlusB;</syntaxhighlight>

Using appropriate user defined types:

 

procedure A_Plus_B is

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

 

=={{header|Aime}}==

list l;

 

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

{{works with|A60}}

comment A+B;

integer a,b;

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

print((read int + read int))</syntaxhighlight>

 

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

integer a, b;

read( a, b );

 

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

#include <hbasic.h>

 

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

 

#include <hbasic.h>

 

 

=={{header|Apex}}==

 

static Integer sumOfTwoNums(Integer A, Integer B) {

 

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

 

=={{header|Arc}}==

(prn (+ (read)

(read)))

{{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)</syntaxhighlight>

(: Output file: output.txt :)

use std, array

Exploiting C standard library functions (scanf and printf).

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

 

.global main

.extern printf

Save in ab.S

Build with:

ld -o a.out ab.o</syntaxhighlight>

 

.align 2

.code 32

=={{header|Arturo}}==

 

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

print add x\0 x\1

 

=={{header|AsciiDots}}==

&-#$-\

.-#?-[+]

.-#?--/

 

=={{header|ATS}}==

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

//

=={{header|AutoHotkey}}==

This handles more than two inputs

Gui, Add, Button, gAdd, Add

Gui, Add, Edit, ReadOnly x+10 w80

 

=={{header|AutoIt}}==

$num = "45 54"

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

===Example2===

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

 

Func Sum($inp)

 

=={{header|AWK}}==

 

=={{header|BASIC}}==

 

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

 

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

INPUT d$

PRINT VAL(TOKEN$(d$, 1)) + VAL(TOKEN$(d$, 2))</syntaxhighlight>

 

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

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

a = explode(t$," ")

 

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

hereY% = VPOS

INPUT LINE "" q$

UNTIL FALSE</syntaxhighlight>

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</syntaxhighlight>

 

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

20 INPUT X$

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

 

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

 

Dim As Integer a, b

Print "Press any key to quit the program"

Sleep</syntaxhighlight>

 

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

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

END</syntaxhighlight>

 

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

 

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

print eval(word$(n$,1);" + ";word$(n$,2))</syntaxhighlight>

 

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

uses console

int i

 

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

20 LET I=1

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

50 GOTO 30

60 PRINT VAL A$( TO I-1)+VAL A$(I+1 TO )</syntaxhighlight>

 

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

REM by Jjuanhdez, 06/2022

 

 

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

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

Print "The sum is: ";s

End

Loop

Return (b@)</syntaxhighlight>

 

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

Prompts version

@echo off

setlocal

endlocal</syntaxhighlight>

All on the commandline version

@echo off

setlocal

endlocal</syntaxhighlight>

Formula on the command line version

@echo off

setlocal

</pre>

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

@echo off

setlocal

=={{header|bc}}==

{{Works with|GNU bc}}

 

=={{header|Befunge}}==

 

=={{header|Bird}}==

 

define Main

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

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

 

 

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

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

 

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

TODO if first symbol is a minus sign print Qgo awayQ

+> initialize sum to one

 

=={{header|Brat}}==

p numbers[0] + numbers[1] #Prints the sum of the input</syntaxhighlight>

 

=={{header|Burlesque}}==

 

=={{header|C}}==

#include <stdio.h>

int main()

return 0;

}</syntaxhighlight>

// Output file: output.txt

#include <stdio.h>

return 0;

}</syntaxhighlight>

#include <stdio.h>

#include <stdlib.h>

 

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

using System.Linq;

 

}</syntaxhighlight>

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

 

class Program

 

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

#include <iostream>

using namespace std;

cout << a + b << endl;

}</syntaxhighlight>

// Output file: output.txt

#include <fstream>

 

=={{header|Ceylon}}==

 

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

}

}</syntaxhighlight>

 

=={{header|Clojure}}==

3

4

=>7</syntaxhighlight>

3 3

6</syntaxhighlight>

 

Translation of Common Lisp version:

3 4

7</syntaxhighlight>

 

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.

 

A second version.

 

 

IDENTIFICATION DIVISION.

=={{header|CoffeeScript}}==

{{trans|JavaScript}}

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

<script type="text/coffeescript">

 

{{works with|Node.js}}

{ stdin } = process

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

 

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

 

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

BlackBox Component Builder

MODULE AB;

IMPORT StdLog, DevCommanders,TextMappers;

 

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

a: 0

b: 0

 

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

=={{header|D}}==

===From Console===

 

void main() {

<pre>30</pre>

===From File===

import std.stdio, std.file;

 

 

=={{header|Dart}}==

 

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

 

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

 

=={{header|Diego}}==

begin_instuct(A + B);

 

=={{header|DMS}}==

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

Result( a + b + "\n" )</syntaxhighlight>

 

=={{header|Dragon}}==

select "graphic"

select "types"

=={{header|DWScript}}==

Ghetto GUI version

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

ShowMessage('Sum is '+IntToStr(a+b));</syntaxhighlight>

{{trans|Python}}

===Console===

for k in split !prompt "" " ":

+ to-num k

 

=={{header|EasyLang}}==

.

print a + b

</syntaxhighlight>

 

=={{header|EchoLisp}}==

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

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

========

 

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.

=={{header|EGL}}==

 

package programs;

 

=={{header|Eiffel}}==

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

class

APPLICATION

 

Alternatively ...

make

-- Run application.

 

=={{header|Ela}}==

 

a'b() = do

 

=={{header|Elena}}==

public program()

 

Or more generic solution:

import extensions;

 

console.printLine(console.readLine()

.split()

.summarize())

}</syntaxhighlight>

 

=={{header|Elixir}}==

|> String.split

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

 

=={{header|Elm}}==

--To write this function directly run cmd

--Type elm-repl to start

 

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

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

(a (car numbers))

(b (cadr numbers)))

(message "%d" (+ a b)))</syntaxhighlight>

 

=={{header|Emojicode}}==

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

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

 

=={{header|Erlang}}==

-export([start/0]).

 

 

=={{header|ERRE}}==

PROGRAM SUM2

 

END PROGRAM

</syntaxhighlight>

 

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

 

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

Two numbers seperated by a blank? >4 5

 

=={{header|Euphoria}}==

 

function snd(sequence s)

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>

 

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

 

let SumOf(str : string) =

 

=={{header|Factor}}==

: a+b ( -- )

readln " " split1

 

=={{header|FALSE}}==

n;!n;!+.</syntaxhighlight>

 

=={{header|Fantom}}==

{

public static Void main ()

=={{header|FBSL}}==

Using stdin and stdout

 

DIM %a, %b

 

PAUSE</syntaxhighlight>

 

=={{header|Fhidwfe}}==

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

reset negative

 

=={{header|Fish}}==

v >~01-0 >

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

 

=={{header|Forth}}==

 

=={{header|Fortran}}==

implicit none

integer :: a,b

end program a_plus_b</syntaxhighlight>

And in Fortran 77

100 FORMAT(2I5)

WRITE (2,200) I+J

 

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

uses

SysUtils;

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

cin sto mystring

#s dec mystring @mystring sprintnl

=={{header|FutureBasic}}==

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

_window = 1

begin enum 1

 

=={{header|Gambas}}==

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

 

=={{header|Gastona}}==

Taking A and B from command line arguments

 

<main>

</syntaxhighlight>

Using Graphical interface

 

<layout of main>

<suma> =, eA + eB

</syntaxhighlight>

 

=={{header|Gema}}==

 

=={{header|Genie}}==

/*

A+B in Genie

 

=={{header|GML}}==

add = argument0; // get the string with the numbers to add

a = real(string_copy(add, 1, string_pos(" ", add)));

 

=={{header|Go}}==

 

import "fmt"

 

=={{header|Golfscript}}==

 

=={{header|Golo}}==

----

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

 

=={{header|Gosu}}==

uses java.io.InputStreamReader

uses java.util.Scanner

 

=={{header|Groovy}}==

def reader = new Scanner(System.in)

def a = reader.nextInt();

=={{header|GUISS}}==

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

Button:2,Button:[equals]</syntaxhighlight>

 

=={{header|Harbour}}==

LOCAL GetList := {}

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

 

=={{header|Haskell}}==

 

=={{header|hexiscript}}==

let ret dict 32

let l len s

=={{header|HicEst}}==

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

WRITE(Messagebox, Name) A, B, "Sum = ", A+B</syntaxhighlight>

 

=={{header|Hoon}}==

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

</syntaxhighlight>

 

=={{header|Huginn}}==

import Text as text;

 

 

=={{header|Hy}}==

Alternatively, with the "threading tail" macro:

 

=={{header|i}}==

 

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

numChars := '-'++&digits

read() ? {

 

=={{header|Idris}}==

main = do

line <- getLine

print $ sum $ map cast $ words line</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</syntaxhighlight>

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

2) Here's a little script, called "a+b.ijs":

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

exit ''</syntaxhighlight>

3) Here is an execution of the script:

5</syntaxhighlight>

 

=={{header|Java}}==

 

public class Sum2 {

}</syntaxhighlight>

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

 

The following code uses a StreamTokenizer instead of a Scanner.

 

import java.nio.charset.Charset;

 

 

 

grammar aplusb ;

 

Client side:

 

<body>

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

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

 

'data',

function (line) {

=== ES6 ===

Node.js in a terminal:

console.log(

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

 

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

get get + fput pop quit.</syntaxhighlight>

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

def addpairs:

if length < 2 then empty

 

addpairs</syntaxhighlight>

$ jq -s -f AB.jq

1 2 3 4 5 6

 

=={{header|Jsish}}==

var line = console.input();

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

=={{header|Julia}}==

Run from the command line:

println(stdout, sum(input))</syntaxhighlight>

 

 

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</syntaxhighlight>

 

=={{header|K}}==

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

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

 

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

 

=={{header|Klong}}==

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

2 3

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

 

=={{header|KQL}}==

'2 2',

'3 2'

 

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

(decl int a)

(decl int b)

 

=={{header|Lambdatalk}}==

Lambdatalk works in a wiki, lambdatank.

 

Several boxes can be created in the wiki page

with any valid lambdatalk expressions.

</syntaxhighlight>

 

=={{header|Lang5}}==

 

read " " split expand drop + .</syntaxhighlight>

 

=={{header|Lasso}}==

 

=={{header|LIL}}==

# Requires lil shell readline routine

set in [readline]

 

=={{header|Lisaac}}==

+ name := A_PLUS_B

 

 

=={{header|Little}}==

string a, b;

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

 

'''Assembly'''

STA 99

INP

 

'''Machine code'''

01 STA 99

02 INP

=={{header|LiveCode}}==

Using Livecode Server script

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

put $0 + $1

 

A graphical version using an input dialog

ask "Enter two numbers"

set itemdelimiter to space

 

=={{header|Logo}}==

 

=={{header|Lua}}==

print(a+b)</syntaxhighlight>

 

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

Do {

Input A%, B%

 

=={{header|M4}}==

 

sumstr(1 2)

 

=={{header|Maple}}==

23 34

57</syntaxhighlight>

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

=={{header|Maude}}==

===Built-in===

red 3 + 4 .

</syntaxhighlight>

===With restrictions===

fmod ADD is

 

 

=={{header|Maxima}}==

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

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

 

=={{header|Mercury}}==

:- interface.

 

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

 

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

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

}</syntaxhighlight>

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

 

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

 

IMPORT InOut;

 

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

 

IMPORT IO;

 

=={{header|MoonScript}}==

print a + b</syntaxhighlight>

 

=={{header|MUMPS}}==

NEW A,B,T,S

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

 

=={{header|Nanoquery}}==

line = input()

 

=={{header|Neko}}==

A+B, Rosetta Code, in Neko

Tectonics:

=={{header|Nemerle}}==

{{trans|C#}}

using System.Console;

using System.Linq;

 

=={{header|NetRexx}}==

 

options replace format comments java symbols binary

 

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

 

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

 

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

20 INPUT "ENTER NUMBER B: ",B

30 PRINT A+B</syntaxhighlight>

 

=={{header|Nyquist}}==

===SAL Syntax===

;version 1

;type tool

 

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

;version 1

;type tool

 

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

 

IMPORT In, Out;

 

=={{header|Objeck}}==

class Vander {

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

 

=={{header|OCaml}}==

 

=={{header|Oforth}}==

Works with any number of integers separated by a space.

 

 

System.Console accept words map( #>integer) reduce( #+ ) printcr .</syntaxhighlight>

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

 

(+ (read) (read))

 

=={{header|Onyx}}==

 

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

} def

===version 1===

{{trans|REXX}}

Say 'enter some numbers to be summed:'

parse pull y

===version 2===

extend for negative numbers

Say 'enter some numbers to be summed:'

parse pull y

 

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

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

 

=={{header|Openscad}}==

There is no means of run-time input in Openscad

a = 5 + 4;

echo (a);

 

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

 

=={{header|Oxygene}}==

// Sum 2 integers read fron standard input

//

 

=={{header|Oz}}==

class TextFile from Open.file Open.text end

 

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

User input:

File input:

 

=={{header|Pascal}}==

a, b: integer;

begin

end.</syntaxhighlight>

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

a, b: integer;

begin

end.</syntaxhighlight>

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

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

Author: Sinuhe Masan (2019) }

 

=={{header|Perl}}==

print "$a $b " . ($a + $b) . "\n";</syntaxhighlight>

 

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

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

 

=={{header|Phixmonti}}==

by Galileo, 05/2022 #/

 

 

over over + >ps

{{out}}

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

 

=={{header|PHP}}==

echo ($a + $b) . "\n";</syntaxhighlight>

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

fclose($in);

 

=={{header|Picat}}==

go =>

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

 

=={{header|PicoLisp}}==

3 4

-> 7</syntaxhighlight>

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

write(a+b +"\n");</syntaxhighlight>

 

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

put (a+b);</syntaxhighlight>

 

=={{header|Pony}}==

actor Main

let _env:Env

 

=={{header|PostScript}}==

dup

token pop % read A

 

=={{header|Potion}}==

input = read

i = 0

 

=={{header|PowerShell}}==

[int]$a + [int]$b</syntaxhighlight>

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

[int]$a + [int]$b</syntaxhighlight>

 

I think this works better and doesn't require string input (following the task closer):

return [int]$args[0] + [int]$args[1]

}</syntaxhighlight>

 

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;

 

=={{header|ProDOS}}==

With the math module:

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

editvar /newvar /value=c

printline -c- </syntaxhighlight>

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

write(N).</syntaxhighlight>

output :

|: 4 5

9

 

=={{header|Pure}}==

printf "%d\n" (x+y) when x,y = scanf "%d %d" end;</syntaxhighlight>

 

=={{header|PureBasic}}==

===Console===

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

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

PrintN(str(a+b))</syntaxhighlight>

===File===

x$=ReadString(0)

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

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

print("Result:", a+b)</syntaxhighlight>

 

=={{header|QB64}}==

DIM c AS LONG

INPUT "Enter A: ", a

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

 

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

20 input "Enter number B: ";b

30 print a+b</syntaxhighlight>

 

=={{header|R}}==

 

=={{header|Ra}}==

class Sum

**Adds two given integers**

=={{header|Racket}}==

 

#lang racket

(+ (read) (read))

 

Or, with additional error checking:

#lang racket

(define a (read))

 

Short version with very little "line noise":

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

Long version:

say $a + $b;</syntaxhighlight>

 

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

 

=={{header|Retro}}==

1

2</syntaxhighlight>

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

 

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

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

 

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

 

=={{header|Ring}}==

Numbers = split(Numbers)

sum = 0

 

=={{header|Robotic}}==

input string "Input A:"

set "A" to "input"

=={{header|Rockstar}}==

Minimized:

Listen to A number

Listen to B

</syntaxhighlight>

Idiomatic:

Listen to my voice

Listen to your thoughts

Shout your thoughts with my voice

</syntaxhighlight>

 

=={{header|Ruby}}==

 

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

print val(word$(x$,1)) + val(word$(x$,2))</syntaxhighlight>

 

=={{header|Rust}}==

 

fn main() {

or

 

 

fn main() {

 

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

variable input, a, b;

 

46</pre>

 

variable input, a, b, rc;

 

 

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

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

 

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.

 

=={{header|Seed7}}==

 

const proc: main is func

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

 

 

=={{header|SenseTalk}}==

put it into a

 

 

put a + b</syntaxhighlight>

split inputFile by space

put sum of inputFile</syntaxhighlight>

 

=={{header|SequenceL}}==

 

main(args(2)) := stringToInt(args[1]) + stringToInt(args[2]);</syntaxhighlight>

 

=={{header|SETL}}==

print(A + B);</syntaxhighlight>

 

=={{header|Shiny}}==

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

end</syntaxhighlight>

=={{header|Sidef}}==

Works with both positive and negative integers.

 

More idiomatically:

 

Explicit summation:

say a+b</syntaxhighlight>

 

=={{header|Simula}}==

WHILE NOT LASTITEM DO

BEGIN

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

{{works with|Smalltalk/X}}

{{works with|VisualWorks Smalltalk}}

task := [:inStream :outStream |

|processLine|

task value: ( 'dataIn.txt' asFilename readStream) value:Transcript.</syntaxhighlight>

or:

 

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

PRINT VAL(LEFT$(n$,(LEN(STR$(VAL(n$))))))+VAL(RIGHT$(n$,(LEN(n$)-LEN(STR$(VAL(n$)))-1)))</syntaxhighlight>

 

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

 

=={{header|SmileBASIC}}==

INPUT B

PRINT A+B

=={{header|SNOBOL4}}==

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

output = a + b

end</syntaxhighlight>

"Integer aware" solution:

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

output = a + b

{{works with|Axiom}}

One of several possibilities:

333 444

 

 

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

 

=={{header|SPARK}}==

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

 

 

=={{header|SPL}}==

#.output(n[1],"+",n[2],"=",#.val(n[1])+#.val(n[2]))</syntaxhighlight>

{{in}}

 

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

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

 

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

* val split : string -> string list

* splits a string at it spaces

{{works with|Swift|2}}

Requires sending EOF.

 

let input = NSFileHandle.fileHandleWithStandardInput()

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

 

import Foundation

 

 

=={{header|Symsyn}}==

 

[] $s

 

=={{header|Tailspin}}==

composer nums

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

 

Alternatively

composer nums

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

 

=={{header|Tcl}}==

puts [expr {$x + $y}]</syntaxhighlight>

Alternatively:

To/from a file:

set out [open "output.txt" w]

scan [gets $in] "%d %d" x y

 

=={{header|Terraform}}==

#Aamrun, August 15th, 2022

 

 

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

:Disp A+B</syntaxhighlight>

 

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

 

:AsmPrgm

:

 

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

:a+b</syntaxhighlight>

 

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

 

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

INTEGER PROC FNMathGetSumAPlusBI( INTEGER A, INTEGER B )

RETURN( A + B )

 

=={{header|TUSCRIPT}}==

SET input="1 2"

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

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

{{works with|Bourne Shell}}

read a b || exit

echo `expr "$a" + "$b"`</syntaxhighlight>

{{works with|zsh}}

Script "a+b.sh":

read a b || exit

echo $(( a + b ))</syntaxhighlight>

{{Out}}

5</syntaxhighlight>

 

One liner :

 

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

</syntaxhighlight>

 

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

set input=($line)

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

 

=={{header|Ursa}}==

# a + b

#

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

 

#include <Core/Core.h>

#include <stdio.h>

=={{header|Ursala}}==

Using standard input and output streams:

#import int

 

main = %zP+ sum:-0+ %zp*FiNCS+ sep` @L</syntaxhighlight>

Overwriting a text file named as a command line parameter:

#import int

 

main = ~command.files.&h; <.contents:= %zP+ sum:-0+ %zp*FiNCS+ sep` @L+ ~contents></syntaxhighlight>

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

#import int

 

=={{header|Vala}}==

Read from stdin while program running:

 

int main (string[] args) {

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

End Sub</syntaxhighlight>

An other version:

Dim stEval As String

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

=={{header|VBScript}}==

A simple version:

t=Split(s)

a=CInt(t(0))

MsgBox c </syntaxhighlight>

An other version:

Dim a, b

Select Case WScript.Arguments.Count

End With

end if</syntaxhighlight>

 

=={{header|Verilog}}==

 

reg signed [11:0] y;

 

=={{header|VHDL}}==

USE std.TEXTIO.all;

 

 

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

 

Sub Main()

End Module</syntaxhighlight>

 

 

fn main() {

 

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

input a

Print 1 "Enter number B:"

 

=={{header|Whitespace}}==

=={{header|Wisp}}==

{{trans|Scheme}}

display : + (read) (read)

 

 

=={{header|Wren}}==

 

while (true) {

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

{{works with|NASM|Linux}}

global _start

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

 

=={{header|xEec}}==

 

=={{header|XLISP}}==

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

(NEWLINE)

 

=={{header|Xojo}}==

var strVals() as string

 

 

=={{header|XPL0}}==

int A, B;

[A:= IntIn(0);

 

=={{header|XQuery}}==

(:

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

 

=={{header|Yabasic}}==

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

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

 

=={{header|Yorick}}==

read, a, b;

write, a + b;</syntaxhighlight>

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

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

comment:

#true

 

=={{header|zkl}}==

<pre>

A B: 123 567

 

=={{header|Zoea}}==

input: '7 11'

output: 18

 

=={{header|zonnon}}==

module ABProblem;

var

 

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

20 INPUT LINE a$

30 GO SUB 90

Another solution

 

20 INPUT LINE a$

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