Input/Output for lines of text

This task has been flagged for clarification. Code on this page in its current state may be flagged incorrect once this task has been clarified. See this page's Talk page for discussion.

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

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

11l

Translation of: Python

F do_stuff(words)
   print(words)

V linecount = Int(input())
L 1..linecount
   V line = input()
   do_stuff(line)

Action!

The user must type in the monitor the following command after compilation and before running the program!

SET EndProg=*

Library: Action! Tool Kit

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

Output:

Screenshot from Atari 8-bit computer

3
hello
hello world
Pack my Box with 5 dozen liquor jugs

hello
hello world
Pack my Box with 5 dozen liquor jugs

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;

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

ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.8.win32

# 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

ALGOL W

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.

Applesoft BASIC

 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

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

Arturo

printLine: function [line]-> print line

lineCount: to :integer strip input ""

do.times:lineCount [
    line: input ""
    printLine line
]

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

Batch File

@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

Input:

3
line 1
this is line 2
line 3 is the longest

Output:

line 1
this is line 2
line 3 is the longest

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

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.

// 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;
}

Output:

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

C++

#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";
    }
}

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

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);
}

Delphi

Library: System.SysUtils

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.

Output:

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

EasyLang

proc dostuff s$ . .
   print s$
.
n = number input
for i to n
   dostuff input
.
input_data
3
hello
hello world
Pack my Box with 5 dozen liquor jugs

Output:

hello
hello world
Pack my Box with 5 dozen liquor jugs

Factor

USING: io kernel strings ;
IN: input-output

GENERIC: do-stuff ( obj -- )
M: string do-stuff print ;

readln drop [ do-stuff ] each-line

Free Pascal

This requires FPC – the FreePascal compiler – to be in a configuration enabling the use ob objects.

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.

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

Output:

3
hello
hello world
Pack my Box with 5 dozen liquor jugs

hello
hello world
Pack my Box with 5 dozen liquor jugs

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

Haskell

import Control.Monad
main = do
        number <- getLine 
        input <- replicateM (read number) getLine
        mapM_ putStrLn input

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

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

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);
		}
	}
}

jq

The following works for both the C and the Go implementations of jq.

jq -Rr 'limit(tonumber; inputs)'

Julia

Works with: Julia version 0.6

function dosomething(words)
    print(words)
end

nlines = parse.(Int, readline())
for _ in 1:nlines
    words = readline()
    dosomething(words)
end

Kotlin

// 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)
}

Output:

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

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)

Nanoquery

Translation of: Ursa

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

Output:

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

Nim

import strutils

proc write(line: string) =
  echo line

let lineCount = stdin.readLine.parseInt()
for _ in 1..lineCount:
  let line = stdin.readLine()
  line.write()

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();
      };
    };
  }
}

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:

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

Perl

$n = scalar <>;

do_stuff(scalar <>) for 1..$n;

sub do_stuff { print $_[0] }

Phix

without js -- (file i/o)
sequence stack = {}
procedure push(string line)
    stack = append(stack,line)
end procedure
 
procedure pop_all()
    while length(stack) do
        puts(1,stack[1])
        stack = stack[2..$]
    end while
end procedure
 
string line = gets(0)
sequence r = scanf(trim(line),"%d")
if length(r)!=1 then
    puts(1,"input not a number\n")
    abort(0)
end if
puts(1,"\n")
for i=1 to r[1][1] do
    line = gets(0)
    push(line)
    puts(1,"\n")
end for
puts(1,"===\n")
pop_all()

Output:

(or more accurately the final state of the console)

3
one
two
three
===
one
two
three

PowerShell

# script.ps1

$in = Get-Content $args[0]
$in[1..($in.Count-1)]

# ./script file.txt

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, []).

Output:

2 ?- lines.
|: 3
line 1
line 2
line 3

The lines you entered were:

line 1
line 2
line 3
true ;
false.

3 ?-

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)

Racket

Translation of: Python

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

Raku

(formerly Perl 6)

Short version:

say get for ^get;

Verbose version:

sub do-stuff ($line) {
    say $line;
}
 
my $n = +get;
for ^$n {
    my $line = get;
    do-stuff $line;
}

REXX

Programming note: this method was chosen because the standard input may be identical to the standard output.

/*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

output where showing the input and the output to the terminal:

3                    ◄■■■■■■■ user input                        
aaa                  ◄■■■■■■■ user input
bbb                  ◄■■■■■■■ user input
ccc                  ◄■■■■■■■ user input
aaa
bbb
ccc

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

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

Ruby

def do_stuff(line)
  puts line
end

n = gets.to_i
n.times do
  line = gets
  do_stuff(line)
end

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

Tcl

proc do_stuff {line} {
    puts $line
}

foreach - [lrepeat [gets stdin] dummy] {
    do_stuff [gets stdin]
}

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

Wren

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

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)

Output:

Sample input/output:

3
hello
hello world
Pack my Box with 5 dozen liquor jugs

hello
hello world
Pack my Box with 5 dozen liquor jugs

XPL0

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

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);
    ]

zkl

File ff.zkl:

numLines:=File.stdin.readln().strip().toInt();
text:=File.stdin.readln(numLines);

text.apply(File.stdout.write);

Output:

cat foo.txt | zkl ff
hello
hello world
Pack my Box with 5 dozen liquor jugs