Input/Output for lines of text
The first line contains the number of lines to follow, followed by that number of lines of text on STDIN.
- Task
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
3 hello hello world Pack my Box with 5 dozen liquor jugs
Output
hello hello world Pack my Box with 5 dozen liquor jugs
- Related tasks
ALGOL 68
<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 </lang>
AWK
<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)
} </lang>
C
<lang C> /*Abhishek Ghosh, 20th March 2014, Rotterdam*/
- 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; } </lang>
D
<lang d>void main() {
import std.stdio, std.conv, std.string;
enum doStuff = (in string line) => line.write;
foreach (_; 0 .. readln.strip.to!uint) doStuff(readln.idup);
}</lang>
Go
<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) }</lang>
Haskell
<lang Haskell> doStuff = print main = getContents >>= mapM_ doStuff.tail.lines </lang>
J
[for number pairs links to this page.]
Example in bash. jconsole is on the PATH. <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 </lang> 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:
g / \ f h | | y y g / \ f h / \ / \ x y x y
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.
;
is "raze". The fork
(; (1!:2) 4:)
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.
Java
<lang java>import java.util.Scanner;
public class Main { public static void doStuff(String word){ System.out.println(word); }
public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = Integer.parseInt(in.nextLine()); //doesn't use nextInt() so nextLine doesn't just read newline character for(int i=0; i<n; i++){ String word = in.nextLine(); doStuff(word); } } }</lang>
Lua
<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)</lang>
PARI/GP
This task is not possible to implement directly in GP: for input()
to take a string the user would have to wrap it in quotes (and escape quotes and newlines). One must use PARI:
<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;
}</lang>
Perl 6
Short version:
<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>
PowerShell
<lang PowerShell>
- script.ps1
$in = Get-Content $args[0] $in[1..($in.Count-1)]
- ./script file.txt
</lang>
Python
<lang python>try: input = raw_input except: pass
def do_stuff(words): print(words)
linecount = int(input()) for x in range(linecount): line = input() do_stuff(line)</lang>
Racket
<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)))</lang>
REXX
Programming note: this method was chosen because the standard input may be identical to the standard output. <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. */
do j=1 for #; x.j=linein(); end /*obtain input lines from stdin (C.L.).*/
call stuff /*call the STUFF subroutine for writes.*/ exit /*stick a fork in it, we're all done. */ /*────────────────────────────────────────────────────────────────────────────*/ stuff: do k=1 for #; call lineout ,x.k; end; return</lang>
Ruby
<lang ruby>def do_stuff(line)
puts line
end
n = gets.to_i n.times do
line = gets do_stuff(line)
end</lang>
Tcl
<lang tcl>proc do_stuff {line} {
puts $line
}
foreach - [lrepeat [gets stdin] dummy] {
do_stuff [gets stdin]
}</lang>
Ursa
<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 endl console
end for </lang>
zkl
File ff.zkl: <lang zkl>numLines:=File.stdin.readln().strip().toInt(); text:=File.stdin.readln(numLines);
text.apply(File.stdout.write);</lang>
- Output:
cat foo.txt | zkl ff hello hello world Pack my Box with 5 dozen liquor jugs