Phrase reversals: Difference between revisions
(Added Ruby) |
(→Tcl: Added implementation) |
||
Line 248: | Line 248: | ||
puts str.split.reverse.join(" ") # Word order reversed.</lang> |
puts str.split.reverse.join(" ") # Word order reversed.</lang> |
||
{{out}} |
|||
<pre> |
|||
lasrever esarhp edoc attesor |
|||
attesor edoc esarhp lasrever |
|||
reversal phrase code rosetta |
|||
</pre> |
|||
=={{header|Tcl}}== |
|||
<lang tcl>set s "rosetta code phrase reversal" |
|||
# Reverse all characters |
|||
puts [string reverse $s] |
|||
# Reverse characters in each word |
|||
puts [lmap word $s {string reverse $word}] |
|||
# Reverse the words but not the characters |
|||
puts [lreverse $s]</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
Revision as of 15:10, 24 November 2014
Given a string of space separated words containing the following phrase:
- "rosetta code phrase reversal"
- Reverse the string.
- 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.
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
<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
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>
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"
- Reverse all characters
puts [string reverse $s]
- Reverse characters in each word
puts [lmap word $s {string reverse $word}]
- Reverse the words but not the characters
puts [lreverse $s]</lang>
- Output:
lasrever esarhp edoc attesor attesor edoc esarhp lasrever reversal phrase code rosetta