CloudFlare suffered a massive security issue affecting all of its customers, including Rosetta Code. All passwords not changed since February 19th 2017 have been expired, and session cookie longevity will be reduced until late March.--Michael Mol (talk) 05:15, 25 February 2017 (UTC)

Reverse words in a string

From Rosetta Code
Task
Reverse words in a string
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Reverse the order of all tokens in each of a number of strings and display the result;   the order of characters within a token should not be modified.


Example

Hey you, Bub!   would be shown reversed as:   Bub! you, Hey


Tokens are any non-space characters separated by spaces (formally, white-space);   the visible punctuation form part of the word within which it is located and should not be modified.

You may assume that there are no significant non-visible characters in the input.   Multiple or superfluous spaces may be compressed into a single space.

Some strings have no tokens, so an empty string   (or one just containing spaces)   would be the result.

Display the strings in order   (1st, 2nd, 3rd, ···),   and one string per line.

(You can consider the ten strings as ten lines, and the tokens as words.)


Input data
             (ten lines within the box)
 line
     ╔════════════════════════════════════════╗
   1 ║  ---------- Ice and Fire ------------  ║
   2 ║                                        ║  ◄─── a blank line here.
   3 ║  fire, in end will world the say Some  ║
   4 ║  ice. in say Some                      ║
   5 ║  desire of tasted I've what From       ║
   6 ║  fire. favor who those with hold I     ║
   7 ║                                        ║  ◄─── a blank line here.
   8 ║  ... elided paragraph last ...         ║
   9 ║                                        ║  ◄─── a blank line here.
  10 ║  Frost Robert -----------------------  ║
     ╚════════════════════════════════════════╝
Cf.



Ada[edit]

Simple_Parse[edit]

To Split a string into words, we define a Package "Simple_Parse". This package is also used for the Phrase Reversal Task [[1]].

package Simple_Parse is
-- a very simplistic parser, useful to split a string into words
 
function Next_Word(S: String; Point: in out Positive)
return String;
-- a "word" is a sequence of non-space characters
-- if S(Point .. S'Last) holds at least one word W
-- then Next_Word increments Point by len(W) and returns W.
-- else Next_Word sets Point to S'Last+1 and returns ""
 
end Simple_Parse;

The implementation of "Simple_Parse":

package body Simple_Parse is
 
function Next_Word(S: String; Point: in out Positive) return String is
Start: Positive := Point;
Stop: Natural;
begin
while Start <= S'Last and then S(Start) = ' ' loop
Start := Start + 1;
end loop; -- now S(Start) is the first non-space,
-- or Start = S'Last+1 if S is empty or space-only
Stop := Start-1; -- now S(Start .. Stop) = ""
while Stop < S'Last and then S(Stop+1) /= ' ' loop
Stop := Stop + 1;
end loop; -- now S(Stop+1) is the first sopace after Start
-- or Stop = S'Last if there is no such space
Point := Stop+1;
return S(Start .. Stop);
end Next_Word;
 
end Simple_Parse;

Main Program[edit]

with Ada.Text_IO, Simple_Parse; 
 
procedure Reverse_Words is
 
function Reverse_Words(S: String) return String is
Cursor: Positive := S'First;
Word: String := Simple_Parse.Next_Word(S, Cursor);
begin
if Word = "" then
return "";
else
return Reverse_Words(S(Cursor .. S'Last)) & " " & Word;
end if;
end Reverse_Words;
 
use Ada.Text_IO;
begin
while not End_Of_File loop
Put_Line(Reverse_Words(Get_Line)); -- poem is read from standard input
end loop;
end Reverse_Words;

Aime[edit]

integer i, j, s;
list l, x;
data b;
file f;
 
l_bill(l, 0,
"---------- Ice and Fire ------------",
"",
"fire, in end will world the say Some",
"ice. in say Some",
"desire of tasted I've what From",
"fire. favor who those with hold I",
"",
"... elided paragraph last ...",
"",
"Frost Robert -----------------------");
 
i = -l_length(l);
while (i) {
b_cast(b, l[i]);
f_b_affix(f, b);
f_list(f, x, 0);
j = l_length(x);
s = 0;
while (j) {
o_space(s);
s = 1;
o_text(x[j -= 1]);
}
o_newline();
i += 1;
}
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost


ALGOL 68[edit]

# returns original phrase with the order of the words reversed #
# a word is a sequence of non-blank characters #
PROC reverse word order = ( STRING original phrase )STRING:
BEGIN
STRING words reversed := "";
STRING separator := "";
INT start pos := LWB original phrase;
WHILE
# skip leading spaces #
WHILE IF start pos <= UPB original phrase
THEN original phrase[ start pos ] = " "
ELSE FALSE
FI
DO start pos +:= 1
OD;
start pos <= UPB original phrase
DO
# have another word, find it #
INT end pos := start pos;
WHILE IF end pos <= UPB original phrase
THEN original phrase[ end pos ] /= " "
ELSE FALSE
FI
DO end pos +:= 1
OD;
( original phrase[ start pos : end pos - 1 ] + separator ) +=: words reversed;
separator := " ";
start pos := end pos + 1
OD;
words reversed
END # reverse word order # ;
 
# reverse the words in the lines as per the task #
print( ( reverse word order ( "--------- Ice and Fire ------------ " ), newline ) );
print( ( reverse word order ( " " ), newline ) );
print( ( reverse word order ( "fire, in end will world the say Some" ), newline ) );
print( ( reverse word order ( "ice. in say Some " ), newline ) );
print( ( reverse word order ( "desire of tasted I've what From " ), newline ) );
print( ( reverse word order ( "fire. favor who those with hold I " ), newline ) );
print( ( reverse word order ( " " ), newline ) );
print( ( reverse word order ( "... elided paragraph last ... " ), newline ) );
print( ( reverse word order ( " " ), newline ) );
print( ( reverse word order ( "Frost Robert -----------------------" ), newline ) )
 
Output:
------------ Fire and Ice ---------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

AppleScript[edit]

on run
 
unlines(map(reverseWords, |lines|("---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------"
)))
 
end run
 
 
-- GENERIC FUNCTIONS ---------------------------------------------------------
 
-- reverseWords :: String -> String
on reverseWords(str)
unwords(|reverse|(|words|(str)))
end reverseWords
 
-- |reverse| :: [a] -> [a]
on |reverse|(xs)
if class of xs is text then
(reverse of characters of xs) as text
else
reverse of xs
end if
end |reverse|
 
-- |lines| :: Text -> [Text]
on |lines|(str)
splitOn(linefeed, str)
end |lines|
 
-- |words| :: Text -> [Text]
on |words|(str)
splitOn(space, str)
end |words|
 
-- ulines :: [Text] -> Text
on unlines(lstLines)
intercalate(linefeed, lstLines)
end unlines
 
-- unwords :: [Text] -> Text
on unwords(lstWords)
intercalate(space, lstWords)
end unwords
 
-- splitOn :: Text -> Text -> [Text]
on splitOn(strDelim, strMain)
set {dlm, my text item delimiters} to {my text item delimiters, strDelim}
set lstParts to text items of strMain
set my text item delimiters to dlm
lstParts
end splitOn
 
-- interCalate :: Text -> [Text] -> Text
on intercalate(strText, lstText)
set {dlm, my text item delimiters} to {my text item delimiters, strText}
set strJoined to lstText as text
set my text item delimiters to dlm
strJoined
end intercalate
 
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to lambda(item i of xs, i, xs)
end repeat
return lst
end tell
end map
 
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property lambda : f
end script
end if
end mReturn
 
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Applesoft BASIC[edit]

100 DATA"---------- ICE AND FIRE ------------"
110 DATA" "
120 DATA"FIRE, IN END WILL WORLD THE SAY SOME"
130 DATA"ICE. IN SAY SOME "
140 DATA"DESIRE OF TASTED I'VE WHAT FROM "
150 DATA"FIRE. FAVOR WHO THOSE WITH HOLD I "
160 DATA" "
170 DATA"... ELIDED PARAGRAPH LAST ... "
180 DATA" "
190 DATA"FROST ROBERT -----------------------"
 
200 FOR L = 1 TO 10
210 READ T$
220 I = LEN(T$)
240 IF I THEN GOSUB 300 : PRINT W$; : IF I THEN PRINT " "; : GOTO 240
250 PRINT
260 NEXT L
270 END
 
300 W$ = ""
310 FOR I = I TO 1 STEP -1
320 IF MID$(T$, I, 1) = " " THEN NEXT I : RETURN
330 FOR I = I TO 1 STEP -1
340 C$ = MID$(T$, I, 1)
350 IF C$ <> " " THEN W$ = C$ + W$ : NEXT I
360 RETURN
 

AutoHotkey[edit]

Data := "
(Join`r`n
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------
)"

 
Loop, Parse, Data, `n, `r
{
Loop, Parse, A_LoopField, % A_Space
Line := A_LoopField " " Line
Output .= Line "`n", Line := ""
}
MsgBox, % RTrim(Output, "`n")

AWK[edit]

 
# syntax: GAWK -f REVERSE_WORDS_IN_A_STRING.AWK
BEGIN {
text[++i] = "---------- Ice and Fire ------------"
text[++i] = ""
text[++i] = "fire, in end will world the say Some"
text[++i] = "ice. in say Some"
text[++i] = "desire of tasted I've what From"
text[++i] = "fire. favor who those with hold I"
text[++i] = ""
text[++i] = "... elided paragraph last ..."
text[++i] = ""
text[++i] = "Frost Robert -----------------------"
leng = i
for (i=1; i<=leng; i++) {
n = split(text[i],arr," ")
for (j=n; j>0; j--) {
printf("%s ",arr[j])
}
printf("\n")
}
exit(0)
}
 
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Batch File[edit]

@echo off

::The Main Thing...

cls
echo.
call :reverse "---------- Ice and Fire ------------"
call :reverse
call :reverse "fire, in end will world the say Some"
call :reverse "ice. in say Some"
call :reverse "desire of tasted I've what From"
call :reverse "fire. favor who those with hold I"
call :reverse
call :reverse "... elided paragraph last ..."
call :reverse
call :reverse "Frost Robert -----------------------"
echo.
pause>nul
exit
::/The Main Thing...

::The Function...

:reverse
set reversed=&set word=&set str=%1
:process
for /f "tokens=1,*" %%A in (%str%) do (
set str=%%B
set word=%%A
)
set reversed=%word% %reversed%
set str="%str%"
if not %str%=="" goto process
 
echo.%reversed%
goto :EOF
::/The Function...
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

BBC BASIC[edit]

      PRINT FNreverse("---------- Ice and Fire ------------")\
\ 'FNreverse("")\
\ 'FNreverse("fire, in end will world the say Some")\
\ 'FNreverse("ice. in say Some")\
\ 'FNreverse("desire of tasted I've what From")\
\ 'FNreverse("fire. favor who those with hold I")\
\ 'FNreverse("")\
\ 'FNreverse("... elided paragraph last ...")\
\ 'FNreverse("")\
\ 'FNreverse("Frost Robert -----------------------")
END
 
DEF FNreverse(s$)
LOCAL sp%
sp%=INSTR(s$," ")
IF sp% THEN =FNreverse(MID$(s$,sp%+1))+" "+LEFT$(s$,sp%-1) ELSE =s$
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost


Bracmat[edit]

("---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------"
 : ?text
& ( reverse
= token tokens reversed
.  :?tokens
& whl
' ( @( !arg
 : ?token (" "|\t|\r) ?arg
)
& !tokens !token:?tokens
)
& !tokens !arg:?tokens
& :?reversed
& whl
' ( !tokens:%?token %?tokens
& " " !token !reversed:?reversed
)
& !tokens !reversed:?reversed
& str$!reversed
)
& :?output
& whl
' ( @(!text:?line \n ?text)
& !output reverse$!line \n:?output
)
& !output reverse$!text:?output
& out$str$!output
);
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Burlesque[edit]

 
blsq ) "It is not raining"wd<-wd
"raining not is It"
blsq ) "ice. in say some"wd<-wd
"some say in ice."
 

C[edit]

#include <stdio.h>
#include <ctype.h>
 
void rev_print(char *s, int n)
{
for (; *s && isspace(*s); s++);
if (*s) {
char *e;
for (e = s; *e && !isspace(*e); e++);
rev_print(e, 0);
printf("%.*s%s", (int)(e - s), s, " " + n);
}
if (n) putchar('\n');
}
 
int main(void)
{
char *s[] = {
"---------- Ice and Fire ------------",
" ",
"fire, in end will world the say Some",
"ice. in say Some ",
"desire of tasted I've what From ",
"fire. favor who those with hold I ",
" ",
"... elided paragraph last ... ",
" ",
"Frost Robert -----------------------",
0
};
int i;
for (i = 0; s[i]; i++) rev_print(s[i], 1);
 
return 0;
}

Output is the same as everyone else's.

C++[edit]

 
#include <algorithm>
#include <functional>
#include <string>
#include <iostream>
#include <vector>
 
//code for a C++11 compliant compiler
template <class BidirectionalIterator, class T>
void block_reverse_cpp11(BidirectionalIterator first, BidirectionalIterator last, T const& separator) {
std::reverse(first, last);
auto block_last = first;
do {
using std::placeholders::_1;
auto block_first = std::find_if_not(block_last, last,
std::bind(std::equal_to<T>(),_1, separator));
block_last = std::find(block_first, last, separator);
std::reverse(block_first, block_last);
} while(block_last != last);
}
 
//code for a C++03 compliant compiler
template <class BidirectionalIterator, class T>
void block_reverse_cpp03(BidirectionalIterator first, BidirectionalIterator last, T const& separator) {
std::reverse(first, last);
BidirectionalIterator block_last = first;
do {
BidirectionalIterator block_first = std::find_if(block_last, last,
std::bind2nd(std::not_equal_to<T>(), separator));
block_last = std::find(block_first, last, separator);
std::reverse(block_first, block_last);
} while(block_last != last);
}
 
int main() {
std::string str1[] =
{
"---------- Ice and Fire ------------",
"",
"fire, in end will world the say Some",
"ice. in say Some",
"desire of tasted I've what From",
"fire. favor who those with hold I",
"",
"... elided paragraph last ...",
"",
"Frost Robert -----------------------"
};
 
std::for_each(begin(str1), end(str1), [](std::string& s){
block_reverse_cpp11(begin(s), end(s), ' ');
std::cout << s << std::endl;
});
 
std::for_each(begin(str1), end(str1), [](std::string& s){
block_reverse_cpp03(begin(s), end(s), ' ');
std::cout << s << std::endl;
});
 
return 0;
}
 

Alternate version[edit]

 
#include <string>
#include <iostream>
using namespace std;
 
string invertString( string s )
{
string st, tmp;
for( string::iterator it = s.begin(); it != s.end(); it++ )
{
if( *it != 32 ) tmp += *it;
else
{
st = " " + tmp + st;
tmp.clear();
}
}
return tmp + st;
}
 
int main( int argc, char* argv[] )
{
string str[] =
{
"---------- Ice and Fire ------------",
"",
"fire, in end will world the say Some",
"ice. in say Some",
"desire of tasted I've what From",
"fire. favor who those with hold I",
"",
"... elided paragraph last ...",
"",
"Frost Robert -----------------------"
};
for( int i = 0; i < 10; i++ )
cout << invertString( str[i] ) << "\n";
 
cout << "\n";
return system( "pause" );
}
 

C#[edit]

using System;
 
public class ReverseWordsInString
{
public static void Main()
{
string[] lines = {
"---------- Ice and Fire ------------",
" ",
"fire, in end will world the say Some",
"ice. in say Some ",
"desire of tasted I've what From ",
"fire. favor who those with hold I ",
" ",
"... elided paragraph last ... ",
" ",
"Frost Robert -----------------------" };
 
foreach(string line in lines)
{
string[] words = line.Split(' ');
Array.Reverse(words);
 
foreach(string word in words)
{
//String.Split() adds empty strings to the array. We must check
if(word.Length != 0)
Console.Write(word + " ");
}
Console.WriteLine();
}
}
}

Clojure[edit]

 
(def poem
"---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------"
)
 
(dorun
(map println (map #(apply str (interpose " " (reverse (re-seq #"[^\s]+" %)))) (clojure.string/split poem #"\n"))))
 

Output is the same as everyone else's.

COBOL[edit]

 
program-id. rev-word.
data division.
working-storage section.
1 text-block.
2 pic x(36) value "---------- Ice and Fire ------------".
2 pic x(36) value " ".
2 pic x(36) value "fire, in end will world the say Some".
2 pic x(36) value "ice. in say Some ".
2 pic x(36) value "desire of tasted I've what From ".
2 pic x(36) value "fire. favor who those with hold I ".
2 pic x(36) value " ".
2 pic x(36) value "... elided paragraph last ... ".
2 pic x(36) value " ".
2 pic x(36) value "Frost Robert -----------------------".
1 redefines text-block.
2 occurs 10.
3 text-line pic x(36).
1 text-word.
2 wk-len binary pic 9(4).
2 wk-word pic x(36).
1 word-stack.
2 occurs 10.
3 word-entry.
4 word-len binary pic 9(4).
4 word pic x(36).
1 binary.
2 i pic 9(4).
2 pos pic 9(4).
2 word-stack-ptr pic 9(4).
 
procedure division.
perform varying i from 1 by 1
until i > 10
perform push-words
perform pop-words
end-perform
stop run
.
 
push-words.
move 1 to pos
move 0 to word-stack-ptr
perform until pos > 36
unstring text-line (i) delimited by all space
into wk-word count in wk-len
pointer pos
end-unstring
add 1 to word-stack-ptr
move text-word to word-entry (word-stack-ptr)
end-perform
.
 
pop-words.
perform varying word-stack-ptr from word-stack-ptr
by -1
until word-stack-ptr < 1
move word-entry (word-stack-ptr) to text-word
display wk-word (1:wk-len) space with no advancing
end-perform
display space
.
end program rev-word.
 
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

CoffeeScript[edit]

Translation of: JavaScript
strReversed = '---------- Ice and Fire ------------\n\n
fire, in end will world the say Some\n
ice. in say Some\n
desire of tasted I\'ve what From\n
fire. favor who those with hold I\n\n
... elided paragraph last ...\n\n
Frost Robert -----------------------'

 
reverseString = (s) ->
s.split('\n').map((l) -> l.split(/\s/).reverse().join ' ').join '\n'
 
console.log reverseString(strReversed)
Output:

As JavaScript.

Common Lisp[edit]

(defun split-and-reverse (str)
(labels
((iter (s lst)
(let ((s2 (string-trim '(#\space) s)))
(if s2
(let ((word-end (position #\space s2)))
(if (and word-end (< (1+ word-end) (length s2)))
(iter (subseq s2 (1+ word-end))
(cons (subseq s2 0 word-end) lst))
(cons s2 lst)))
lst))))
(iter str NIL)))
 
(defparameter *poem*
"---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------"
)
 
(with-input-from-string (s *poem*)
(loop for line = (read-line s NIL)
while line
do (format t "~{~a~#[~:; ~]~}~%" (split-and-reverse line))))

Output is the same as everyone else's.

D[edit]

void main() {
import std.stdio, std.string, std.range, std.algorithm;
 
immutable text =
"---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------"
;
 
writefln("%(%-(%s %)\n%)",
text.splitLines.map!(r => r.split.retro));
}

The output is the same as the Python entry.

EchoLisp[edit]

Using a here-string input :

 
(define S #<<
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------
>>#)
 
(for-each writeln
(for/list ((line (string-split S "\n")))
(string-join (reverse (string-split line " ")) " ")))
 
Output:
------------ Fire and Ice ----------    
    
Some say the world will end in fire,    
Some say in ice.    
From what I've tasted of desire    
I hold with those who favor fire.    
    
... last paragraph elided ...    
    
----------------------- Robert Frost    

Elena[edit]

#import system.
#import system'routines.
 
#symbol program =
[
#var text := ("---------- Ice and Fire ------------",
"",
"fire, in end will world the say Some",
"ice. in say Some",
"desire of tasted I've what From",
"fire. favor who those with hold I",
"",
"... elided paragraph last ...",
"",
"Frost Robert -----------------------").
 
text run &each: line
[
line split &by:" " reverse run &each: word
[
console write:word write:" ".
].
console writeLine.
].
].

Elixir[edit]

defmodule RC do
def reverse_words(txt) do
txt |> String.split("\n") # split lines
|> Enum.map(&( # in each line
&1 |> String.split # split words
|> Enum.reverse # reverse words
|> Enum.join(" "))) # rejoin words
|> Enum.join("\n") # rejoin lines
end
end

Usage:

txt = """
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------
"""
 
IO.puts RC.reverse_words(txt)

Elm[edit]

 
reversedPoem =
String.trim """
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------
"""
 
reverseWords string =
string |> String.words |> List.reverse |> String.join " "
 
reverseLinesWords string =
string |> String.lines |> List.map reverseWords |> String.join "\n"
 
poem =
reverseLinesWords reversedPoem
 

Emacs Lisp[edit]

 
(defun reverse-words (line)
(insert
(format "%s\n"
(mapconcat 'identity (reverse (split-string line)) " "))))
 
(defun reverse-lines (lines)
(mapcar 'reverse-words lines))
 
(reverse-lines
'("---------- Ice and Fire ------------"
""
"fire, in end will world the say Some"
"ice. in say Some"
"desire of tasted I've what From"
"fire. favor who those with hold I"
""
"... elided paragraph last ..."
""
"Frost Robert ----------------------- "))
 

Output:

------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Forth[edit]

The method shown is based on submissions in comp.lang.forth. Comments have been added for those less familiar with reading Forth. This example makes use of the Forth interpreter/compiler internals by calling PARSE-NAME which is a Forth 2012 word that parses the input stream, ignores leading spaces and delimits at the space character. This method makes clever use of the data stack. Strings are not copied in memory by rather pointers are collected on the stack as PARSE-NAME processes a sentence. This of course leaves the strings in the reversed order so they are simply printed off the data stack.

create buf 1000 chars allot                    \ string buffer
buf value pp \ pp points to buffer address
 
: tr ( caddr u -- )
dup >r pp swap cmove \ move string into buffer
r> pp + to pp  ; \ advance pointer by u bytes
 
: collect ( -- addr len .. addr[n] len[n]) \ words deposit on data stack
begin
parse-name dup \ parse input stream, dup the len
while \ while stack <> 0
tuck pp >r tr r> swap
repeat
2drop ; \ clean up stack
 
: reverse ( -- )
buf to pp \ initialize pointer to buffer address
collect
depth 2/ 0 ?do type space loop \ type the strings with a trailing space
cr ; \ final new line
 
reverse ---------- Ice and Fire ------------
reverse
reverse fire, in end will world the say Some
reverse ice. in say Some
reverse desire of tasted I've what From
reverse fire. favor who those with hold I
reverse
reverse ... elided paragraph last ...
reverse
reverse Frost Robert -----------------------

Output Interpreted above code at the Forth console

Some say the world will end in fire, 
Some say in ice. 
From what I've tasted of desire 
I hold with those who favor fire. 

... last paragraph elided ... 

----------------------- Robert Frost 
 ok

Fortran[edit]

Compiled using G95 on x86 system running Puppy Linux. Fortran syntax is mostly Fortran 77.

 
character*40 words
character*40 reversed
logical inblank
ierr=0
read (5,fmt="(a)",iostat=ierr)words
do while (ierr.eq.0)
inblank=.true.
ipos=1
do i=40,1,-1
if(words(i:i).ne.' '.and.inblank) then
last=i
inblank=.false.
end if
if(.not.inblank.and.words(i:i).eq.' ') then
reversed(ipos:ipos+last-i)=words(i+1:last)
ipos=ipos+last-i+1
inblank=.true.
end if
if(.not.inblank.and.i.eq.1) then
reversed(ipos:ipos+last-1)=words(1:last)
ipos=ipos+last
end if
end do
print *,words,'=> ',reversed(1:ipos-1)
read (5,fmt="(a)",iostat=ierr)words
end do
end
 
 
Output from comand: cat frostPoem.txt | reverse

where file frostPoem.txt contains the input text.


 ---------- Ice and Fire -----------     => ----------- Fire and Ice ----------
                                         => 
 fire, in end will world the say Some    => Some say the world will end in fire,
 ice. in say Some                        => Some say in ice.
 desire of tasted I've what From         => From what I've tasted of desire
 fire. favor who those with hold I       => I hold with those who favor fire.
                                         => 
 ... elided paragraph last ...           => ... last paragraph elided ...
                                         => 
 Frost Robert -----------------------    => ----------------------- Robert Frost

FreeBASIC[edit]

' FB 1.05.0 Win64
 
Sub split (s As String, sepList As String, result() As String, removeEmpty As Boolean = False)
If s = "" OrElse sepList = "" Then
Redim result(0)
result(0) = s
Return
End If
Dim As Integer i, j, count = 0, empty = 0, length
Dim As Integer position(Len(s) + 1)
position(0) = 0
 
For i = 0 To len(s) - 1
For j = 0 to Len(sepList) - 1
If s[i] = sepList[j] Then
count += 1
position(count) = i + 1
End If
Next j
Next i
 
Redim result(count)
If count = 0 Then
result(0) = s
Return
End If
 
position(count + 1) = len(s) + 1
 
For i = 1 To count + 1
length = position(i) - position(i - 1) - 1
result(i - 1 - empty) = Mid(s, position(i - 1) + 1, length)
If removeEmpty Andalso CBool(length = 0) Then empty += 1
Next
 
If empty > 0 Then Redim Preserve result(count - empty)
End Sub
 
Dim s As String = "Hey you, Bub!"
Dim a() As String
split(s, " ", a(), true)
Dim reversed As String = ""
For i As Integer = UBound(a) To LBound(a) Step -1
reversed += a(i)
If i > LBound(a) Then reversed += " "
Next
 
Print "Original String = "; s
Print "Reversed String = "; reversed
Print
Print "Press any key to quit"
Sleep
Output:
Original String = Hey you, Bub!
Reversed String = Bub! you, Hey

Frink[edit]

 
lines=split["\n",
"""---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
.. elided paragraph last ...
 
Frost Robert -----------------------"""]
 
for line = lines
println[join[" ", reverse[split[%r/\s+/, line]]]]
 

Gema[edit]

\L<G> <U>=@{$2} $1

Go[edit]

package main
 
import (
"fmt"
"strings"
)
 
// a number of strings
var n = []string{
"---------- Ice and Fire ------------",
" ",
"fire, in end will world the say Some",
"ice. in say Some ",
"desire of tasted I've what From ",
"fire. favor who those with hold I ",
" ",
"... elided paragraph last ... ",
" ",
"Frost Robert -----------------------",
}
 
func main() {
for i, s := range n {
t := strings.Fields(s) // tokenize
// reverse
last := len(t) - 1
for j, k := range t[:len(t)/2] {
t[j], t[last-j] = t[last-j], k
}
n[i] = strings.Join(t, " ")
}
// display result
for _, t := range n {
fmt.Println(t)
}
}
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Groovy[edit]

def text = new StringBuilder()
.append('---------- Ice and Fire ------------\n')
.append(' \n')
.append('fire, in end will world the say Some\n')
.append('ice. in say Some \n')
.append('desire of tasted I\'ve what From \n')
.append('fire. favor who those with hold I \n')
.append(' \n')
.append('... elided paragraph last ... \n')
.append(' \n')
.append('Frost Robert -----------------------\n').toString()
 
text.eachLine { line ->
println "$line --> ${line.split(' ').reverse().join(' ')}"
}
Output:
---------- Ice and Fire ------------   -->   ------------ Fire and Ice ----------
                                       -->   
fire, in end will world the say Some   -->   Some say the world will end in fire,
ice. in say Some                       -->   Some say in ice.
desire of tasted I've what From        -->   From what I've tasted of desire
fire. favor who those with hold I      -->   I hold with those who favor fire.
                                       -->   
... elided paragraph last ...          -->   ... last paragraph elided ...
                                       -->   
Frost Robert -----------------------   -->   ----------------------- Robert Frost

Haskell[edit]

 
revstr :: String -> String
revstr = unwords . reverse . words -- point-free style
--equivalent:
--revstr s = unwords (reverse (words s))
 
revtext :: String -> String
revtext = unlines . map revstr . lines -- applies revstr to each line independently
 
test = revtext "---------- Ice and Fire ------------\n\
\\n\
\fire, in end will world the say Some\n\
\ice. in say Some\n\
\desire of tasted I've what From\n\
\fire. favor who those with hold I\n\
\\n\
\... elided paragraph last ...\n\
\\n\
\Frost Robert -----------------------\n"
--multiline string notation requires \ at end and start of lines, and \n to be manually input
 

unwords, reverse, words, unlines, map and lines are built-in functions, all available at GHC's Prelude. For better visualization, use "putStr test"

Icon and Unicon[edit]

Works in both languages:

procedure main()
every write(rWords(&input))
end
 
procedure rWords(f)
every !f ? {
every (s := "") := genWords() || s
suspend s
}
end
 
procedure genWords()
while w := 1(tab(upto(" \t")),tab(many(" \t"))) || " " do suspend w
end
Output:
for test file:
->rw <rw.in
------------ Fire and Ice ----------  
 
Some say the world will end in fire,  
Some say in ice.  
From what I've tasted of desire  
I hold with those who favor fire.  
 
... last paragraph elided ...  
 
----------------------- Robert Frost  
->

J[edit]

Treated interactively:

   ([:;@|.[:<;.1 ' ',]);._2]0 :0
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------
)
------------ Fire and Ice ----------
 
Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.
 
... last paragraph elided ...
 
----------------------- Robert Frost
 

The verb phrase ( [:  ; @ |. [: < ;. 1 ' ' , ]) reverses words in a string. The rest of the implementation has to do with defining the block of text we are working on, and applying this verb phrase to each line of that text.

Java[edit]

public class ReverseWords {
 
static final String[] lines = {
" ----------- Ice and Fire ----------- ",
" ",
" fire, in end will world the say Some ",
" ice. in say Some ",
" desire of tasted I've what From ",
" fire. favor who those with hold I ",
" ",
" ... elided paragraph last ... ",
" Frost Robert ----------------------- "};
 
public static void main(String[] args) {
for (String line : lines) {
String[] words = line.split("\\s");
for (int i = words.length - 1; i >= 0; i--)
System.out.printf("%s ", words[i]);
System.out.println();
}
}
}
Works with: Java version 8+
package string;
 
import static java.util.Arrays.stream;
 
public interface ReverseWords {
public static final String[] LINES = {
" ----------- Ice and Fire ----------- ",
" ",
" fire, in end will world the say Some ",
" ice. in say Some ",
" desire of tasted I've what From ",
" fire. favor who those with hold I ",
" ",
" ... elided paragraph last ... ",
" Frost Robert ----------------------- "
};
 
public static String[] reverseWords(String[] lines) {
return stream(lines)
.parallel()
.map(l -> l.split("\\s"))
.map(ws -> stream(ws)
.parallel()
.map(w -> " " + w)
.reduce(
"",
(w1, w2) -> w2 + w1
)
)
.toArray(String[]::new)
;
}
 
public static void main(String... arguments) {
stream(reverseWords(LINES))
.forEach(System.out::println)
;
}
}
Output:
----------- Fire and Ice ----------- 

Some say the world will end in fire,   
Some say in ice.   
From what I've tasted of desire   
I hold with those who favor fire.   

... last paragraph elided ...   

----------------------- Robert Frost 

JavaScript[edit]

var strReversed =
"---------- Ice and Fire ------------\n\
\n\
fire, in end will world the say Some\n\
ice. in say Some\n\
desire of tasted I've what From\n\
fire. favor who those with hold I\n\
\n\
... elided paragraph last ...\n\
\n\
Frost Robert -----------------------"
;
 
function reverseString(s) {
return s.split('\n').map(
function (line) {
return line.split(/\s/).reverse().join(' ');
}
).join('\n');
}
 
console.log(
reverseString(strReversed)
);

Output:

------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

jq[edit]

split("[ \t\n\r]+") | reverse | join(" ")

This solution requires a version of jq with regex support for split.

The following example assumes the above line is in a file named reverse_words.jq and that the input text is in a file named IceAndFire.txt. The -r option instructs jq to read the input file as strings, line by line.
$ jq -R -r -M -f reverse_words.jq IceAndFire.txt
------------ Fire and Ice ----------
 
Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.
 
... last paragraph elided ...
 
----------------------- Robert Frost

Julia[edit]

revstring (str) = join(reverse(split(str, " ")), " ")
Output:
julia> revstring("Hey you, Bub!")
"Bub! you, Hey"

julia> s = IOBuffer(
"---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------")

julia>  for line in eachline(s)
          println(revstring(chomp(line)))
        end
------------ Fire and Ice ----------
 
Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.
 
... last paragraph elided ...
 
----------------------- Robert Frost

Kotlin[edit]

// version 1.0.6
 
fun reversedWords(s: String) = s.split(" ").reversed().joinToString(" ")
 
fun main(args: Array<String>) {
val s = "Hey you, Bub!"
println(reversedWords(s))
println()
val sl = listOf(
" ---------- Ice and Fire ------------ ",
" ",
" fire, in end will world the say Some ",
" ice. in say Some ",
" desire of tasted I've what From ",
" fire. favor who those with hold I ",
" ",
" ... elided paragraph last ... ",
" ",
" Frost Robert ----------------------- "
)
sl.forEach { println(reversedWords(it).trimStart()) }
}
Output:
Bub! you, Hey

------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Liberty BASIC[edit]

 
for i = 1 to 10
read string$
print reverse$(string$)
next
end
 
function reverse$(string$)
token$="*"
while token$<>""
i=i+1
token$ = word$(string$, i)
output$=token$+" "+output$
wend
reverse$ = trim$(output$)
end function
 
data "---------- Ice and Fire ------------"
data ""
data "fire, in end will world the say Some"
data "ice. in say Some"
data "desire of tasted I've what From"
data "fire. favor who those with hold I"
data ""
data "... elided paragraph last ..."
data ""
data "Frost Robert -----------------------"
 
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

LiveCode[edit]

The input text has been entered into the contents of a text field called "Fieldtxt", add a button and put the following in its mouseUp

repeat for each line txtln in fld "Fieldtxt"
repeat with i = the number of words of txtln down to 1
put word i of txtln & space after txtrev
end repeat
put cr after txtrev -- preserve line
end repeat
put txtrev


LiveScript[edit]

 
poem =
"""
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------
"""
 
reverse-words = (.split ' ') >> (.reverse!) >> (.join ' ')
reverse-string = (.split '\n') >> (.map reverse-words) >> (.join '\n')
reverse-string poem
 

[edit]

This version just reads the words from standard input.

do.until [
make "line readlist
print reverse :line
] [word? :line]
bye
Output:
Given this input:
---------- Ice and Fire ------------

fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I

... elided paragraph last ...

Frost Robert -----------------------

it produces this output:

------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Lua[edit]

(Note: The Wiki's syntax highlighting for Lua does not highlight the following valid string literal correctly, so the listing is split in two parts.)

   s = [[---------- Ice and Fire ------------
   
   fire, in end will world the say Some
   ice. in say Some
   desire of tasted I've what From
   fire. favor who those with hold I
   
   ... elided paragraph last ...
   
   Frost Robert -----------------------
   ]]
function table.reverse(a)
local res = {}
for i = #a, 1, -1 do
res[#res+1] = a[i]
end
return res
end
 
function splittokens(s)
local res = {}
for w in s:gmatch("%S+") do
res[#res+1] = w
end
return res
end
 
for line, nl in s:gmatch("([^\n]-)(\n)") do
print(table.concat(table.reverse(splittokens(line)), ' '))
end

Note: With the technique used here for splitting s into lines (not part of the task) the last line will be gobbled up if it does not end with a newline.

Mathematica[edit]

poem = "---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------";
lines = StringSplit[poem, "\n"];
wordArray = StringSplit[#] & @ lines ;
reversedWordArray = Reverse[#] & /@ wordArray ;
linesWithReversedWords =
StringJoin[Riffle[#, " "]] & /@ reversedWordArray;
finaloutput = StringJoin[Riffle[#, "\n"]] & @ linesWithReversedWords
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

MATLAB[edit]

function testReverseWords
testStr = {'---------- Ice and Fire ------------' ; ...
''  ; ...
'fire, in end will world the say Some'  ; ...
'ice. in say Some'  ; ...
'desire of tasted I''ve what From'  ; ...
'fire. favor who those with hold I'  ; ...
''  ; ...
'... elided paragraph last ...'  ; ...
''  ; ...
'Frost Robert -----------------------' };
for k = 1:length(testStr)
fprintf('%s\n', reverseWords(testStr{k}))
end
end
 
function strOut = reverseWords(strIn)
strOut = strtrim(strIn);
if ~isempty(strOut)
% Could use strsplit() instead of textscan() in R2013a or later
words = textscan(strOut, '%s');
words = words{1};
strOut = strtrim(sprintf('%s ', words{end:-1:1}));
end
end
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Nim[edit]

import strutils
 
let text = """---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------"""
 
proc reversed*[T](a: openArray[T], first, last: int): seq[T] =
result = newSeq[T](last - first + 1)
var x = first
var y = last
while x <= last:
result[x] = a[y]
dec(y)
inc(x)
 
proc reversed*[T](a: openArray[T]): seq[T] =
reversed(a, 0, a.high)
 
for line in text.splitLines():
echo line.split(' ').reversed().join(" ")
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Objeck[edit]

use Collection;
 
class Reverselines {
function : Main(args : String[]) ~ Nil {
lines := List->New();
lines->AddBack("---------- Ice and Fire ------------");
lines->AddBack("");
lines->AddBack("fire, in end will world the say Some");
lines->AddBack("ice. in say Some");
lines->AddBack("desire of tasted I've what From");
lines->AddBack("fire. favor who those with hold I");
lines->AddBack("");
lines->AddBack("... elided paragraph last ...");
lines->AddBack("");
lines->AddBack("Frost Robert -----------------------");
 
lines->Rewind();
each(i : lines) {
words := lines->Get()->As(String)->Split(" ");
if(words <> Nil) {
for(j := words->Size() - 1; j > -1; j-=1;) {
IO.Console->Print(words[j])->Print(" ");
};
};
IO.Console->PrintLine();
lines->Next();
};
}
}
Output:
------------ Fire and Ice ---------- 

Some say the world will end in fire, 
Some say in ice. 
From what I've tasted of desire 
I hold with those who favor fire. 

... last paragraph elided ... 

----------------------- Robert Frost 

OCaml[edit]

#load "str.cma"
let input = ["---------- Ice and Fire ------------";
"";
"fire, in end will world the say Some";
"ice. in say Some";
"desire of tasted I've what From";
"fire. favor who those with hold I";
"";
"... elided paragraph last ...";
"";
"Frost Robert -----------------------"];;
 
let splitted = List.map (Str.split (Str.regexp " ")) input in
let reversed = List.map List.rev splitted in
let final = List.map (String.concat " ") reversed in
List.iter print_endline final;;

Sample usage

$ ocaml reverse.ml
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Oforth[edit]

: revWords(s) 
s words reverse unwords ;
 
: reverseWords
"---------- Ice and Fire ------------" revWords println
" " revWords println
"fire, in end will world the say Some" revWords println
"ice. in say Some " revWords println
"desire of tasted I've what From " revWords println
"fire. favor who those with hold I " revWords println
" " revWords println
"... elided paragraph last ... " revWords println
" " revWords println
"Frost Robert -----------------------" revWords println ;
Output:
>reverseWords
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost
ok

Pascal[edit]

Free Pascal 3.0.0

program Reverse_words(Output);
{$H+}
 
const
nl = chr(10); // Linefeed
sp = chr(32); // Space
TXT =
'---------- Ice and Fire -----------'+nl+
nl+
'fire, in end will world the say Some'+nl+
'ice. in say Some'+nl+
'desire of tasted I''ve what From'+nl+
'fire. favor who those with hold I'+nl+
nl+
'... elided paragraph last ...'+nl+
nl+
'Frost Robert -----------------------'+nl;
 
var
I : integer;
ew, lw : ansistring;
c : char;
 
function addW : ansistring;
var r : ansistring = '';
begin
r := ew + sp + lw;
ew := '';
addW := r
end;
 
begin
ew := '';
lw := '';
 
for I := 1 to strlen(TXT) do
begin
c := TXT[I];
case c of
sp : lw := addW;
nl : begin writeln(addW); lw := '' end;
else ew := ew + c
end;
end;
readln;
end.
Output:
----------- Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Perl[edit]

print join(" ", reverse split), "\n" for <DATA>;
__DATA__
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------

Perl 6[edit]

We'll read input from stdin

say ~.words.reverse for lines
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Phix[edit]

constant test="""
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------
"""
sequence lines = split(test,'\n')
for i=1 to length(lines) do
lines[i] = join(reverse(split(lines[i])))
end for
puts(1,join(lines,"\n"))
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

PicoLisp[edit]

 
(in "FireIce.txt"
(until (eof)
(prinl (glue " " (flip (split (line) " "))))))
 
Output:

Same as anybody else.

PL/I[edit]

rev: procedure options (main);          /* 5 May 2014 */
declare (s, reverse) character (50) varying;
declare (i, j) fixed binary;
declare in file;
 
open file (in) title ('/REV-WRD.DAT,type(text),recsize(5> Nil) {
for(j := words->Size() - 1; j > -1; j-=1;) {
IO.Console->Print(words[j])->Print(" ");
};
};
IO.Console->PrintLine();
lines->Next();
};
}
}0)');
 
do j = 1 to 10;
get file (in) edit (s) (L);
put skip list (trim(s));
 
reverse = '';
 
do while (length(s) > 0);
s = trim(s);
i = index(s, ' ');
if i = 0 then
if s ^= '' then i = length(s)+1;
if i > 0 then reverse = substr(s, 1, i-1) || ' ' || reverse;
if length(s) = i then s = ''; else s = substr(s, i);
end;
put edit ('---> ', reverse) (col(40), 2 A);
end;
end rev;
Output:
---------- Ice and Fire ------------   ---> ------------ Fire and Ice ---------- 
                                       ---> 
fire, in end will world the say Some   ---> Some say the world will end in fire, 
ice. in say Some                       ---> Some say in ice. 
desire of tasted I've what From        ---> From what I've tasted of desire 
fire. favor who those with hold I      ---> I hold with those who favor fire. 
                                       ---> 
... elided paragraph last ...          ---> ... last paragraph elided ... 
                                       ---> 
Frost Robert -----------------------   ---> ----------------------- Robert Frost 

PowerShell[edit]

Works with: PowerShell version 4.0
 
Function Reverse-Words($lines) {
$lines | foreach {
$array = $PSItem.Split(' ')
$array[($array.Count-1)..0] -join ' '
}
}
 
$lines =
"---------- Ice and Fire ------------",
"",
"fire, in end will world the say Some",
"ice. in say Some",
"desire of tasted I've what From",
"fire. favor who those with hold I",
"",
"... elided paragraph last ...",
"",
"Frost Robert -----------------------"
 
Reverse-Words($lines)
 

output :

------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

PureBasic[edit]

a$ =    "---------- Ice and Fire ------------" +#CRLF$+
" " +#CRLF$+
"fire, in end will world the say Some" +#CRLF$+
"ice. in say Some " +#CRLF$+
"desire of tasted I've what From " +#CRLF$+
"fire. favor who those with hold I " +#CRLF$+
" " +#CRLF$+
"... elided paragraph last ... " +#CRLF$+
" " +#CRLF$+
"Frost Robert -----------------------" +#CRLF$
a$ = "Hey you, Bub! " +#CRLF$+#CRLF$+ a$
 
OpenConsole()
For p1=1 To CountString(a$,#CRLF$)
b$=StringField(a$,p1,#CRLF$) : c$=""
For p2=1 To CountString(b$,Chr(32))+1
c$=StringField(b$,p2,Chr(32))+Space(1)+c$
Next
PrintN(LSet(b$,36,Chr(32))+" ---> "+Trim(c$))
Next
Input()
 
Output:
Hey you, Bub!                        ---> Bub! you, Hey
                                     --->
---------- Ice and Fire ------------ ---> ------------ Fire and Ice ----------
                                     --->
fire, in end will world the say Some ---> Some say the world will end in fire,
ice. in say Some                     ---> Some say in ice.
desire of tasted I've what From      ---> From what I've tasted of desire
fire. favor who those with hold I    ---> I hold with those who favor fire.
                                     --->
... elided paragraph last ...        ---> ... last paragraph elided ...
                                     --->
Frost Robert ----------------------- ---> ----------------------- Robert Frost

PHP[edit]

 
<?php
 
function strInv ($string) {
 
$str_inv = '' ;
 
for ($i=0,$s=count($string);$i<$s;$i++){
$str_inv .= implode(' ',array_reverse(explode(' ',$string[$i])));
$str_inv .= '<br>';
}
 
return $str_inv;
 
}
 
$string[] = "---------- Ice and Fire ------------";
$string[] = "";
$string[] = "fire, in end will world the say Some";
$string[] = "ice. in say Some";
$string[] = "desire of tasted I've what From";
$string[] = "fire. favor who those with hold I";
$string[] = "";
$string[] = "... elided paragraph last ...";
$string[] = "";
$string[] = "Frost Robert ----------------------- ";
 
 
echo strInv($string);

Output:

------------ Fire and Ice ----------
 
Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.
 
... last paragraph elided ...
 
----------------------- Robert Frost

Python[edit]

 text = '''\
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------'''

 
for line in text.split('\n'): print(' '.join(line.split()[::-1]))

Output:

------------ Fire and Ice ----------
 
Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.
 
... last paragraph elided ...
 
----------------------- Robert Frost

Racket[edit]

#lang racket/base
 
(require racket/string)
 
(define (split-reverse str)
(string-join
(reverse
(string-split str))))
 
(define poem
"---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------")
 
 
(let ([poem-port (open-input-string poem)])
(let loop ([l (read-line poem-port)])
(unless (eof-object? l)
(begin (displayln (split-reverse l))
(loop (read-line poem-port))))))
 

REXX[edit]

natural order[edit]

This REXX version process the words in a natural order (first to last).

/*REXX program reverses the order of tokens in a string (but not the letters).*/
@.=; @.1 = "---------- Ice and Fire ------------"
@.2 = ' '
@.3 = "fire, in end will world the say Some"
@.4 = "ice. in say Some"
@.5 = "desire of tasted I've what From"
@.6 = "fire. favor who those with hold I"
@.7 = ' '
@.8 = "... elided paragraph last ..."
@.9 = ' '
@.10 = "Frost Robert -----------------------"
 
do j=1 while @.j\=='' /*process each of the 10 lines of poem.*/
$= /*nullify the $ string (the new line)*/
do k=1 for words(@.j) /*process each word in a @.j string.*/
$=word(@.j,k) $ /*prepend a word to the new line ($). */
end /*k*/ /* [↑] we could do this another way. */
 
say $ /*display the newly constructed line. */
end /*j*/ /*stick a fork in it, we're all done. */

output   when using the (internal text) ten lines of input:

------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

reverse order[edit]

This REXX version process the words in reverse order (last to first).

/*REXX program reverses the order of tokens in a string (but not the letters).*/
@.=; @.1 = "---------- Ice and Fire ------------"
@.2 = ' '
@.3 = "fire, in end will world the say Some"
@.4 = "ice. in say Some"
@.5 = "desire of tasted I've what From"
@.6 = "fire. favor who those with hold I"
@.7 = ' '
@.8 = "... elided paragraph last ..."
@.9 = ' '
@.10 = "Frost Robert -----------------------"
 
do j=1 while @.j\=='' /*process each of the 10 lines of poem.*/
$= /*nullify the $ string (the new line)*/
do k=words(@.j) to 1 by -1 /*process each word in a @.j string.*/
$=$ word(@.j,k) /*append a word to the new line ($). */
end /*k*/ /* [↑] process last word to first word*/
 
say $ /*display the newly constructed line. */
end /*j*/ /*stick a fork in it, we're all done. */

output   is the same as the 1st REXX version.

Ring[edit]

 
aList = str2list("
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------
")
aList = str2list(cStr)
for x in aList
x2 = substr(x," ",nl) alist2 = str2list(x2) aList2 = reverse(aList2)
for y in aList2 see y + " " next see nl
next
 

Output

 
------------ Fire and Ice ----------
 
Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.
 
... last paragraph elided ...
----------------------- Robert Frost
 

Ruby[edit]

puts <<EOS
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------
EOS

.each_line.map {|line| line.split.reverse.join(' ')}

Output the same as everyone else's.


Run BASIC[edit]

for i = 1 to 10
read string$
j = 1
r$ = ""
while word$(string$,j) <> ""
r$ = word$(string$,j) + " " + r$
j = j + 1
WEND
print r$
next
end
 
data "---------- Ice and Fire ------------"
data ""
data "fire, in end will world the say Some"
data "ice. in say Some"
data "desire of tasted I've what From"
data "fire. favor who those with hold I"
data ""
data "... elided paragraph last ..."
data ""
data "Frost Robert -----------------------"

Output:

------------ Fire and Ice ---------- 

Some say the world will end in fire, 
Some say in ice. 
From what I''ve tasted of desire 
I hold with those who favor fire. 

... last paragraph elided ... 

----------------------- Robert Frost 

Rust[edit]

const TEXT: &'static str = 
"---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------";
 
fn main() {
println!("{}",
TEXT.lines() // Returns iterator over lines
.map(|line| // Applies closure to each item in iterator (for each line)
line.split_whitespace() // Returns iterator of words
.rev() // Reverses iterator of words
.collect::<Vec<_>>() // Collects words into Vec<&str>
.join(" ")) // Convert vector of words back into line
.collect::<Vec<_>>() // Collect lines into Vec<String>
.join("\n")); // Concatenate lines into String
}


S-lang[edit]

variable ln, in =
["---------- Ice and Fire ------------",
"fire, in end will world the say Some",
"ice. in say Some",
"desire of tasted I've what From",
"fire. favor who those with hold I",
"",
"... elided paragraph last ...",
"",
"Frost Robert -----------------------"];
 
foreach ln (in) {
ln = strtok(ln, " \t");
array_reverse(ln);
() = printf("%s\n", strjoin(ln, " "));
}
Output:
------------ Fire and Ice ----------
Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Scala[edit]

Works with: Scala version 2.9.x
object ReverseWords extends App {
 
"""| ---------- Ice and Fire ------------
|
| fire, in end will world the say Some
| ice. in say Some
| desire of tasted I've what From
| fire. favor who those with hold I
|
| ... elided paragraph last ...
|
| Frost Robert ----------------------- "
""
.stripMargin.lines.toList.map{_.split(" ")}.map{_.reverse}
.map(_.mkString(" "))
.foreach{println}
 
}
Output:
 ------------ Fire and Ice ----------

 Some say the world will end in fire,
 Some say in ice.
 From what I've tasted of desire
 I hold with those who favor fire.

 ... last paragraph elided ...

 ----------------------- Robert Frost

Scheme[edit]

Works with: Gauche Scheme
 
(for-each
(lambda (s) (print (string-join (reverse (string-split s #/ +/)))))
(string-split
"---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------"

#/[ \r]*\n[ \r]*/))
 

Output:

------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Seed7[edit]

$ include "seed7_05.s7i";
 
const array string: lines is [] (
"---------- Ice and Fire ------------",
"",
"fire, in end will world the say Some",
"ice. in say Some",
"desire of tasted I've what From",
"fire. favor who those with hold I",
"",
"... elided paragraph last ...",
"",
"Frost Robert -----------------------");
 
const proc: main is func
local
var string: line is "";
var array string: words is 0 times "";
var integer: index is 0;
begin
for line range lines do
words := split(line, ' ');
for index range length(words) downto 1 do
write(words[index] <& " ");
end for;
writeln;
end for;
end func;
Output:
------------ Fire and Ice ---------- 
 
Some say the world will end in fire, 
Some say in ice. 
From what I've tasted of desire 
I hold with those who favor fire. 
 
... last paragraph elided ... 
 
----------------------- Robert Frost 

Sidef[edit]

DATA.each{|line| line.words.reverse.join(" ").say};
 
__DATA__
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------

Smalltalk[edit]

 
poem := '---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I'
've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------'
.
 
(poem lines collect: [ :line | ((line splitOn: ' ') reverse) joinUsing: ' ' ]) joinUsing: (String cr).
 
Output:
'------------ Fire and Ice ----------
 
Some say the world will end in fire,
Some say in ice.
From what I''ve tasted of desire
I hold with those who favor fire.
 
... last paragraph elided ...
 
----------------------- Robert Frost'

Sparkling[edit]

This only considers space as the word separator, not tabs, form feeds or any other sort of whitespace. (This, however, turns out not to be an issue with the example input.)

let lines = split("---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------", "\n");
 
foreach(lines, function(idx, line) {
let words = split(line, " ");
let reverseWords = map(words, function(idx) { return words[sizeof words - idx - 1]; });
foreach(reverseWords, function(idx, word) {
printf("%s ", word);
});
 
print();
});

Swift[edit]

import Foundation
 
// convenience extension for better clarity
extension String {
var lines: [String] {
get {
return self.componentsSeparatedByCharactersInSet(NSCharacterSet.newlineCharacterSet())
}
}
var words: [String] {
get {
return self.componentsSeparatedByCharactersInSet(NSCharacterSet.whitespaceCharacterSet())
}
}
}
 
let input = "---------- Ice and Fire ------------\n\nfire, in end will world the say Some\nice. in say Some\ndesire of tasted I've what From\nfire. favor who those with hold I\n\n... elided paragraph last ...\n\nFrost Robert -----------------------\n"
 
let output = input.lines.map { $0.words.reverse().joinWithSeparator(" ") }.joinWithSeparator("\n")
 
print(output)
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Tcl[edit]

set lines {
"---------- Ice and Fire ------------"
""
"fire, in end will world the say Some"
"ice. in say Some"
"desire of tasted I've what From"
"fire. favor who those with hold I"
""
"... elided paragraph last ..."
""
"Frost Robert -----------------------"
}
foreach line $lines {
puts [join [lreverse [regexp -all -inline {\S+} $line]]]
# This would also work for data this simple:
### puts [lreverse $line]
}
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost

Alternatively…

Works with: Tcl version 8.6
puts [join [lmap line $lines {lreverse $line}] "\n"]

TXR[edit]

Run from command line:

txr reverse.txr verse.txt

Solution:

@(collect)
@ (some)
@(coll)@{words /[^ ]+/}@(end)
@ (or)
@(bind words nil)
@ (end)
@(end)
@(set words @(mapcar (fun nreverse) words))
@(output)
@ (repeat)
@(rep)@words @(last)@words@(end)
@ (end)
@(end)
 

New line should be present after the last @(end) terminating vertical definition. i.e.

@(end)
[EOF]

not

@(end)[EOF]

UNIX Shell[edit]

Works with: bash
while read -a words; do
for ((i=${#words[@]}-1; i>=0; i--)); do
printf "%s " "${words[i]}"
done
echo
done << END
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------
END
Works with: ksh
Same as above, except change
read -a
to
read -A

VBScript[edit]

 
Option Explicit
 
Dim objFSO, objInFile, objOutFile
Dim srcDir, line
 
Set objFSO = CreateObject("Scripting.FileSystemObject")
 
srcDir = objFSO.GetParentFolderName(WScript.ScriptFullName) & "\"
 
Set objInFile = objFSO.OpenTextFile(srcDir & "In.txt",1,False,0)
 
Set objOutFile = objFSO.OpenTextFile(srcDir & "Out.txt",2,True,0)
 
Do Until objInFile.AtEndOfStream
line = objInFile.ReadLine
If line = "" Then
objOutFile.WriteLine ""
Else
objOutFile.WriteLine Reverse_String(line)
End If
Loop
 
Function Reverse_String(s)
Dim arr, i
arr = Split(s," ")
For i = UBound(arr) To LBound(arr) Step -1
If arr(i) <> "" Then
If i = UBound(arr) Then
Reverse_String = Reverse_String & arr(i)
Else
Reverse_String = Reverse_String & " " & arr(i)
End If
End If
Next
End Function
 
objInFile.Close
objOutFile.Close
Set objFSO = Nothing
 
Output:

Output written to a file.

 ------------ Fire and Ice ----------

 Some say the world will end in fire,
 Some say in ice.
 From what I've tasted of desire
 I hold with those who favor fire.

 ... last paragraph elided ...

----------------------- Robert Frost

zkl[edit]

text:=Data(0,String,
#<<<
"---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------");
#<<<
 
text.pump(11,Data,fcn(s){ // process stripped lines
s.split(" ").reverse().concat(" ") + "\n" })
.text.print();
Output:
------------ Fire and Ice ----------

Some say the world will end in fire,
Some say in ice.
From what I've tasted of desire
I hold with those who favor fire.

... last paragraph elided ...

----------------------- Robert Frost