Input/Output for pairs of numbers: Difference between revisions

{{trans|Python}}

 

R a + b

 

L 1..t

V (a, b) = input().split(‘ ’).map(Int)

 

 

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

INT sum,i

CHAR ARRAY tmp(100)

PrintIE(sums(i))

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Input_Output_for_pairs_of_numbers.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

There can be newlines before or between numbers. The pairs may be on separate lines or the same line.

with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

 

New_Line;

end loop;

{{output}}

Output using the example input:

=={{header|ALGOL 68}}==

Simple version - there can be newlines before or between the numbers

# 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

print( ( a + b, newline ) )

OD

Strict version - the pairs of numbers must appear on the same line.

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

get( numbers, ( a, b ) );

print( ( a + b, newline ) )

{{out}}

<pre>

+10

</pre>

 

=={{header|AWK}}==

NR > n+1 {exit}

 

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

@echo off

setlocal enabledelayedexpansion

for /l %%i in (1,1,%pairs%) do echo !sum%%i!

pause>nul

{{in}}

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

DIM pairs%(n% - 1, 1)

FOR i% = 0 TO n% - 1

FOR i% = 0 TO n% - 1

PRINT pairs%(i%, 0) + pairs%(i%, 1)

With the sample inputs:

<pre>?5

 

=={{header|C}}==

#include <stdlib.h>

 

 

return 0;

 

Output for example input

 

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

using static System.Linq.Enumerable;

 

}

}

{{out}}

<pre>

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

 

#include <vector>

using namespace std;

cout << doStuff(list[j].first, list[j].second) << endl;;

}

 

Run as per given input

=={{header|D}}==

This works with any number of integers on lines.

import std.stdio, std.string, std.conv, std.algorithm;

 

foreach (immutable _; 0 .. readln.strip.to!uint)

readln.split.to!(int[]).sum.writeln;

 

=={{header|Factor}}==

USING: io math.parser prettyprint sequences splitting ;

IN: rosetta-code.pair-output

MAIN: main

{{out}}

<pre>

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

 

write(*, "(i0)") sum(pairs, 2)

 

 

=={{header|FreeBASIC}}==

 

Dim As UInteger n

Print Str(sums(i))

Next

 

{{out}}

10

</pre>

 

=={{header|Go}}==

 

import (

fmt.Println(a + b)

}

 

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

 

contents <- getContents

let numberOfLines = read.head.lines$ contents

nums = map (map read.words).take numberOfLines.tail.lines$ contents

sums = map sum nums

 

=={{header|J}}==

$ cat <<EOF | jconsole -js '([: exit 0: [: smoutput [: ,. [: ({. {. }.) [: (+/"1) [: (0&".;._2) (1!:1)) 3'

> 5

102

10

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

 

public class Main {

}

}

 

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

< input.txt jq -n '

input as $n

| [input,input] | add

end'

{{out}}

<pre>

 

=={{header|Julia}}==

const lines = parseints()[1]

println(sum(parseints()))

end

<pre>

3

 

=={{header|Kotlin}}==

 

import java.util.Scanner

println()

for (i in 0 until n) println(x[i] + y[i])

Sample input/output:

{{out}}

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

for i = 1, numLines do

sum = 0

table.insert(intTab, sum)

end

 

=={{header|Nim}}==

 

let lineCount = stdin.readLine.parseInt()

assert fields.len == 2

let pair = fields.map(parseInt)

 

{{Out}}

=={{header|OCaml}}==

 

let n = int_of_string (input_line stdin) in

for i = 1 to n do

| _ ->

raise (Invalid_argument "wrong input")

 

{{out}}

 

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:

#include <stdlib.h>

#include <pari/pari.h>

pari_printf("%Ps", f);

return 0;

Of course for such a simple task this has very little advantage over C, but it does demonstrate the general principle.

 

=={{header|Perl}}==

Reads from STDIN, added any pair of numbers.

 

for (1..$n) {

($a,$b) = split ' ', <>;

print $a + $b . "\n";

 

=={{header|Phix}}==

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

{{out}}

(or more accurately the final state of the console)

{3,30,2,102,10}

</pre>

 

=={{header|PowerShell}}==

# script.ps1

 

 

# ./script file.txt

 

=={{header|Python}}==

return a + b

 

for x in range(0, t):

a, b = raw_input().strip().split()

 

===Python: Alternative===

Or without the function do_stuff() and that works for Python 3 and Python 2:

except NameError: raw_input = input

 

5 5

10

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

print(sum(int(numberstring)

for numberstring in raw_input('two numbers: ').strip().split()))

two numbers: 5 5

10

 

=={{header|Racket}}==

;(define line-number (read)) ;reads all kind of things

;(for ([i (in-range line-number)])

(displayln (apply +

(map string->number

 

=={{header|Raku}}==

(formerly Perl 6)

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.

/*all input is from the Command Line. */

do linein() /*read the number of pairs to be add*ed*/

say word($, 1) + word($, 2) /*display the sum of a pair of numbers.*/

end /*linein() */

 

=={{header|Ring}}==

# Project : Input/Output for Pairs of Numbers

 

ok

next

Output:

<pre>

 

===Ring: Alternative===

# Project : Input/Output for Pairs of Numbers (Alternative)

 

ok

next

<pre>

3

102

10

</pre>

 

=={{header|Ruby}}==

n.times do

a, b = gets.split.map(&:to_i)

puts a + b

 

=={{header|Scala}}==

private val in = scala.io.StdIn

private val n = in.readInt()

 

}

 

=={{header|Tcl}}==

while {$n > 0} {

if {[scan [gets stdin] "%d %d" a b] == 2} {

}

incr n -1

 

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

{{works with|Bourne Again SHell}}

 

while (( n > 0 )); do

read a b

echo $((a+b))

((n--))

 

=={{header|Ursa}}==

set amount (in int console)

 

for (set i 0) (< i (size ints)) (set i (int (+ 2 i)))

out (int (+ ints<i> ints<(int (+ i 1))>)) endl console

Networked version. Runs on port 20000.

decl port p

sp.attach 20000

for (set i 0) (< i (size ints)) (set i (int (+ 2 i)))

out (int (+ ints<i> ints<(int (+ i 1))>)) endl p

 

=={{header|Wren}}==

This assumes that both Stdin and Stdout are connected to a terminal.

 

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

}

System.print()

 

{{out}}

=={{header|XPL0}}==

The input file must be redirected on the command line, for example: iopair <iopair.txt

for N:= 1 to IntIn(1) do

[IntOut(0, IntIn(1) + IntIn(1));

CrLf(0);

 

{{out}}

=={{header|zkl}}==

Using the console as the input stream:

n:=ask("num pairs: ").toInt();

do(n){ask("1 pair: ").split(" ").sum().println()}

{{out}}

<pre>