> Thanks again to David and Russ for comments on previous version of
> this exercise.  For some reason, my posted replies to them are not
> yet appearing on my newsreader.  Anyway, here's another version.
> I hope this one addresses the problems in the previous ones.  I
> also tried to make it more robust:  it accepts a command-line
> string if there is one, but otherwise uses a default string.
> Also, I wrote it so that one can slip in more than one space
> between tokens (words) in the string and still get a new string
> with the tokens reversed and only once space between them.  Total
> memory usage is five char pointers, plus the allocated memory and
> whatever memory is used for the original string.

> Amittai Aviram

> /* reverser.c */
> /* Accepts string from command line or uses default
>     string and reverses order of tokens (words). */

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

> int main(int argc, char *argv[])
> {
>     char *string = NULL;
>     char *rev = NULL;
>     char *start = NULL;
>     char *end = NULL;
>     char *revstart = NULL;

>     /* Assign command-line input to string if available. */
>     if (argc > 1)
>         string = argv[1];

>     /* Otherwise, use default string. */
>     else
>     {
>         string = "The cow jumped over the moon.";
>         puts("Using default string.");
>         puts("(You can also enter a string in the command line.)\n");
>     }

>     /* Print string in original form. */
>     printf("Original: %s\n", string);

>     /* Allocate space for reversed string. */
>     if (!(rev = malloc(strlen(string) + 1)))
>     {
>         perror("Memory allocation failure for *rev.");
>         exit(EXIT_FAILURE);
>     }

>     /* Initialize rev string to mere spaces
>         and terminate with null. */
>     rev[strlen(string)] = '\0';
>     memset(rev, ' ', strlen(string));

>     /* Put both start and end pointers at end
>         of original string and revstart pointer
>         at beginning of rev string before
>         finding tokens and copying them in
>         reverse order. */
>     start = end = &string[strlen(string)];
>     revstart = rev;

>     /* Loop through original string backwards
>         from end to find tokens and copy each
>         token in forward order in rev, moving
>         revstart forward each time to end of
>         new token. */
>     while(start > string)
>     {
>         for(start = end - 1; *start != ' ' && start >= string; start--);
>         start++;
>         strncpy(revstart, start, end - start);
>         revstart = revstart + (end - start) + 1;
>         for(end = start - 1; *end == ' ' && end > string; end--);
>         end++;
>     }

>     /* Reassign string pointer to point to reversed string. */
>     string = rev;
>     printf("Reversed: %s\n", string);

>     /* Free memory allocated to reversed string. */
>     free(string);
>     return EXIT_SUCCESS;
> }

> /* ====================================== */
> /* reverse string in place, return length */
> size_t revstring(char *string)
> {
[...]
> } /* revstring */

> int main(int argc, char *argv[])
> {
>     char *string = NULL;
>     char *rev = NULL;
>     char *start = NULL;
>     char *end = NULL;

>     /* Assign command-line input to string if available. */

> /*
>  * reverse word order in each input line
>  */

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

> char *
> reverse(char *buf)
> {
>     char *s, *e, c;

>     for(s=buf, e=buf+strlen(buf)-1; e > s; e--, s++){
>         c = *s;
>         *s = *e;
>         *e = c;
>     }
>     return buf;
> }

> int
> main(int argc, char *argv[])
> {
>     char    s[4096];    /* string */
>     char    r[4096];    /* reversed */

>     while(fgets(s, sizeof s, stdin) != 0){
>         if(s[0] == '\n'){
>             puts("");
>             continue;
>         }
>         s[strlen(s)-1] = 0;
>         r[0] = 0;
>         for(t=strtok(s, " "); t != 0; t=strtok(0, " ")){
>             strcat(r, " ");
>             strcat(r, reverse(t));
>         }
>         puts(reverse(r+1));
>     }
>     return 0;
> }

> david

> > Here is a version that uses only four pointers [...]

> > /* reverser.c */
> > /* Accepts string from command line or uses default
> >     string and reverses order of tokens (words). */

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

> > int main(int argc, char *argv[])
> > {
> >     char *string = NULL;
> >     char *rev = NULL;
> >     char *start = NULL;
> >     char *end = NULL;

> >     /* Assign command-line input to string if available. */
> [snip]

> This is a little clumsy because you have to include the whole string on
> the command-line, and it's subject to shell quoting rules. For this
> program to actually be useful, you should probably just read from stdin.

> And this is entirely superfluous.

> >     /* Allocate space for reversed string. */
> >     if (!(rev = malloc(strlen(string) + 1)))

> Although a style issue, it's not considered good practice to use a
> logical operator with a non-boolean expression. Prefer

> or something similar.

> >     {
> >         perror("Memory allocation failure for *rev.");
> >         exit(EXIT_FAILURE);
> >     }

> >     /* Initialize reversed string to mere spaces
> >         and close with null termination. */
> >     rev[strlen(string)] = '\0';
> >     memset(rev, ' ', strlen(string));

> This memset is strange here, but you need it because of your strange
> algorithm. When manipulating strings, it's much easier to use functions
> which write and make use of the null character.

> >     /* Put end pointer at end
> >         of original string before
> >         finding tokens and copying them in
> >         reverse order. */
> >     end = &string[strlen(string)];

> >     /* Loop through original string backwards
> >          from end to find tokens and copy each
> >         token in forward order in rev. */
> >     while(end > string)
> >     {
> >         for(start = end - 1; start - 1 >= string && *(start - 1) != ' ';
> > start--);
> >         if (*rev == ' ')
> >             strncpy(rev, start, end - start);
> >         else
> >             strncpy((strstr(rev, "  ")) + 1, start, end - start);
> >         for(end = start - 1; end > string && *(end - 1) == ' '; end--);
> >     }

> This algorithm does not work (at least as I understand the problem):
> the case ' hello world' becomes 'world hello ' and not 'world hello'.

> Why not just print rev here? That is more logical.

> Likewise, you should free(rev) here since you malloc'd rev earlier.

> > Here is a version that uses only four pointers [...]

>No, see, that's exactly _not_ the challenge.  The challenge was, originally,
>to write a program that reversed a string using as little memory as
>possible,

> > > int main(int argc, char *argv[])
> > > {
> > >     char *string = NULL;
> > >     char *rev = NULL;
> > >     char *start = NULL;
> > >     char *end = NULL;

> > >     /* Assign command-line input to string if available. */
> > [snip]

> > This is a little clumsy because you have to include the whole string on
> > the command-line, and it's subject to shell quoting rules. For this
> > program to actually be useful, you should probably just read from stdin.

> In order to avoid the command line technique, I would have to gets() or
> fgets() or otherwise retrieve the input -- into a predefined array, which
> gets us back to the requirement of defining a big enough array, which goes
> against the spirit of the original challenge, which was to use as little
> memory as possible.  (Please see my previous response on this thread.)