Phrase reversals: Difference between revisions

 

<br><br>

 

=={{header|Ada}}==

[[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>

 

=={{header|AppleScript}}==

 

AppleScript has a very small and patchy library of primitive functions. To accumulate a larger and more coherent library, which includes some higher order functions, we can try to overcome two architectural weaknesses: 1. Built-in functions have a different type from user functions, and 2. user functions are second class properties of (first class) script objects.

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

reversal phrase code rosetta"</pre>

 

 

 

set astid to AppleScript's text item delimiters

set AppleScript's text item delimiters to ""

set AppleScript's text item delimiters to space

set AppleScript's text item delimiters to linefeed

set AppleScript's text item delimiters to astid

 

{{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>

</pre>

 

 

PRINT REVERSE$(phrase$)

PRINT REV$(REVERSE$(phrase$))

 

{{out}}

<pre>

attesor edoc esarhp lasrever

reversal phrase code rosetta

</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

attesor edoc esarhp lasrever

reversal phrase code rosetta</pre>

 

=={{header|EchoLisp}}==

(define (string-reverse string)

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

"attesor edoc esarhp lasrever"

"reversal phrase code rosetta"

 

=={{header|Elena}}==

import extensions'text;

import system'routines;

console.printLine(reverse(phrase));

//Reverse each individual word in the string, maintaining original string order.

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

{{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}}==

 

(defun reverse-chars (line)

 

(defun reverse-words (line)

 

 

=={{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...

</pre>

 

 

 

 

 

 

{{out}}

<pre>

</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

reversal phrase code rosetta</pre>

 

 

=={{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}}

 

</pre>

 

=={{header|Kotlin}}==

 

 

fun main(args: Array<String>) {

println("Reversed string => $reversed")

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

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

 

{{out}}

Reversed order => reversal phrase code rosetta

</pre>

 

=={{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>

attesoR edoC esarhP lasreveR

lasreveR esarhP edoC attesoR

</pre>

 

=={{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

attesoR edoC esarhP lasreveR

</pre>

 

=={{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}}==

{{out}}

<pre>

</pre>

 

=={{header|Phixmonti}}==

dup reverse print 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

Words reversed: attesor edoc esarhp lasrever

Word order reversed: reversal phrase code rosetta</pre>

 

=={{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}}

\def\RSWend\RSWB\RevSingleWordi#1#2\RSWA{\RSWgobtoA#1}

%---

\def\firstchartonil#1#2\nil{#1}

\def\RevOrderSameWords#1{\RevOrderSameWordsi{}#1 \. \* \* \* \* \* \* \* \* \.}

\def\RevOrderSameWordsi#1#2 #3 #4 #5 #6 #7 #8 #9 {%

}

\def\ROSWend#1#2\.{\ROSWendi#1}

\def\RevOnlyWords#1{\edef\ROWtemp{\noexpand\RevOnlyWordsi{}#1 \noexpand\ROWquark\space}\ROWtemp}

\def\RevOnlyWordsi#1#2 {%

}

\def\ROWgoblastspace#1 \nil{#1}

\def\RevAll#1{\RevAlli{}#1 \. \* \* \* \* \* \* \* \* \.\:}

\def\RevAlli#1#2 #3 #4 #5 #6 #7 #8 #9 {%

}

\def\RAWend#1#2\.{\RAWendi#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>

reversal phrase code rosetta

</pre>

 

=={{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:

wordsWithReversedCharacters -> 'attesor edoc esarhp lasrever'

reversedWordOrder -> 'reversal phrase code rosetta'</pre>

 

=={{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

Each word reversed : attesor edoc esarhp lasrever

Word-order reversed : reversal phrase code rosetta</pre>

 

=={{header|REXX}}==

===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}}

Reverse words, same order: attesor edoc esarhp lasrever

Reverse order, same words: reversal phrase code rosetta

</pre>

 

=={{header|Sidef}}==

 

say str.reverse; # reversed string

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

{{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}}

3.) Reverse word order --> reversal phrase code rosetta</pre>

 

 

 

{{out}}

<pre>

</pre>

 

=={{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