Phrase reversals

Phrase reversals
You are encouraged to solve this task according to the task description, using any language you may know.

Given a string of space separated words containing the following phrase:

"rosetta code phrase reversal"

1. Reverse the string.
2. Reverse each individual word in the string, maintaining original string order.
3. Reverse the order of each word of the phrase, maintaining the order of characters in each word.

Show your output here.

See also

• Reverse a string
• Reverse words in a string

AWK

<lang awk># Usage: awk -f phrase_revers.awk function rev(s, del, n,i,a,r) {

  n = split(s, a, del)
  r = a[1]
  for(i=2; i <= n; i++) {r = a[i] del r }    
  return r

}

BEGIN {

 p0 = "Rosetta Code Phrase Reversal"

 fmt = "%-20s: %s\n"
 printf( fmt, "input",               p0 )
 printf( fmt, "string reversed",     rev(p0, "") )
 wr = rev(p0, " ")
 printf( fmt, "word-order reversed", wr )
 printf( fmt, "each word reversed",  rev(wr) )

}</lang>

Output:

input               : Rosetta Code Phrase Reversal
string reversed     : lasreveR esarhP edoC attesoR
word-order reversed : Reversal Phrase Code Rosetta
each word reversed  : attesoR edoC esarhP lasreveR

D

Partially lazy. <lang d>void main() {

   import std.stdio, std.range;

   immutable phrase = "rosetta code phrase reversal";
   phrase.retro.writeln;                          // Reversed string.
   phrase.splitter.map!retro.joiner(" ").writeln; // Words reversed.
   phrase.split.retro.joiner(" ").writeln;        // Word order reversed.

}</lang>

Output:

lasrever esarhp edoc attesor
attesor edoc esarhp lasrever
reversal phrase code rosetta

Go

Simple

<lang go>package main

import ( "fmt" "strings" )

const phrase = "rosetta code phrase reversal"

func revStr(s string) string { rs := make([]rune, len(s)) i := len(s) for _, r := range s { i-- rs[i] = r } return string(rs[i:]) }

func main() { fmt.Println("Reversed: ", revStr(phrase))

ws := strings.Fields(phrase) for i, w := range ws { ws[i] = revStr(w) } fmt.Println("Words reversed: ", strings.Join(ws, " "))

ws = strings.Fields(phrase) last := len(ws) - 1 for i, w := range ws[:len(ws)/2] { ws[i], ws[last-i] = ws[last-i], w } fmt.Println("Word order reversed:", strings.Join(ws, " ")) }</lang>

Output:

Reversed:            lasrever esarhp edoc attesor
Words reversed:      attesor edoc esarhp lasrever
Word order reversed: reversal phrase code rosetta

Alternative

<lang go>package main

import ( "fmt" "regexp" "sort" "strings" )

const phrase = "rosetta code phrase reversal"

type reversible interface { Len() int Swap(i, j int) }

func reverse(p reversible) { mid := p.Len() / 2 last := p.Len() - 1 for i := 0; i < mid; i++ { p.Swap(i, last-i) } }

type runeSlice []rune

func (p runeSlice) Len() int { return len(p) } func (p runeSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }

func reverseString(s string) string { r := runeSlice(s) reverse(r) return string(r) }

var rx = regexp.MustCompile(`\S*`)

func reverseWords(s string) string { return rx.ReplaceAllStringFunc(s, func(m string) string { return reverseString(m) }) }

func reverseWordOrder(s string) string { l := sort.StringSlice(strings.Fields(s)) reverse(l) return strings.Join(l, " ") }

func main() { fmt.Println("Reversed: ", reverseString(phrase)) fmt.Println("Words reversed: ", reverseWords(phrase)) fmt.Println("Word order reversed:", reverseWordOrder(phrase)) }</lang>

Output:

Reversed:            lasrever esarhp edoc attesor
Words reversed:      attesor edoc esarhp lasrever
Word order reversed: reversal phrase code rosetta

Java

Works with: Java version 1.5+

<lang java5>import java.util.Arrays;

public class PhraseRev{ private static String reverse(String x){ return new StringBuilder(x).reverse().toString(); }

private static <T> T[] reverse(T[] x){ T[] rev = Arrays.copyOf(x, x.length); for(int i = x.length - 1; i >= 0; i--){ rev[x.length - 1 - i] = x[i]; } return rev; }

private static String join(String[] arr, String joinStr){ StringBuilder joined = new StringBuilder(); for(int i = 0; i < arr.length; i++){ joined.append(arr[i]); if(i < arr.length - 1) joined.append(joinStr); } return joined.toString(); }

public static void main(String[] args){ String str = "rosetta code phrase reversal";

System.out.println("Straight-up reversed: " + reverse(str)); String[] words = str.split(" "); for(int i = 0; i < words.length; i++){ words[i] = reverse(words[i]); } System.out.println("Reversed words: " + join(words, " ")); System.out.println("Reversed word order: " + join(reverse(str.split(" ")), " ")); } }</lang>

Output:

Straight-up reversed: lasrever esarhp edoc attesor
Reversed words: attesor edoc esarhp lasrever
Reversed word order: reversal phrase code rosetta

Perl

<lang perl>my $s = "rosetta code phrase reversal"; my $rev_s = reverse($s); my $rev_ew = join(" ", reverse split(/ /,reverse $s)); my $rev_wo = join(" ", reverse split(/ /,$s));

printf "0. %-20s: %s\n", "input", $s; printf "1. %-20s: %s\n", "string reversed", $rev_s; printf "2. %-20s: %s\n", "each word reversed", $rev_ew; printf "3. %-20s: %s\n", "word-order reversed", $rev_wo;</lang>

Output:

0. input               : rosetta code phrase reversal
1. string reversed     : lasrever esarhp edoc attesor
2. each word reversed  : attesor edoc esarhp lasrever
3. word-order reversed : reversal phrase code rosetta

Perl 6

<lang perl6>my $s = 'rosetta code phrase reversal';

say 'Input  : ', $s; say 'String reversed  : ', $s.flip; say 'Each word reversed  : ', $s.words».flip; say 'Word-order reversed : ', $s.words.reverse;</lang>

Output:

Input               : rosetta code phrase reversal
String reversed     : lasrever esarhp edoc attesor
Each word reversed  : attesor edoc esarhp lasrever
Word-order reversed : reversal phrase code rosetta

PHP

This example is incomplete. Shows prompt "Word order reversed:" twice. Please ensure that it meets all task requirements and remove this message.

<lang php><?php // Initialize a variable with the input desired $strin = "rosetta code phrase reversal";

// Show user what original input was echo "Input: ".$strin."\n";

// Show the full input reversed echo "Reversed: ".strrev($strin)."\n";

// reverse the word letters in place $str_words_reversed = ""; $temp = explode(" ", $strin); foreach($temp as $word) $str_words_reversed .= strrev($word)." ";

// Show the reversed words in place echo "Word order reversed: ".$str_words_reversed."\n";

// reverse the word order while leaving the words in order $str_word_order_reversed = ""; $temp = explode(" ", $strin); for($i=(count($temp)-1); $i>=0; $i--) $str_word_order_reversed .= $temp[$i]." ";

// Show the reversal of the word order while leaving the words in order echo "Word order reversed: ".$str_word_order_reversed."\n"; </lang>

Input: rosetta code phrase reversal
Reversed: lasrever esarhp edoc attesor
Word order reversed: attesor edoc esarhp lasrever 
Word order reversed: reversal phrase code rosetta

Python

<lang python>>>> phrase = "rosetta code phrase reversal" >>> phrase[::-1] # Reversed. 'lasrever esarhp edoc attesor' >>> ' '.join(word[::-1] for word in phrase.split()) # Words reversed. 'attesor edoc esarhp lasrever' >>> ' '.join(word for word in phrase.split()[::-1]) # Word order reversed. 'reversal phrase code rosetta' >>> </lang>

Racket

<lang racket>#lang racket/base (require

 (only-in srfi/13 string-reverse)
 (only-in racket/string string-split string-join))

(define (phrase-reversal s)

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

(for-each displayln (phrase-reversal "rosetta code phrase reversal"))</lang>

Output:

lasrever esarhp edoc attesor
attesor edoc esarhp lasrever
reversal phrase code rosetta

Ruby

<lang ruby>str = "rosetta code phrase reversal"

puts str.reverse # Reversed string. puts str.split.map(&:reverse).join(" ") # Words reversed. puts str.split.reverse.join(" ") # Word order reversed.</lang>

Output:

lasrever esarhp edoc attesor
attesor edoc esarhp lasrever
reversal phrase code rosetta

Tcl

<lang tcl>set s "rosetta code phrase reversal"

1. Reverse all characters

puts [string reverse $s]

1. Reverse characters in each word

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

1. Reverse the words but not the characters

puts [lreverse $s]</lang>

Output:

lasrever esarhp edoc attesor
attesor edoc esarhp lasrever
reversal phrase code rosetta