Phrase reversals: Difference between revisions

{{task}}

 

 

Show your output here.

 

 

 

 

 

 

 

 

 

 

{{out}}

</pre>

 

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

2. Reverse words, same order: "attesor edoc esarhp lasrever"

2. Reverse order, same words: "reversal phrase code rosetta"</pre>

 

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

each word reversed : attesoR edoC esarhP lasreveR

</pre>

 

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

Reversed order: "reversal phrase code rosetta"

</pre>

 

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

#include <vector>

#include <algorithm>

#include <string>

 

std::cout << "Each word reversed : " ;

std::cout << '\n' ;

{{Out}}

<pre>Input : rosetta code phrase reversal

Each word reversed : attesor edoc esarhp lasrever

Original word order reversed : reversal phrase code rosetta

</pre>

 

=={{header|D}}==

Partially lazy.

 

immutable phrase = "rosetta code phrase reversal";

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

Word order reversed: reversal phrase code rosetta

</pre>

 

=={{header|Haskell}}==

 

 

{{out}}

<pre>

attesor edoc esarhp lasrever

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

Reversed words: attesor edoc esarhp lasrever

Reversed word order: reversal phrase code rosetta</pre>

 

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

2. each word reversed: attesor edoc esarhp lasrever

3. word-order reversed: reversal phrase code rosetta

 

=={{header|Perl}}==

 

{{out}}

<pre>

</pre>

 

 

{{out}}

 

=={{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|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(word[::-1] for word in phrase.split()) # Words reversed.

'attesor edoc esarhp lasrever'

'reversal phrase code rosetta'

 

=={{header|Racket}}==

 

(require

(only-in srfi/13 string-reverse)

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

 

 

{{out}}

<pre>lasrever esarhp edoc attesor

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

<pre>

</pre>

 

=={{header|Ruby}}==

 

puts str.reverse # Reversed string.

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

 

{{out}}

<pre>

 

=={{header|Sidef}}==

 

say str.reverse; # reversed string

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

{{out}}

<pre>lasrever esarhp edoc attesor

attesor edoc esarhp lasrever

reversal phrase code rosetta</pre>

 

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

 

 

 

=={{header|zkl}}==

rosetta code phrase reversal

 

 

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