Rosetta Code

Reverse the order of lines in a text file while preserving the contents of each line: Difference between revisions

Page Discussion

Reverse the order of lines in a text file while preserving the contents of each line (view source)

Revision as of 12:28, 2 February 2024

12,410 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Wren}}: Minor tidy)
 
(22 intermediate revisions by 19 users not shown)
Line 2:
 
;Task:
:*   Read an an entire (input) file   (into memory or buffers).
:*   Display the lines/records of the entire file in reverse order.
:*   Show the results here, on this page.
Line 22:
Reference: [https://linuxhint.com/bash_tac_command/ Bash tac command]
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">:start:
V fileData = File(:argv[1]).read().split("\n")
 
L(line) reversed(fileData)
print(line)</syntaxhighlight>
 
=={{header|Action!}}==
In the following solution the input file [https://gitlab.com/amarok8bit/action-rosetta-code/-/blob/master/source/rodgers.txt rodgers.txt] is loaded from H6 drive. Altirra emulator automatically converts CR/LF character from ASCII into 155 character in ATASCII charset used by Atari 8-bit computer when one from H6-H10 hard drive under DOS 2.5 is used.
<syntaxhighlight lang="action!">DEFINE PTR="CARD"
DEFINE BUFFERSIZE="1000"
BYTE ARRAY buffer(BUFFERSIZE)
PTR ARRAY lines(100)
BYTE count=[0]
 
PROC AddLine(CHAR ARRAY line)
CHAR ARRAY dst
 
IF count=0 THEN
dst=buffer
ELSE
dst=lines(count-1)
dst==+dst(0)+1
FI
IF dst+line(0)+1>=buffer+BUFFERSIZE THEN
Print("End of memory!")
Break()
FI
SCopy(dst,line)
lines(count)=dst
count==+1
RETURN
 
PROC ReadFile(CHAR ARRAY fname)
CHAR ARRAY line(255)
BYTE dev=[1]
 
Close(dev)
Open(dev,fname,4)
WHILE Eof(dev)=0
DO
InputSD(dev,line)
AddLine(line)
OD
Close(dev)
RETURN
 
PROC Main()
CHAR ARRAY s
BYTE i,LMARGIN=$52,oldLMARGIN
 
oldLMARGIN=LMARGIN
LMARGIN=0 ;remove left margin on the screen
Put(125) PutE() ;clear the screen
 
ReadFile("H6:RODGERS.TXT")
FOR i=0 TO count-1
DO
s=lines(count-1-i)
PrintE(s)
OD
 
LMARGIN=oldLMARGIN ;restore left margin on the screen
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Reverse_the_order_of_lines_in_a_text_file_while_preserving_the_contents_of_each_line.png Screenshot from Atari 8-bit computer]
<pre>
--- Will Rodger
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
</pre>
 
=={{header|Ada}}==
<syntaxhighlight lang="ada">with Ada.Text_Io;
with Ada.Containers.Indefinite_Vectors;
with Ada.Command_Line;
 
procedure Reverse_Lines_In_File is
 
subtype Line_Number is Natural;
 
package Line_Vectors
is new Ada.Containers.Indefinite_Vectors
(Index_Type => Line_Number,
Element_Type => String);
 
use Line_Vectors,
Ada.Text_Io,
Ada.Command_Line;
 
File : File_Type;
Buffer : Vector;
begin
if Argument_Count = 1 then
Open (File, In_File, Argument (1));
Set_Input (File);
end if;
 
while not End_Of_File loop
Buffer.Prepend (Get_Line);
end loop;
 
if Is_Open (File) then
Close (File);
end if;
 
for Line of Buffer loop
Put_Line (Line);
end loop;
 
end Reverse_Lines_In_File;</syntaxhighlight>
 
=={{header|ALGOL W}}==
<syntaxhighlight lang="algolw">begin % reverse the order of the lines read from standard input %
% record to hold a line and link to the next %
record LinkedLine ( string(256) text; reference(LinkedLine) next );
string(256) line;
reference(LinkedLine) lines;
% allow the program to continue after reaching end-of-file %
ENDFILE := EXCEPTION( false, 1, 0, false, "EOF" );
% handle the input %
lines := null;
readcard( line );
while not XCPNOTED(ENDFILE) do begin
lines := LinkedLine( line, lines );
readcard( line )
end while_not_eof ;
% show the lines in reverse order %
while lines not = null do begin
integer len;
% find the length of the line with trailing spaces removed %
len := 255;
line := text(lines);
while len > 0 and line( len // 1 ) = " " do len := len - 1;
% print the line, note Algol W does not allow variable length substrings %
write( s_w := 0, line( 0 // 1 ) );
for cPos := 1 until len do writeon( s_w := 0, line( cPos // 1 ) );
lines := next(lines)
end while_lines_ne_null
end.</syntaxhighlight>
{{out}}
<pre>
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f REVERSE_THE_ORDER_OF_LINES_IN_A_TEXT_FILE_WHILE_PRESERVING_THE_CONTENTS_OF_EACH_LINE.AWK filename
{ arr[NR] = $0 }
END {
for (i=NR; i>=1; i--) {
printf("%s\n",arr[i])
}
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
</pre>
 
 
=={{header|BASIC256}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="basic256">source = freefile
open (source, "text.txt")
textEnt$ = ""
dim textSal$(size(source)*8)
linea = 0
 
while not eof(source)
textEnt$ = readline(source)
linea += 1
textSal$[linea] = textEnt$
end while
 
for n = size(source) to 1 step -1
print textSal$[n];
next n
close source
end</syntaxhighlight>
{{out}}
<pre>
Igual que la entrada de FreeBASIC.
</pre>
 
 
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
// Reverse the order of lines in a text file while preserving the contents of each line. Nigel Galloway: August 9th., 2022
seq{use n=System.IO.File.OpenText("wr.txt") in while not n.EndOfStream do yield n.ReadLine()}|>Seq.rev|>Seq.iter(printfn "%s")
</syntaxhighlight>
{{out}}
<pre>
-- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
</pre>
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">USING: io io.encodings.utf8 io.files sequences ;
 
"rodgers.txt" utf8 file-lines <reversed> [ print ] each</langsyntaxhighlight>
{{out}}
<pre>
Line 35 ⟶ 246:
"Diplomacy is the art of
</pre>
 
=={{header|Delphi}}==
''See maybe [[#Free Pascal|Free Pascal]]''
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">open "text.txt" for input as #1
dim as string textEnt, textSal()
dim as integer n, linea = 0
 
do while not eof(1)
line input #1, textEnt
linea += 1
redim preserve textSal(linea)
textSal(linea) = textEnt
loop
 
for n = ubound(textSal) to 1 step -1
print textSal(n)
next n
close #1
sleep</syntaxhighlight>
{{out}}
<pre>
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
</pre>
 
=={{header|Free Pascal}}==
<syntaxhighlight lang="pascal">program TAC;
{$IFDEF FPC}
{$MODE DELPHI}
{$ELSE}
{$APPTYPE CONSOLE}
{$ENDIF}
uses
sysutils, classes;
var
Sl:TStringList;
i,j : nativeInt;
begin
Sl := TStringList.Create;
Sl.Loadfromfile('Rodgers.txt');
i := 0;
j := Sl.Count-1;
While i<j do
Begin
Sl.Exchange(i,j);
inc(i);
dec(j);
end;
writeln(Sl.text);
end.</syntaxhighlight>{{out}}
<pre> --- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of</pre>
 
=={{header|Go}}==
{{trans|Wren}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 80 ⟶ 351:
}
fmt.Println(string(b))
}</langsyntaxhighlight>
 
{{out}}
Line 89 ⟶ 360:
saying 'Nice Doggy'
"Diplomacy is the art of
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import qualified Data.Text as T
import qualified Data.Text.IO as TIO
 
main :: IO ()
main = TIO.interact $ T.unlines . reverse . T.lines</syntaxhighlight>
{{out}}
<pre>
$ tac < tac.in
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
</pre>
 
=={{header|J}}==
 
<syntaxhighlight lang="j"> ;|.<;.2 text
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of</syntaxhighlight>
 
where
<syntaxhighlight lang="j">text=: {{)n
"Diplomacy is the art of
saying 'Nice Doggy'
until you can find a rock."
 
--- Will Rodgers
}}</syntaxhighlight>
 
or <syntaxhighlight lang="j">text=: fread 'filename'</syntaxhighlight> if the text were stored in a file named <code>filename</code>.
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="sh">
jq -nRr '[inputs] | reverse[]' input.txt
</syntaxhighlight>
{{out}}
<pre>
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
</pre>
 
Line 94 ⟶ 416:
The optional <pre>keep</pre> argument to <pre>readlines</pre> means to keep the newline '\n' char or '\r\n' digraph at the end of each line. The <pre>|></pre>
symbolism is the pipe operator. and the <pre>.|></pre> symbolism means to pipe each line in the read array to print separately.
<langsyntaxhighlight lang="julia">readlines("diplomacyrodgers.txt", keep=true) |> reverse .|> print</langsyntaxhighlight>{{output}}
<pre>
--- Will Rodgers
Line 110 ⟶ 432:
 
– there is enough memory to process the file in memory i.e to store the input file as a string, the sequence of lines, the reverse sequence of lines and the output file as a string.
<langsyntaxhighlight Nimlang="nim">import algorithm, strutils
 
proc reverseLines(infile, outfile: File) =
Line 125 ⟶ 447:
echo ">>>>> Output file:"
reverseLines(infile, stdout)
echo ">>>>>"</langsyntaxhighlight>
 
{{out}}
Line 144 ⟶ 466:
"Diplomacy is the art of
>>>>></pre>
 
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let rec read_lines_reverse lst =
match read_line () with
| line -> read_lines_reverse (line :: lst)
| exception End_of_file -> lst
 
let () = read_lines_reverse [] |> List.iter print_endline</syntaxhighlight>
{{out}}
<pre>
$ ocaml tac.ml <file.txt
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
</pre>
 
=={{header|Pascal}}==
''See also [[#Delphi|Delphi]] and [[#Free Pascal|Free Pascal]]''<br/>
{{works with|Free Pascal}} maybe {{works with|Delphi}}
The following is an ISO-compliant <tt>program</tt>.
<lang pascal>program TAC;
Some compilers, however, such as the FPC (Free Pascal Compiler) or Delphi, cannot handle files without file names.
{$IFDEF FPC}
<syntaxhighlight lang="pascal">program tac(input, output);
{$MODE DELPHI}
 
{$ELSE}
procedure reverse;
{$APPTYPE CONSOLE}
{$ENDIF}
uses
sysutils, classes;
var
line: text;
Sl:TStringList;
i,j : nativeInt;
begin
{ Open for (over-)writing. }
Sl := TStringList.Create;
rewrite(line);
Sl.Loadfromfile('Rodgers.txt');
i := 0;
{ `EOLn` is shorthand for `EOLn(input)`. }
j := Sl.Count-1;
while not While i<jEOLn do
begin
Begin
{ `line^` and `input^` refer to buffer variables [their values]. }
Sl.Exchange(i,j);
line^ := input^;
inc(i);
{ Write buffer and advance writing position. }
dec(j);
put(line);
end;
{ Advance reading cursor and obtain next value [if such exists]. }
writeln(Sl.text);
get(input)
end.</lang>{{out}}
end;
<pre> --- Will Rodgers
{ Consume “newline” character in `input` }
readLn;
{ Likewise, `EOF` is shorthand for `EOF(input)`. }
if not EOF then
begin
reverse
end;
{ (Re‑)open for reading. }
reset(line);
while not EOLn(line) do
begin
output^ := line^;
put(output);
get(line)
end;
{ `writeLn` is shorthand for `writeLn(output)`. }
writeLn
end;
 
begin
until you can find a rock."
reverse
saying 'Nice Doggy'
end.</syntaxhighlight>
"Diplomacy is the art of</pre>
{{out}}
--- Will Rodgers
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
Note, this <tt>program</tt> will append a “new line” character to the final line if it did not exist.
 
=={{header|Perl}}==
as one-liner ..
<langsyntaxhighlight lang="perl">// 20210803 Perl programming solution
 
< input.txt perl -e 'print reverse <>'</langsyntaxhighlight>
{{out}}
<pre>
Line 192 ⟶ 557:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">text</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""
Line 208 ⟶ 573:
<span style="color: #000000;">fn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">open</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"rogers.txt"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"r"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">text</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">get_text</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"\r\n"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">close</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">lines</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #000000;">text</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">,</span><span style="color: #004600;">false</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">putsprintf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">(</span><span style="color: #000000;">lines</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)})</span>
<!--</langsyntaxhighlight>-->
Obviously you can test the file handling by running the above, then changing eg Diplomacy to Diplomaxy and re-running it, and checking it outputs the previously saved c rather than the replacement x.
{{out}}
<pre>
Line 222 ⟶ 588:
"Diplomacy is the art of
</pre>
 
=={{header|Python}}==
Interactive program which takes input from a file :
<syntaxhighlight lang="python">
#Aamrun, 4th October 2021
 
import sys
 
if len(sys.argv)!=2:
print("Usage : python " + sys.argv[0] + " <filename>")
exit()
 
dataFile = open(sys.argv[1],"r")
 
fileData = dataFile.read().split('\n')
 
dataFile.close()
 
[print(i) for i in fileData[::-1]]
</syntaxhighlight>
Input file :
<pre>
"Diplomacy is the art of
saying 'Nice Doggy'
until you can find a rock."
--- Will Rodgers
</pre>
Sample run and output:
{{out}}
<pre>
 
C:\My Projects\BGI>python rosetta7.py diplomaticQuote.txt
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
 
C:\My Projects\BGI>
</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="Quackery"> [ sharefile drop
[] swap
[ carriage over find split
dup $ "" != while
behead drop
unrot nested swap join
swap again ]
drop nested swap join
witheach [ echo$ cr ] ] is task ( $ --> )
 
$ "rosetta/input.txt" task</syntaxhighlight>
 
{{out}}
 
<pre> --- Will Rodgers
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
</pre>
 
=={{header|R}}==
<syntaxhighlight lang="rsplus">text <- scan("Rodgers.txt", character(), sep = "\n")
print(text)
reversed <- rev(text)
print(reversed)
write(reversed, "SaveTheOutput.txt")</syntaxhighlight>
{{out}}
<pre>Read 5 items
[1] " \"Diplomacy is the art of"
[2] " saying 'Nice Doggy'"
[3] "until you can find a rock.\""
[4] " "
[5] " --- Will Rodgers"
[1] " --- Will Rodgers"
[2] " "
[3] "until you can find a rock.\""
[4] " saying 'Nice Doggy'"
[5] " \"Diplomacy is the art of" </pre>
 
=={{header|Raku}}==
Line 235 ⟶ 684:
* May hold entire file in memory.
 
<syntaxhighlight lang="raku" perl6line>.put for reverse lines</langsyntaxhighlight>
 
===Few assumptions===
Line 246 ⟶ 695:
raku -e'print join "\x00\x00", (1..6).map: * x 8' > nul.txt
 
<syntaxhighlight lang="raku" perl6line>my $input-record-separator = "\x00\x00";
 
my $fh = open("nul.txt".IO, :r, :bin);
Line 269 ⟶ 718:
}
 
say $buffer; # emit any remaining record</langsyntaxhighlight>
{{out}}
<pre>66666666
Line 283 ⟶ 732:
 
No assumptions were made concerning line/record termination, &nbsp; as REXX takes care of that.
<langsyntaxhighlight lang="rexx">/*REXX pgm reads a file, and displays the lines (records) of the file in reverse order. */
parse arg iFID . /*obtain optional argument from the CL.*/
if iFID=='' | iFID=="," then iFID='REVERSEF.TXT' /*Not specified? Then use the default.*/
Line 294 ⟶ 743:
say @.k /*display a record of the file ──► term*/
end /*k*/
call lineout iFID /*close file, good programming practice*/</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 311 ⟶ 760:
::* &nbsp; CMS REXX compiler
::* &nbsp; CMS OREXX
<syntaxhighlight lang="text">/*REXX pgm reads a file, and displays the lines (records) of the file in reverse order. */
parse arg iFID . /*obtain optional argument from the CL.*/
if iFID=='' | iFID=="," then iFID='REVERSEF.TXT' /*Not specified? Then use the default.*/
call lineout iFID /*close file, good programming practice*/
options noFast_lines_BIF_defaultnofast_lines_BIF_default /*an option just for Regina REXX. */
#= lines(iFID) /*#: the number of lines in the file. */
do j=# by -1 for # /*read file (backwards), from bot──►top*/
@.j=say linein(iFID, j) /*assigndisplay record contents of a record to──► arrayterminal.*/
say @.j /*display a record of the file ──► term*/
end /*j*/
call lineout iFID /*close file, good programming practice*/</langsyntaxhighlight>
{{out|output|text=&nbsp; is identical to the 1<sup>st</sup> REXX version.}} <br><br>
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
Line 354 ⟶ 802:
 
see nl + "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 373 ⟶ 821:
</pre>
 
=={{header|UNIX ShellRuby}}==
<syntaxhighlight lang="ruby">puts File.readlines("diplomacy.txt").reverse</syntaxhighlight>
{{works with|Bourne Again SHell}}
{{out}}
<pre> --- Will Rodgers
 
until you can find a rock."
<lang bash>tac rodgers.txt</lang>
saying 'Nice Doggy'
Output:
"Diplomacy is the art of
</pre>
=={{header|sed}}==
<syntaxhighlight lang="sed">1!G
h
$!d</syntaxhighlight>
{{out}}
<pre>
$ sed -f tac.sed file.txt
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
 
</pre>
 
=={{header|UNIX Shell}}==
<syntaxhighlight lang="bash">tac rodgers.txt</syntaxhighlight>
{{out}}
<pre>
--- Will Rodgers
Line 385 ⟶ 855:
"Diplomacy is the art of
</pre>
 
Notice that '''tac''' is '''cat''' in reverse order.
 
=={{header|Wren}}==
{{libheader|Wren-ioutil}}
<langsyntaxhighlight ecmascriptlang="wren">import "./ioutil" for File, FileUtil
 
var fileName1 = "rodgers.txt"
Line 406 ⟶ 875:
}
// print contents of output file to terminal
System.print(File.read(fileName2))</langsyntaxhighlight>
 
{{out}}
Line 419 ⟶ 888:
=={{header|XPL0}}==
Usage: rev <will.txt
<langsyntaxhighlight XPL0lang="xpl0">char Array(1000, 1000); \(tacky)
int Line, Char, I;
def LF=$0A, EOF=$1A;
Line 435 ⟶ 904:
until Char = LF;
];
]</langsyntaxhighlight>
 
{{out}}
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/314577...354969"