A+B

From Rosetta Code
Task
A+B
You are encouraged to solve this task according to the task description, using any language you may know.

A+B - in programming contests, classic problem, which is given so contestants can gain familiarity with online judging system being used.

Problem statement
Given 2 integer numbers, A and B. One needs to find their sum.

Input data
Two integer numbers are written in the input stream, separated by space.
Output data
The required output is one integer: the sum of A and B.
Example:
Input Output
2 2 4
3 2 5

0815

<lang 0815>|x|+%</lang>

ABAP

<lang ABAP>report z_sum_a_b. data: lv_output type i. selection-screen begin of block input.

 parameters:
   p_first type i,
   p_second type i.

selection-screen end of block input.

at selection-screen output.

 %_p_first_%_app_%-text  = 'First Number: '.
 %_p_second_%_app_%-text = 'Second Number: '.

start-of-selection.

 lv_output = p_first + p_second.
 write : / lv_output.</lang>

Ada

<lang Ada>-- Standard I/O Streams

with Ada.Integer_Text_Io; procedure APlusB is

  A, B : Integer;

begin

  Ada.Integer_Text_Io.Get (Item => A);
  Ada.Integer_Text_Io.Get (Item => B);
  Ada.Integer_Text_Io.Put (A+B);

end APlusB;</lang> Using appropriate user defined types: <lang Ada>with Ada.Text_IO;

procedure A_Plus_B is

  type Small_Integers is range -2_000 .. +2_000;
  subtype Input_Values is Small_Integers range -1_000 .. +1_000;
  package IO is new Ada.Text_IO.Integer_IO (Num => Small_Integers);
  A, B : Input_Values;

begin

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

end A_Plus_B;</lang>

ALGOL 68

Translation of: python
Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Console

<lang algol68>print((read int + read int))</lang> Input:

1 2

Output:

         +3

File

<lang algol68>open(stand in, "input.txt", stand in channel); open(stand out, "output.txt", stand out channel); print((read int + read int))</lang> Input "input.txt":

3 4

Output "output.txt":

         +7

ANTLR

aplusb
aplusb
aplusb
aplusb


Java

<lang> grammar aplusb ;

options { language = Java; }

aplusb : (WS* e1=Num WS+ e2=Num NEWLINE {System.out.println($e1.text + " + " + $e2.text + " = " + (Integer.parseInt($e1.text) + Integer.parseInt($e2.text)));})+ ; Num : '-'?('0'..'9')+ ; WS : (' ' | '\t') ; NEWLINE : WS* '\r'? '\n'

       ;

</lang> Produces:

>java Test
1 2
23 89
13 567
-75 6
-75 -29
^Z
1 + 2 = 3
23 + 89 = 112
13 + 567 = 580
-75 + 6 = -69
-75 + -29 = -104

Argile

Translation of: C
Works with: Argile version 1.0.0

<lang Argile>(: Standard input-output streams :) use std, array Cfunc scanf "%d%d" (&val int a) (&val int b) printf "%d\n" (a + b)</lang> <lang Argile>(: Input file : input.txt :) (: Output file: output.txt :) use std, array let in = fopen "input.txt" "r" let out = fopen "output.txt" "w" let int x, y. Cfunc fscanf in "%d%d" (&x) (&y) (:fscanf not yet defined in std.arg:) fprintf out "%d\n" (x+y) fclose in fclose out</lang>

AutoHotkey

<lang AutoHotkey>InputBox, input , A+B, Two integer numbers`, separated by space. StringSplit, output, input, %A_Space% msgbox, % output1 . "+" . output2 "=" output1+output2</lang>

AutoIt

<lang AutoIt>;AutoIt Version: 3.2.10.0 $num = "45 54" consolewrite ("Sum of " & $num & " is: " & sum($num)) Func sum($numbers)

  $numm = StringSplit($numbers," ")
  Return $numm[1]+$numm[$numm[0]]

EndFunc</lang>

AWK

<lang awk>{print $1 + $2}</lang>

Batch File

Prompts version <lang dos>::aplusb.cmd @echo off setlocal set /p a="A: " set /p b="B: " set /a c=a+b echo %c% endlocal</lang> All on the commandline version <lang dos>::aplusb.cmd @echo off setlocal set a=%1 set b=%2 set /a c=a+b echo %c% endlocal</lang> Formula on the command line version <lang dos>::aplusb.cmd @echo off setlocal set /a c=%~1 echo %c% endlocal</lang> Example of 'Formula on the command line version'

>aplusb 123+456
579
>aplusb "1+999"
1000

Parse the input stream version (thanks to Tom Lavedas on alt.msdos.batch.nt) <lang dos>::aplusb.cmd @echo off setlocal set /p a="Input stream: " call :add %a% echo %res% endlocal goto :eof

add

set /a res=res+%1 shift if "%1" neq "" goto :add</lang> Example of 'parse the input stream version'

>aplusb
Input stream: 1234 5678
6912
>aplusb
Input stream: 123 234 345 456 567 678 789 890
4082

BASIC

<lang qbasic>DEFINT A-Z

tryagain: backhere = CSRLIN INPUT "", i$ i$ = LTRIM$(RTRIM$(i$)) where = INSTR(i$, " ") IF where THEN

   a = VAL(LEFT$(i$, where - 1))
   b = VAL(MID$(i$, where + 1))
   c = a + b
   LOCATE backhere, LEN(i$) + 1
   PRINT c

ELSE

   GOTO tryagain

END IF</lang>

BASIC256

<lang basic256>dim a(2) input "Enter two numbers seperated by a space?", t$ a = explode(t$," ") print t$ + " " + (a[0] + a[1])</lang>

BBC BASIC

<lang bbc> REPEAT

       hereY% = VPOS
       INPUT LINE "" q$
       hereX% = LEN(q$) + 1
       WHILE LEFT$(q$, 1) = " "
         q$ = MID$(q$, 2)
       ENDWHILE
       space% = INSTR(q$, " ")
       IF space% THEN
         a = VAL(LEFT$(q$, space% - 1))
         b = VAL(MID$(q$, space% + 1))
         PRINT TAB(hereX%, hereY%) ; a + b
       ENDIF
     UNTIL FALSE</lang>

That seems overly complicated. What's wrong with: <lang bbc> REPEAT

       INPUT LINE "" q$
       space% = INSTR(q$," ")
       PRINT VAL LEFT$(q$,space%-1) + VAL MID$(q$,space%+1)
     UNTIL FALSE</lang>

Befunge

<lang befunge>&&+.@</lang>

Bracmat

filter 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. <lang bracmat>( out $ ( put$"Enter two integer numbers between -1000 and 1000:"

   & (filter=~/#%:~<-1000:~>1000)
   & get':(!filter:?a) (!filter:?b)
   & !a+!b
 | "Invalid input. Try again"
 )

);</lang>

Brainf***

This example is incorrect. Please fix the code and remove this message.

Details: It only handles single-digit inputs and output.

<lang brainf***>, Read first number >,, Eat separator and read second number [<+>-] Add ASCII values ,++ Use newline to get a 12 [<---->-] Subtract 48 to get back to ASCII <. and print</lang>

Brat

<lang brat>numbers = g.split[0,1].map(:to_i) p numbers[0] + numbers[1] #Prints the sum of the input</lang>

Burlesque

<lang burlesque>ps++</lang>

C

<lang c>// Standard input-output streams

  1. include <stdio.h>

int main() {

  int a, b;
  scanf("%d%d", &a, &b);
  printf("%d\n", a + b);
  return 0;

}</lang> <lang c>// Input file: input.txt // Output file: output.txt

  1. include <stdio.h>

int main() {

  freopen("input.txt", "rt", stdin);
  freopen("output.txt", "wt", stdout);
  int a, b;
  scanf("%d%d", &a, &b);
  printf("%d\n", a + b);
  return 0;

}</lang>

C#

<lang csharp>using System; using System.Linq;

class Program {

   static void Main()
   {
       Console.WriteLine(Console.ReadLine().Split().Select(int.Parse).Sum());
   }

}</lang> Another way (not recommended since it does not work with more than two numbers): <lang csharp>using System;

class Program

   {
       static void Main()
       {
           start:
           string input = Console.ReadLine();
           int index = input.IndexOf(" ");
           string num1 = input.Substring(0, index);
           string num2 = input.Substring(index + 1);
           int sum = int.Parse(num1) + int.Parse(num2);
           Console.WriteLine(sum.ToString());
           goto start;
           
       }
   }</lang>

C++

<lang cpp>// Standard input-output streams

  1. include <iostream>

using namespace std; void main() {

  int a, b;
  cin >> a >> b;
  cout << a + b << endl;

}</lang> <lang cpp>// Input file: input.txt // Output file: output.txt

  1. include <fstream>

using namespace std; int main() {

  ifstream in("input.txt");
  ofstream out("output.txt");
  int a, b;
  in >> a >> b;
  out << a + b << endl;
  return 0;

}</lang>

Clojure

<lang clojure>(println (+ (Integer/parseInt (read-line)) (Integer/parseInt (read-line)))) 3 4 =>7</lang> <lang clojure>(eval (read-string (str "(+ " (read-line) " )") )) 3 3 6</lang>

CoffeeScript

Translation of: JavaScript

<lang html4strict><html> <script type="text/javascript" src="http://jashkenas.github.com/coffee-script/extras/coffee-script.js"></script> <script type="text/coffeescript"> a = window.prompt 'enter A number', b = window.prompt 'enter B number', document.getElementById('input').innerHTML = a + ' ' + b sum = parseInt(a) + parseInt(b) document.getElementById('output').innerHTML = sum </script> <body>

</body> </html></lang>

Common Lisp

<lang lisp>(write (+ (read) (read)))</lang>

D

From Console

<lang d>import std.stdio, std.conv, std.string;

void main() {

   string[] r;
   try
       r = readln().split();
   catch (StdioException e)
       r = ["10", "20"];
   writeln(to!int(r[0]) + to!int(r[1]));

}</lang>

Output:
30

From File

<lang d>import std.stdio, std.conv, std.string;

void main() {

   auto fin = File("sum_input.txt", "r");
   auto r = fin.readln().split();
   auto fout = File("sum_output.txt", "w");
   fout.writeln(to!int(r[0]) + to!int(r[1]));

}</lang>

dc

<lang dc>? + psz</lang>

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

Déjà Vu

Translation of: Python

Console

<lang dejavu>0 for k in split " " input: + to-num k print</lang>

Delphi

Console version. <lang delphi>program SUM;

{$APPTYPE CONSOLE}

uses

 SysUtils;

var

 s1, s2:string;

begin

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

end.</lang>

DMS

<lang DMS>number a = GetNumber( "Please input 'a'", a, a ) // prompts for 'a' number b = GetNumber( "Please input 'b'", b, b ) // prompts for 'b' Result( a + b + "\n" )</lang>

DWScript

Ghetto GUI version <lang delphi>var a := StrToInt(InputBox('A+B', 'Enter 1st number', '0')); var b := StrToInt(InputBox('A+B', 'Enter 2nd number', '0')); ShowMessage('Sum is '+IntToStr(a+b));</lang>

Eiffel

argument(0) contains the path of the executable - thus we start at argument(1) <lang eiffel> class APPLICATION inherit ARGUMENTS create make feature {NONE} -- Initialization make -- Run application. do print(argument(1).to_integer + argument(2).to_integer) end end </lang>

Ela

<lang ela>open console list string read

readn() |> string.split " " |> map readStr |> sum</lang>

Output:

1 2 3 4 5 6
21

Elena

<lang elena>#define std'basic'*.

  1. define ext'io'*.
  1. symbol Console =>

[

   #var anOutput := __wrap(ELineInput, 'program'input).
   #var A := anOutput >> Integer.
   #var B := anOutput >> Integer.
   
   'program'output << A + B.

].</lang>

Erlang

<lang erlang>-module(aplusb). -export([start/0]).

start() ->

   case io:fread("","~d~d") of
       eof -> ok;
       {ok, [A,B]} ->
           io:format("~w~n",[A+B]),
           start()
   end.</lang>

Euler Math Toolbox

<lang Euler Math Toolbox> >s=lineinput("Two numbers seperated by a blank");

Two numbers seperated by a blank? >4 5

>vs=strtokens(s)

4
5

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

9

</lang>

Euphoria

<lang euphoria>include get.e

function snd(sequence s)

   return s[2]

end function

integer a,b

a = snd(get(0)) b = snd(get(0))

printf(1," %d\n",a+b)</lang>

EGL

<lang EGL> package programs;

// basic program // program AplusB type BasicProgram {} function main() try arg1 string = SysLib.getCmdLineArg(1); arg2 string = SysLib.getCmdLineArg(2); int1 int = arg1; int2 int = arg2; sum int = int1 + int2; SysLib.writeStdout("sum1: " + sum); onException(exception AnyException) SysLib.writeStdout("No valid input. Provide 2 integer numbers as arguments to the program."); end end end </lang>

F#

<lang fsharp>open System let plus = (fun (a:string) (b:string) -> Console.WriteLine(int(a)+int(b))) (Console.ReadLine()) (Console.ReadLine());;</lang>

Factor

<lang factor>USING: math.parser splitting ;

a+b ( -- )
   readln " " split1
   [ string>number ] bi@ +
   number>string print ;</lang>
( scratchpad ) a+b
2 2
4

FALSE

<lang false>[0[^$$'9>'0@>|~]['0-\10*+]#%]n: {read an integer} n;!n;!+.</lang>

Fantom

<lang fantom>class APlusB {

 public static Void main () 
 {
   echo ("Enter two numbers: ")
   Str input := Env.cur.in.readLine
   Int sum := 0
   input.split.each |n| { sum += n.toInt }
   echo (sum)
 }

}</lang>

FBSL

Using stdin and stdout <lang qbasic>#APPTYPE CONSOLE

DIM %a, %b SCANF("%d%d", @a, @b) PRINT a, "+", b, "=", a + b

PAUSE</lang>

Fish

<lang Fish>i:o:"-"=?v1$68*-v v >~01-0 > >i:o:" "=?v68*-$a*+

         >~*i:o:"-"=?v1$68*-v

v >~01-0 > >i:o:d=?v68*-$a*+

       >~*+aonao;</lang>

Forth

<lang Forth>pad dup 80 accept evaluate + .</lang>

Fortran

<lang fortran>program a_plus_b

 implicit none
 integer :: a
 integer :: b
 read (*, *) a, b
 write (*, '(i0)') a + b

end program a_plus_b</lang>

GML

<lang GML>add = argument0 // get the string with the numbers to add a = real(string_copy(add, 1, string_pos(" ", add))) b = real(string_copy(add, string_pos(" ", add) + 1, string_length(add) - string_pos(" ", add))) return(a + b)</lang>

Go

<lang go>package main

import "fmt"

func main() {

   var a, b int
   fmt.Scanf("%d %d", &a, &b)
   fmt.Printf("%d\n", a+b)

}</lang>

Golfscript

<lang golfscript>~+</lang>

Gosu

<lang Gosu> uses java.io.InputStreamReader uses java.util.Scanner uses java.lang.System

var scanner = new Scanner( new InputStreamReader( System.in ) ) var a = scanner.nextInt() var b = scanner.nextInt()

print( a + b ) </lang>

Groovy

<lang groovy>def abAdder = {

   def reader = new Scanner(System.in)
   def a = reader.nextInt();
   def b = reader.nextInt();
   assert (-1000..1000).containsAll([a,b]) : "both numbers must be between -1000 and 1000 (inclusive)"
   a + b

} abAdder()</lang>

GUISS

We cannot use variables, but we can find the sum of two numbers.Here we add 3 + 2: <lang guiss>Start,Programs,Accessories,Calculator,Button:3,Button:[plus], Button:2,Button:[equals]</lang>

Haskell

<lang haskell>main = getLine >>= print . sum . map read . words</lang>

HicEst

A and B are input via edit controls with spinners limiting inputs to +-1000. <lang HicEst>DLG(Edit=A, DNum, MIn=-1000, MAx=1000, E=B, DN, MI=-1000, MA=1000) WRITE(Messagebox, Name) A, B, "Sum = ", A+B</lang>

Icon and Unicon

<lang icon>procedure main()

    numChars := '-'++&digits
    read() ? {
        A := (tab(upto(numChars)), integer(tab(many(numChars))))
        B := (tab(upto(numChars)), integer(tab(many(numChars))))
        }
    write((\A + \B) | "Bad input")

end</lang>

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: <lang J> 2+3 5</lang> In the following expression, 1!:1(3) reads a line from STDIN; -.LF drops the line ending character; ". converts the remaining text to a sequence of numbers which are then summed using +/. <lang J>+/". (1!:1(3))-.LF</lang> Here's a little script, called "a+b.ijs": <lang J>#!/Applications/j602/bin/jconsole echo +/". (1!:1(3))-.LF exit </lang> Here is the execution of the script: <lang bash>echo 2 3 | ./a+b.ijs 5</lang>

Java

<lang java>import java.util.*;

public class Sum2 {

  public static void main(String[] args) {
     Scanner in = new Scanner(System.in); // Standard input
     System.out.println(in.nextInt() + in.nextInt()); // Standard output
  }

}</lang> 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. <lang java>import java.io.*; import java.util.*;

public class SumDif {

  StreamTokenizer in;
  PrintWriter out;
  public static void main(String[] args) throws IOException {
     new SumDif().run();
  }
  private int nextInt() throws IOException {
     in.nextToken();
     return (int)in.nval;
  }
  public void run() throws IOException {
     in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in))); // Standard input
     out = new PrintWriter(new OutputStreamWriter(System.out)); // Standard output
     solve();
     out.flush();
  }
  private void solve() throws IOException {
     out.println(nextInt() + nextInt());
  }

}</lang> <lang java>import java.io.*;

public class AplusB { public static void main(String[] args) { try { StreamTokenizer in = new StreamTokenizer(new FileReader("input.txt")); in.nextToken(); int a = (int) in.nval; in.nextToken(); int b = (int) in.nval; FileWriter outFile = new FileWriter("output.txt"); outFile.write(Integer.toString(a + b)); outFile.close(); } catch (IOException e) { System.out.println("IO error"); } } }</lang>

JavaScript

Client side:

<lang html4strict><html> <body>

<script type='text/javascript'> var a = window.prompt('enter A number', ); var b = window.prompt('enter B number', ); document.getElementById('input').innerHTML = a + ' ' + b;

var sum = Number(a) + Number(b); document.getElementById('output').innerHTML = sum; </script> </body> </html></lang>

Server side (with node.js):

<lang javascript>process.openStdin().on (

   'data',
   function (line) {
       var xs = String(line).match(/^\s*(\d+)\s+(\d+)\s*/)
       console.log (
           xs ? Number(xs[1]) + Number(xs[2]) : 'usage: <integer> <integer>'
       )
       process.exit()
   }

)</lang>

$ node io.js
2 3
5
$ node io.js
x 3
usage: <integer> <integer>

Julia

Run from the command line: <lang julia>

  1. A+B

function AB() input = sum(map(int,split(readline(STDIN)," "))) println(input) end AB()</lang>

Output:
>julia AB.jl
1 1
2

Joy

Console

<lang Joy>get get +.</lang>

File

<lang Joy>"input.txt" include "output.txt" "w" fopen get get + fput pop quit.</lang>

Lang5

<lang lang5>read read + .

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

Liberty BASIC

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

Lisaac

<lang lisaac>Section Header

+ name := A_PLUS_B

Section Public

- main <- (    (IO.read_integer; IO.last_integer) +
               (IO.read_integer; IO.last_integer) ).println;</lang>

<lang logo>show apply "sum readlist</lang>

Lua

<lang Lua>a,b = io.read("*number", "*number") print(a+b)</lang>

Kite

<lang Kite>#!/usr/bin/kite

import "System.file";

in = System.file.stdin; line = in|readline; while(not (line is null)) [

   arry = line|split(" ");
   result = (arry[0])|int + (arry[1])|int;
   result|print;
   line = in|readline;

];</lang> Output: <lang Kite> $ kite a_plus_b.kt <<EOF 5 6 EOF 11 $</lang>

Maple

<lang Maple>> convert( scanf( "%d %d" ), '`+`' ); 23 34

                                  57</lang>

Mathematica

Interactive in a notebook <lang Mathematica>Input[] + Input[]</lang>

MATLAB

<lang MATLAB>function sumOfInputs = APlusB()

   inputStream = input('Enter two numbers, separated by a space: ', 's');
   numbers = str2num(inputStream);                         %#ok<ST2NM>
   if any(numbers < -1000 | numbers > 1000)
       warning('APlusB:OutOfRange', 'Some numbers are outside the range');
   end
   sumOfInputs = sum(numbers);    

end</lang>

Mercury

<lang>:- module a_plus_b.

- interface.
- import_module io.
- pred main(io::di, io::uo) is det.
- implementation.
- import_module int, list, string.

main(!IO) :-

  io.read_line_as_string(Result, !IO),
  ( if
       Result = ok(Line),
       [AStr, BStr] = string.words(Line),
       string.to_int(AStr, A), string.to_int(BStr, B)
    then
       io.format("%d\n", [i(A + B)], !IO)
    else
       true
   ).</lang>

mIRC Scripting Language

<lang mirc>alias a+b {

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

}</lang>

МК-61/52

С/П + С/П

ML/I

The two numbers are read from 'standard input' or its equivalent. <lang ML/I>MCSKIP "WITH" NL "" A+B "" assumes macros on input stream 1, terminal on stream 2 MCSKIP MT,<> MCINS %. MCDEF SL SPACES NL AS <MCSET T1=%A1. MCSET T2=%A2. %T1+T2. MCSET S10=0 > MCSKIP SL WITH * MCSET S1=1

  • MCSET S10=2</lang>

Modula-2

<lang modula2>MODULE ab;

IMPORT InOut;

VAR A, B  : INTEGER;

BEGIN

 InOut.ReadInt (A);
 InOut.ReadInt (B);
 InOut.WriteInt (A + B, 8);
 InOut.WriteLn

END ab.</lang>

MUMPS

<lang MUMPS>ANB

NEW A,B,T,S
READ !,"Input two integers between -1000 and 1000, separated by a space: ",S
SET A=$PIECE(S," ",1),B=$PIECE(S," ",2)
SET T=(A>=-1000)&(A<=1000)&(B>=-1000)&(B<=1000)&(A\1=A)&(B\1=B) 
IF T WRITE !,(A+B)
IF 'T WRITE !,"Bad input"
QUIT</lang>

Nemerle

Translation of: C#

<lang Nemerle>using System; using System.Console; using System.Linq;

module AplusB {

   Main() : void
   {
       WriteLine(ReadLine().Split().Select(int.Parse).Sum());
   }    

}</lang>

NetRexx

<lang NetRexx>/* NetRexx */

options replace format comments java crossref savelog symbols binary

parse ask a b . say a '+' b '=' a + b</lang>

newLISP

<lang newLISP>(println (apply + (map int (parse (read-line)))))</lang>

Nimrod

A+B: <lang nimrod>import strutils, os

echo parseInt(paramStr(1)) + parseInt(paramStr(2))</lang> Arbitrary number of arguments: <lang nimrod>import strutils, os var sum = 0 for i in countup(1, paramCount()):

 sum = sum + parseInt(paramStr(i))

echo sum</lang>

Objeck

<lang objeck>bundle Default {

  class Vander {
     function : Main(args : String[]) ~ Nil {
        values := IO.Console->ReadString()->Split(" ");
        if(values->Size() = 2) { 
           (values[0]->Trim()->ToInt() + values[1]->Trim()->ToInt())->PrintLine();
        };
     }
  }

}</lang>

Oberon-2

<lang oberon2>MODULE ab;

IMPORT In, Out;

VAR A, B  : INTEGER;

BEGIN

 In.Int (A);
 In.Int (B);
 Out.Int (A + B, 8);
 Out.Ln

END ab.</lang> Producing

12 34
      46

OCaml

<lang ocaml>Scanf.scanf "%d %d" (fun a b -> Printf.printf "%d\n" (a + b))</lang>

OpenEdge/Progress

<lang progress>DEFINE VARIABLE a AS INTEGER NO-UNDO FORMAT "->>>9". DEFINE VARIABLE b AS INTEGER NO-UNDO FORMAT "->>>9".

IF SESSION:BATCH THEN DO:

  INPUT FROM "input.txt".
  IMPORT a b.
  INPUT CLOSE.

END. ELSE

  UPDATE a b.

MESSAGE a + b VIEW-AS ALERT-BOX</lang>

Openscad

<lang openscad>a = 5 + 4; echo (a);</lang>

Oxygene

<lang oxygene> // Sum 2 integers read fron standard input // // Nigel Galloway - April 16th., 2012 // namespace aplusb;

interface

 uses System.Text.RegularExpressions.*;

type

 aplusb = class
 public
   class method Main; 
 end;

implementation

class method aplusb.Main; var

 gc: GroupCollection;
 m : Match;

begin

 m := new Regex('^\s*(?<a>-?[1-9]\d{0,2}|0|-?1000)\s+(?-?[1-9]\d{0,2}|0|-?1000)\s*$').Match(Console.ReadLine());
 if m.Success then
   begin
     gc := m.Groups;
     Console.WriteLine("{0} + {1} = {2}", gc['a'].Value, gc['b'].Value, Integer.Parse(gc['a'].Value) + Integer.Parse(gc['b'].Value));
   end
 else Console.WriteLine("Invalid Input");

end;

end. </lang> Produces:

>aplusb
23 -99
23 + -99 = -76

Oz

<lang oz>declare

 class TextFile from Open.file Open.text end
 StdIn = {New TextFile init(name:stdin)}
 fun {ReadInt}
    {String.toInt {StdIn getS($)}}
 end

in

 {Show {ReadInt}+{ReadInt}}</lang>

PARI/GP

User input: <lang parigp>input()+input()</lang> File input: <lang parigp>read("file1")+read("file2")</lang>

Pascal

<lang pascal>var

  a, b: integer;

begin

  readln(a, b);
  writeln(a + b);

end.</lang> Same with input from file input.txt and output from file output.txt. <lang pascal>var

  a, b: integer;

begin

  reset(input, 'input.txt');
  rewrite(output, 'output.txt');
  readln(a, b);
  writeln(a + b);
  close(input);
  close(output);

end.</lang>

Perl

<lang Perl>my ($a,$b) = split(/\D+/,<STDIN>); print "$a $b " . ($a + $b) . "\n";</lang>

Perl 6

<lang perl6>say [+] .words for lines</lang>

PHP

<lang php>fscanf(STDIN, "%d %d\n", $a, $b); //Reads 2 numbers from STDIN echo ($a + $b) . "\n";</lang> <lang php>$in = fopen("input.dat", "r"); 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"); fclose($out);</lang>

PicoLisp

<lang PicoLisp>(+ (read) (read)) 3 4 -> 7</lang>

Piet

The code is fairly straightforward. The individual commands are as follows: <lang text>in(num) in(num) add out(num)</lang>

Pike

<lang Pike>string line = Stdio.stdin->gets(); sscanf(line, "%d %d", int a, int b); write(a+b +"\n");</lang>

PL/I

<lang PL/I>get (a, b); put (a+b);</lang>

PostScript

<lang postscript>(%stdin) (r) file  % get stdin dup token pop  % read A exch token pop  % read B add =</lang>

PowerShell

<lang powershell>$a,$b = -split "$input" [int]$a + [int]$b</lang> This solution does not work interactively, while the following only works interactively: <lang powershell>$a,$b = -split (Read-Host) [int]$a + [int]$b</lang>

ProDOS

With the math module: <lang ProDOS>editvar /newvar /value=a /title=Enter an integer: editvar /newvar /value=b /title=Enter another integer: editvar /newvar /value=c do add -a-,-b-=-c- printline -c- </lang> Without the math module: <lang ProDOS>editvar /newvar /value=a /title=Enter an integer: editvar /newvar /value=b /title=Enter another integer: editvar /newvar /value=c=-a-+-b- printline -c- </lang>

Prolog

Works with: SWI-Prolog

<lang Prolog>plus :-

   read_line_to_codes(user_input,X),
   atom_codes(A, X),
   atomic_list_concat(L, ' ', A),
   maplist(atom_number, L, LN),
   sumlist(LN, N),
   write(N).</lang>

output : <lang Prolog>?- plus. |: 4 5 9 true.</lang>

Pure

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

PureBasic

Console

<lang PureBasic>x$=Input() a=Val(StringField(x$,1," ")) b=Val(StringField(x$,2," ")) PrintN(str(a+b))</lang>

File

<lang PureBasic>If ReadFile(0,"in.txt")

 x$=ReadString(0)
 a=Val(StringField(x$,1," "))
 b=Val(StringField(x$,2," "))
 If OpenFile(1,"out.txt")
   WriteString(1,str(a+b))
   CloseFile(1)
 EndIf
 CloseFile(0)

EndIf </lang>

Python

Console

<lang python>try: raw_input except: raw_input = input

print(sum(int(x) for x in raw_input().split()))</lang>

File

<lang python>a = int(raw_input("Enter integer 1: ")) b = int(raw_input("Enter integer 2: "))

print a + b</lang>

R

<lang r>sum(scan("", numeric(0), 2))</lang>

Racket

<lang scheme>

  1. lang racket

(+ (read) (read)) </lang>

Or, with additional error checking:

<lang scheme>

  1. lang racket

(define a (read)) (unless (number? a) (error 'a+b "number" a)) (define b (read)) (unless (number? b) (error 'a+b "number" b)) (displayln (+ a b)) </lang>

REBOL

<lang rebol>forever [x: load input print x/1 + x/2]</lang> Sample output:

1 2
3
2 2
4
3 2
5

Retro

<lang Retro>: try ( "-n ) getToken toNumber getToken toNumber + putn ;</lang> <lang Retro>try 1 2</lang>

REXX

version 1, unnormalized

The numbers can be any valid REXX number (integer, fixed point decimal, floating point (with exponential notation, ...). <lang rexx>parse pull a b say a+b</lang>

version 2, normalizied

If the user entered 4.00000 and wanted to add 5 to that, and expects 9,
then the output needs to be normalized before displaying the result.
Normally, REXX will keep the greatest precision in the results;
adding 4.00000 and 5 will yield 9.00000 <lang rexx>parse pull a b say (a+b)/1 /*dividing by 1 normalizes the REXX number.*/</lang>

version 3, extended precision

Using the numeric digits statement allows more digits to be used, the default is 9. <lang rexx>numeric digits 300 parse pull a b z=(a+b)/1 say z</lang>

version 4, multiple numbers

This REXX program version adds all the numbers entered (not just two). <lang rexx>numeric digits 1000 /*just in case the user gets ka-razy. */ say 'enter some numbers to be summed:' parse pull y many=words(y) sum=0

           do j=1 for many  
           sum=sum+word(y,j)
           end

say 'sum of' many "numbers = " sum/1</lang>

Ruby

<lang ruby>puts gets.split.map{|x| x.to_i}.inject{|sum, x| sum + x}</lang>

Works with: Ruby version 1.8.7+

<lang ruby>puts gets.split.map(&:to_i).inject(&:+)</lang>

Run BASIC

<lang runbasic>input, x$ print val(word$(x$,1)) + val(word$(x$,2))</lang>

Scala

<lang scala>println(readLine() split " " take 2 map (_.toInt) sum)</lang>

Scheme

<lang scheme> (let* ((x (read))

      (y (read)))
 (write (+ x y)))

</lang>

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. <lang sed>: Loop

  1. All done

/^-*00* /s/// / -*00*$/s/// t

  1. Negative Check

/^\(-*\)[0-9].* \1[0-9]/!b Negative

  1. Create magic lookup table

s/\(.[0-9]*\) \(.[0-9]*\)/\1;987654321000009999000999009909 \2;012345678999990000999000990090/ s/ \(-\)*\(9*;\)/ \10\2/

  1. Decrement 1st number

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

  1. Increment 2nd

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

Negative
  1. Create magic lookup table

s/\(.[0-9]*\) \(.[0-9]*\)/\1;987654321000009999000999009909 \2;987654321000009999000999009909/

  1. Decrement 1st number

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

  1. Decrement 2nd

s/\([^0]\)\(0*\);[^0]*\1\(.\).*\2\(9*\).*/\3\4/ t Loop</lang>

Another method, based off of this StackExchange answer: <lang sed>#!/bin/sed -f

  1. Add a marker in front of each digit, for tracking tens, hundreds, etc.

s/[0-9]/<&/g

  1. Convert numbers to, in essence, tally marks

s/0//g; s/1/|/g; s/2/||/g; s/3/|||/g; s/4/||||/g; s/5/|||||/g s/6/||||||/g; s/7/|||||||/g; s/8/||||||||/g; s/9/|||||||||/g

  1. Multiply by ten for each digit from the back they were.
tens

s/|</<||||||||||/g t tens

  1. We don't want the digit markers any more

s/<//g

  1. Negative minus negative is the negation of their absolute values.

s/^-\(|*\) *-/-\1/

  1. Negative plus positive equals positive plus negative, and we want the negative at the back.

s/^-\(|*\) \+\(|*\)$/\2-\1/

  1. Get rid of any space between the numbers

s/ //g

  1. A tally on each side can be canceled.
minus

s/|-|/-/ t minus s/-$//

  1. Convert back to digits
back

s/||||||||||/</g s/<\([0-9]*\)$/<0\1/g s/|||||||||/9/g; s/|||||||||/9/g; s/||||||||/8/g; s/|||||||/7/g; s/||||||/6/g; s/|||||/5/g; s/||||/4/g; s/|||/3/g; s/||/2/g; s/|/1/g; s/</|/g t back s/^$/0/</lang>

Seed7

<lang seed7>$ include "seed7_05.s7i";

const proc: main is func

 local
   var integer: a is 0;
   var integer: b is 0;
 begin
   read(a);
   read(b);
   writeln(a + b);
 end func;</lang>

Shiny

<lang shiny>if (io.line 'stdin').match ~(\d+)\s+(\d+)~

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

end</lang>

SNOBOL4

Simple-minded solution (literally "two somethings separated by space") <lang snobol> input break(" ") . a " " rem . b output = a + b end</lang> "Integer aware" solution: <lang snobol> nums = "0123456789" input span(nums) . a break(nums) span(nums) . b output = a + b end</lang>

==Smalltalk=/g s/= 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. <lang smalltalk>'From Squeak3.7 of 4 September 2004 [latest update: #5989] on 8 August 2011 at 3:50:55 pm'! Object subclass: #ABTask instanceVariableNames: classVariableNames: poolDictionaries: category: 'rosettacode'!

"-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "!

ABTask class instanceVariableNames: !

!ABTask class methodsFor: 'demo'! parseInteger: inputStream ^ Integer readFrom: inputStream skipSeparators! !

!ABTask class methodsFor: 'demo'! sum: inputStream ^ (self parseInteger: inputStream) + (self parseInteger: inputStream)! !

!ABTask class methodsFor: 'demo'! test2Plus2 ^ self sum: (ReadStream on: '2 2')! !

!ABTask class methodsFor: 'demo'! test3Plus2 ^ self sum: (ReadStream on: '3 2')! !</lang>

but all have a stream hierarchy, so the task could be restated to pass input and output as stream arguments:

Works with: Smalltalk/X

<lang smalltalk>|task| task := [:inStream :outStream |

   |processLine|
   processLine := 
       [
           |a b|
           a := Integer readFrom: inStream.
           b := Integer readFrom: inStream.
           "is validation part of the task?"
           self assert:( a between:-1000 and: 1000).
           self assert:( b between:-1000 and: 1000).
           outStream print (a+b); cr.
       ].
   [ inStream atEnd ] whileFalse:processLine.

].

task value: ( 'dataIn.txt' asFilename readStream) value:Transcript.</lang> or: <lang smalltalk>task value: Stdin value: Stdout.</lang>

SPARK

<lang Ada>-- By Jacob Sparre Andersen -- Validates with SPARK GPL 2010's Examiner/Simplifier

with SPARK_IO; --# inherit SPARK_IO;

--# main_program; procedure A_Plus_B --# global in out SPARK_IO.Inputs, SPARK_IO.Outputs; --# derives SPARK_IO.Inputs from SPARK_IO.Inputs & --# SPARK_IO.Outputs from SPARK_IO.Inputs, SPARK_IO.Outputs; is

  subtype Small_Integers is Integer range -1_000 .. +1_000;
  A, B       : Integer;
  A_OK, B_OK : Boolean;

begin

  SPARK_IO.Get_Integer 
    (File  => SPARK_IO.Standard_Input,
     Item  => A,
     Width => 0,
     Read  => A_OK);
  
  A_OK := A_OK and A in Small_Integers;
  
  SPARK_IO.Get_Integer 
    (File  => SPARK_IO.Standard_Input,
     Item  => B,
     Width => 0,
     Read  => B_OK);
  
  B_OK := B_OK and B in Small_Integers;
  
  if A_OK and B_OK then
     SPARK_IO.Put_Integer 
       (File  => SPARK_IO.Standard_Output,
        Item  => A + B,
        Width => 4,
        Base  => 10);
  else
     SPARK_IO.Put_Line 
       (File => SPARK_IO.Standard_Output,
        Item => "Input data does not match specification.",
        Stop => 0);
  end if;

end A_Plus_B;</lang>

SQL

<lang sql>select A+B</lang> Example: <lang sql>select 2+3</lang> This should produce a result set containing the value 5.

Note however that declaration of variables is outside the scope of the ANSI SQL standards, unless by variables you mean tables (which would complicate the example considerably).

Tcl

<lang tcl>scan [gets stdin] "%d %d" x y puts [expr {$x + $y}]</lang> Alternatively: <lang tcl>puts [tcl::mathop::+ {*}[gets stdin]]</lang> To/from a file: <lang tcl>set in [open "input.txt"] set out [open "output.txt" w] scan [gets $in] "%d %d" x y puts $out [expr {$x + $y}] close $in close $out</lang>

TI-83 BASIC, TI-89 BASIC

<lang ti83b>:Prompt A,B

Disp A+B</lang>

Alternate TI-89 BASIC version (returns the result on the Home screen): <lang ti89b>:aplusb(a,b)

a+b</lang>

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. <lang Torque>Function aPlusB(%input) {

   return getWord(%input, 0) + getWord(%input, 1);

}</lang>

TUSCRIPT

<lang tuscript>$$ MODE TUSCRIPT SET input="1 2" SET input=SPLIT(input,": :") SET input=JOIN (input) SET output=SUM(input)</lang>

UNIX Shell

Works with: Bourne Shell

<lang sh>#!/bin/sh read a b || exit echo `expr "$a" + "$b"`</lang>

Works with: bash
Works with: ksh93
Works with: pdksh
Works with: zsh

Script "a+b.sh": <lang bash>#!/bin/bash read a b || exit echo $(( a + b ))</lang> Output: <lang bash>echo 2 3 | ksh a+b.sh 5</lang>

C Shell

<lang csh>set line=$< set input=($line) @ sum = $input[1] + $input[2] echo $sum</lang>

Ursala

Using standard input and output streams: <lang Ursala>#import std

  1. import int
  1. executable&

main = %zP+ sum:-0+ %zp*FiNCS+ sep` @L</lang> Overwriting a text file named as a command line parameter: <lang Ursala>#import std

  1. import int
  1. executable -[parameterized]-

main = ~command.files.&h; <.contents:= %zP+ sum:-0+ %zp*FiNCS+ sep` @L+ ~contents></lang> Creating a new file named after the input file with suffix .out: <lang Ursala>#import std

  1. import int
  1. executable -[parameterized]-

main =

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

  contents: %zP+ sum:-0+ %zp*FiNCS+ sep` @L+ ~contents,
  path: ~path; ^|C\~& ~=`.-~; ^|T/~& '.out'!]</lang>

Vala

Read from stdin while program running: <lang vala>stdout.printf("Please enter int value for A\n"); int a = int.parse(stdin.read_line()); stdout.printf("Please enter int value for B\n"); int b = int.parse(stdin.read_line());

stdout.printf("A+B = %d\n", a+b);</lang>

VBScript

<lang vb>Option Explicit Dim a, b Select Case WScript.Arguments.Count Case 0 'No arguments, prompt for them. WScript.Echo "Enter values for a and b" a = WScript.Stdin.ReadLine if Instr(a, " ") > 0 then 'If two variables were passed b = Split(a)(1) a = Split(a)(0) else WScript.Echo "Enter value for b" b = WScript.Stdin.ReadLine end if Case 1 'One argument, assume it's an input file, e.g. "in.txt" Dim FSO : Set FSO = CreateObject("Scripting.FileSystemObject") With FSO.OpenTextFile(WScript.Arguments(0), 1) a = .ReadLine b = Split(a)(1) a = Split(a)(0) .Close End With Case 2 'Two arguments, assume they are values a = WScript.Arguments(0) b = WScript.Arguments(1) End Select 'At this point, a and b are strings as entered, make them numbers a = CInt(a) b = CInt(b)

'Write the sum Wscript.Echo a + b if 1 = WScript.Arguments.Count then With FSO.CreateTextFile("out.txt") .WriteLine a + b .Close End With end if</lang>

VHDL

<lang VHDL>LIBRARY std; USE std.TEXTIO.all;


entity test is end entity test;


architecture beh of test is begin

 process
   variable line_in, line_out : line;
   variable a,b : integer;
 begin
   readline(INPUT, line_in);
   read(line_in, a);
   read(line_in, b);
   
   write(line_out, a+b);
   writeline(OUTPUT, line_out);
   wait; -- needed to stop the execution
 end process;

end architecture beh;</lang>

Visual Basic .NET

<lang vbnet>Module Module1

 Sub Main()
   Dim s() As String = Nothing
   s = Console.ReadLine().Split(" "c)
   Console.WriteLine(CInt(s(0)) + CInt(s(1)))
 End Sub

End Module</lang>

Whitespace

<lang whitespace>






</lang>

X86 Assembly

Works with: NASM version Linux

<lang asm>section .text global _start

_print: mov ebx, 1 mov eax, 4 int 0x80 ret

_get_input: mov edx, 4 mov ebx, 0 mov eax, 3 int 0x80 ret

_start: mov edx, in_val_len mov ecx, in_val_msg call _print mov ecx, a call _get_input ;make 'a' an actual number rather than a char. sub dword [a], 0x30 mov edx, in_val_len mov ecx, in_val_msg call _print mov ecx, b call _get_input ;calc real number for 'b' sub dword [b], 0x30 mov eax, dword [a] mov ebx, dword [b] add eax, ebx ;get the character for our sum. add eax, 0x30 mov dword [sum], eax mov edx, out_val_len mov ecx, out_val_msg call _print mov [sum+1], dword 0xa mov edx, 4 mov ecx, sum call _print push 0x1 mov eax, 1 push eax int 0x80 ret

section .data in_val_msg db "Please input an integer:",0 in_val_len equ $-in_val_msg out_val_msg db "The sum of a+b is: ",0 out_val_len equ $-out_val_msg

section .bss a resd 1 b resd 1 sum resd 1</lang> 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.

XPL0

<lang XPL0>include c:\cxpl\codes; int A, B; [A:= IntIn(0);

B:= IntIn(0);
IntOut(0, A+B);
CrLf(0);

]</lang>

Yorick

<lang yorick>a = b = 0; read, a, b; write, a + b;</lang>

ZED

<lang ZED>(A+B) comment (always) (+) (read) (default-input-port)

   (read) (default-input-port)</lang>