Reverse word order in string

s1 = "Z Y X si eman yM"

s1 = "Z Y X is name My"

11

static char[] ReverseAllWords(char[] in_text)
{
    int lindex = 0;
    int rindex = in_text.Length - 1;
    if (rindex > 1)
    {
        //reverse complete phrase
        in_text = ReverseString(in_text, 0, rindex);

        //reverse each word in resultant reversed phrase
        for (rindex = 0; rindex <= in_text.Length; rindex++)
        {
            if (rindex == in_text.Length || in_text[rindex] == ' ')
            {
                in_text = ReverseString(in_text, lindex, rindex - 1);
                lindex = rindex + 1;
            }
        }
    }
    return in_text;
}

static char[] ReverseString(char[] intext, int lindex, int rindex)
{
    char tempc;
    while (lindex < rindex)
    {
        tempc = intext[lindex];
        intext[lindex++] = intext[rindex];
        intext[rindex--] = tempc;
    }
    return intext;
}

3

Not exactly in place, but anyway: Python:

>>> a = "These pretzels are making me thirsty"
>>> " ".join(a.split()[::-1])
'thirsty me making are pretzels These'

2

'These pretzels are making me thirsty' subStrings reduce: [:a :b| b, ' ', a]

0

string words = "this is a test";

// Reverse the entire string
for(int i = 0; i < strlen(words) / 2; ++i) {
  char temp = words[i];
  words[i] = words[strlen(words) - i];
  words[strlen(words) - i] = temp;
}

// Reverse each word
for(int i = 0; i < strlen(words); ++i) {
  int wordstart = -1;
  int wordend = -1;
  if(words[i] != ' ') {
    wordstart = i;
    for(int j = wordstart; j < strlen(words); ++j) {
      if(words[j] == ' ') {
        wordend = j - 1;
        break;
      }
    }
    if(wordend == -1)
      wordend = strlen(words);
    for(int j = wordstart ; j <= (wordend + wordstart) / 2 ; ++j) {
      char temp = words[j];
      words[j] = words[wordend - (j - wordstart)];
      words[wordend - (j - wordstart)] = temp;
    }
    i = wordend;
  }
}

3

words = aString.split(" ");
for (i = 0; i < words.length; i++) {
    words[i] = words[words.length-i];
}

2

public static String ReverseString(String str)
{
    int word_length = 0;
    String result = "";
    for (int i=0; i<str.Length; i++)
    {
        if (str[i] == ' ')
        {
            result = " " + result;
            word_length = 0;
        } else 
        {
            result = result.Insert(word_length, str[i].ToString());
            word_length++;
        }
    }
    return result;
}

0

In Python...

ip = "My name is X Y Z"
words = ip.split()
words.reverse()
print ' '.join(words)

1

This is assuming all words are separated by spaces:

#include <stdio.h>
#include <string.h>

int main()
{
    char string[] = "What are you looking at";
    int i, n = strlen(string);

    int tail = n-1;
    for(i=n-1;i>=0;i--)
    {
        if(string[i] == ' ' || i == 0)
        {
            int cursor = (i==0? i: i+1);
            while(cursor <= tail)
                printf("%c", string[cursor++]);
            printf(" ");
            tail = i-1;
        }
    }
    return 0;
}

class Program
{
    static void Main(string[] args)
    {
        string s1 =" My Name varma:;
        string[] arr = s1.Split(' ');
        Array.Reverse(arr);
        string str = string.Join(" ", arr);
        Console.WriteLine(str);
        Console.ReadLine();

    }
}

This is not perfect but it works for me right now. I don’t know if it has O(n) running time btw (still studying it ^^) but it uses one additional array to fulfill the task.

It is probably not the best answer to your problem because i use a dest string to save the reversed version instead of replacing each words in the source string. The problem is that i use a local stack variable named buf to copy all the words in and i can not copy but into the source string as this would lead to a crash if the source string is const char * type.

But it was my first attempt to write s.th. like this Ok enough blablub. here is code:

#include <iostream>
using namespace std;

void reverse(char *des, char * const s);
int main (int argc, const char * argv[])
{    
    char* s = (char*)"reservered. rights All Saints. The 2011 (c) Copyright 11/10/11 on Pfundstein Markus by Created";
    char *x = (char*)"Dogfish! White-spotted Shark, Bullhead";

    printf("Before: |%s|n", x);
    printf("Before: |%s|n", s);

    char *d = (char*)malloc((strlen(s)+1)*sizeof(char));  
    char *i = (char*)malloc((strlen(x)+1)*sizeof(char));

    reverse(d,s);
    reverse(i,x);

    printf("After: |%s|n", i);
    printf("After: |%s|n", d);

    free (i);
    free (d);

    return 0;
}

void reverse(char *dest, char *const s) {
    // create a temporary pointer
    if (strlen(s)==0) return;
    unsigned long offset = strlen(s)+1;

    char *buf = (char*)malloc((offset)*sizeof(char));
    memset(buf, 0, offset);

    char *p;
    // iterate from end to begin and count how much words we have
    for (unsigned long i = offset; i != 0; i--) {
        p = s+i;
        // if we discover a whitespace we know that we have a whole word
        if (*p == ' ' || *p == '') {
            // we increment the counter
            if (*p != '') {
                // we write the word into the buffer
                ++p;
                int d = (int)(strlen(p)-strlen(buf));
                strncat(buf, p, d);
                strcat(buf, " ");
            }
        }
    }

    // copy the last word
    p -= 1;
    int d = (int)(strlen(p)-strlen(buf));
    strncat(buf, p, d);
    strcat(buf, "");

    // copy stuff to destination string
    for (int i = 0; i < offset; ++i) {
        *(dest+i)=*(buf+i);
    }

    free(buf);
}

We can insert the string in a stack and when we extract the words, they will be in reverse order.

void ReverseWords(char Arr[])
{
    std::stack<std::string> s;
    char *str;
    int length = strlen(Arr);
    str = new char[length+1];
    std::string ReversedArr;
    str = strtok(Arr," ");
    while(str!= NULL)
    {
        s.push(str);
        str = strtok(NULL," ");
    }
    while(!s.empty())
    {
        ReversedArr = s.top();
        cout << " " << ReversedArr;
        s.pop();
    }
}

#include <stdio.h>
#include <stdlib.h>
struct node
{
    char word[50];
    struct node *next;
};
struct stack
{
    struct node *top;
};
void print (struct stack *stk);
void func (struct stack **stk, char *str);
main()
{
    struct stack *stk = NULL;
    char string[500] = "the sun is yellow and the sky is blue";
    printf("n%sn", string);
    func (&stk, string);
    print (stk);
}
void func (struct stack **stk, char *str)
{
    char *p1 = str;
    struct node *new = NULL, *list = NULL;
    int i, j;
    if (*stk == NULL)
    {
        *stk = (struct stack*)malloc(sizeof(struct stack));
        if (*stk == NULL)
            printf("n####### stack is not allocated #####n");
        (*stk)->top = NULL;
    }
    i = 0;
    while (*(p1+i) != '')
    {
        if (*(p1+i) != ' ')
        {
            new = (struct node*)malloc(sizeof(struct node));
            if (new == NULL)
                printf("n####### new is not allocated #####n");
            j = 0;
            while (*(p1+i) != ' ' && *(p1+i) != '')
            {
                new->word[j] = *(p1 + i);
                i++;
                j++;
            }
            new->word[j++] = ' ';
            new->word[j] = '';
            new->next = (*stk)->top;
            (*stk)->top = new;
        }
        i++;
   }
}
void print (struct stack *stk)
{
    struct node *tmp = stk->top;
    int i;
    while (tmp != NULL)
    {
        i = 0;
        while (tmp->word[i] != '')
        {
            printf ("%c" , tmp->word[i]);
            i++;
        }
        tmp = tmp->next;
    }
    printf("n");
}

2

Most of these answers fail to account for leading and/or trailing spaces in the input string. Consider the case of str=" Hello world"… The simple algo of reversing the whole string and reversing individual words winds up flipping delimiters resulting in f(str) == "world Hello ".

The OP said «I want to reverse the order of the words» and did not mention that leading and trailing spaces should also be flipped! So, although there are a ton of answers already, I’ll provide a [hopefully] more correct one in C++:

#include <string>
#include <algorithm>

void strReverseWords_inPlace(std::string &str)
{
  const char delim = ' ';
  std::string::iterator w_begin, w_end;
  if (str.size() == 0)
    return;

  w_begin = str.begin();
  w_end   = str.begin();

  while (w_begin != str.end()) {
    if (w_end == str.end() || *w_end == delim) {
      if (w_begin != w_end)
        std::reverse(w_begin, w_end);
      if (w_end == str.end())
        break;
      else
        w_begin = ++w_end;
    } else {
      ++w_end;
    }
  }

  // instead of reversing str.begin() to str.end(), use two iterators that
  // ...represent the *logical* begin and end, ignoring leading/traling delims
  std::string::iterator str_begin = str.begin(), str_end = str.end();
  while (str_begin != str_end && *str_begin == delim)
    ++str_begin;
  --str_end;
  while (str_end != str_begin && *str_end == delim)
    --str_end;
  ++str_end;
  std::reverse(str_begin, str_end);
}

My version of using stack:

public class Solution {
    public String reverseWords(String s) {
        StringBuilder sb = new StringBuilder();
        String ns= s.trim();
        Stack<Character> reverse = new Stack<Character>();
        boolean hadspace=false;

        //first pass
        for (int i=0; i< ns.length();i++){
            char c = ns.charAt(i);
            if (c==' '){
                if (!hadspace){
                    reverse.push(c);
                    hadspace=true;
                }
            }else{
                hadspace=false;
                reverse.push(c);
            }
        }
        Stack<Character> t = new Stack<Character>();
        while (!reverse.empty()){
            char temp =reverse.pop();
            if(temp==' '){
                //get the stack content out append to StringBuilder
                while (!t.empty()){
                    char c =t.pop();
                    sb.append(c);
                }
                sb.append(' ');
            }else{
                //push to stack
                t.push(temp);
            }
        }
        while (!t.empty()){
            char c =t.pop();
            sb.append(c);
        }
        return sb.toString();
    }
}

Store Each word as a string in array then print from end

public void rev2() {
    String str = "my name is ABCD";
    String A[] = str.split(" ");

    for (int i = A.length - 1; i >= 0; i--) {
        if (i != 0) {
            System.out.print(A[i] + " ");
        } else {
            System.out.print(A[i]);
        }
    }

}

In Python, if you can’t use [::-1] or reversed(), here is the simple way:

def reverse(text):

  r_text = text.split(" ")
  res = []
  for word in range(len(r_text) - 1, -1, -1): 
    res.append(r_text[word])

  return " ".join(res)

print (reverse("Hello World"))

>> World Hello
[Finished in 0.1s]

Printing words in reverse order of a given statement using C#:

    void ReverseWords(string str)
    {
        int j = 0;
        for (int i = (str.Length - 1); i >= 0; i--)
        {
            if (str[i] == ' ' || i == 0)
            {
                j = i == 0 ? i : i + 1;

                while (j < str.Length && str[j] != ' ')
                    Console.Write(str[j++]);
                Console.Write(' ');
            }
        }
    }

Here is the Java Implementation:

public static String reverseAllWords(String given_string)
{
    if(given_string == null || given_string.isBlank())
        return given_string;

    char[] str = given_string.toCharArray();
    int start = 0;

    // Reverse the entire string
    reverseString(str, start, given_string.length() - 1);

    // Reverse the letters of each individual word
    for(int end = 0; end <= given_string.length(); end++)
    {
        if(end == given_string.length() || str[end] == ' ')
        {
            reverseString(str, start, end-1);
            start = end + 1;
        }
    }
    return new String(str);
}

// In-place reverse string method
public static void reverseString(char[] str, int start, int end)
{
    while(start < end)
    {
        char temp = str[start];
        str[start++] = str[end];
        str[end--] = temp;
    }
}

words = aString.split(" ");
for (i = 0; i < words.length; i++) {
    words[i] = words[words.length-i];
}

words = aString.split(" "); // make up a list
i = 0; j = words.length - 1; // find the first and last elements
while (i < j) {
    temp = words[i]; words[i] = words[j]; words[j] = temp; //i.e. swap the elements
    i++; 
    j--;
}

2

var words = "My name is X Y Z";
var wr = String.Join( " ", words.Split(' ').Reverse().ToArray() );

2

In c, this is how you might do it, O(N) and only using O(1) data structures (i.e. a char).

#include<stdio.h>
#include<stdlib.h>
main(){
  char* a = malloc(1000);
  fscanf(stdin, "%[^n]", a);
  int x = 0, y;
  while(a[x]!='')
  {
    if (a[x]==' ' || a[x]=='n')
    {
      x++;
    }
    else
    {
      y=x;
      while(a[y]!='' && a[y]!=' ' && a[y]!='n')
      { 
        y++;
      }
      int z=y;
      while(x<y)
      {
        y--;
        char c=a[x];a[x]=a[y];a[y]=c; 
        x++;
      }
      x=z;
    }
  }

  fprintf(stdout,a);
  return 0;
}

It can be done more simple using sscanf:

void revertWords(char *s);
void revertString(char *s, int start, int n);
void revertWordsInString(char *s);

void revertString(char *s, int start, int end)
{
     while(start<end)
     {
         char temp = s[start];
         s[start] = s[end];
         s[end]=temp;
         start++;
         end --;
     }
}


void revertWords(char *s)
{
  int start = 0;

  char *temp = (char *)malloc(strlen(s) + 1);
  int numCharacters = 0;
  while(sscanf(&s[start], "%s", temp) !=EOF)
  {
      numCharacters = strlen(temp);

      revertString(s, start, start+numCharacters -1);
      start = start+numCharacters + 1;
      if(s[start-1] == 0)
      return;

  }
  free (temp);

}

void revertWordsInString(char *s)
{
   revertString(s,0, strlen(s)-1);
   revertWords(s);
}

int main()
{
   char *s= new char [strlen("abc deff gh1 jkl")+1];
   strcpy(s,"abc deff gh1 jkl");
   revertWordsInString(s);
   printf("%s",s);
   return 0;
}

import java.util.Scanner;

public class revString {
   static char[] str;

   public static void main(String[] args) {
    //Initialize string
    //str = new char[] { 'h', 'e', 'l', 'l', 'o', ' ', 'a', ' ', 'w', 'o',
    //'r', 'l', 'd' };
    getInput();

    // reverse entire string
    reverse(0, str.length - 1);

    // reverse the words (delimeted by space) back to normal
    int i = 0, j = 0;
    while (j < str.length) {

        if (str[j] == ' ' || j == str.length - 1) {

            int m = i;
            int n;

            //dont include space in the swap. 
            //(special case is end of line)
            if (j == str.length - 1)
                n = j;
            else
                n = j -1;


            //reuse reverse
            reverse(m, n);

            i = j + 1;

        }
        j++;
    }

    displayArray();
}

private static void reverse(int i, int j) {

    while (i < j) {

        char temp;
        temp = str[i];
        str[i] = str[j];
        str[j] = temp;

        i++;
        j--;
    }
}
private static void getInput() {
    System.out.print("Enter string to reverse: ");
    Scanner scan = new Scanner(System.in);
    str = scan.nextLine().trim().toCharArray(); 
}

private static void displayArray() {
    //Print the array
    for (int i = 0; i < str.length; i++) {
        System.out.print(str[i]);
    }
}

}

In Java using an additional String (with StringBuilder):

public static final String reverseWordsWithAdditionalStorage(String string) {
    StringBuilder builder = new StringBuilder();

    char c = 0;
    int index = 0;
    int last = string.length();
    int length = string.length()-1;
    StringBuilder temp = new StringBuilder();
    for (int i=length; i>=0; i--) {
        c = string.charAt(i);
        if (c == SPACE || i==0) {
            index = (i==0)?0:i+1;
            temp.append(string.substring(index, last));
            if (index!=0) temp.append(c);
            builder.append(temp);
            temp.delete(0, temp.length());
            last = i;
        }
    }

    return builder.toString();
}

In Java in-place:

public static final String reverseWordsInPlace(String string) {
    char[] chars = string.toCharArray();

    int lengthI = 0;
    int lastI = 0;
    int lengthJ = 0;
    int lastJ = chars.length-1;

    int i = 0;
    char iChar = 0;
    char jChar = 0;
    while (i<chars.length && i<=lastJ) {
        iChar = chars[i];
        if (iChar == SPACE) {
            lengthI = i-lastI;
            for (int j=lastJ; j>=i; j--) {
                jChar = chars[j];
                if (jChar == SPACE) {
                    lengthJ = lastJ-j;
                    swapWords(lastI, i-1, j+1, lastJ, chars);
                    lastJ = lastJ-lengthI-1;
                    break;
                }
            }
            lastI = lastI+lengthJ+1;
            i = lastI;
        } else {
            i++;
        }
    }

    return String.valueOf(chars);
}

private static final void swapWords(int startA, int endA, int startB, int endB, char[] array) {
    int lengthA = endA-startA+1;
    int lengthB = endB-startB+1;

    int length = lengthA;
    if (lengthA>lengthB) length = lengthB;

    int indexA = 0;
    int indexB = 0;
    char c = 0;
    for (int i=0; i<length; i++) {
        indexA = startA+i;
        indexB = startB+i;

        c = array[indexB];
        array[indexB] = array[indexA];
        array[indexA] = c;
    }

    if (lengthB>lengthA) {
        length = lengthB-lengthA;
        int end = 0;
        for (int i=0; i<length; i++) {
            end = endB-((length-1)-i);
            c = array[end];
            shiftRight(endA+i,end,array);
            array[endA+1+i] = c;
        }
    } else if (lengthA>lengthB) {
        length = lengthA-lengthB;
        for (int i=0; i<length; i++) {
            c = array[endA];
            shiftLeft(endA,endB,array);
            array[endB+i] = c;
        }
    }
}

private static final void shiftRight(int start, int end, char[] array) {
    for (int i=end; i>start; i--) {
        array[i] = array[i-1];
    }
}

private static final void shiftLeft(int start, int end, char[] array) {
    for (int i=start; i<end; i++) {
        array[i] = array[i+1];
    }
}

Here is a C implementation that is doing the word reversing inlace, and it has O(n) complexity.

char* reverse(char *str, char wordend=0)
{
    char c;
    size_t len = 0;
    if (wordend==0) {
        len = strlen(str);
    }
    else {
        for(size_t i=0;str[i]!=wordend && str[i]!=0;i++)
            len = i+1;
    }
            for(size_t i=0;i<len/2;i++) {
                c = str[i];
                str[i] = str[len-i-1];
                str[len-i-1] = c;
            }
    return str;
}

char* inplace_reverse_words(char *w)
{
    reverse(w); // reverse all letters first
    bool is_word_start = (w[0]!=0x20);

    for(size_t i=0;i<strlen(w);i++){
        if(w[i]!=0x20 && is_word_start) {
            reverse(&w[i], 0x20); // reverse one word only
            is_word_start = false;
        }
        if (!is_word_start && w[i]==0x20) // found new word
            is_word_start = true;
    }
    return w;
}

using System;
class helloworld {
    public void ReverseString(String[] words) {
        int end = words.Length-1;
        for (int start = 0; start < end; start++) {
            String tempc;
            if (start < end ) {
                tempc = words[start];
                words[start] = words[end];
                words[end--] = tempc;
            }
        }
        foreach (String s1 in words) {
            Console.Write("{0} ",s1);
        }
    }
}
class reverse {
    static void Main() {
        string s= "beauty lies in the heart of the peaople";
        String[] sent_char=s.Split(' ');
        helloworld h1 = new helloworld();
        h1.ReverseString(sent_char);
    }
}

0

Better version
Check my blog http://bamaracoulibaly.blogspot.co.uk/2012/04/19-reverse-order-of-words-in-text.html

public string reverseTheWords(string description)
{
    if(!(string.IsNullOrEmpty(description)) && (description.IndexOf(" ") > 1))
    {
        string[] words= description.Split(' ');
        Array.Reverse(words);
        foreach (string word in words)
        {
            string phrase = string.Join(" ", words);
            Console.WriteLine(phrase);
        }
        return phrase;
    }
    return description;
}

public class manip{

public static char[] rev(char[] a,int left,int right) {
    char temp;
    for (int i=0;i<(right - left)/2;i++)    {
        temp = a[i + left];
        a[i + left] = a[right -i -1];
        a[right -i -1] = temp;
    }

    return a;
}
public static void main(String[] args) throws IOException {

    String s= "i think this works";
    char[] str = s.toCharArray();       
    int i=0;
    rev(str,i,s.length());
    int j=0;
    while(j < str.length) {
        if (str[j] != ' ' && j != str.length -1) {
            j++;
        } else
        {
            if (j == (str.length -1))   {
                j++;
            }
            rev(str,i,j);
            i=j+1;
            j=i;
        }
    }
    System.out.println(str);
}

#include<stdio.h>

char * strRev(char *str, char tok)
{
   int len = 0, i;
   char *temp = str;
   char swap;

   while(*temp != tok && *temp != '') {
      len++; temp++;
   }   
   len--;

   for(i = 0; i < len/2; i++) {
      swap = str[i];
      str[i] = str[len - i]; 
      str[len - i] = swap;
   }   

   // Return pointer to the next token.
   return str + len + 1;
}

int main(void)
{
   char a[] = "Reverse this string.";
   char *temp = a;

   if (a == NULL)
      return -1; 

   // Reverse whole string character by character.
   strRev(a, '');

   // Reverse every word in the string again.
   while(1) {
      temp = strRev(temp, ' ');
      if (*temp == '')
         break;

      temp++;
   }   
   printf("Reversed string: %sn", a); 
   return 0;
}

1

C++

C

Java

Python3

C#

Javascript

Output

much very program this like i

C++

C

Java

Python3

C#

Javascript

Output

much very program this like i

C++

Java

Python3

C#

Javascript

Output

much very program this like i

C++

Java

Python3

C#

Javascript

Output

much very program this like i

C++

Java

Python3

C#

Javascript

Output

much very program this like i

Java

Python3

PHP

C#

Javascript

C++

Output

much very program this like i

Java

Output

Before reversing length of string : 28
After reversing length of string : 26
"Geeks For Geeks to Welcome"

Before reversing length of string : 28
After reversing length of string : 24
"Programming     Java Love I"

Reverse words in a string
You are encouraged to solve this task according to the task description, using any language you may know.

V text =
‘---------- Ice and Fire ------------

fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I

... elided paragraph last ...

Frost Robert -----------------------’

L(line) text.split("n")
   print(reversed(line.split(‘ ’)).join(‘ ’))

PROC Reverse(CHAR ARRAY src,dst)
  BYTE i,j,k,beg,end

  i=1 j=src(0)
  WHILE j>0
  DO
    WHILE j>0 AND src(j)=$20
    DO j==-1 OD
    IF j=0 THEN
      EXIT
    ELSE
      end=j
    FI
    
    WHILE j>0 AND src(j)#$20
    DO j==-1 OD
    beg=j+1

    IF i>1 THEN
      dst(i)=$20 i==+1
    FI

    FOR k=beg TO end
    DO
      dst(i)=src(k) i==+1
    OD
  OD
  dst(0)=i-1
RETURN

PROC Test(CHAR ARRAY src)
  CHAR ARRAY dst(40)

  Reverse(src,dst)
  PrintE(dst)
RETURN

PROC Main()
  Test("---------- Ice and Fire ------------")
  Test("")
  Test("fire, in end will world the say Some")
  Test("ice. in say Some")
  Test("desire of tasted I've what From")
  Test("fire. favor who those with hold I")
  Test("")
  Test("... elided paragraph last ...")
  Test("")
  Test("Frost Robert -----------------------")
RETURN

package Simple_Parse is
   -- a very simplistic parser, useful to split a string into words
   
   function Next_Word(S: String; Point: in out Positive) 
		     return String;
   -- a "word" is a sequence of non-space characters
   -- if S(Point .. S'Last) holds at least one word W
   -- then  Next_Word increments Point by len(W) and returns W. 
   -- else  Next_Word sets Point to S'Last+1 and returns ""
      
end Simple_Parse;

package body Simple_Parse is
   
   function Next_Word(S: String; Point: in out Positive) return String is
      Start: Positive := Point;
      Stop: Natural;
   begin
      while Start <= S'Last and then S(Start) = ' ' loop
	 Start := Start + 1;
      end loop; -- now S(Start) is the first non-space, 
		-- or Start = S'Last+1 if S is empty or space-only
      Stop := Start-1; -- now S(Start .. Stop) = ""
      while Stop < S'Last and then S(Stop+1) /= ' ' loop
	 Stop := Stop + 1;
      end loop; -- now S(Stop+1) is the first sopace after Start
		-- or Stop = S'Last if there is no such space
      Point := Stop+1;
      return S(Start .. Stop);
   end Next_Word;
      
end Simple_Parse;

with Ada.Text_IO, Simple_Parse; 

procedure Reverse_Words is
   
   function Reverse_Words(S: String) return String is
      Cursor: Positive := S'First;
      Word: String := Simple_Parse.Next_Word(S, Cursor);
   begin
      if Word = "" then 
         return "";
      else
         return Reverse_Words(S(Cursor .. S'Last)) & " " & Word;
      end if;
   end Reverse_Words;
   
   use Ada.Text_IO;
begin
   while not End_Of_File loop
      Put_Line(Reverse_Words(Get_Line)); -- poem is read from standard input
   end loop;
end Reverse_Words;

integer j;
list l, x;
text s, t;

l = list("---------- Ice and Fire ------------",
         "",
         "fire, in end will world the say Some",
         "ice. in say Some",
         "desire of tasted I've what From",
         "fire. favor who those with hold I",
         "",
         "... elided paragraph last ...",
         "",
         "Frost Robert -----------------------");

for (, t in l) {
    file().b_affix(t).list(x, 0);
    for (j, s in x.reverse) {
        o_space(sign(j));
        o_text(s);
    }
    o_newline();
}

# returns original phrase with the order of the words reversed #
# a word is a sequence of non-blank characters                 #
PROC reverse word order = ( STRING original phrase )STRING:
     BEGIN
        STRING words reversed := "";
        STRING separator      := "";
        INT    start pos      := LWB original phrase;
        WHILE
            # skip leading spaces #
            WHILE IF start pos <= UPB original phrase
                  THEN original phrase[ start pos ] = " "
                  ELSE FALSE
                  FI
            DO start pos +:= 1
            OD;
            start pos <= UPB original phrase
        DO
            # have another word, find it #
            INT end pos := start pos;
            WHILE IF end pos <= UPB original phrase
                  THEN original phrase[ end pos ] /= " "
                  ELSE FALSE
                  FI
            DO end pos +:= 1
            OD;
            ( original phrase[ start pos : end pos - 1 ] + separator ) +=: words reversed;
            separator := " ";
            start pos := end pos + 1
        OD;
        words reversed
     END # reverse word order # ;
 
# reverse the words in the lines as per the task #
print( ( reverse word order ( "--------- Ice and Fire ------------ " ), newline ) );
print( ( reverse word order ( "                                    " ), newline ) );
print( ( reverse word order ( "fire, in end will world the say Some" ), newline ) );
print( ( reverse word order ( "ice. in say Some                    " ), newline ) );
print( ( reverse word order ( "desire of tasted I've what From     " ), newline ) );
print( ( reverse word order ( "fire. favor who those with hold I   " ), newline ) );
print( ( reverse word order ( "                                    " ), newline ) );
print( ( reverse word order ( "... elided paragraph last ...       " ), newline ) );
print( ( reverse word order ( "                                    " ), newline ) );
print( ( reverse word order ( "Frost Robert -----------------------" ), newline ) )

on run

    unlines(map(reverseWords, |lines|("---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------")))

end run


-- GENERIC FUNCTIONS ---------------------------------------------------------

-- reverseWords :: String -> String
on reverseWords(str)
    unwords(|reverse|(|words|(str)))
end reverseWords

-- |reverse| :: [a] -> [a]
on |reverse|(xs)
    if class of xs is text then
        (reverse of characters of xs) as text
    else
        reverse of xs
    end if
end |reverse|

-- |lines| :: Text -> [Text]
on |lines|(str)
    splitOn(linefeed, str)
end |lines|

-- |words| :: Text -> [Text]
on |words|(str)
    splitOn(space, str)
end |words|

-- ulines :: [Text] -> Text
on unlines(lstLines)
    intercalate(linefeed, lstLines)
end unlines

-- unwords :: [Text] -> Text
on unwords(lstWords)
    intercalate(space, lstWords)
end unwords

-- splitOn :: Text -> Text -> [Text]
on splitOn(strDelim, strMain)
    set {dlm, my text item delimiters} to {my text item delimiters, strDelim}
    set lstParts to text items of strMain
    set my text item delimiters to dlm
    lstParts
end splitOn

-- interCalate :: Text -> [Text] -> Text
on intercalate(strText, lstText)
    set {dlm, my text item delimiters} to {my text item delimiters, strText}
    set strJoined to lstText as text
    set my text item delimiters to dlm
    strJoined
end intercalate

-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
    tell mReturn(f)
        set lng to length of xs
        set lst to {}
        repeat with i from 1 to lng
            set end of lst to lambda(item i of xs, i, xs)
        end repeat
        return lst
    end tell
end map

-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
    if class of f is script then
        f
    else
        script
            property lambda : f
        end script
    end if
end mReturn

100 DATA"---------- ICE AND FIRE ------------"
110 DATA"                                    "
120 DATA"FIRE, IN END WILL WORLD THE SAY SOME"
130 DATA"ICE. IN SAY SOME                    "
140 DATA"DESIRE OF TASTED I'VE WHAT FROM     "
150 DATA"FIRE. FAVOR WHO THOSE WITH HOLD I   "
160 DATA"                                    "
170 DATA"... ELIDED PARAGRAPH LAST ...       "
180 DATA"                                    "
190 DATA"FROST ROBERT -----------------------"

200 FOR L = 1 TO 10
210     READ T$
220     I = LEN(T$)
240     IF I THEN GOSUB 300 : PRINT W$; : IF I THEN PRINT " "; : GOTO 240
250     PRINT
260 NEXT L
270 END

300 W$ = ""
310 FOR I = I TO 1 STEP -1
320     IF MID$(T$, I, 1) = " " THEN NEXT I : RETURN
330 FOR I = I TO 1 STEP -1
340     C$ = MID$(T$, I, 1)
350     IF C$ <> " " THEN  W$ = C$ + W$ : NEXT I
360 RETURN

text: {
---------- Ice and Fire ------------
 
fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I
 
... elided paragraph last ...
 
Frost Robert -----------------------}

reversed: map split.lines text =>
    [join.with:" " reverse split.words &]

print join.with:"n" reversed

Data := "
(Join`r`n
---------- Ice and Fire ------------

fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I

... elided paragraph last ...

Frost Robert ----------------------- 
)"

Loop, Parse, Data, `n, `r
{
	Loop, Parse, A_LoopField, % A_Space
		Line := A_LoopField " " Line
	Output .= Line "`n", Line := ""
}
MsgBox, % RTrim(Output, "`n")

# syntax: GAWK -f REVERSE_WORDS_IN_A_STRING.AWK
BEGIN {
    text[++i] = "---------- Ice and Fire ------------"
    text[++i] = ""
    text[++i] = "fire, in end will world the say Some"
    text[++i] = "ice. in say Some"
    text[++i] = "desire of tasted I've what From"
    text[++i] = "fire. favor who those with hold I"
    text[++i] = ""
    text[++i] = "... elided paragraph last ..."
    text[++i] = ""
    text[++i] = "Frost Robert -----------------------"
    leng = i
    for (i=1; i<=leng; i++) {
      n = split(text[i],arr," ")
      for (j=n; j>0; j--) {
        printf("%s ",arr[j])
      }
      printf("n")
    }
    exit(0)
}

PRINT REV$("---------- Ice and Fire ------------")
PRINT
PRINT REV$("fire, in end will world the say Some")
PRINT REV$("ice. in say Some                    ")
PRINT REV$("desire of tasted I've what From     ")
PRINT REV$("fire. favor who those with hold I   ")
PRINT
PRINT REV$("... elided paragraph last ...       ")
PRINT
PRINT REV$("Frost Robert -----------------------")

@echo off

::The Main Thing...
cls
echo.
call :reverse "---------- Ice and Fire ------------"
call :reverse
call :reverse "fire, in end will world the say Some"
call :reverse "ice. in say Some"
call :reverse "desire of tasted I've what From"
call :reverse "fire. favor who those with hold I"
call :reverse
call :reverse "... elided paragraph last ..."
call :reverse
call :reverse "Frost Robert -----------------------" 
echo.
pause>nul
exit
::/The Main Thing...

::The Function...
:reverse
set reversed=&set word=&set str=%1
:process
for /f "tokens=1,*" %%A in (%str%) do (
	set str=%%B
	set word=%%A
)
set reversed=%word% %reversed%
set str="%str%"
if not %str%=="" goto process

echo.%reversed%
goto :EOF
::/The Function...

source = freefile
open (source, "m:text.txt")
textEnt$ = ""
dim textSal$(size(source)*8)
linea = 0

while not eof(source)
	textEnt$ = readline(source)
	linea += 1
	textSal$[linea] = textEnt$
end while

for n = size(source) to 1 step -1
	print textSal$[n];
next n
close source

      PRINT FNreverse("---------- Ice and Fire ------------")
          'FNreverse("")
          'FNreverse("fire, in end will world the say Some")
          'FNreverse("ice. in say Some")
          'FNreverse("desire of tasted I've what From")
          'FNreverse("fire. favor who those with hold I")
          'FNreverse("")
          'FNreverse("... elided paragraph last ...")
          'FNreverse("")
          'FNreverse("Frost Robert -----------------------")
      END

      DEF FNreverse(s$)
      LOCAL sp%
      sp%=INSTR(s$," ")
      IF sp% THEN =FNreverse(MID$(s$,sp%+1))+" "+LEFT$(s$,sp%-1) ELSE =s$

("---------- Ice and Fire ------------
                                    
fire, in end will world the say Some
ice. in say Some                    
desire of tasted I've what From     
fire. favor who those with hold I   
                                    
... elided paragraph last ...       
                                    
Frost Robert -----------------------"
  : ?text
& ( reverse
  =   token tokens reversed
    .   :?tokens
      &   whl
        ' ( @( !arg
             : ?token (" "|t|r) ?arg
             )
          & !tokens !token:?tokens
          )
      & !tokens !arg:?tokens
      & :?reversed
      &   whl
        ' ( !tokens:%?token %?tokens
          & " " !token !reversed:?reversed
          )
      & !tokens !reversed:?reversed
      & str$!reversed
  )
& :?output
&   whl
  ' ( @(!text:?line n ?text)
    & !output reverse$!line n:?output
    )
& !output reverse$!text:?output
& out$str$!output
);

blsq ) "It is not raining"wd<-wd
"raining not is It"
blsq ) "ice. in say some"wd<-wd
"some say in ice."

#include <stdio.h>
#include <ctype.h>

void rev_print(char *s, int n)
{
        for (; *s && isspace(*s); s++);
        if (*s) {
                char *e;
                for (e = s; *e && !isspace(*e); e++);
                rev_print(e, 0);
                printf("%.*s%s", (int)(e - s), s, " " + n);
        }
        if (n) putchar('n');
}

int main(void)
{
        char *s[] = {
                "---------- Ice and Fire ------------",
                "                                    ",
                "fire, in end will world the say Some",
                "ice. in say Some                    ",
                "desire of tasted I've what From     ",
                "fire. favor who those with hold I   ",
                "                                    ",
                "... elided paragraph last ...       ",
                "                                    ",
                "Frost Robert -----------------------",
                0
        };
        int i;
        for (i = 0; s[i]; i++) rev_print(s[i], 1);

        return 0;
}

using System;

public class ReverseWordsInString
{
    public static void Main(string[] args)
    {
        string text = @"
            ---------- Ice and Fire ------------

            fire, in end will world the say Some
            ice. in say Some
            desire of tasted I've what From
            fire. favor who those with hold I

            ... elided paragraph last ...

            Frost Robert -----------------------
            ";

        foreach (string line in text.Split(Environment.NewLine)) {
            //Splits on any whitespace, not just spaces
            string[] words = line.Split(default(char[]), StringSplitOptions.RemoveEmptyEntries);
            Array.Reverse(words);
            WriteLine(string.Join(" ", words));
        }
    }
}

#include <algorithm>
#include <functional>
#include <string>
#include <iostream>
#include <vector>

//code for a C++11 compliant compiler
template <class BidirectionalIterator, class T>
void block_reverse_cpp11(BidirectionalIterator first, BidirectionalIterator last, T const& separator) {
   std::reverse(first, last);
   auto block_last = first;
   do {
      using std::placeholders::_1;
      auto block_first = std::find_if_not(block_last, last, 
         std::bind(std::equal_to<T>(),_1, separator));
      block_last = std::find(block_first, last, separator);
      std::reverse(block_first, block_last);
   } while(block_last != last);
}

//code for a C++03 compliant compiler
template <class BidirectionalIterator, class T>
void block_reverse_cpp03(BidirectionalIterator first, BidirectionalIterator last, T const& separator) {
   std::reverse(first, last);
   BidirectionalIterator block_last = first;
   do {
      BidirectionalIterator block_first = std::find_if(block_last, last, 
         std::bind2nd(std::not_equal_to<T>(), separator));
      block_last = std::find(block_first, last, separator);
      std::reverse(block_first, block_last);
   } while(block_last != last);
}

int main() {
   std::string str1[] = 
    {
        "---------- Ice and Fire ------------",
        "",
        "fire, in end will world the say Some",
        "ice. in say Some",
        "desire of tasted I've what From",
        "fire. favor who those with hold I",
        "",
        "... elided paragraph last ...",
        "",
        "Frost Robert -----------------------"
    };

   std::for_each(begin(str1), end(str1), [](std::string& s){
      block_reverse_cpp11(begin(s), end(s), ' ');
      std::cout << s << std::endl;
   });
   
   std::for_each(begin(str1), end(str1), [](std::string& s){
      block_reverse_cpp03(begin(s), end(s), ' ');
      std::cout << s << std::endl;
   });

   return 0;
}

#include <string>
#include <iostream>
using namespace std;
 
string invertString( string s )
{
    string st, tmp;
    for( string::iterator it = s.begin(); it != s.end(); it++ )
    {
        if( *it != 32 ) tmp += *it;
        else
        {
            st = " " + tmp + st;
            tmp.clear();
        }
    }
    return tmp + st;
}
 
int main( int argc, char* argv[] )
{
    string str[] = 
    {
        "---------- Ice and Fire ------------",
        "",
        "fire, in end will world the say Some",
        "ice. in say Some",
        "desire of tasted I've what From",
        "fire. favor who those with hold I",
        "",
        "... elided paragraph last ...",
        "",
        "Frost Robert -----------------------"
    };
    for( int i = 0; i < 10; i++ )
        cout << invertString( str[i] ) << "n";
 
    cout << "n";
    return system( "pause" );
}

(def poem 
  "---------- Ice and Fire ------------
 
   fire, in end will world the say Some
   ice. in say Some 
   desire of tasted I've what From
   fire. favor who those with hold I
 
   ... elided paragraph last ...
 
   Frost Robert -----------------------")

(dorun
  (map println (map #(apply str (interpose " " (reverse (re-seq #"[^s]+" %)))) (clojure.string/split poem #"n"))))

       program-id. rev-word.
       data division.
       working-storage section.
       1 text-block.
        2 pic x(36) value "---------- Ice and Fire ------------".
        2 pic x(36) value "                                    ".
        2 pic x(36) value "fire, in end will world the say Some".
        2 pic x(36) value "ice. in say Some                    ".
        2 pic x(36) value "desire of tasted I've what From     ".
        2 pic x(36) value "fire. favor who those with hold I   ".
        2 pic x(36) value "                                    ".
        2 pic x(36) value "... elided paragraph last ...       ".
        2 pic x(36) value "                                    ".
        2 pic x(36) value "Frost Robert -----------------------".
       1 redefines text-block.
        2 occurs 10.
         3 text-line pic x(36).
       1 text-word.
        2 wk-len binary pic 9(4).
        2 wk-word pic x(36).
       1 word-stack.
        2 occurs 10.
         3 word-entry.
          4 word-len binary pic 9(4).
          4 word pic x(36).
       1 binary.
        2 i pic 9(4).
        2 pos pic 9(4).
        2 word-stack-ptr pic 9(4).

       procedure division.
           perform varying i from 1 by 1
           until i > 10
               perform push-words
               perform pop-words
           end-perform
           stop run
           .

       push-words.
           move 1 to pos
           move 0 to word-stack-ptr
           perform until pos > 36
               unstring text-line (i) delimited by all space
               into wk-word count in wk-len
               pointer pos
               end-unstring
               add 1 to word-stack-ptr
               move text-word to word-entry (word-stack-ptr)
           end-perform
           .

       pop-words.
           perform varying word-stack-ptr from word-stack-ptr
               by -1
           until word-stack-ptr < 1
               move word-entry (word-stack-ptr) to text-word
               display wk-word (1:wk-len) space with no advancing
           end-perform
           display space
           .
       end program rev-word.

strReversed = '---------- Ice and Fire ------------nn
fire, in end will world the say Somen
ice. in say Somen
desire of tasted I've what Fromn
fire. favor who those with hold Inn
... elided paragraph last ...nn
Frost Robert -----------------------'

reverseString = (s) ->
  s.split('n').map((l) -> l.split(/s/).reverse().join ' ').join 'n'

console.log reverseString(strReversed)

(defun split-and-reverse (str)
  (labels 
    ((iter (s lst)
       (let ((s2 (string-trim '(#space) s)))
         (if s2
             (let ((word-end (position #space s2)))
               (if (and word-end (< (1+ word-end) (length s2)))
                   (iter (subseq s2 (1+ word-end))
                         (cons (subseq s2 0 word-end) lst))
                   (cons s2 lst)))
               lst))))
  (iter str NIL)))

(defparameter *poem* 
  "---------- Ice and Fire ------------
   
   fire, in end will world the say Some
   ice. in say Some 
   desire of tasted I've what From
   fire. favor who those with hold I
 
   ... elided paragraph last ...
 
   Frost Robert -----------------------")

(with-input-from-string (s *poem*)
  (loop for line = (read-line s NIL)
        while line
        do (format t "~{~a~#[~:; ~]~}~%" (split-and-reverse line))))

void main() {
    import std.stdio, std.string, std.range, std.algorithm;

    immutable text =
"---------- Ice and Fire ------------

fire, in end will world the say Some
ice. in say Some
desire of tasted I've what From
fire. favor who those with hold I

... elided paragraph last ...

Frost Robert -----------------------";

    writefln("%(%-(%s %)n%)",
             text.splitLines.map!(r => r.split.retro));
}

program RosettaCode_ReverseWordsInAString;

{$APPTYPE CONSOLE}

uses Classes, Types, StrUtils;

const
  TXT =
  '---------- Ice and Fire -----------'+sLineBreak+
  sLineBreak+
  'fire, in end will world the say Some'+sLineBreak+
  'ice. in say Some'+sLineBreak+
  'desire of tasted I''ve what From'+sLineBreak+
  'fire. favor who those with hold I'+sLineBreak+
  sLineBreak+
  '... elided paragraph last ...'+sLineBreak+
  sLineBreak+
  'Frost Robert -----------------------'+sLineBreak;

var
  i, w: Integer;
  d: TStringDynArray;
begin
  with TStringList.Create do
  try
    Text := TXT;
    for i := 0 to Count - 1 do
    begin
      d := SplitString(Strings[i], #32);
      Strings[i] := '';
      for w := Length(d) - 1 downto 0 do
        Strings[i] := Strings[i] + #32 + d[w];
    end;
    Writeln(Text);
  finally
    Free
  end;
  ReadLn;
end.

(define S #<<
---------- Ice and Fire ------------
 
fire, in end will world the say Some 
ice. in say Some             
desire of tasted I've what From 
fire. favor who those with hold I 
 
... elided paragraph last ... 
 
Frost Robert -----------------------
>>#)
			
(for-each writeln 
    (for/list ((line (string-split S "n"))) 
        (string-join (reverse (string-split line " ")) " ")))

import extensions;
import system'routines;
 
public program()
{
    var text := new string[]{"---------- Ice and Fire ------------",
                  "",
                  "fire, in end will world the say Some",
                  "ice. in say Some",
                  "desire of tasted I've what From",
                  "fire. favor who those with hold I",
                  "",
                  "... elided paragraph last ...",
                  "",
                  "Frost Robert -----------------------"};
 
    text.forEach:(line)
    {
        line.splitBy:" ".sequenceReverse().forEach:(word)
        {
            console.print(word," ")
        };
        console.writeLine()
    }
}

defmodule RC do
  def reverse_words(txt) do
    txt |> String.split("n")       # split lines
        |> Enum.map(&(              # in each line
             &1 |> String.split       # split words
                |> Enum.reverse       # reverse words
                |> Enum.join(" ")))   # rejoin words
        |> Enum.join("n")          # rejoin lines
  end 
end