reverse sentence while maintaining the location of space in C language - c

Question

i got headache trying to solve this assignment of mine..here is the question:
Reverse the order of words
Write a function to reverse the order of words
Given a sentence of words in a character array, write a C function to reverse the order of words.
char* reverse_word_order (char* str);
The function gets a character array as its sole argument, reverses the order of words in it, and puts back the result into it. It returns the pointer to the argument on termination for convenience sake.
See the following example.
char str[] = `" this is very beautiful "`;
printf ("[%s]\n", reverse_word_order(str)); /* print `[beautiful very is this ]` */
Beware that the location of space characters has not moved; the result of the example above is [beautiful very is this ], not [ beautiful very is this].
The following constraints apply:
No external function calls. (strlen, strcpy, etc). No explicit memory
allocation on the heap (malloc, realloc, dynamic arrays, etc) If you
need these functions, write your own.
i wrote this code:
#include <stdio.h>
int length (char* str){
int L=0;
while(*str++){
L++;
}
return L;
}
int Last(char* zi) {
int i;
for(i=length (zi); i>0;i--){
if (zi[i]!='\0'){
return i;
}
}
}
void reverse_substring(char* zi, int start, int end){
char Temporary;
int i,z;
for(i=start, z=end; i<z; i++,z--){
Temporary = zi[i];
zi[i]=zi[z];
zi[z]=Temporary;
}
}
char* reverse(char* zi){
char *str = zi;
int len = length (zi);
int i=0;
int count=0;
reverse_substring(str,0,Last(str));
while(i<=len){
if(str[i] ==' ' || i==len){
reverse_substring(str,i-count,i-1);
count=0;
}
if(str[i]!=' '){
count++;
}
i++;
}
return str;
}
int main(int argc, char **argv){
char str[] = " this is very beautiful ";
printf("Length of string: %d\n",length(str));
printf("[%s]\n", reverse(str));
}
but the output from the code above is : [ beautiful very is this] which does not confirm the requirement of the question.
the output should be :[beautiful very is this ]
any ideas?
thanks.

Answer 1

Ok: so I added two functions one that strips all the unnecessary spaces and counts their amount and the other that puts them together. I will just copy the main and the functions here.
void strip_spaces(char *str, int *spaces)
{
int len = length(str);
int i, j, l, flag;
for (i = 0; i < 100; i++)
spaces[i] = 0;
i = 0; j = 0; l = 0;
while(str[i] != '\0'){
flag = 0;
while(str[i] == ' '){
i++;
flag = 1;
spaces[l]++;
}
if (flag == 1){
l++;
str[j++] = ' ';
}
else{
str[j++] = str[i++];
}
}
str[j] = '\0';
}
void add_spaces(char *str, int *spaces)
{
int i = 0;
int flag;
int l = 0;
char stra[1000];
while(str[i] != '\0'){
stra[i] = str[i];
i++;
}
stra[i] = str[i] = '\0';
printf("%s*\n%s*\n", stra, str);
i = 0;
int j = 0;
while(stra[i] != '\0'){
flag = 0;
if(stra[i] == ' ')
while(spaces[j] > 0 ){
flag = 1;
spaces[j]--;
str[l] = ' ';
l++;
}
if (flag == 1){
j++;
i++;
}
else{
str[l++] = stra[i++];
}
}
str[l] = '\0';
}
int main(int argc, char **argv)
{
char str[] = " this is very beautiful ";
int spaces[100];
strip_spaces(str, spaces);
reverse(str);
add_spaces(str, spaces);
printf("Length of string: %d\n",length(str));
printf("%s\n", str);
return 0;
}

Answer 2

For simplicity, lets treat the string " this is very beautiful " as "X t~s A is B v~y C b~l Y", and the result you want is "X b~l A v~y B is C t~s Y". So the first step is the truely wonderful:
"X t~s A is B v~y C b~l Y" -- reverse the words...
"X s~t A si B y~v C l~b Y" -- reverse all but the leading and trailing...
"X b~l C v~y B is A t~s Y" -- shazam :-)
now the problem is that A, B and C are out of order. So let's try another reverse, excluding the stuff which is now in the right place at either end:
"X b~l A si B y~v C t~s Y"
which restores the order of A, B and C, but the words are in a mess. Since we only have a hammer, let's hit the thing again, again excluding stuff which is in the right place:
"X b~l A v~y B is C t~s Y"
By George ! I think we have it :-)
Obviously this can be extended to any number of words, by repeatedly moving in from the ends, reversing the stuff which is not yet in the required order, until there are no words left.
In this case we have an odd number of white-space sections. The solution may be slightly different with an even number of same... but I guess I should leave some of the exercise to you.
If the white-space sections are just spaces, the the order of those does not matter. But if they were a mixture of spaces and tabs (say), then you'd need to check that those ended up in the right order as well. (The analysis needs to be repeated but using, say, Aa, Bb, etc. and throwing in some extra reverses as required.)
I find that it can help to (a) try to cut away the clutter, and (b) sit down with a pencil an paper and doodle out the steps in the process -- on a small subset, or a simplified version, of the problem. Doing this can reveal the pattern(s) and allow me to visualise the process, which can then be checked against a more general version of the problem, and then translated into code.