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.

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

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

20 INPUT X$

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

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

Dim As Integer a, b

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

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

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

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

while i < len a$ and substr a$ i 1 <> " "

i += 1

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

ELENA 5.0 :

public program()

Or more generic solution:

import extensions;

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

=={{header|Emojicode}}==

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

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

=={{header|Erlang}}==

-export([start/0]).

=={{header|ERRE}}==

PROGRAM SUM2

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

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

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

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

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