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

16,893 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(31 intermediate revisions by 22 users not shown)
Line 30:
*   [[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}}
<langsyntaxhighlight lang="algol68"># outputs line plus a newline #
PROC show line = ( STRING line )VOID:
print( ( line, newline ) );
Line 44 ⟶ 146:
show line( ( STRING line; read( ( line, newline ) ); line ) )
OD
</syntaxhighlight>
</lang>
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang="algolw">begin
% outputs line on a newline %
procedure showLine ( string(80) value line ); write( line );
Line 58 ⟶ 160:
showLine( line )
end for_lineNumber
end.</langsyntaxhighlight>
 
=={{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">
<lang AWK>
# syntax: GAWK -f INPUT_OUTPUT_FOR_LINES_OF_TEXT.AWK
BEGIN {
Line 72 ⟶ 221:
exit(0)
}
</syntaxhighlight>
</lang>
 
=={{header|Batch File}}==
<langsyntaxhighlight lang="dos">
@echo off
setlocal enabledelayedexpansion
Line 85 ⟶ 234:
for /l %%i in (1,1,%lines%) do echo !line%%i!
pause>nul
</syntaxhighlight>
</lang>
{{in}}
<pre>
Line 101 ⟶ 250:
 
=={{header|C}}==
<syntaxhighlight lang="c">
<lang C>
/*Abhishek Ghosh, 20th March 2014, Rotterdam*/
 
#include<stdlib.h>
#include<stdio.h>
Line 134 ⟶ 281:
return 0;
}
</syntaxhighlight>
</lang>
 
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 144 ⟶ 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}}==
<langsyntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
Sub printLines(lines() As String)
Line 163 ⟶ 526:
Print
printLines lines()
Sleep</langsyntaxhighlight>
 
{{out}}
Line 178 ⟶ 541:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 229 ⟶ 592:
func doStuff(line string) {
fmt.Println(line)
}</langsyntaxhighlight>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import Control.Monad
<lang Haskell>
main = do
doStuff = putStrLn
number <- getLine
main = getContents >>= mapM_ doStuff.tail.lines
input <- replicateM (read number) getLine
</lang>
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}}==
Line 241 ⟶ 618:
 
Example in bash. jconsole is on the PATH.
<syntaxhighlight lang="j">
<lang J>
$ cat <<EOF | jconsole -js '2!:55@:0:@:(; (1!:2) 4:)@:(}. {.~ _ ". [: }: 0&{::)@:(<;.2)@:(1!:1) 3'
> 3
Line 251 ⟶ 628:
hello world
Pack my Box with 5 dozen liquor jugs
</syntaxhighlight>
</lang>
From the dictionary of j (DOJ) the data flow for the fork (f g h) is
 
Line 303 ⟶ 680:
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">import java.util.Scanner;
 
public class Main {
Line 318 ⟶ 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}}==
<langsyntaxhighlight lang="scala">// version 1.1
 
fun output(lines: Array<String>) = println(lines.joinToString("\n"))
Line 331 ⟶ 727:
println("\nThe lines you entered are:\n")
output(lines)
}</langsyntaxhighlight>
 
{{out}}
Line 350 ⟶ 746:
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">function show (t)
for _, line in pairs(t) do print(line) end
end
Line 356 ⟶ 752:
local lineTable, numLines = {}, io.read()
for i = 1, numLines do table.insert(lineTable, io.read()) end
show(lineTable)</langsyntaxhighlight>
 
=={{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}}==
<langsyntaxhighlight lang="objeck">use System.IO.File;
 
class Rosetta {
Line 378 ⟶ 811:
};
}
}</langsyntaxhighlight>
 
=={{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:
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <pari/pari.h>
Line 408 ⟶ 841:
pari_printf("%Ps", vec);
return 0;
}</langsyntaxhighlight>
 
=={{header|Perl 6}}==
<syntaxhighlight lang="perl">$n = scalar <>;
 
do_stuff(scalar <>) for 1..$n;
Short version:
 
sub do_stuff { print $_[0] }</syntaxhighlight>
<lang perl6>say get for ^get;</lang>
 
Verbose version:
 
<lang perl6>sub do-stuff ($line) {
say $line;
}
my $n = +get;
for ^$n {
my $line = get;
do-stuff $line;
}</lang>
 
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(notonline)-->
<lang Phix>sequence stack = {}
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (file i/o)</span>
procedure push(string line)
<span style="color: #004080;">sequence</span> <span style="color: #000000;">stack</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
stack = append(stack,line)
<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>
end procedure
<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>
procedure pop_all()
while length(stack) do
<span style="color: #008080;">procedure</span> <span style="color: #000000;">pop_all</span><span style="color: #0000FF;">()</span>
puts(1,stack[1])
<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>
stack = stack[2..$]
<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>
end while
<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>
end procedure
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
 
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
string line = gets(0)
sequence r = scanf(trim(line),"%d")
<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>
if length(r)!=1 then
<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>
puts(1,"input not a number\n")
<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>
abort(0)
<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>
end if
<span style="color: #7060A8;">abort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
puts(1,"\n")
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
for i=1 to r[1][1] do
<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>
line = gets(0)
<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>
push(line)
<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>
puts(1,"\n")
<span style="color: #7060A8;">push</span><span style="color: #0000FF;">(</span><span style="color: #000000;">line</span><span style="color: #0000FF;">)</span>
end for
<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>
puts(1,"===\n")
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
pop_all()</lang>
<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)
Line 469 ⟶ 894:
 
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
<lang PowerShell>
# script.ps1
 
Line 476 ⟶ 901:
 
# ./script file.txt
</syntaxhighlight>
</lang>
 
=={{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|Python}}==
<langsyntaxhighlight lang="python">try: input = raw_input
except: pass
 
Line 488 ⟶ 955:
for x in range(linecount):
line = input()
do_stuff(line)</langsyntaxhighlight>
 
=={{header|Racket}}==
{{trans|Python}}
<langsyntaxhighlight Racketlang="racket">#lang racket
(define (do-stuff str)
(displayln str))
Line 503 ⟶ 970:
 
(for ([i (in-range line-count)])
(do-stuff (read-line)))</langsyntaxhighlight>
 
=={{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 writes a number of lines from the default input file (C.L.). */
#=linein() /*number of lines to be read from C.L. */
 
Line 515 ⟶ 1,001:
exit /*stick a fork in it, we're all done. */
/*────────────────────────────────────────────────────────────────────────────*/
stuff: do k=1 for #; call lineout ,x.k; end; return</langsyntaxhighlight>
{{out|output|text=&nbsp; where showing the input and the output to the terminal:}}
{{out}}
<pre>3
3 ◄■■■■■■■ user input
aaa ◄■■■■■■■ user input
bbb ◄■■■■■■■ user input
ccc ◄■■■■■■■ user input
aaa
bbb
ccc
</pre>
aaa
bbb
ccc</pre>
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
# Project : Input/Output for Lines of Text
# Date : 2017/10/18
# Author : Gal Zsolt (~ CalmoSoft ~)
# Email : <calmosoft@gmail.com>
 
see "n = "
Line 546 ⟶ 1,031:
see lines[i] + nl
next
</syntaxhighlight>
</lang>
Input:
<pre>
Line 562 ⟶ 1,047:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">def do_stuff(line)
puts line
end
Line 570 ⟶ 1,055:
line = gets
do_stuff(line)
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 579 ⟶ 1,078:
foreach - [lrepeat [gets stdin] dummy] {
do_stuff [gets stdin]
}</langsyntaxhighlight>
 
=={{header|Ursa}}==
<langsyntaxhighlight lang="ursa">#
# input/output for lines of text
#
Line 602 ⟶ 1,101:
out lines<i> endl console
end for
</syntaxhighlight>
</lang>
 
=={{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:
<langsyntaxhighlight lang="zkl">numLines:=File.stdin.readln().strip().toInt();
text:=File.stdin.readln(numLines);
 
text.apply(File.stdout.write);</langsyntaxhighlight>
{{out}}
<pre>
PureFox
9,476

edits

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