Rosetta Code

Input/Output for lines of text: Difference between revisions

Page Discussion

Input/Output for lines of text (view source)

Revision as of 19:26, 10 December 2023

28,159 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
(+ D entry)
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(66 intermediate revisions by 39 users not shown)
Line 1:
{{draft task}}
{{clarify task}}
The first line contains the number of lines to follow, followed by that number of lines of text on STDIN. Output to STDOUT each line of input by passing it to a method as an intermediate step. The code should demonstrate these 3 things. See also [[Input/Output for Pairs of Numbers]] and [[File/Input and Output]].
 
;Task:
The first line contains the number of lines to follow, followed by that number of lines of text on   STDIN.
 
Write to   STDOUT   each line of input by passing it to a method as an intermediate step. The code should demonstrate these 3 things.
 
 
;Sample input with corresponding output:
 
'''Input'''
<pre>3
3
hello
hello world
Line 12 ⟶ 19:
 
'''Output'''
<pre>hello
hello
hello world
Pack my Box with 5 dozen liquor jugs</pre>
</pre>
 
 
;Related tasks:
* &nbsp; [[Input/Output for Pairs of Numbers]]
* &nbsp; [[File/Input and Output]]
<br><br>
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">F do_stuff(words)
print(words)
 
V linecount = Int(input())
L 1..linecount
V line = input()
do_stuff(line)</syntaxhighlight>
 
=={{header|Action!}}==
The user must type in the monitor the following command after compilation and before running the program!<pre>SET EndProg=*</pre>
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">CARD EndProg ;required for ALLOCATE.ACT
 
INCLUDE "D2:ALLOCATE.ACT" ;from the Action! Tool Kit. You must type 'SET EndProg=*' from the monitor after compiling, but before running this program!
 
PROC Main()
DEFINE PTR="CARD"
BYTE i,nLines
PTR ARRAY lines(256)
CHAR ARRAY line(256),p
 
AllocInit(0)
Put(125) PutE()
 
nLines=InputB()
IF nLines=0 THEN RETURN FI
 
FOR i=0 TO nLines-1
DO
InputS(line)
p=Alloc(line(0)+1)
MoveBlock(p,line,line(0)+1)
lines(i)=p
OD
 
PutE()
FOR i=0 TO nLines-1
DO
p=lines(i)
PrintE(p)
OD
 
FOR i=0 TO nLines-1
DO
p=lines(i)
Free(p,p(0)+1)
lines(i)=0
OD
nLines=0
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Input_Output_for_lines_of_text.png Screenshot from Atari 8-bit computer]
<pre>
3
hello
hello world
Pack my Box with 5 dozen liquor jugs
 
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
 
=={{header|Ada}}==
<syntaxhighlight lang="ada">--
-- The first line contains the number of lines to follow, followed by that
-- number of lines of text on STDIN.
--
-- Write to STDOUT each line of input by passing it to a method as an
-- intermediate step. The code should demonstrate these 3 things.
--
 
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
 
procedure Main is
Num_Lines : Integer;
begin
Get(Num_Lines);
Skip_Line;
for I in 1..Num_Lines loop
Put_Line(Get_Line);
end loop;
end Main;
</syntaxhighlight>
'''Input:'''
<pre>
3
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
{{output}}
<pre>
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
 
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}
<syntaxhighlight lang="algol68"># outputs line plus a newline #
PROC show line = ( STRING line )VOID:
print( ( line, newline ) );
 
# copy the lines with an loop with an anonymous loop counter #
# as the loop limit is evaluated only once, we can read the #
# number of lines in the "TO" part #
TO ( INT n; read( ( n, newline ) ); n )
DO
show line( ( STRING line; read( ( line, newline ) ); line ) )
OD
</syntaxhighlight>
 
=={{header|ALGOL W}}==
<syntaxhighlight lang="algolw">begin
% outputs line on a newline %
procedure showLine ( string(80) value line ); write( line );
 
string(80) line;
integer lineCount;
read( lineCount );
for lineNumber := 1 until lineCount do begin
read( line );
showLine( line )
end for_lineNumber
end.</syntaxhighlight>
 
=={{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 L$(N)
140 FOR I = 0 TO N
150 GOSUB 230"INPUT LINE"
160 LET L$(I) = L$
170 NEXT I
190 FOR I = 0 TO N
200 PRINT L$(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</syntaxhighlight>
'''Input'''
<pre>
3
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
{{out}}
<pre>
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
=={{header|Arturo}}==
 
<syntaxhighlight lang="arturo">printLine: function [line]-> print line
 
lineCount: to :integer strip input ""
 
do.times:lineCount [
line: input ""
printLine line
]</syntaxhighlight>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f INPUT_OUTPUT_FOR_LINES_OF_TEXT.AWK
BEGIN {
getline n
while (i++ < n) {
getline
str = sprintf("%s%s\n",str,$0)
}
printf("%s",str)
exit(0)
}
</syntaxhighlight>
 
=={{header|Batch File}}==
<syntaxhighlight lang="dos">
@echo off
setlocal enabledelayedexpansion
 
set /p lines=
 
for /l %%i in (1,1,%lines%) do set /p line%%i=
cls
for /l %%i in (1,1,%lines%) do echo !line%%i!
pause>nul
</syntaxhighlight>
{{in}}
<pre>
3
line 1
this is line 2
line 3 is the longest
</pre>
{{out}}
<pre>
line 1
this is line 2
line 3 is the longest
</pre>
 
=={{header|C}}==
<syntaxhighlight lang="c">
#include<stdlib.h>
#include<stdio.h>
 
#define LEN 100 /* Max string length */
 
int main()
{
char **list;
int num, i;
scanf("%d",&num);
list = (char**)malloc(num*sizeof(char*));
for(i=0;i<num;i++)
{
list[i] = (char*)malloc(LEN*sizeof(char));
fflush(stdin);
fgets(list[i],LEN,stdin);
}
printf("\n");
for(i=0;i<num;i++)
{
printf("%s",list[i]);
}
return 0;
}
</syntaxhighlight>
 
Alternative code:
 
This program will read a number through STDIN... well, trough pipeline:
 
$ echo n | io
 
where "n" is the number of lines it will print.
 
When the total number of lines entered has been reached, it will display a message indicating that you must enter a number.
 
<syntaxhighlight lang="c">
// Programa IO.C
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
 
int check_number(const char *s){
const char*t=s;
while(*t!='\n'){
if( !isdigit(*t) ) return 0;
++t;
}
return 1;
}
int main( int argc, char *argv[] )
{
char s[100],r[10];
int n=0;
FILE *fp;
fgets(s,100,stdin); // input trough stdin.
if( (fp = fopen("temporal.txt","r"))!=NULL){
fgets(r,10,fp);
n=atoi(r);
if(n>0){
--n;
fclose(fp);
fp=fopen("temporal.txt","w");
sprintf(r,"%d",n);
fputs(r,fp);
fclose(fp);
printf("%s\n",s);
}else{
fclose(fp);
remove("temporal.txt");
perror("I need a number of the lines here!\n");
}
}else{
if(check_number((const char*)s)){
fp=fopen("temporal.txt","w");
fputs(s,fp);
fclose(fp);
}else{
perror("I need a number of the lines here!\n");
}
}
return 0;
}
</syntaxhighlight>
{{out}}
<pre>
$ echo 3 | ./io
$ echo "hola" | ./io
hola
 
$ echo "hola mundo" | ./io
hola mundo
 
$ echo "lore ipsum et la concha de la lora latinus" | ./io
lore ipsum et la concha de la lora latinus
 
$ echo "lore ipsum et la concha de la lora latinus" | ./io
I need a number of the lines here!
: Success
$
</pre>
 
=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <iostream>
#include <vector>
 
int main()
{
// read the number of lines
int numberOfLines;
std::cin >> numberOfLines;
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // skip to next line
// read the lines
std::vector<std::string> lines(numberOfLines);
for(int i = 0; i < numberOfLines; ++i)
{
std::getline(std::cin, lines[i]);
}
 
// print the lines
for(const auto& value : lines)
{
std::cout << value << "\n";
}
}</syntaxhighlight>
'''Input:'''
<pre>
3
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
{{out}}
<pre>
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
 
=={{header|D}}==
<langsyntaxhighlight lang="d">void main() {
import std.stdio, std.conv, std.string;
 
Line 24 ⟶ 408:
foreach (_; 0 .. readln.strip.to!uint)
doStuff(readln.idup);
}</langsyntaxhighlight>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
<syntaxhighlight lang="delphi">
program Output_for_Lines_of_Text;
 
{$APPTYPE CONSOLE}
 
uses
System.SysUtils;
 
function QueryIntNumber(): Integer;
var
val: string;
begin
Result := 0;
repeat
Writeln('Digite a number(Enter to confirm):');
Readln(val);
 
if not TryStrToInt(val, Result) then
begin
Writeln('"', val, '" is not a valid number.');
Continue;
end;
if Result <= 0 then
begin
Writeln('"', val, '" must be greater then 0');
Continue;
end;
until Result > 0;
end;
 
var
n_lines, i: integer;
lines, line: string;
 
begin
lines := '';
n_lines := QueryIntNumber;
 
for i := 1 to n_lines do
begin
Readln(line);
if i > 1 then
lines := lines + #10;
lines := lines + line;
end;
 
Writeln(lines);
Readln;
end.</syntaxhighlight>
{{out}}
<pre>
Digite a number(Enter to confirm):
3
hello
hello world
Pack my Box with 5 dozen liquor jugs
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
 
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: io kernel strings ;
IN: input-output
 
GENERIC: do-stuff ( obj -- )
M: string do-stuff print ;
 
readln drop [ do-stuff ] each-line</syntaxhighlight>
 
=={{header|Free Pascal}}==
This requires FPC – the FreePascal compiler – to be in a configuration enabling the use ob <tt>object</tt>s.
<syntaxhighlight lang="pascal">program head(input, output, stdErr);
 
type
obj = object
public
procedure method(const s: string); static;
end;
 
procedure obj.method(const s: string);
begin
writeLn(s);
end;
 
var
numberOfLines: integer;
line: string;
begin
readLn(numberOfLines);
for numberOfLines := numberOfLines downto 1 do
begin
readLn(line);
obj.method(line);
end;
end.</syntaxhighlight>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
Sub printLines(lines() As String)
For i As Integer = LBound(lines) To UBound(lines)
Print lines(i)
Next
End Sub
 
Dim As UInteger n
Input "", n
Dim lines(1 To n) As String
For i As Integer = 1 To n
Line Input lines(i)
Next
Print
printLines lines()
Sleep</syntaxhighlight>
 
{{out}}
<pre>
3
hello
hello world
Pack my Box with 5 dozen liquor jugs
 
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
 
=={{header|Go}}==
<syntaxhighlight lang="go">package main
 
import (
"bufio"
"fmt"
"io"
"log"
"os"
)
 
func main() {
// Often we'd already have wrapped os.Stdin (or some other
// io.Reader, like an *os.File) in a bufio.Reader by this point
// and we'd use fmt.Fscanln() on that reader instead.
var lines int
n, err := fmt.Scanln(&lines)
if n != 1 || err != nil {
log.Fatal(err)
}
 
// Use a bufio.Scanner. This uses a SplitFunc which we can choose
// or provide our own that splits or otherwise pre-processes the
// input into tokens however we like.
//
// Could also just use bufio.ReadString('\n') but a Scanner
// with ScanLines matches (and removes) `\r?\n$` and is more
// general purpose.
//
// Normally the loop would be just:
// for scanner.Scan() {
// // use scanner.Text() or scanner.Bytes()
// }
// and we'd loop until the scan indicated EOF. But for this task
// we've got an explictly specified number of lines to read.
 
scanner := bufio.NewScanner(os.Stdin)
scanner.Split(bufio.ScanLines) // not needed, this is the default
for ; scanner.Scan() && lines > 0; lines-- {
doStuff(scanner.Text())
}
if err := scanner.Err(); err != nil {
log.Fatal(err)
}
// Check for too few lines, normally not needed
if lines > 0 {
log.Fatalln("early", io.EOF)
}
}
 
func doStuff(line string) {
fmt.Println(line)
}</syntaxhighlight>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import Control.Monad
main = do
number <- getLine
input <- replicateM (read number) getLine
mapM_ putStrLn input
</syntaxhighlight>'''Input:'''
<pre>
3
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
{{out}}
<pre>
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
 
=={{header|J}}==
[[http://rosettacode.org/wiki/Input/Output_for_Pairs_of_Numbers#J|io for number pairs links to this page.]]
 
Example in bash. jconsole is on the PATH.
<syntaxhighlight lang="j">
$ cat <<EOF | jconsole -js '2!:55@:0:@:(; (1!:2) 4:)@:(}. {.~ _ ". [: }: 0&{::)@:(<;.2)@:(1!:1) 3'
> 3
> hello
> hello world
> Pack my Box with 5 dozen liquor jugs
> EOF
hello
hello world
Pack my Box with 5 dozen liquor jugs
</syntaxhighlight>
From the dictionary of j (DOJ) the data flow for the fork (f g h) is
 
''5. Forks
 
As illustrated above, an isolated sequence of three verbs is called a fork; its monadic and dyadic cases are defined by:''
<pre>
g
/ \
f h
| |
y y
 
g
/ \
f h
/ \ / \
x y x y
</pre>
 
Reading from left to right
 
2!:55 is exit.
0: is a verb that returns 0 for any input.
So now we know the script will terminate the j session with successful status.
 
What does it do before this?
1!:2 is "write to file", with left argument x as the data to write, and the right argument y specifies the file.
4: is a verb returning 4 for any input. File 4 is stdout.
<pre>;</pre> is "raze".
The fork <pre>(; (1!:2) 4:)</pre> writes data to stdout.
Good!
 
What is the data?
(}. {.~ _ ". [: }: 0&{::)
Because it has an odd number of verbs, this expresses a fork. And because {:: (fetch) is in the fork the right argument y is a vector of boxes. We know that the data has a number followed by some lines of text. Let's read the fork from left to right. The second verb, {. is "take" modified by the ~ "passive" adverb to swap arguments. Take uses a shape argument on left (x), and the data to take as y. Remembering the passive effect, the data to which take applies will be the beheaded vector of boxes---beheading removes the first line which is the number, and the fork to the right of {.~ computes the shape. Now looking at the fourth verb, ". (numbers) the default in case of error is _ (infinity meaning "all" when used along a shape dimension to take) and the data for numbers is the curtailed }: content of the first box (index origin 0). 0 is & (bonded also known as curried) to fetch. Curtailing removes the line feed. Since this gives a list of boxes, but we need to display literal data, raze "unboxes" one level of boxing.
Good, if we have a list of boxed lines of input.
 
(<;.2)@:(1!:1) 3
(<;.2) is "< (box) ;. (cut) 2 . The 2 specifies the last item of the data as the fret, and to preserve the frets.
(1!:1) 3 is "read stdin".
 
I chose to connect the parts into a single verb using @: (at).
 
 
With predefined verbs from standard profile we can write the simpler, more readable for native English speakers, and robust sentence which ensures a final linefeed fret and discards the frets with <;._2
 
exit@:0:@:(smoutput&>)@:(}. {.~ _ ". 0&{::)@:cutLF@:(1!:1) 3
 
Cheers! That's tacit j.
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.util.Scanner;
 
public class Main {
Line 42 ⟶ 695:
}
}
}</langsyntaxhighlight>
 
=={{header|jq}}==
The following works for both the C and the Go implementations of jq.
<pre>
jq -Rr 'limit(tonumber; inputs)'
</pre>
 
=={{header|Julia}}==
{{works with|Julia|0.6}}
 
<syntaxhighlight lang="julia">function dosomething(words)
print(words)
end
 
nlines = parse.(Int, readline())
for _ in 1:nlines
words = readline()
dosomething(words)
end</syntaxhighlight>
 
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1
 
fun output(lines: Array<String>) = println(lines.joinToString("\n"))
 
fun main(args: Array<String>) {
println("Enter the number of lines to be input followed by those lines:\n")
val n = readLine()!!.toInt()
val lines = Array(n) { readLine()!! }
println("\nThe lines you entered are:\n")
output(lines)
}</syntaxhighlight>
 
{{out}}
<pre>
Enter the number of lines to be input followed by those lines:
 
3
hello
hello world
Pack my Box with 5 dozen liquor jugs
 
The lines you entered are:
 
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
 
=={{header|Lua}}==
<syntaxhighlight lang="lua">function show (t)
for _, line in pairs(t) do print(line) end
end
 
local lineTable, numLines = {}, io.read()
for i = 1, numLines do table.insert(lineTable, io.read()) end
show(lineTable)</syntaxhighlight>
 
=={{header|Nanoquery}}==
{{trans|Ursa}}
<syntaxhighlight lang="nanoquery">// get how many lines the user wants
amount = int(input())
 
// loop through and get lines
lines = {}
for i in range(1, amount)
lines.append(input())
end
 
// output the lines that the user entered
println
for line in lines
println line
end</syntaxhighlight>
{{out}}
<pre>3
this is a test
the program will read three lines from the console
this is the third line
 
this is a test
the program will read three lines from the console
this is the third line</pre>
 
=={{header|Nim}}==
<syntaxhighlight lang="nim">import strutils
 
proc write(line: string) =
echo line
 
let lineCount = stdin.readLine.parseInt()
for _ in 1..lineCount:
let line = stdin.readLine()
line.write()</syntaxhighlight>
 
=={{header|Objeck}}==
<syntaxhighlight lang="objeck">use System.IO.File;
 
class Rosetta {
function : Main(args : String[]) ~ Nil {
in : FileReader;
leaving {
if(in <> Nil) {
in->Close();
};
};
if(args->Size() = 1) {
in := FileReader->New(args[0]);
i := in->ReadString()->ToInt();
while(i-- <> 0) {
in->ReadString()->PrintLine();
};
};
}
}</syntaxhighlight>
 
=={{header|PARI/GP}}==
 
This task is not possible to implement directly in GP: for <code>input()</code> to take a string the user would have to wrap it in quotes (and escape quotes and newlines). 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, s;
GEN vec;
// 1 MB stack, not using prime table
pari_init(1000000, 0);
scanf("%d", &n);
GEN vec = cgetg(n+1, t_VEC);
 
for (i = 1; i <= n; i++) {
if (1 != scanf("%s", &s)) abort();
gel(vec, i) = strtoGENstr(s);
}
 
pari_printf("%Ps", vec);
return 0;
}</syntaxhighlight>
 
=={{header|Perl}}==
<syntaxhighlight lang="perl">$n = scalar <>;
 
do_stuff(scalar <>) for 1..$n;
 
sub do_stuff { print $_[0] }</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;">sequence</span> <span style="color: #000000;">stack</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
<span style="color: #008080;">procedure</span> <span style="color: #7060A8;">push</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;">stack</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">stack</span><span style="color: #0000FF;">,</span><span style="color: #000000;">line</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">pop_all</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">while</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">stack</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</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: #000000;">stack</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
<span style="color: #000000;">stack</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">stack</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">..$]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</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: #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;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"input not a number\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">abort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</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: #7060A8;">push</span><span style="color: #0000FF;">(</span><span style="color: #000000;">line</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: #000000;">pop_all</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
{{out}}
(or more accurately the final state of the console)
<pre>
3
one
two
three
===
one
two
three
</pre>
 
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
# script.ps1
 
$in = Get-Content $args[0]
$in[1..($in.Count-1)]
 
# ./script file.txt
</syntaxhighlight>
 
=={{header|Prolog}}==
<syntaxhighlight lang="prolog">
number_of_lines(Num) :-
current_input(In),
read_line_to_codes(In, Line),
number_codes(Num, Line).
input_lines_for_num(0, ListOfLines) :-
format('~nThe lines you entered were: ~n~n'),
maplist(format('~w~n'), ListOfLines).
input_lines_for_num(Num, CurrentLines) :-
Num > 0,
Num1 is Num - 1,
current_input(In),
read_line_to_codes(In, Line),
atom_codes(LineAsAtom, Line),
append(CurrentLines, [LineAsAtom], MoreLines),
input_lines_for_num(Num1, MoreLines).
lines :-
number_of_lines(Num),
input_lines_for_num(Num, []).
</syntaxhighlight>
{{out}}
<pre>
2 ?- lines.
|: 3
line 1
line 2
line 3
 
The lines you entered were:
 
line 1
line 2
line 3
true ;
false.
 
3 ?-
</pre>
 
=={{header|Perl 6}}==
<lang perl6>$*OUT.say($*IN.get) xx $*IN.get;</lang>
=={{header|Python}}==
<langsyntaxhighlight lang="python">try: input = raw_input
except: pass
 
Line 56 ⟶ 955:
for x in range(linecount):
line = input()
do_stuff(line)</langsyntaxhighlight>
 
=={{header|Racket}}==
{{trans|Python}}
<syntaxhighlight lang="racket">#lang racket
(define (do-stuff str)
(displayln str))
 
;(define line-count (read)) ;reads all kind of things
 
(define line-count (string->number ;only reads numbers
(string-trim
(read-line))))
 
(for ([i (in-range line-count)])
(do-stuff (read-line)))</syntaxhighlight>
 
=={{header|Raku}}==
(formerly Perl 6)
 
Short version:
 
<syntaxhighlight lang="raku" line>say get for ^get;</syntaxhighlight>
 
Verbose version:
 
<syntaxhighlight lang="raku" line>sub do-stuff ($line) {
say $line;
}
my $n = +get;
for ^$n {
my $line = get;
do-stuff $line;
}</syntaxhighlight>
 
=={{header|REXX}}==
Programming note: &nbsp; this method was chosen because the standard input may be identical to the standard output.
<langsyntaxhighlight lang="rexx">/*REXX program outputswrites a number of lines from the default input file (C.L.). */
#=linein() /*the number of lines to followbe read from C.L. */
 
do j=1 for #; x.j=linein(); end /*obtain input lines from stdin. */
call stuff do j=1 for #; x.j=linein(); end /*callobtain STUFFinput routinelines forfrom stdin output(C.L.). */
 
exit /*stick a fork in it, we're done.*/
call stuff /*call the STUFF subroutine for writes.*/
/*──────────────────────────────────STUFF routine───────────────────────*/
stuff:exit do k=1 for #; call lineout ,x.k; end; return /*outputstick a fork in it, we're all done. */</lang>
/*────────────────────────────────────────────────────────────────────────────*/
stuff: do k=1 for #; call lineout ,x.k; end; return</syntaxhighlight>
{{out|output|text=&nbsp; where showing the input and the output to the terminal:}}
<pre>
3 ◄■■■■■■■ user input
aaa ◄■■■■■■■ user input
bbb ◄■■■■■■■ user input
ccc ◄■■■■■■■ user input
aaa
bbb
ccc
</pre>
 
=={{header|Ring}}==
<syntaxhighlight lang="ring">
# Project : Input/Output for Lines of Text
 
see "n = "
give n
lines = list(number(n))
for i = 1 to n
see "lines[" + i + "] = " + nl
give lines[i]
next
see nl
printlines(lines)
 
func printlines(lines)
for i = 1 to len(lines)
see lines[i] + nl
next
</syntaxhighlight>
Input:
<pre>
3
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
Output:
<pre>
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">def do_stuff(wordline)
puts wordline
end
 
tn = gets.to_i
for i in 1n..ttimes do
word line = gets
do_stuff(wordline)
end</langsyntaxhighlight>
 
=={{header|Scala}}==
<syntaxhighlight lang="scala">// Input/Output for Lines of Text
object IOLines extends App {
private val in = scala.io.StdIn
private val n = in.readInt()
 
private def doStuff(word: String): Unit = println(word)
 
for (_ <- 0 until n) {
val word = in.readLine()
doStuff(word)
}
}</syntaxhighlight>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">proc do_stuff {line} {
puts $line
}
Line 86 ⟶ 1,078:
foreach - [lrepeat [gets stdin] dummy] {
do_stuff [gets stdin]
}</langsyntaxhighlight>
 
=={{header|Ursa}}==
<syntaxhighlight lang="ursa">#
# input/output for lines of text
#
 
# get how many lines the user wants
decl int amount
set amount (in int console)
 
# loop through and get lines
decl string<> lines
decl int i
for (set i 0) (< i amount) (inc i)
append (in string console) lines
end for
 
# output the lines that the user entered
out endl console
for (set i 0) (< i amount) (inc i)
out lines<i> endl console
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 { |lines| System.print(lines.join("\n")) }
 
var n = Num.fromString(Stdin.readLine())
if (!n || !n.isInteger || n < 1) Fiber.abort("Number of lines must be a positive integer.")
var lines = List.filled(n, "")
for (i in 0...n) lines[i] = Stdin.readLine()
System.print()
output.call(lines)</syntaxhighlight>
 
{{out}}
Sample input/output:
<pre>
3
hello
hello world
Pack my Box with 5 dozen liquor jugs
 
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
 
=={{header|XPL0}}==
The input file must be redirected on the command line, for example: iotext <iotext.txt
<syntaxhighlight lang="xpl0">string 0;
 
proc PrintLn(Str); \"method" to print a line of text
char Str;
[Text(0, Str);
CrLf(0);
];
 
char Line(1000);
int N, I, C;
for N:= 1 to IntIn(1) do
[I:= 0;
loop [repeat C:= ChIn(1) until C # $0D \CR\;
if C = $0A \LF\ then quit;
Line(I):= C;
I:= I+1;
];
Line(I):= 0;
PrintLn(Line);
]</syntaxhighlight>
 
=={{header|zkl}}==
File ff.zkl:
<syntaxhighlight lang="zkl">numLines:=File.stdin.readln().strip().toInt();
text:=File.stdin.readln(numLines);
 
text.apply(File.stdout.write);</syntaxhighlight>
{{out}}
<pre>
cat foo.txt | zkl ff
hello
hello world
Pack my Box with 5 dozen liquor jugs
</pre>
PureFox
9,479

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/238611...352274"