Phrase reversals: Difference between revisions

{{trans|Python}}

 

print(reversed(phrase))

print(phrase.split(‘ ’).map(word -> reversed(word)).join(‘ ’))

 

{{out}}

 

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

BYTE i

 

ReverseWords(s,rev)

PrintE(rev)

{{out}}

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

[[http://rosettacode.org/wiki/Reverse_words_in_a_string#Ada]] is used.

 

 

procedure Phrase_Reversal is

Put_Line("2. Reverse words, same order: """ & Reverse_Words(Phrase) & """");

Put_Line("2. Reverse order, same words: """ & Reverse_Order(Phrase) & """");

 

{{out}}

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

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

PROC in place reverse = ( REF STRING str, INT start pos, INT end pos )VOID:

BEGIN

, original phrase, ": order reversed -> ", order reversed, newline

)

{{out}}

<pre>

Here is a simple illustration of unifying (and elevating) the function type by wrapping the built-in functions in user handlers (perhaps making some of them polymorphic where needed), and also obtaining first class status for ordinary user handler functions by 'lifting' them (for use as arguments in higher order functions) into a first class script object. (This process can be inlined, or abstracted out to an '''mReturn''' or '''mInject''' function).

 

 

-- reverseString, reverseEachWord, reverseWordOrder :: String -> String

on unwords(lstWords)

intercalate(space, lstWords)

{{out}}

<pre>"lasrever esarhp edoc attesor

===Idiomatic===

 

 

set astid to AppleScript's text item delimiters

set AppleScript's text item delimiters to astid

 

 

{{output}}

attesor edoc esarhp lasrever

 

=={{header|Arturo}}==

 

 

print ["(0)" phr]

print ["(1)" reverse phr]

print ["(2)" join.with:" " map split.words phr => reverse]

 

{{out}}

 

=={{header|AutoHotkey}}==

(

Rosetta Code Phrase Reversal

ExitApp

 

 

{{out}}

 

=={{header|AWK}}==

function rev(s, del, n,i,a,r) {

n = split(s, a, del)

printf( fmt, "word-order reversed", wr )

printf( fmt, "each word reversed", rev(wr) )

{{Out}}

<pre>

 

=={{header|BaCon}}==

 

PRINT REVERSE$(phrase$)

PRINT REV$(REVERSE$(phrase$))

 

{{out}}

<pre>

 

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

setlocal enabledelayedexpansion

%=== The Main Thing... ===%

set %var3%=!%var3%:~1,1000000!

goto :EOF

{{Out}}

<pre>Original: Rosetta Code phrase reversal

=={{header|Bracmat}}==

This example only works correctly with strings only consisting of byte-sized characters.

& rev$!text:?output1

& get$(!text,MEM):?words

$ ("0:\"" !text "\"\n1:\"" !output1 "\"\n2:\"" !output2 "\"\n3:\"" !output3 \"\n)

)

Output:

<pre>0:"rosetta code phrase reversal"

=={{header|C}}==

Working with C strings is often long-winded.

#include <stdio.h>

#include <string.h>

return 0;

}

{{Out}}

<pre>

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

 

using System.Linq;

namespace ConsoleApplication

}

}

 

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

#include <vector>

#include <algorithm>

reverse_copy(words.begin(), words.end(), std::ostream_iterator<std::string>(std::cout, " "));

std::cout << '\n' ;

{{Out}}

<pre>Input : rosetta code phrase reversal

 

=={{header|Clojure}}==

(def phrase "rosetta code phrase reversal")

(defn str-reverse [s] (apply str (reverse s)))

; Word order reversed

(apply str (interpose " " (reverse (split phrase #" "))))

{{out}}

<pre>"lasrever esarhp edoc attesor"

 

=={{header|COBOL}}==

program-id. phra-rev.

data division.

.

end program phra-rev.

{{out}}

<pre>

 

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

(defun split-string (str)

"Split a string into space separated words including spaces"

nil )

 

{{out}}<pre>(task "rosetta code phrase reversal")

 

=={{header|D}}==

Partially lazy.

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

 

phrase.splitter.map!retro.joiner(" ").writeln; // Words reversed.

phrase.split.retro.joiner(" ").writeln; // Word order reversed.

{{out}}

<pre>lasrever esarhp edoc attesor

 

=={{header|Dyalect}}==

//or you can use a built-in method String.reverse

print("1. \(reverse(str))")

print("2. \(reverseByWord(str))")

 

{{out}}

 

=={{header|EchoLisp}}==

(define (string-reverse string)

(list->string (reverse (string->list string))))

"attesor edoc esarhp lasrever"

"reversal phrase code rosetta"

 

=={{header|Elena}}==

ELENA 4.x :

import extensions'text;

import system'routines;

//Reverse the order of each word of the phrase, maintaining the order of characters in each word.

console.printLine(reverse(phrase.splitBy:" ".selectBy:(s => s + " ")))

{{out}}

<pre>

 

=={{header|Elixir}}==

 

IO.puts String.reverse(str)

IO.puts String.split(str) |> Enum.map(&String.reverse(&1)) |> Enum.join(" ")

 

{{out}}

 

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

(mapconcat 'identity (reverse (split-string words sep)) sep))

 

(terpri)

(princ (reverse-words line))

 

{{out}}

 

=={{header|Factor}}==

USE: splitting

 

 

"rosetta code phrase reversal" [ reverse-string ] [ reverse-words ] [ reverse-phrase ] tri

{{out}}

<pre>

By identifying the first and last character position of each word in TEXT (or equivalently, their indices in ATXT) and storing them in arrays IST and LST, the i'th word can be fingered via IST(i) to LST(i) and of course a DO-loop can step in either direction.

 

L1 = L1 + 1

Would be rather more structured and involve fewer GO TOs and their labels, but alas, modern Fortran specifies that there is no specification as to whether or not both terms of an expression such as (A '''and''' B) will always be evaluated or instead there will be a shortcut: if A is ''false'' then the B term is ignored. And here, the A term checks whether or not L1 is within bounds and if it is not, then the B term should not be evaluated, not just because of the waste of effort but because to do so might involve accessing outside the definition of ATXT. As when the scan chases through the trailing spaces. One could make the array one longer, or rather, <code>L = LEN(TEXT) - 1</code> for this case but that would be messy, require explanation, be easily forgotten, and, typical ad-hoc testing would be unlikely to detect the mistake.

 

IF (ATXT(L1).GT." ") EXIT

 

CHARACTER*(66) TEXT !Holds the text. Easily long enough.

CHARACTER*1 ATXT(66) !But this is what I play with.

 

22 FORMAT (A36,":",66A1)

 

And the output is...

 

=={{header|FreeBASIC}}==

 

Sub split (s As Const String, sepList As Const String, result() As String)

Print : Print

Print "Press any key to quit"

 

{{out}}

Frink also has smart, human-language aware functions for splitting a string into a list of words. It correctly handles hyphenated words, numbers, and punctuation. It also has a built-in smart <CODE>reverseWords</CODE> function to reverse the words in a string.

 

println[reverse[a]]

println[join["", map["reverse", wordList[a]]]]

// Alternately, the above could be

// join["", reverse[wordList[a]]]

 

{{out}}

=={{header|Gambas}}==

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

Dim sString As String = "rosetta code phrase reversal" 'The string

Dim sNewString, sTemp As String 'String variables

Print "Words reversed = \t" & sNewString 'Print words reversed

 

Output:

<pre>

=={{header|Go}}==

===Simple===

 

import (

}

fmt.Println("Word order reversed:", strings.Join(ws, " "))

{{out}}

<pre>

</pre>

===Alternative===

 

import (

fmt.Println("Words reversed: ", reverseWords(phrase))

fmt.Println("Word order reversed:", reverseWordOrder(phrase))

{{out}}

<pre>

 

=={{header|Groovy}}==

 

def text = 'rosetta code phrase reversal'

println "Reversed: ${phaseReverse(text) { it.reverse().collect { it.reverse() } } }"

println "Reversed Words: ${phaseReverse(text) { it.collect { it.reverse() } } }"

{{out}}

<pre>Original: rosetta code phrase reversal

 

=={{header|Haskell}}==

reverseString = reverse

 

(putStrLn . unlines) $

[reverseString, reverseEachWord, reverseWordOrder] <*>

{{Out}}

<pre>lasrever esarhp edoc attesor

 

=={{header|IS-BASIC}}==

110 LET S$="Rosetta Code Pharse Reversal"

120 PRINT S$

340 NEXT

350 LET REVERSEC$=LTRIM$(T$)

 

=={{header|J}}==

'''Solution:'''

reverseString=: |.

reverseWords=: |.&.>&.getWords

'''Usage:'''

(reverseWordOrder , reverseWords ,: reverseString) phrase

reversal phrase code rosetta

attesor edoc esarhp lasrever

 

=={{header|Java}}==

{{works with|Java|1.5+}}

 

public class PhraseRev{

System.out.println("Reversed word order: " + join(reverse(str.split(" ")), " "));

}

{{out}}

<pre>Straight-up reversed: lasrever esarhp edoc attesor

=={{header|JavaScript}}==

===ES5===

return [

p.split('').reverse().join(''),

].join('\n');

 

{{out}}

<pre>lasrever esarhp edoc attesor

 

===ES6===

'use strict'

 

], ["rosetta code phrase reversal"])

);

{{Out}}

<pre>lasrever esarhp edoc attesor

=={{header|jq}}==

{{works with|jq|1.4}}

 

"rosetta code phrase reversal"

"1. string reversed: \(reverse_string)",

"2. each word reversed: \($words | map(reverse_string) | join(" "))",

{{out}}

$ jq -r -n -f Phrase_reversals.jq

 

=={{header|Julia}}==

s = "rosetta code phrase reversal"

 

t = join(reverse(split(s, " ")), " ")

println(" ", t)

 

{{out}}

 

=={{header|K}}==

/ Rosetta code phrase reversal

/ phraserev.k

revwordorder: {rw:""; while[~(x~""); x: getnxtwd x;rw:" ",rw;rw:w,rw];:-1 _ rw}

 

The output of a session is given below:

{{out}}

 

=={{header|Klingphix}}==

"Rosetta Code Phrase Reversal" dup ?

len [drop pop swap reverse print " " print] for drop nl nl

 

 

=={{header|Kotlin}}==

 

fun reverseEachWord(s: String) = s.split(" ").map { it.reversed() }.joinToString(" ")

println("Reversed words => ${reverseEachWord(original)}")

println("Reversed order => ${reverseEachWord(reversed)}")

 

{{out}}

 

=={{header|Lambdatalk}}==

{W.reverse word} reverses characters in a word

{S.reverse words} reverses a sequence of words

{S.map W.reverse {S}} -> attesor edoc esarhp lasrever

{S.reverse {S}} -> reversal phrase code rosetta

 

=={{header|Lua}}==

function reverseEach (t)

local rev = {}

print("1. " .. str:reverse())

print("2. " .. table.concat(reverseEach(tab), " "))

{{out}}

<pre>1. lasrever esarhp edoc attesor

 

=={{header|Maple}}==

str := "rosetta code phrase reversal":

print(StringTools:-Reverse(str)):

print(StringTools:-Join(convert(lst,list)," ")):

#reverse word order

{{Out|Output}}

<pre> "lasrever esarhp edoc attesor"

 

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

 

reverseWords[phrase_String] :=

 

{phrase, reverseWords@phrase, reverseLetters@phrase,

 

{{out}}<pre>

 

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

function r=revstr(s,d)

slist=strsplit(s,d);

 

revstr('Rosetta Code Phrase Reversal', ' ')

 

 

 

=={{header|MiniScript}}==

 

// general sequence reversal function

// 3. Reverse the order of each word of the string, maintaining the order of characters in each word.

print reverse(phrase.split).join

{{out}}

<pre>lasrever esarhp edoc attesor

 

=={{header|MUMPS}}==

set str="",len=$length(string," ")

for i=1:1:len set $piece(str," ",i)=$piece(string," ",len-i+1)

write $reverse(string),!

write str,!

 

{{out}}<pre>Rosetta Code Phrase Reversal

 

=={{header|Nim}}==

 

const Phrase = "rosetta code phrase reversal"

echo "Reversed phrase: ", reversed(Phrase).join()

echo "Reversed words: ", Phrase.split().mapIt(reversed(it).join()).join(" ")

 

If we prefer to avoid using modules “algorithm” and “sequtils” and produce somewhat more efficient (but also more verbose) code, here is another solution:

 

 

const Phrase = "rosetta code phrase reversal"

echo "Reversed phrase: ", reversed(Phrase)

echo "Reversed words: ", reversedWords(Phrase)

 

{{out}}

=={{header|Oforth}}==

 

"rosetta code phrase reversal" words map(#reverse) unwords println

 

{{out}}

=={{header|Perl}}==

 

my $s = "rosetta code phrase reversal";

 

 

# Or, using a regex:

 

{{out}}

 

=={{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;">"rosetta code phrase reversal"</span><span style="color: #0000FF;">,</span>

<span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #000000;">test</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">reverse</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: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #000000;">test</span><span style="color: #0000FF;">)))})</span>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

"Rosetta Code Phrase Reversal" dup print nl

dup reverse print nl

split dup reverse len for . pop swap print " " print endfor . nl

{{out}}

<pre>Rosetta Code Phrase Reversal

 

=={{header|PHP}}==

// Initialize a variable with the input desired

$strin = "rosetta code phrase reversal";

// Show the reversal of the word order while leaving the words in order

echo "Word order reversed: ".$str_word_order_reversed."\n";

 

<pre>Input: rosetta code phrase reversal

 

=={{header|Picat}}==

 

go =>

println([reverse(W) : W in S.split()].join(' ')),

println(reverse(S.split()).join(' ')),

 

{{out}}

 

=={{header|PicoLisp}}==

(prinl (reverse S))

(prinl (glue " " (mapcar reverse L)))

Output:

<pre>lasrever esarhp edoc attesor

 

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

reverser: procedure options (main); /* 19 August 2015 */

declare (phrase, r, word) character (100) varying;

 

end reverser;

Output:

<pre>

 

=={{header|plainTeX}}==

\def\RevSingleWord#1{\RevSingleWordi{}#1\RSWA\RSWB\RSWB\RSWB\RSWB\RSWB\RSWB\RSWB\RSWB\RSWA}

\def\RevSingleWordi#1#2#3#4#5#6#7#8#9{\RSWgobtoB#9\RSWend\RSWB\RevSingleWordi{#9#8#7#6#5#4#3#2#1}}

Reverse order, same words&\RevOrderSameWords{rosetta code phrase reversal}\cr

Reverse only words&\RevOnlyWords{rosetta code phrase reversal}\cr\crcr}

 

pdf or dvi output looks like:

 

=={{header|PowerShell}}==

function reverse($a, $sep = "") {

if($a.Length -gt 0) {

$task2

$task3

<b>Output:</b>

<pre>

 

=={{header|PureBasic}}==

 

If OpenConsole("rosetta code phrase reversal")

Input()

{{out}}

<pre>Original: rosetta code phrase reversal

=={{header|Python}}==

These examples use the [https://docs.python.org/2/whatsnew/2.3.html#extended-slices extended slicing] notation of <code>[::-1]</code> to reverse strings and lists of strings:

>>> phrase[::-1] # Reversed.

'lasrever esarhp edoc attesor'

>>> ' '.join(phrase.split()[::-1]) # Word order reversed.

'reversal phrase code rosetta'

 

 

Or, variously composing three reusable abstractions – '''reverse''', '''words''', and '''unwords''':

 

 

 

 

if __name__ == '__main__':

{{Out}}

<pre>rosetta code phrase reversal:

=={{header|Quackery}}==

 

 

3 times dup

say "1. " reverse echo$ cr

say "2. " nest$ witheach [ reverse echo$ sp ] cr

 

{{out}}

=={{header|Racket}}==

 

(require

(only-in srfi/13 string-reverse)

(string-join (reverse (string-split s)))))

 

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

 

put 'Input : ', $s;

put 'String reversed : ', $s.flip;

put 'Each word reversed : ', $s.words».flip;

{{out}}

<pre>Input : rosetta code phrase reversal

===version 1===

Working with REXX (strings and words) is trivial.

r1=reverse(s)

r2=''

say "string reversed : " r1

say "each word reversed : " r2

{{out}}

<pre>input : rosetta code phrase reversal

 

===version 2===

parse arg $ /*obtain optional arguments from the CL*/

if $='' then $= "rosetta code phrase reversal" /*Not specified? Then use the default.*/

say ' original phrase reversed: ' reverse($)

say ' reversed individual words: ' strip(L)

{{out|output|text=&nbsp; when using the default input string:}}

<pre>

 

=={{header|Ring}}==

aString = "Welcome to the Ring Language"

bString = ""

next

return bString

 

Output:

 

=={{header|Ruby}}==

 

puts str.reverse # Reversed string.

puts str.split.map(&:reverse).join(" ") # Words reversed.

 

{{out}}

 

=={{header|Rust}}==

string.chars().rev().collect::<String>()

}

}

}

 

=={{header|Scala}}==

val phrase = scala.io.StdIn.readLine

println(phrase.reverse)

println(phrase.split(' ').map(_.reverse).mkString(" "))

println(phrase.split(' ').reverse.mkString(" "))

 

{{out}}

 

=={{header|Seed7}}==

 

const proc: main is func

end for;

writeln("Reverse order, same words:" rpad 27 <& join(wordList, ' '));

 

{{out}}

 

=={{header|SenseTalk}}==

put phrase reversed

put (the reverse of each word of phrase) joined by space

put (each word of phrase) reversed joined by space

{{out}}

<pre>

 

=={{header|Sidef}}==

 

say str.reverse; # reversed string

say str.words.map{.reverse}.join(' '); # words reversed

{{out}}

<pre>lasrever esarhp edoc attesor

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

str := 'rosetta code phrase reversal'.

 

Transcript showCR:(str reversed).

Transcript showCR:(((str splitBy:$ ) collect:#reversed) join:$ ).

{{out}}

<pre>lasrever esarhp edoc attesor

 

=={{header|Swift}}==

func reverseString(s:String)->String{

var temp = [Character]()

print(reverseWord(s:str))

print(flipString(s:str))

 

=={{header|Tcl}}==

# Reverse all characters

puts [string reverse $s]

puts [lmap word $s {string reverse $word}]

# Reverse the words but not the characters

{{out}}

<pre>

{{works with|bash}}

{{works with|ksh93}}

echo "Original string ----------------------> "$s1

 

while [ $word_num != 0 ];do

echo -n $(echo $s1|cut -d " " -f $word_num);echo -n " "

 

{{out}}

{{works with|bash}}

{{works with|ksh93}}

echo "Original string --> "$s1

 

while [ $word_num != 0 ];do

echo -n $(echo $s1|cut -d " " -f $word_num);echo -n " "

 

{{out}}

=={{header|VBA}}==

 

Option Explicit

 

Reverse_the_order_of_each_word = Trim(strTemp)

End Function

{{out}}

<pre>Original String : rosetta code phrase reversal

 

=={{header|VBScript}}==

Phrase = "rosetta code phrase reversal"

 

Next

End Function

{{Out}}

<pre>

 

=={{header|Vlang}}==

fn main() {

str := 'rosetta code phrase reversal'

println('Char-Word Reverse: ${words.map(it.reverse()).join(' ')}')

println('Word Reverse: ${words.reverse().join(' ')}')

{{out}}

<pre>Original: rosetta code phrase reversal

 

=={{header|Wren}}==

System.print("Input : %(s)")

System.print("String reversed : %(s[-1..0])")

System.print("Each word reversed : %(s.split(" ").map { |w| w[-1..0] }.join(" "))")

 

{{out}}

 

=={{header|Yabasic}}==

 

dim word$(1)

return rw$

{{out}}

<pre>Rosetta Code Phrase Reversal

 

=={{header|zkl}}==

rosetta code phrase reversal

 

 

zkl: str.split().reverse().concat(" ") #3