Input/Output for lines of text: Difference between revisions

{{trans|Python}}

 

print(words)

 

L 1..linecount

V line = input()

 

=={{header|Ada}}==

-- The first line contains the number of lines to follow, followed by that

-- number of lines of text on STDIN.

end loop;

end Main;

'''Input:'''

<pre>

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

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

PROC show line = ( STRING line )VOID:

print( ( line, newline ) );

show line( ( STRING line; read( ( line, newline ) ); line ) )

OD

 

=={{header|ALGOL W}}==

% outputs line on a newline %

procedure showLine ( string(80) value line ); write( line );

showLine( line )

end for_lineNumber

 

=={{header|AWK}}==

# syntax: GAWK -f INPUT_OUTPUT_FOR_LINES_OF_TEXT.AWK

BEGIN {

exit(0)

}

 

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

@echo off

setlocal enabledelayedexpansion

for /l %%i in (1,1,%lines%) do echo !line%%i!

pause>nul

{{in}}

<pre>

 

=={{header|C}}==

#include<stdlib.h>

#include<stdio.h>

return 0;

}

 

Alternative code:

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>

return 0;

}

{{out}}

<pre>

 

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

#include <vector>

 

std::cout << value << "\n";

}

'''Input:'''

<pre>

 

=={{header|D}}==

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

 

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

doStuff(readln.idup);

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

program Output_for_Lines_of_Text;

 

Writeln(lines);

Readln;

{{out}}

<pre>

 

=={{header|Factor}}==

IN: input-output

 

M: string do-stuff print ;

 

 

=={{header|Free Pascal}}==

This requires FPC – the FreePascal compiler – to be in a configuration enabling the use ob <tt>object</tt>s.

 

type

obj.method(line);

end;

 

=={{header|FreeBASIC}}==

 

Sub printLines(lines() As String)

Print

printLines lines()

 

{{out}}

 

=={{header|Go}}==

 

import (

func doStuff(line string) {

fmt.Println(line)

 

=={{header|Haskell}}==

main = do

number <- getLine

input <- replicateM (read number) getLine

mapM_ putStrLn input

<pre>

3

 

Example in bash. jconsole is on the PATH.

$ cat <<EOF | jconsole -js '2!:55@:0:@:(; (1!:2) 4:)@:(}. {.~ _ ". [: }: 0&{::)@:(<;.2)@:(1!:1) 3'

> 3

hello world

Pack my Box with 5 dozen liquor jugs

From the dictionary of j (DOJ) the data flow for the fork (f g h) is

 

 

=={{header|Java}}==

 

public class Main {

}

}

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

print(words)

end

words = readline()

dosomething(words)

 

=={{header|Kotlin}}==

 

fun output(lines: Array<String>) = println(lines.joinToString("\n"))

println("\nThe lines you entered are:\n")

output(lines)

 

{{out}}

 

=={{header|Lua}}==

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

 

=={{header|Nanoquery}}==

{{trans|Ursa}}

amount = int(input())

 

for line in lines

println line

{{out}}

<pre>3

 

=={{header|Nim}}==

 

proc write(line: string) =

for _ in 1..lineCount:

let line = stdin.readLine()

 

=={{header|Objeck}}==

 

class Rosetta {

};

}

 

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

#include <stdlib.h>

#include <pari/pari.h>

pari_printf("%Ps", vec);

return 0;

 

=={{header|Perl}}==

 

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

 

 

=={{header|Phix}}==

{{out}}

(or more accurately the final state of the console)

 

=={{header|PowerShell}}==

# script.ps1

 

 

# ./script file.txt

 

=={{header|Prolog}}==

number_of_lines(Num) :-

current_input(In),

number_of_lines(Num),

input_lines_for_num(Num, []).

{{out}}

<pre>

 

=={{header|Python}}==

except: pass

 

for x in range(linecount):

line = input()

 

=={{header|Racket}}==

{{trans|Python}}

(define (do-stuff str)

(displayln str))

 

(for ([i (in-range line-count)])

 

=={{header|Raku}}==

Short version:

 

 

Verbose version:

 

say $line;

}

my $line = get;

do-stuff $line;

 

=={{header|REXX}}==

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

#=linein() /*number of lines to be read from C.L. */

 

exit /*stick a fork in it, we're all done. */

/*────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; where showing the input and the output to the terminal:}}

<pre>

 

=={{header|Ring}}==

# Project : Input/Output for Lines of Text

 

see lines[i] + nl

next

Input:

<pre>

 

=={{header|Ruby}}==

puts line

end

line = gets

do_stuff(line)

 

=={{header|Scala}}==

object IOLines extends App {

private val in = scala.io.StdIn

doStuff(word)

}

 

=={{header|Tcl}}==

puts $line

}

foreach - [lrepeat [gets stdin] dummy] {

do_stuff [gets stdin]

 

=={{header|Ursa}}==

# input/output for lines of text

#

out lines<i> endl console

end for

 

=={{header|Wren}}==

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

 

var output = Fn.new { |lines| System.print(lines.join("\n")) }

for (i in 0...n) lines[i] = Stdin.readLine()

System.print()

 

{{out}}

Pack my Box with 5 dozen liquor jugs

</pre>

 

=={{header|zkl}}==

File ff.zkl:

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

 

{{out}}

<pre>