View source for Input/Output for pairs of numbers

{{draft task}}
From lines of input starting with a line containing the numbers of pairs to follows, followed by that number of pairs of integers separated by a space on separate lines from STDIN, output the sum of each pair to STDOUT. 


;Sample input with corresponding output:

'''Input'''
<pre>5
1 2
10 20
-3 5
100 2
5 5</pre>

'''Output'''
<pre>3
30
2
102
10</pre>

=={{header|11l}}==
{{trans|Python}}

<syntaxhighlight lang="11l">F do_stuff(a, b)
   R a + b

V t = Int(input())
L 1..t
   V (a, b) = input().split(‘ ’).map(Int)
   print(do_stuff(a, b))</syntaxhighlight>


=={{header|Action!}}==
<syntaxhighlight lang="action!">INT FUNC CalcSum(CHAR ARRAY s)
  INT sum,i
  CHAR ARRAY tmp(100)

  sum=ValI(s)
  FOR i=1 TO s(0)
  DO
    IF s(i)=32 THEN EXIT FI
  OD
  SCopyS(tmp,s,i,s(0))
  sum==+ValI(tmp)
RETURN (sum)

PROC Main()
  BYTE i,nLines
  INT ARRAY sums(256)
  CHAR ARRAY line(256)

  nLines=InputB()
  IF nLines=0 THEN RETURN FI

  FOR i=0 TO nLines-1
  DO
    InputS(line)
    sums(i)=CalcSum(line)
  OD

  PutE()
  FOR i=0 TO nLines-1
  DO
    PrintIE(sums(i))
  OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Input_Output_for_pairs_of_numbers.png Screenshot from Atari 8-bit computer]
<pre>
5
1 2
10 20
-3 5
100 2
5 5

3
30
2
102
10
</pre>

=={{header|Ada}}==
There can be newlines before or between numbers. The pairs may be on separate lines or the same line.
<syntaxhighlight lang="ada">with Ada.Text_IO;         use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

procedure Main is
   count  : Integer;
   First  : Integer;
   Second : Integer;
begin
   Get (count);
   for I in 1 .. count loop
      Get (First);
      Get (Second);
      Put (Item => First + Second, Width => 1);
      New_Line;
   end loop;
end Main;</syntaxhighlight>
{{output}}
Output using the example input:
<pre>
3
30
2
102
10
</pre>

=={{header|ALGOL 68}}==
Simple version - there can be newlines before or between the numbers
<syntaxhighlight lang="algol68"># read a number from stand in then read and add that many pairs of numbers from stand in      #
# and write the sum to stand out. If non integer data is supplied, a runtime error will occur #
TO ( INT n; read( ( n, newline ) ); n ) DO
    INT a, b;
    read( ( a, b, newline ) );
    print( ( a + b, newline ) )
OD
</syntaxhighlight>
Strict version - the pairs of numbers must appear on the same line.
<syntaxhighlight lang="algol68">
# read a number from stand in then read and add that many pairs of numbers from stand in      #
# and write the sum to stand out. If non integer data is supplied, a runtime error will occur #
# This version does not allow the pairs of numbers to be spread over several lines            #
STRING line;
FILE   numbers;
associate( numbers, line );
TO ( INT n
   ; read( ( line, newline ) )
   ; reset( numbers )
   ; get( numbers, ( n ) )
   ; n
   )
DO
    INT a, b;
    read( ( line, newline ) );
    reset( numbers );
    get( numbers, ( a, b ) );
    print( ( a + b, newline ) )
OD</syntaxhighlight>
{{out}}
<pre>
         +3
        +30
         +2
       +102
        +10
</pre>

=={{header|Applesoft BASIC}}==
<syntaxhighlight lang="gwbasic"> 100  GOSUB 230"INPUT LINE"
 110  LET N =  VAL (L$) - 1
 120  IF N < 0 THEN  END 
 130  DIM SUM(N)
 140  FOR I = 0 TO N
 150      GOSUB 330"SUM PAIR FROM INPUT LINE"
 160      LET SUM(I) = S
 170  NEXT I
 190  FOR I = 0 TO N
 200      PRINT SUM(I)
 210  NEXT 
 220  END

 230  LET L$ = ""
 240  LET C$ = ""
 250  FOR C = 0 TO 1 STEP 0
 260      LET L$ = L$ + C$
 270      GET C$
 280      PRINT  CHR$ (0)C$;
 290      LET C = C$ =  CHR$ (13)
 300  NEXT C
 310  LET C =  FRE (0)
 320  RETURN 

 330  GOSUB 230"INPUT LINE"
 340  FOR C = 1 TO LEN(L$)
 350      IF MID$(L$, C, 1) <> " " THEN NEXT C
 360  S = VAL(MID$(L$, 1, C - 1)) + VAL(MID$(L$, C + 1))
 370  RETURN</syntaxhighlight>
'''Input'''
<pre>
5
1 2
10 20
-3 5
100 2
5 5
</pre>
{{out}}
<pre>
3
30
2
102
10
</pre>
=={{header|Arturo}}==

<syntaxhighlight lang="arturo">printNumbers: function [num]-> 
    print [num\0 "+" num\1 "=" num\0 + num\1]

lineCount: to :integer strip input ""

do.times:lineCount [
    numbers: to [:integer] split.words input ""
    printNumbers numbers
]</syntaxhighlight>

{{out}}

<pre>3
2 10
2 + 10 = 12 
4 5
4 + 5 = 9 
-123 45
-123 + 45 = -78</pre>

=={{header|AWK}}==
<syntaxhighlight lang="awk">NR == 1 {n=$1; next} 
NR > n+1 {exit} 
{print $1+$2}</syntaxhighlight>

=={{header|Batch File}}==
<syntaxhighlight lang="dos">
@echo off
setlocal enabledelayedexpansion

set /p pairs=

for /l %%i in (1,1,%pairs%) do set /p pair%%i=
for /l %%i in (1,1,%pairs%) do (
  for %%j in (!pair%%i!) do (
    set /a sum%%i+=%%j
  )
)

for /l %%i in (1,1,%pairs%) do echo !sum%%i!
pause>nul
</syntaxhighlight>
{{in}}
<pre>
5
10 10
5 6
-3 2
-6 -8
111 2
</pre>
{{out}}
<pre>
20
11
-1
-14
113
</pre>

=={{header|BBC BASIC}}==
The specification is a bit ambiguous, but I understood it as wanting us to read all the numbers in <i>first</i> and then print all the sums. This program does that. It could be a couple of lines shorter if we were allowed to use a comma instead of a space as separator.
<syntaxhighlight lang="bbcbasic">INPUT n%
DIM pairs%(n% - 1, 1)
FOR i% = 0 TO n% - 1
  INPUT s$
  pairs%(i%, 0) = VAL(LEFT$(s$, INSTR(s$, " ")))
  pairs%(i%, 1) = VAL(MID$(s$, INSTR(s$, " ")))
NEXT
FOR i% = 0 TO n% - 1
  PRINT pairs%(i%, 0) + pairs%(i%, 1)
NEXT</syntaxhighlight>
With the sample inputs:
<pre>?5
?1 2
?10 20
?-3 5
?100 2
?5 5
         3
        30
         2
       102
        10</pre>

=={{header|C}}==
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>

int main(void)
{
	int i, n, a, b, *f;
	scanf("%d", &n);
	f = malloc(sizeof(*f) * n);

	for (i = 0; i < n; i++) {
		if (2 != scanf("%d %d", &a, &b))
			abort();
		f[i] = a + b;
	}

	for (i = 0; i < n; i++)
		printf("%d\n", f[i]);

	return 0;
}</syntaxhighlight>

Output for example input

<pre>
3
30
2
102
10
</pre>

=={{header|C sharp}}==
<syntaxhighlight lang="csharp">using System;
using static System.Linq.Enumerable;

public class Program
{
    static void Main(string[] args)
    {
	int count = Convert.ToInt32(Console.ReadLine());
	for (int line = 0; line < count; line++) {
            Console.WriteLine(Console.ReadLine().Split(' ').Sum(i => Convert.ToInt32(i)));
	}
    }
}</syntaxhighlight>
{{out}}
<pre>
3
30
2
102
10
</pre>

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

<syntaxhighlight lang="cpp">#include <iostream>
#include <vector>
using namespace std;
 
int doStuff(int a, int b) {
	return a + b;
}
 
int main() {
 
	int t;
	cin >> t;
 
	vector<pair<int, int>> list(t);
 
	for(int j=0; j<t; j++){
		cin >> list[j].first >> list[j].second;
	}
 
	cout << endl;
 
	for(int j=0;j<t;j++){
		cout << doStuff(list[j].first, list[j].second) << endl;;
	}
}</syntaxhighlight>

Run as per given input

<pre>
5
1 2
10 20
-3 5
100 2
5 5

3
30
2
102
10
</pre>

=={{header|D}}==
This works with any number of integers on lines.
<syntaxhighlight lang="d">void main() {
    import std.stdio, std.string, std.conv, std.algorithm;

    foreach (immutable _; 0 .. readln.strip.to!uint)
        readln.split.to!(int[]).sum.writeln;
}</syntaxhighlight>

=={{header|EasyLang}}==
<syntaxhighlight>
n = number input
for i to n
   a[] = number strsplit input " "
   print a[1] + a[2]
.
input_data
5
1 2
10 20
-3 5
100 2
5 5
</syntaxhighlight>
{{out}}
<pre>
3
30
2
102
10
</pre>


=={{header|Factor}}==
<syntaxhighlight lang="factor">
USING: io math.parser prettyprint sequences splitting ;
IN: rosetta-code.pair-output

: process-line ( str -- n )
    " " split [ string>number ] map-sum ;
: main ( -- ) lines 1 tail [ process-line ] map [ . ] each ;
    
MAIN: main
</syntaxhighlight>
{{out}}
<pre>
3
30
2
102
10
</pre>

=={{header|Fortran}}==
{{works with|Fortran|95 and later}}
<syntaxhighlight lang="fortran">program i_o_pairs
  implicit none

  integer :: npairs
  integer :: i
  integer, allocatable :: pairs(:,:)

  read(*,*) npairs
  allocate(pairs(npairs,2))
 
  do i = 1, npairs
    read(*,*) pairs(i,:)
  end do
  write(*, "(i0)") sum(pairs, 2)

end program</syntaxhighlight>

=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64

Dim As UInteger n 
Dim As Integer x, y
Input "", n
Dim sums(1 To n) As Integer
For i As Integer = 1 To  n
  Input "", x, y
  sums(i) =  x + y
Next 
Print
For i As Integer = 1 To n
  Print Str(sums(i))
Next 
Sleep</syntaxhighlight>

{{out}}
<pre>
5
1 2
10 20
-3 5
100 2
5 5

3
30
2
102
10
</pre>

=={{header|Free Pascal}}==
''See [[#Pascal|Pascal]]''

=={{header|Go}}==
<syntaxhighlight lang="go">package main

import (
	"fmt"
	"log"
)

func main() {
	var lines int
	n, err := fmt.Scanln(&lines)
	if n != 1 || err != nil {
		log.Fatal(err)
	}

	var a, b int
	for ; lines > 0; lines-- {
		n, err = fmt.Scanln(&a, &b)
		if n != 2 || err != nil {
			log.Fatal(err)
		}
		fmt.Println(a + b)
	}
}</syntaxhighlight>

=={{header|Haskell}}==
This solution will actually add any number of integers placed on each line. Additionally, after removing the bits of code that cut out the specified number of lines, the solution will sum any number of lines of integers.

<syntaxhighlight lang="haskell">main = do
    contents <- getContents
    let numberOfLines  =  read.head.lines$ contents
        nums  =  map (map read.words).take numberOfLines.tail.lines$ contents
        sums  =  map sum nums
    mapM_ print sums</syntaxhighlight>

=={{header|J}}==
<syntaxhighlight lang="j">
$ cat <<EOF | jconsole -js '([: exit 0: [: smoutput [: ,. [: ({. {. }.) [: (+/"1) [: (0&".;._2) (1!:1)) 3'
> 5
> 1 2
> 10 20
> -3 5
> 100 2
> 5 5
> EOF
  3
 30
  2
102
 10
</syntaxhighlight>
Considerably simpler than [[http://rosettacode.org/wiki/Input/Output_for_Lines_of_Text#J|see explanation]] output for lines of text, this sentence is a single fork.  J pads the numeric arrays of 0&".;._2 (numbers cut) with 0 .  We form the +/"1 (row sums), then take the sum of the first row of the beheaded sums ({. {. }.) for display.  ,. (raveled items) reshapes the vector into a column-vector shaped matrix.  And the [: (cap) causes the monadic form of the verb to cap's right.

=={{header|Java}}==
<syntaxhighlight lang="java">import java.util.Scanner;

public class Main {

	public static int doStuff(int a, int b){
	    int sum = a+b;
	    return sum;
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);

		int n = in.nextInt();
		for(int i=0; i<n; i++){
			int a = in.nextInt();
			int b= in.nextInt();
			int result = doStuff(a, b);
			System.out.println(result);
		}
	}
}</syntaxhighlight>

=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''

The solution below assumes the input is in a file named input.txt, and is quite lenient about the presentation of the numbers.  For example, it does not require that each pair of numbers be presented on the same line.
<syntaxhighlight lang="sh">
< input.txt jq -n '
  input as $n
  | if $n | (type != "number" or . < 0)
    then "Number of pairs must be non-negative." | error
    else range(0; $n)
    | [input,input] | add
    end'
</syntaxhighlight>
{{out}}
<pre>
3
30
2
102
10
</pre>

=={{header|Julia}}==
<syntaxhighlight lang="julia">parseints() = (a = split(strip(readline()), r"\s+"); map(x -> parse(Int, x), a)) 
 
const lines = parseints()[1]

for _ in 1:lines
    println(sum(parseints()))
end
</syntaxhighlight>{{out}}
<pre>
3
5 6
11
8 2
10
9 23
32
</pre>

=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.0.6

import java.util.Scanner

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)  // note: backticks required as 'in' is a Kotlin keyword
    val n = sc.nextInt()
    val x = IntArray(n)
    val y = IntArray(n)
    for (i in 0 until n) {
        x[i] = sc.nextInt()
        y[i] = sc.nextInt()  
    }
    println()
    for (i in 0 until n) println(x[i] + y[i])
}</syntaxhighlight>
Sample input/output:
{{out}}
<pre>
5
1 2
10 20
-3 5
100 2
5 5

3
30
2
102
10
</pre>

=={{header|Lua}}==
This solution will sum any number of space-separated numbers per input line, assuming the user won't input too many to store in the available RAM.
<syntaxhighlight lang="lua">local intTab, numLines, sum = {}, io.read()
for i = 1, numLines do
    sum = 0
    for number in io.read():gmatch("%S+") do sum = sum + number end
    table.insert(intTab, sum)
end
for _, result in pairs(intTab) do print(result) end</syntaxhighlight>

=={{header|Nim}}==
<syntaxhighlight lang="nim">import sequtils, strutils

let lineCount = stdin.readLine.parseInt()
for _ in 1..lineCount:
  let line = stdin.readLine()
  let fields = line.splitWhitespace()
  assert fields.len == 2
  let pair = fields.map(parseInt)
  echo pair[0] + pair[1]</syntaxhighlight>

{{Out}}
For the sample input:
<pre>3
30
2
102
10</pre>

=={{header|OCaml}}==

<syntaxhighlight lang="ocaml">let () =
  let n = int_of_string (input_line stdin) in
  for i = 1 to n do
    let line = input_line stdin in
    match String.split_on_char ' ' line with
    | a::b::[] ->
        let x = int_of_string a + int_of_string b in
        print_int x;
        print_newline ()
    | _ ->
        raise (Invalid_argument "wrong input")
  done</syntaxhighlight>

{{out}}
<pre>
$ cat input.txt
5
1 2
10 20
-3 5
100 2
5 5
$ cat input.txt | ocaml pairs.ml 
3
30
2
102
10
</pre>

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

Interestingly, this task is not possible to implement directly in GP, since <code>input()</code>, like the gp REPL itself, ignores spaces. One must use PARI:
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <pari/pari.h>

int main(void);
 
int
main()
{
  int i, n, a, b;
  GEN f, sum;
  pari_sp ltop;
  
  // 1 MB stack, not using prime table
  pari_init(1000000, 0);
  
  scanf("%d", &n);
  GEN f = cgetg(n+1, t_VEC);

  for (i = 1; i <= n; i++) {
    if (2 != scanf("%d %d", &a, &b)) abort();
	
    ltop = avma;
	
	// Add a and b in PARI
	sum = addii(stoi(a), stoi(b));
	
	// Store the sum in a vector, collecting garbage as you go.
	gel(f, i) = gerepileupto(ltop, sum);
  }

  pari_printf("%Ps", f);
  return 0;
}</syntaxhighlight>
Of course for such a simple task this has very little advantage over C, but it does demonstrate the general principle.

=={{header|Pascal}}==
<syntaxhighlight lang="pascal">program inputOutputForPairsOfNumbers(input, output);
var
	lines: integer;
	x: integer;
	y: integer;
begin
	readLn(lines);
	for lines := 1 to lines do
	begin
		readLn(x, y);
		writeLn(x + y)
	end
end.</syntaxhighlight>
{{out}}
           3
          30
           2
         102
          10

=={{header|Perl}}==
Reads from STDIN, added any pair of numbers.
<syntaxhighlight lang="perl">$n = scalar <>;

for (1..$n) {
    ($a,$b) = split ' ', <>;
    print $a + $b . "\n";
}</syntaxhighlight>

=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(notonline)-->
 <span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (file i/o)</span>
 <span style="color: #004080;">string</span> <span style="color: #000000;">line</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">gets</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
 <span style="color: #004080;">sequence</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">scanf</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">trim</span><span style="color: #0000FF;">(</span><span style="color: #000000;">line</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
 <span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">)!=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
     <span style="color: #7060A8;">crash</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"input not a number"</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
 <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">][</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">do</span>
     <span style="color: #000000;">line</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">gets</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
     <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">scanf</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">trim</span><span style="color: #0000FF;">(</span><span style="color: #000000;">line</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"%d %d"</span><span style="color: #0000FF;">)</span>
     <span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">)!=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
         <span style="color: #7060A8;">crash</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"input not a pair of numbers"</span><span style="color: #0000FF;">)</span>
     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
     <span style="color: #000000;">s</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
     <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
 <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"===\n"</span><span style="color: #0000FF;">)</span>
 <span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
(or more accurately the final state of the console)
<pre>
5
1 2
10 20
-3 5
100 2
5 5
===
{3,30,2,102,10}
</pre>
===avoiding file i/o===
And hence runnable in a browser, as well as on the desktop.<br>
User input would need to be a proper GUI rather than a console prompt, perhaps like [[Arithmetic/Integer#Phix]] or the much prettier/more polished [[Morse_code#Phix]].
<!--<syntaxhighlight lang="phix">(phixonline)-->
 <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
 <span style="color: #004080;">sequence</span> <span style="color: #000000;">lines</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"""
 5
 1 2
 10 20
 -3 5
 100 2
 5 5"""</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
 <span style="color: #004080;">string</span> <span style="color: #000000;">line</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">lines</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
 <span style="color: #004080;">sequence</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">scanf</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">trim</span><span style="color: #0000FF;">(</span><span style="color: #000000;">line</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
 <span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">)!=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
     <span style="color: #7060A8;">crash</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"input not a number"</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
 <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
 <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">][</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">do</span>
     <span style="color: #000000;">line</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">lines</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
     <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">scanf</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">trim</span><span style="color: #0000FF;">(</span><span style="color: #000000;">line</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"%d %d"</span><span style="color: #0000FF;">)</span>
     <span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">)!=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
         <span style="color: #7060A8;">crash</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"input not a pair of numbers"</span><span style="color: #0000FF;">)</span>
     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
     <span style="color: #000000;">s</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
 <span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
Output same as the last line of the above.

=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
# script.ps1

$in, $line = (Get-Content $args[0]), 0
$nb = $in[$line++]
1..$nb | foreach {
    $sum = 0
    $in[$line++].Split() | foreach{ $sum += $_} 
    $sum
}

# ./script file.txt
</syntaxhighlight>

=={{header|Python}}==
<syntaxhighlight lang="python">def do_stuff(a, b):
	return a + b

t = input()
for x in range(0, t):
	a, b = raw_input().strip().split()
	print do_stuff(int(a), int(b))</syntaxhighlight>

===Python: Alternative===
Or without the function do_stuff() and that works for Python 3 and Python 2:
<syntaxhighlight lang="python">>>> try: raw_input
except NameError: raw_input = input

>>> for i in range(int(raw_input())):
	print(sum(int(numberstring)
		  for numberstring
		  in raw_input().strip().split()))

	
5
1 2
3
10 20
30
-3 5
2
100 2
102
5 5
10
>>> </syntaxhighlight>
(All but the first line of single numbers, (the 5), is output from the program).

===Python: With prompts===
More than is asked for by the task, but if working interactively then the following version adds prompts.
<syntaxhighlight lang="python">>>> for i in range(int(raw_input('lines: '))):
	print(sum(int(numberstring) 
                  for numberstring in raw_input('two numbers: ').strip().split()))

	
lines: 5
two numbers: 1 2
3
two numbers: 10 20
30
two numbers: -3 5
2
two numbers: 100 2
102
two numbers: 5 5
10
>>> </syntaxhighlight>

=={{header|Quackery}}==

<syntaxhighlight lang="Quackery"> []
 $ "How many pairs? " input
 quackery times
   [ $ "Pair "
     i^ 1+ number$ join
     $ ": " join input
     join
     $ " + echo cr " join ]
 quackery</syntaxhighlight>

{{out}}

<pre>How many pairs? 5
Pair 1: 1 2
Pair 2: 10 20
Pair 3: -3 5
Pair 4: 100 2
Pair 5: 5 5
3
30
2
102
10
</pre>

=={{header|Racket}}==
<syntaxhighlight lang="racket">#lang racket
;(define line-number (read)) ;reads all kind of things 
;(for ([i (in-range line-number)])
;  (displayln (+ (read) (read))))

(define line-count (string->number ;only reads numbers
                    (string-trim (read-line)))) 
 
(for ([i (in-range line-count)])
  (displayln (apply + 
                    (map string->number 
                         (string-split (read-line))))))</syntaxhighlight>

=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>for ^get() { say [+] get.words }</syntaxhighlight>
This does more than the task asks.  It will sum as many numbers as you care to put on each line, and the numbers need not be integers, but may also be a mix of rational, floating-point, or complex numbers.  More subtly, <tt>get</tt> can read from a file specified as a command-line argument, but defaults to taking STDIN if no filename is specified.

=={{header|REXX}}==
This version isn't limited to summing integers, any form of number that REXX supports can be used. 
<syntaxhighlight lang="rexx">/*REXX pgm reads a number (from the CL), reads that number of pairs, & writes their sum.*/
                                                 /*all input is from the  Command Line. */
     do  linein()                                /*read the number of pairs to be add*ed*/
     $=linein()                                  /*read a line (a record) from the C.L. */
     say word($, 1)   +   word($, 2)             /*display the sum of a pair of numbers.*/
     end   /*linein() */
                                                 /*stick a fork in it,  we're all done. */</syntaxhighlight>

=={{header|Ring}}==
<syntaxhighlight lang="ring">
# Project : Input/Output for Pairs of Numbers

pairs = ["5", "1 2", "10 20", "-3 5", "100 2", "5 5"]
for n = 1 to len(pairs)
    nr = 0
    for p = 1 to len(pairs[n])
        if substr(pairs[n], p, 1) = " "
           nr = p
        ok
    next
    if nr > 0
       n1 = number(left(pairs[n], nr - 1))
       n2 = number(right(pairs[n], len(pairs[n]) - nr + 1))
       n3 = n1 + n2
       see n3 + nl
    ok
next
</syntaxhighlight>
Output:
<pre>
3
30
2
102
10
</pre>

===Ring: Alternative===
<syntaxhighlight lang="ring">
# Project : Input/Output for Pairs of Numbers (Alternative)

pairs = ["5", "1 2", "10 20", "5 -3", "100 2", "5 5"]
for n = 1 to len(pairs)
    nr = 0
    for p = 1 to len(pairs[n])
        if substr(pairs[n], p, 1) = " "
           pairs[n] = substr(pairs[n], " ", "+")
           nr = p
        ok
    next
    if nr > 0
       eval("ev = " + pairs[n])
       see ev + nl
    ok
next
>>> </syntaxhighlight>
<pre>
3
30
2
102
10
</pre>

=={{header|RPL}}==
 « 1 "How many pairs" "" INPUT STR→ '''FOR''' j
      "Enter pair #" j + "" INPUT STR→ + 
   '''NEXT'''
 » '<span style=color:blue">TASK</span>' STO
{{out}}
<pre>
5: 3
4: 30
3: 2
2: 102
1: 10
</pre>

=={{header|Ruby}}==
<syntaxhighlight lang="ruby">n = gets.to_i
n.times do
  a, b = gets.split.map(&:to_i)
  puts a + b
end</syntaxhighlight>

=={{header|Scala}}==
<syntaxhighlight lang="scala">object IOPairs extends App {
  private val in = scala.io.StdIn
  private val n = in.readInt()

  for (_ <- 0 until n) {
    val Array(a, b) = in.readLine().split(" ").map(_.toInt)

    def doStuff(a: Long, b: Long): Long = a + b

    println(doStuff(a, b))
  }

}
</syntaxhighlight>

=={{header|Tcl}}==
<syntaxhighlight lang="tcl">gets stdin n
while {$n > 0} {
    if {[scan [gets stdin] "%d %d" a b] == 2} {
        puts [expr {$a + $b}]
    }
    incr n -1
}</syntaxhighlight>

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

{{works with|Bourne Again SHell}}

<syntaxhighlight lang="bash">read n
while (( n > 0 )); do
    read a b
    echo $((a+b))
    ((n--))
done</syntaxhighlight>

=={{header|Ursa}}==
<syntaxhighlight lang="ursa">decl int amount
set amount (in int console)

decl int<> ints
for (decl int i) (< i amount) (inc i)
        decl string input
        set input (in string console)
        append (int (split input " ")<0>) (int (split input " ")<1>) ints
end for

out endl console

for (set i 0) (< i (size ints)) (set i (int (+ 2 i)))
        out (int (+ ints<i> ints<(int (+ i 1))>)) endl console
end for</syntaxhighlight>
Networked version. Runs on port 20000.
<syntaxhighlight lang="ursa">decl serverport sp
decl port p
sp.attach 20000
set p (sp.getconn)

decl int amount
set amount (in int p)

decl int<> ints
for (decl int i) (< i amount) (inc i)
        decl string input
        set input (in string p)
        append (int (split input " ")<0>) (int (split input " ")<1>) ints
end for

out endl p

for (set i 0) (< i (size ints)) (set i (int (+ 2 i)))
        out (int (+ ints<i> ints<(int (+ i 1))>)) endl p
end for</syntaxhighlight>

=={{header|Wren}}==
This assumes that both Stdin and Stdout are connected to a terminal. 
<syntaxhighlight lang="wren">import "io" for Stdin

var output = Fn.new { |pairs| pairs.each { |p| System.print(p[0] + p[1]) } }

var n = Num.fromString(Stdin.readLine())
if (!n || !n.isInteger || n < 1) Fiber.abort("Number of pairs must be a positive integer.")
var pairs = []
for (i in 0...n) {
    var line = Stdin.readLine()
    var sp = line.split(" ")
    if (sp.count != 2) Fiber.abort("Each line must contain 2 integers, separated by a space.")
    var p1 = Num.fromString(sp[0])
    if (!p1 || !p1.isInteger) Fiber.abort("First value is not an integer.")
    var p2 = Num.fromString(sp[1])
    if (!p2 || !p2.isInteger) Fiber.abort("Second value is not an integer.")
    pairs.add([p1, p2])
}
System.print()
output.call(pairs)</syntaxhighlight>

{{out}}
Sample input/output:
<pre>
5
1 2
10 20
-3 5
100 2
5 5

3
30
2
102
10
</pre>

=={{header|XPL0}}==
The input file must be redirected on the command line, for example: iopair <iopair.txt
<syntaxhighlight lang="xpl0">int N;
for N:= 1 to IntIn(1) do
    [IntOut(0, IntIn(1) + IntIn(1));
    CrLf(0);
    ]</syntaxhighlight>

{{out}}
<pre>
3
30
2
102
10
</pre>

=={{header|zkl}}==
Using the console as the input stream:
<syntaxhighlight lang="zkl">fcn pairs{
   n:=ask("num pairs: ").toInt(); 
   do(n){ask("1 pair: ").split(" ").sum().println()}
}</syntaxhighlight>
{{out}}
<pre>
pairs()
num pairs: 5
1 pair: 1 2
3
1 pair: 10 20
30
1 pair: -3 5
2
1 pair: 100 2
102
1 pair: 5 5 
10
</pre>