Reverse words in a string: Difference between revisions

{{trans|Python}}

 

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

 

 

L(line) text.split("\n")

 

{{out}}

 

=={{header|Action!}}==

BYTE i,j,k,beg,end

 

Test("")

Test("Frost Robert -----------------------")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Reverse_words_in_a_string.png Screenshot from Atari 8-bit computer]

To Split a string into words, we define a Package "Simple_Parse". This package is also used for the Phrase Reversal Task [[http://rosettacode.org/wiki/Phrase_reversals#Ada]].

 

-- a very simplistic parser, useful to split a string into words

-- else Next_Word sets Point to S'Last+1 and returns ""

 

The implementation of "Simple_Parse":

 

function Next_Word(S: String; Point: in out Positive) return String is

end Next_Word;

 

===Main Program===

 

 

procedure Reverse_Words is

Put_Line(Reverse_Words(Get_Line)); -- poem is read from standard input

end loop;

 

=={{header|Aime}}==

list l, x;

text s, t;

}

o_newline();

{{out}}

<pre>------------ Fire and Ice ----------

 

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

# a word is a sequence of non-blank characters #

PROC reverse word order = ( STRING original phrase )STRING:

print( ( reverse word order ( " " ), newline ) );

print( ( reverse word order ( "Frost Robert -----------------------" ), newline ) )

{{out}}

<pre>

=={{header|AppleScript}}==

 

 

unlines(map(reverseWords, |lines|("---------- Ice and Fire ------------

end if

end mReturn

{{out}}

 

 

=={{header|Applesoft BASIC}}==

110 DATA" "

120 DATA"FIRE, IN END WILL WORLD THE SAY SOME"

350 IF C$ <> " " THEN W$ = C$ + W$ : NEXT I

360 RETURN

 

=={{header|Arturo}}==

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

[join.with:" " reverse split.words &]

 

 

{{out}}

 

=={{header|AutoHotkey}}==

(Join`r`n

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

Output .= Line "`n", Line := ""

}

 

=={{header|AWK}}==

# syntax: GAWK -f REVERSE_WORDS_IN_A_STRING.AWK

BEGIN {

exit(0)

}

{{Output}}

<pre>

 

=={{header|BaCon}}==

PRINT REV$("---------- Ice and Fire ------------")

PRINT

PRINT

PRINT REV$("Frost Robert -----------------------")

Using the REV$ function which takes a sentence as a delimited string where the items are separated by a delimiter (the space character is the default delimiter).

{{out}}

 

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

 

::The Main Thing...

echo.%reversed%

goto :EOF

{{Out}}

<pre>

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

open (source, "m:\text.txt")

textEnt$ = ""

print textSal$[n];

next n

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

\ 'FNreverse("")\

\ 'FNreverse("fire, in end will world the say Some")\

LOCAL sp%

sp%=INSTR(s$," ")

 

{{out}}

 

=={{header|Bracmat}}==

fire, in end will world the say Some

& !output reverse$!text:?output

& out$str$!output

{{out}}

<pre>------------ Fire and Ice ----------

 

=={{header|Burlesque}}==

blsq ) "It is not raining"wd<-wd

"raining not is It"

blsq ) "ice. in say some"wd<-wd

"some say in ice."

 

=={{header|C}}==

#include <ctype.h>

 

 

return 0;

Output is the same as everyone else's.

 

=={{header|C sharp|C#}}==

 

public class ReverseWordsInString

}

}

 

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

#include <algorithm>

#include <functional>

return 0;

}

 

===Alternate version===

#include <string>

#include <iostream>

return system( "pause" );

}

 

=={{header|Clojure}}==

(def poem

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

(dorun

(map println (map #(apply str (interpose " " (reverse (re-seq #"[^\s]+" %)))) (clojure.string/split poem #"\n"))))

Output is the same as everyone else's.

 

=={{header|COBOL}}==

program-id. rev-word.

data division.

.

end program rev-word.

{{out}}

<pre>

=={{header|CoffeeScript}}==

{{trans|JavaScript}}

fire, in end will world the say Some\n

ice. in say Some\n

s.split('\n').map((l) -> l.split(/\s/).reverse().join ' ').join '\n'

 

{{out}}

As JavaScript.

 

=={{header|Common Lisp}}==

(labels

((iter (s lst)

(loop for line = (read-line s NIL)

while line

 

Output is the same as everyone else's.

 

=={{header|D}}==

import std.stdio, std.string, std.range, std.algorithm;

 

writefln("%(%-(%s %)\n%)",

text.splitLines.map!(r => r.split.retro));

The output is the same as the Python entry.

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

end;

ReadLn;

The output is the same as the Pascal entry.

 

=={{header|EchoLisp}}==

Using a here-string input :

(define S #<<

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

(for/list ((line (string-split S "\n")))

(string-join (reverse (string-split line " ")) " ")))

{{out}}

<pre>

=={{header|Elena}}==

ELENA 5.0:

import system'routines;

console.writeLine()

}

 

=={{header|Elixir}}==

def reverse_words(txt) do

txt |> String.split("\n") # split lines

|> Enum.join("\n") # rejoin lines

end

Usage:

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

"""

 

 

=={{header|Elm}}==

 

reversedPoem =

String.trim """

poem =

reverseLinesWords reversedPoem

 

=={{header|Emacs Lisp}}==

 

(insert

(format "%s\n"

"... elided paragraph last ..."

""

 

{{out}}

 

=={{header|F_Sharp|F#}}==

//Reverse words in a string. Nigel Galloway: July 14th., 2021

[" ---------- Ice and Fire ------------ ";

" ";

" Frost Robert ----------------------- "]|>List.map(fun n->n.Split " "|>Array.filter((<>)"")|>Array.rev|>String.concat " ")|>List.iter(printfn "%s")

{{out}}

<pre>

</pre>

=={{header|Factor}}==

IN: rosetta-code.reverse-words

 

Frost Robert -----------------------"

 

{{out}}

<pre>

=={{header|Forth}}==

The word "parse-name" consumes a word from input stream and places it on the stack. The word "type" takes a word from the data stack and prints it. Calling these two words before and after the recursive call effectively reverses a string.

: (reverse) parse-name not-empty? IF recurse THEN type space ;

: reverse (reverse) cr ;

reverse ... elided paragraph last ...

reverse

 

'''Output'''

Fortran syntax is mostly Fortran 77.

 

character*40 words

character*40 reversed

end

 

 

Output from comand: <b>cat frostPoem.txt | reverse</b><p>

 

=={{header|FreeBASIC}}==

 

Sub split (s As String, sepList As String, result() As String, removeEmpty As Boolean = False)

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Frink}}==

lines=split["\n",

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

for line = lines

println[join[" ", reverse[split[%r/\s+/, line]]]]

 

=={{header|FutureBasic}}==

include "NSLog.incl"

 

 

HandleEvents

 

Output:

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=c81c1bbf94e856035fd382015d208272 Click this link to run this code]'''

Dim sString As New String[10] 'Array for the input text

Dim sLine As New String[] 'Array of each word in a line

Print sOutput 'Print the output

 

Output:

<pre>

 

=={{header|Gema}}==

 

=={{header|Go}}==

 

import (

fmt.Println(t)

}

{{out}}

<pre>

 

=={{header|Groovy}}==

.append('---------- Ice and Fire ------------\n')

.append(' \n')

text.eachLine { line ->

println "$line --> ${line.split(' ').reverse().join(' ')}"

{{output}}

<pre>---------- Ice and Fire ------------ --> ------------ Fire and Ice ----------

 

=={{header|Haskell}}==

revstr :: String -> String

revstr = unwords . reverse . words -- point-free style

\\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"

 

Works in both languages:

every write(rWords(&input))

end

procedure genWords()

while w := 1(tab(upto(" \t")),tab(many(" \t"))) || " " do suspend w

 

{{out}} for test file:

Treated interactively:

 

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

 

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

 

The verb phrase <code>( [: ; @ |. [: < ;. 1 ' ' , ])</code> 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.

Another approach:

 

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

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

 

produces:

 

=={{header|Java}}==

 

static final String[] lines = {

}

}

{{works with|Java|8+}}

 

import static java.util.Arrays.stream;

;

}

 

{{out}}

 

=={{header|JavaScript}}==

"---------- Ice and Fire ------------\n\

\n\

console.log(

reverseString(strReversed)

 

Output:

 

=={{header|jq}}==

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

 

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

 

... last paragraph elided ...

 

 

=={{header|Jsish}}==

From Javascript entry.

"---------- Ice and Fire ------------\n

fire, in end will world the say Some

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

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

<pre>julia> revstring("Hey you, Bub!")

"Bub! you, Hey"

 

=={{header|Kotlin}}==

 

fun main() {

)

sl.forEach { println(reversedWords(it)) }

 

{{out}}

 

=={{header|Ksh}}==

#!/bin/ksh

 

... elided paragraph last ...

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

{{out}}<pre>

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

=={{header|Lambdatalk}}==

This answer illustrates how a missing primitive (line_split) can be added directly in the wiki page.

1) We write a function

 

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

 

=={{header|Liberty BASIC}}==

for i = 1 to 10

read string$

data ""

data "Frost Robert -----------------------"

{{Out}}

<pre>------------ Fire and Ice ----------

=={{header|LiveCode}}==

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 with i = the number of words of txtln down to 1

put word i of txtln & space after txtrev

put cr after txtrev -- preserve line

end repeat

 

=={{header|LiveScript}}==

poem =

"""

reverse-string = (.split '\n') >> (.map reverse-words) >> (.join '\n')

reverse-string poem

 

=={{header|Logo}}==

This version just reads the words from standard input.

 

make "line readlist

print reverse :line

] [word? :line]

 

{{Out}}

See below for original entry and the input string under variable 's'. Here is a significantly shorter program.

 

local lines = {}

for line in (s .. "\n"):gmatch("(.-)\n") do

end

print(table.concat(lines, "\n"))

 

 

]]

 

local res = {}

for i = #a, 1, -1 do

for line, nl in s:gmatch("([^\n]-)(\n)") do

print(table.concat(table.reverse(splittokens(line)), ' '))

 

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

 

=={{header|Maple}}==

input := readline("input.txt"):

if input = 0 then break: fi:

input := StringTools:-Join(ListTools:-Reverse(StringTools:-Split(input, " "))," "):

printf("%s\n", input):

{{Out|Output}}

<pre>------------ Fire and Ice ----------

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

fire, in end will world the say Some

linesWithReversedWords =

StringJoin[Riffle[#, " "]] & /@ reversedWordArray;

{{out}}

<pre>------------ Fire and Ice ----------

 

=={{header|MATLAB}} / {{header|Octave}}==

testStr = {'---------- Ice and Fire ------------' ; ...

'' ; ...

strOut = strtrim(sprintf('%s ', words{end:-1:1}));

end

{{out}}

<pre>------------ Fire and Ice ----------

 

=={{header|MAXScript}}==

-- MAXScript : Reverse words in a string : N.H. 2019

--

) -- end of while eof

)

{{out}}

Output to MAXScript Listener:

 

=={{header|MiniScript}}==

"| ---------- Ice and Fire ------------ |",

"| |",

end while

print newLine.join

{{out}}

<pre>

{{trans|Pascal}}

{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}

MODULE ReverseWords;

 

END;

END ReverseWords.

 

=={{header|Nanoquery}}==

tokens = split(string, " ")

if len(tokens) = 0

for line in split(data, "\n")

println reverse_words(line)

{{out}}

<pre>------------ Fire and Ice ----------

{{works with|Q'Nial Version 6.3}}

 

# Define a function to convert a list of strings to a single string.

join is rest link (' ' eachboth link)

'' \

'Poe Edgar -----------------------'

 

{{out}}

 

=={{header|Nim}}==

 

let text = """---------- Ice and Fire ------------

 

for line in text.splitLines():

{{out}}

<pre>------------ Fire and Ice ----------

 

=={{header|Objeck}}==

 

class Reverselines {

};

}

 

{{out}}

 

=={{header|OCaml}}==

let input = ["---------- Ice and Fire ------------";

"";

let reversed = List.map List.rev splitted in

let final = List.map (String.concat " ") reversed in

Sample usage

<pre>$ ocaml reverse.ml

=={{header|Oforth}}==

 

s words reverse unwords ;

 

"... elided paragraph last ... " revWords println

" " revWords println

 

{{out}}

=={{header|Pascal}}==

Free Pascal 3.0.0

{$H+}

 

end;

readln;

{{out}}

<pre>----------- Fire and Ice ----------

 

=={{header|Perl}}==

__DATA__

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

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

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">=</span><span style="color: #008000;">"""

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</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>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

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

else drop endif

drop nl

{{out}}

<pre>

 

=={{header|PHP}}==

<?php

 

 

'''Output''':

 

 

Some say the world will end in fire,

... last paragraph elided ...

 

 

=={{header|PicoLisp}}==

(in "FireIce.txt"

(until (eof)

(prinl (glue " " (flip (split (line) " "))))))

{{Out}}

Same as anybody else.

 

=={{header|Pike}}==

fire, in end will world the say Some

foreach(story/"\n", string line)

write("%s\n", reverse(line/" ")*" ");

 

=={{header|PL/I}}==

declare (s, reverse) character (50) varying;

declare (i, j) fixed binary;

put edit ('---> ', reverse) (col(40), 2 A);

end;

{{out}}

<pre>

=={{header|PowerShell}}==

{{works with|PowerShell|4.0}}

Function Reverse-Words($lines) {

$lines | foreach {

 

Reverse-Words($lines)

 

'''output''' :

 

=={{header|PureBasic}}==

" " +#CRLF$+

"fire, in end will world the say Some" +#CRLF$+

Next

Input()

{{out}}

<pre>

 

=={{header|Python}}==

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

 

Frost Robert -----------------------'''

 

 

'''Output''':

 

 

Some say the world will end in fire,

... last paragraph elided ...

 

 

=={{header|Quackery}}==

 

$ ""

$ " fire, in end will world the say Some "

witheach

[ echo$ sp ]

 

{{out}}

=={{header|R}}==

 

whack <- function(s) {

paste( rev( unlist(strsplit(s, " "))), collapse=' ' ) }

 

for (line in poem) cat( whack(line), "\n" )

 

{{out}}

(Everything that happens in R is a function-call.)

 

> `{` <- function(s) rev(unlist(strsplit(s, " ")))

> {"one two three four five"}

[1] "five" "four" "three" "two" "one"

 

You had better restart your REPL after trying this.

 

=={{header|Racket}}==

 

(require racket/string)

(begin (displayln (split-reverse l))

(loop (read-line poem-port))))))

 

In Wheeler-readable/sweet notation (https://readable.sourceforge.io/) as implemented by Asumu Takikawa (https://github.com/takikawa/sweet-racket):

#lang sweet-exp racket/base

require racket/string

displayln split-reverse(l)

loop read-line(poem-port)

 

=={{header|Raku}}==

(formerly Perl 6)

We'll read input from stdin

{{out}}

<pre>------------ Fire and Ice ----------

 

=={{header|Red}}==

foreach line

split

print reverse split line " "

]

 

=={{header|REXX}}==

===natural order===

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

@.=; @.1 = "---------- Ice and Fire ------------"

@.2 = ' '

 

say $ /*display the newly constructed line. */

'''output''' &nbsp; when using the (internal text) ten lines of input:

<pre>

===reverse order===

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

@.=; @.1 = "---------- Ice and Fire ------------"

@.2 = ' '

 

say $ /*display the newly constructed line. */

'''output''' &nbsp; is the same as the 1^st REXX version. <br><br>

 

=={{header|Ring}}==

aList = str2list("

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

for y in aList2 see y + " " next see nl

next

 

Output

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

 

... last paragraph elided ...

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

 

=={{header|Ruby}}==

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

 

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

EOS

 

Output the same as everyone else's.

 

=={{header|Run BASIC}}==

read string$

j = 1

data "... elided paragraph last ..."

data ""

Output:

<pre>------------ Fire and Ice ----------

 

=={{header|Rust}}==

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

.collect::<Vec<_>>() // Collect lines into Vec<String>

.join("\n")); // Concatenate lines into String

 

=={{header|S-lang}}==

["---------- Ice and Fire ------------",

"fire, in end will world the say Some",

array_reverse(ln);

() = printf("%s\n", strjoin(ln, " "));

{{out}}

<pre>------------ Fire and Ice ----------

{{works with|Scala|2.9.x}}

 

 

"""| ---------- Ice and Fire ------------

.foreach{println}

 

{{out}}

{{works with|Gauche Scheme}}

 

(for-each

(lambda (s) (print (string-join (reverse (string-split s #/ +/)))))

Frost Robert -----------------------"

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

<b>Output:</b>

<pre>

 

=={{header|sed}}==

 

G

s/^[[:space:]]*\([^[:space:]][^[:space:]]*\)\(.*\n\)/\2 \1/

t loop

 

=={{header|Seed7}}==

 

const array string: lines is [] (

writeln;

end for;

 

{{out}}

 

=={{header|SenseTalk}}==

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

 

put (each word of it) reversed joined by space

end repeat

{{out}}

<pre>

 

=={{header|Sidef}}==

 

__DATA__

... elided paragraph last ...

 

 

=={{header|Smalltalk}}==

poem := '---------- Ice and Fire ------------

 

(poem lines collect: [ :line | ((line splitOn: ' ') reverse) joinUsing: ' ' ]) joinUsing: (String cr).

 

{{out}}

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

 

 

fire, in end will world the say Some

 

print();

 

=={{header|Standard ML}}==

" ---------- Ice and Fire ------------ ",

" ",

val revWords = String.concatWith " " o rev o String.tokens Char.isSpace

 

 

=={{header|Swift}}==

 

// convenience extension for better clarity

let output = input.lines.map { $0.words.reverse().joinWithSeparator(" ") }.joinWithSeparator("\n")

 

{{out}}

<pre>

 

=={{header|Tailspin}}==

def input: ['---------- Ice and Fire ------------',

'',

$input... -> '$ -> words -> $(last..first:-1)...;

' -> !OUT::write

 

=={{header|Tcl}}==

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

""

# This would also work for data this simple:

### puts [lreverse $line]

{{out}}

<pre>

Alternatively…

{{works with|Tcl|8.6}}

 

=={{header|TXR}}==

Run from command line:

'''Solution:'''

@ (some)

@(coll)@{words /[^ ]+/}@(end)

@ (end)

@(end)

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

i.e.

not

 

=={{header|UNIX Shell}}==

{{works with|bash}}

for ((i=${#words[@]}-1; i>=0; i--)); do

printf "%s " "${words[i]}"

 

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

{{works with|ksh}}

 

=={{header|VBA}}==

Option Explicit

 

ReverseLine = Join(R, Separat)

End If

{{Out}}

<pre>------------- Fire And Ice -------------

 

=={{header|VBScript}}==

Option Explicit

 

objOutFile.Close

Set objFSO = Nothing

 

{{Out}}

 

=={{header|Vlang}}==

mut n := [

"---------- Ice and Fire ------------",

println(t)

}

 

 

'''Simpler version:'''

"---------- Ice and Fire ------------",

" ",

it.fields().reverse().join(' ').trim_space()

).join('\n')

 

 

 

=={{header|Wren}}==

"---------- Ice and Fire ------------",

" ",

tokens = tokens[-1..0]

System.print(tokens.join(" "))

 

{{out}}

 

=={{header|XBS}}==

(x=="")&=>send x+"<br>";

set sp = x::split(" ");

foreach(v of lines){

log(revWords(v));

{{out}}

<pre>

 

=={{header|XPL0}}==

def LF=$0A, CR=$0D;

 

Text(0, Str);

CrLf(0);

 

{{out}}

 

=={{header|Yabasic}}==

data " "

data " fire, in end will world the say Some "

break

end if

 

=={{header|zkl}}==

#<<<

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

text.pump(11,Data,fcn(s){ // process stripped lines

s.split(" ").reverse().concat(" ") + "\n" })

{{out}}

<pre>