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

21,476 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Wren}}: Minor tidy)
 
(43 intermediate revisions by 25 users not shown)
Line 2:
 
;Task:
Reverse:* the  order of the lines (records) ofRead 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 20 ⟶ 19:
Also, don't include the rightmost informative comments   (◄■■■■■■),   as they are not meant to be part of the file.
<br><br>
 
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}}
<syntaxhighlight lang="factor">USING: io io.encodings.utf8 io.files sequences ;
 
"rodgers.txt" utf8 file-lines <reversed> [ print ] each</syntaxhighlight>
{{out}}
<pre>
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"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 65 ⟶ 351:
}
fmt.Println(string(b))
}</langsyntaxhighlight>
 
{{out}}
Line 74 ⟶ 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>
 
=={{header|Julia}}==
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 95 ⟶ 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 110 ⟶ 447:
echo ">>>>> Output file:"
reverseLines(infile, stdout)
echo ">>>>>"</langsyntaxhighlight>
 
{{out}}
Line 129 ⟶ 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/>
The following is an ISO-compliant <tt>program</tt>.
Some compilers, however, such as the FPC (Free Pascal Compiler) or Delphi, cannot handle files without file names.
<syntaxhighlight lang="pascal">program tac(input, output);
 
procedure reverse;
var
line: text;
begin
{ Open for (over-)writing. }
rewrite(line);
{ `EOLn` is shorthand for `EOLn(input)`. }
while not EOLn do
begin
{ `line^` and `input^` refer to buffer variables [their values]. }
line^ := input^;
{ Write buffer and advance writing position. }
put(line);
{ Advance reading cursor and obtain next value [if such exists]. }
get(input)
end;
{ 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
reverse
end.</syntaxhighlight>
{{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 143 ⟶ 555:
"Diplomacy is the art of
</pre>
 
=={{header|Phix}}==
<!--<syntaxhighlight lang="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;">"""
"Diplomacy is the art of
saying 'Nice Doggy'
until you can find a rock."
--- Will Rodgers"""</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">then</span>
<span style="color: #004080;">integer</span> <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;">if</span> <span style="color: #000000;">fn</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
<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;">"w"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">text</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: #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;">printf</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>
<!--</syntaxhighlight>-->
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>
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"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}}==
Not going to bother testing with the task recommended file. It demonstrates nothing to do with file handling, record separators, memory conservation or anything useful. May as well just be "Reverse this list" for all the good it does.
 
===Lots of assumptions===
Simplest thing that could possibly satisfy the extremely vague task description and completely glossing over all of the questions raised on the discussion page.
 
Line 153 ⟶ 684:
* May hold entire file in memory.
 
<syntaxhighlight lang="raku" perl6line>.put for reverse lines</langsyntaxhighlight>
 
===Few assumptions===
Processes a small (configurable) number of bytes at a time so file can be multi-terabyte and it will handle with ease. ''Does'' assume Latin 1 for reduced complexity.
 
No assumptions were made concerning line/record termination, full stop.
 
Run the following to generate nul.txt. (digits 1 through 6 repeated 8 times with double null as record separators):
 
raku -e'print join "\x00\x00", (1..6).map: * x 8' > nul.txt
 
<syntaxhighlight lang="raku" line>my $input-record-separator = "\x00\x00";
 
my $fh = open("nul.txt".IO, :r, :bin);
$fh.seek(0, SeekFromEnd); # start at the end of the file
 
my $bytes = 5 min $fh.tell - 1; # read in file 5 bytes at a time (or whatever)
 
$fh.seek(-$bytes, SeekFromCurrent);
 
my $buffer = $fh.read($bytes).decode('Latin1'); # assume Latin1 for reduced complexity
 
loop {
my $seek = ($fh.tell < $bytes * 2) ?? -$fh.tell !! -$bytes * 2;
$fh.seek($seek, SeekFromCurrent);
$buffer = $buffer R~ $fh.read((-$seek - $bytes) max 0).decode('Latin1');
if $buffer.contains: $input-record-separator {
my @rest;
($buffer, @rest) = $buffer.split: $input-record-separator;
.say for reverse @rest; # emit any full records that have been processed
}
last if $fh.tell < $bytes;
}
 
say $buffer; # emit any remaining record</syntaxhighlight>
{{out}}
<pre>66666666
55555555
44444444
33333333
22222222
11111111</pre>
 
=={{header|REXX}}==
=== version 1 ===
This will work for all REXXes, &nbsp; but it reads all the file's lines/records into memory (storage or buffers).
 
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.*/
call lineout iFidiFID /*close file, good programming practice*/
do #=1 while lines(iFID)>0 /*read the file, one record at a time. */
 
do j@.#=1 while lineslinein(iFID)>0 /*readassign thecontents file,of onea record atto a timearray. */
@.j= linein(iFID) end /*assign contents of a record to array.#*/
recs= # - 1 end /*j# will be 1 more ('cause of DO loop)*/
recs= j - 1 /*J will be 1 more ('cause of DO loop)*/
do k=recs by -1 for recs /*process array (@.k) in reverse order.*/
say @.k /*display a record of the file ──► term*/
end /*k*/
call lineout iFidiFID /*close file, good programming practice*/</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 178 ⟶ 752:
"Diplomacy is the art of
</pre>
 
=== version 2 ===
This will work for all the following REXXes &nbsp; (and perhaps other REXXes as well):
::* &nbsp; Regina REXX
::* &nbsp; R4 REXX
::* &nbsp; ROO REXX
::* &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_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*/
say linein(iFID, j) /*display record contents ──► terminal.*/
end /*j*/
call lineout iFID /*close file, good programming practice*/</syntaxhighlight>
{{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 209 ⟶ 802:
 
see nl + "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 227 ⟶ 820:
done...
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">puts File.readlines("diplomacy.txt").reverse</syntaxhighlight>
{{out}}
<pre> --- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"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
until you can find a rock."
saying 'Nice Doggy'
"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 246 ⟶ 875:
}
// print contents of output file to terminal
System.print(File.read(fileName2))</langsyntaxhighlight>
 
{{out}}
Line 255 ⟶ 884:
saying 'Nice Doggy'
"Diplomacy is the art of
</pre>
 
=={{header|XPL0}}==
Usage: rev <will.txt
<syntaxhighlight lang="xpl0">char Array(1000, 1000); \(tacky)
int Line, Char, I;
def LF=$0A, EOF=$1A;
[Line:= 0;
repeat I:= 0;
repeat Char:= ChIn(1);
Array(Line, I):= Char; I:= I+1;
until Char = LF or Char = EOF;
Line:= Line+1;
until Char = EOF;
for Line:= Line-2 downto 0 do
[I:= 0;
repeat Char:= Array(Line, I); I:= I+1;
ChOut(0, Char);
until Char = LF;
];
]</syntaxhighlight>
 
{{out}}
<pre>
--- Will Rodgers
 
until you can find a rock."
saying 'Nice Doggy'
"Diplomacy is the art of
 
</pre>
PureFox
9,476

edits

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