Reversing only the characters in a string of multiple words and/or spaces

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

#include "tools.h"

/*
    remove when CLUE is accepting beyond ANSI
    Maintaining Backwards compatibility
*/
extern char* strdup( const char*);

/*
   See tests.c for details on the required functions and data structures
*/
extern const int NB_TESTS;
extern const char * tests_inputs[];
extern const char * tests_expected[];


/* Forward definition of prototype, defined at the end of this source file */
void runAllTests();

/* MAIN starts here  */
int main()
{
    printf("\tWelcome to PA202\n\n");
    runAllTests();

    return EXIT_SUCCESS;
}


void runAllTests(){
    /* ROLE       Runs all the tests specified and displays results
    */
    int i;
    char *test_input       		= NULL; 	/* what we provide our function with */
    const char *test_expected   = NULL;  	/* what we expect the result to be */
    char *test_observed    		= NULL; 	/* what our function returns */
    int test_outcome;              			/* test successful or not? */

    /* let's iterate over all available tests */
    for(i=0; i < NB_TESTS; i++){
            printf("Test #%d\t\t", i);

            /* setting up this specific test */
            test_input = (char*)strdup(tests_inputs[i]);
            test_expected = tests_expected[i];

            /* getting the result from our implementations */
            words_modify(test_input);

            /* test_input has been modified */
            test_observed = test_input;

            if (!test_observed){
                printf("FAILED\n");
                continue;
            }

            test_outcome = strcmp(test_observed, test_expected);

            /* verifying if observed result is the expected one */
            if ( test_outcome != 0){
                   /* if expected output is not the produced one, test fails*/
                   printf("FAILED");
            }else{
                    /* otherwise test was successfull */
                    printf("OK");
            }
            printf("\t\t[%s]->[%s]", tests_inputs[i], test_observed);
            printf("\n");

            /* de-allocating memory allocated by words_modify */
            if (test_observed) free(test_observed);
			test_input = NULL; 	/* test input is now a dangling pointer */
    }
}

Select allOpen in new window

#ifndef _TOOLS_H_
#define _TOOLS_H_

void words_modify( char* str );
    /* 	ROLE        Parses the string str and identify each word in it.
                    Words are separated by any character which makes the
                    is_separator function returns true.
                    The address of the first character of each word in
                    the string str, is stored as a pointer in the array words.
                    When we find the end of the word we just added in the string
                    str, we modify it so that the next character becomes '\0'.
                    We are not able to handle more than maxwords words
                    and subsequent ones will be ignored.
                    Our function will return the number of words it found
                    which also indicates how many of the maxwords elements in
                    the array words are meaningful.
		RETURNS     the number of words identified in the string input.
		PARAMETERS  input    - string in which we will identify words
                    words    - an array of pointer on strings which will be the
                               words we have identified
                    maxwords - the size of the words array of pointers
    */
#endif

Select allOpen in new window

#include <stdlib.h>
#include <ctype.h>


void word_reverse( char* str ){
     /* ROLE:       [ Reverses the order of the characters in the string. Does
                      not modify the end of string marker '\0'. ]
        RETURNS:    [ nothing - void ]
        PARAMETERS: [ str - the string to reverse ]
        AUTHOR:     [ REMOVED ]
        DATE:       [ 3/19/12 ]
     */

     char hold;      // temporary location used to swap characters in the string
     char *end_ptr;      // char pointer used to swap characters in the string

     // set char pointer to str
     end_ptr = str;


     // Loop through all characters in string
     while(*end_ptr){
        end_ptr++;
     }

     // Set end pointer to character just before string terminator '\0'
     --end_ptr;

     /* Loop through half of string swapping the first character with the last
        character, then the second with the next to last, etc., excluding the string-
        terminating character '\0'. If the string has and odd number of characters,
        the middle character does not change.*/

     while(str < end_ptr){
         hold = *str;
         *str = *end_ptr;
         *end_ptr = hold;

         str++;
         end_ptr--;
     } // end while
} // end function word_reverse



int is_separator( char data ){
    /* ROLE:        [ Tests if the character passed as parameter is a separator;
                    i.e. something different than a letter or digit. ]
       RETURNS:     [ 1 - if data is a separator
                      0 - otherwize ]
       PARAMETERS:  [ data - the character to test ]
       AUTHOR:      [ REMOVED ]
       DATE:        [ 3/19/12 ]
    */

    return(!isalnum(data));

} // end function is_separator

int words_initialize( char* str, char* words[], int maxwords ){
    /* 	ROLE:       [ Parses the string str and identify each word in it.
                      Words are separated by any character which makes the
                      is_separator function return true.
                      The address of the first character of each word in
                      the string str, is stored as a pointer in the array words.
                      When we find the end of the word we just added in the string
                      str, we modify it so that the next character becomes '\0'.
                      We are not able to handle more than maxwords words
                      and subsequent ones will be ignored.
                      Our function will return the number of words it found
                      which also indicates how many of the maxwords elements in
                      the array words are meaningful. ]

		RETURNS:    [ the number of words identified in the string input ]
		PARAMETERS: [ str      - string in which we will identify words
                      words    - an array of pointers to strings which will be the
                                 words we have identified
                      maxwords - the size of the words array of pointers ]
        AUTHOR:      [ REMOVED ]
        DATE:        [ 3/19/12 ]
    */

    int nbwords = 0; /* total number of words in str;
                        also indicates how many of the maxwords elements in
                        the array words are meaningful.
                     */

    int state = 0;   /* state = 0 means we're looking for the start of a word
                        state = 1 means we're looking for the end of a word
                     */

    // Loop through all characters in the string
    while(*str){

        // When we are outside a word (state == 0)
        if (state == 0){

            // The first non-separator character...
            if (!is_separator(*str)){

                if( nbwords < maxwords)
                   // ...is the beginning of the first word
                   words[nbwords++] = str;
                else
                   // If we have exceeded maxwords, break out of the loop, ignoring all subsequent words
                   break;

                // We are now inside a word
                state = 1;
            } // end if
        } // end if
        else {

            // When we are inside a word (state == 1), the first separator character...
            if (is_separator(*str)) {
                // ...is the end of the word
                *str = '\0';
                // We are now outside of a word
                state = 0;
            } // end if
        } // end else

        // Move to the next character in the string
        str++;
    } // end while

    return nbwords;
} // end function words_initialize


void word_handle_marker(char* str){  // WORKING FUNCTION - JUST DOCUMENT :)  - GIFT
     /* ROLE:        [ Replaces the end of string marker '\0' by a space ' ' ]
        RETURNS:     [ nothing - void ]
        PARAMETERS:  [ str - the string to modify ]
        AUTHOR:      [ REMOVED ]
        DATE:        [ 3/19/12 ]
     */

     // Loop through all characters in the string
     while(*str){
        str++;
     } // end while

     /* Set the separator character changed to '\0' by
        function words_initialize to a space ' '
     */
     *str = ' ';
} // end function word_handle_marker

void words_modify(char* str, int* key){
     /* ROLE:        [ Modifies a string by calling functions words_initialize,
                       words_reverse, and words_handle_marker]
        RETURNS:     [ nothing - void ]
        PARAMETERS:  [ str - the string to modify ]
        AUTHOR:      [ REMOVED ]
        DATE:        [ 3/19/12 ]
     */

     // Maximum number of words that can be initialized by function words_initialize
     const int MAXWORDS = 256;
     // array of pointers to characters to be used in function words_initalize
     char* allwords[MAXWORDS];

     int i;         // loop counter
     int nbwords;   // number of words in string

     // initialize all pointers in allwords to NULL
     for(i=0; i < MAXWORDS ; i++)
              allwords[i] = NULL;

    // Get number of words in string
    nbwords = words_initialize(str, allwords, MAXWORDS);

    // Reverse all the words in the string
    for(i=0 ; i < nbwords ; i++){
            word_reverse(allwords[i]);
    }

    // Scramble all the words in the string
    for(i=0 ; i < nbwords ; i++)
            word_scramble(allwords[i], (int)key);


    /* Set separator characters modified to string terminators '\0'
       in words_initialize to spaces
    */
    for(i=0 ; i < (nbwords-1) ; i++)
            word_handle_marker(allwords[i]);

} // end function words_modify

Select allOpen in new window

#include <stdlib.h>

const int NB_TESTS = 19;


const char *tests_inputs[] = {
    "hello",                    // single word with odd number of characters
    "test",                     // single word with even number of characters
    "how are you",              // multiple words with one space between words
    "several   spaces",         // several spaces in a row between words
    " space in front",          // one spaces before any words
    "  spaces in front",        // several spaces before any words
    "space at end ",            // one space at the end
    "spaces at end   ",         // several spaces at the end
    "tab    control",           // tab control between words
    " ",                        // space only
    "    ",                     // several spaces only
    "",                         // empty string
    "?punctuation",             // single punctuation mark at beginning of word
    "punctuation?",             // single punctuation mark at end of word
    "punct.uation",             // single punctuation mark in the middle of word
    "?#.@*punctuation",         // mutiple punctuation marks at beginning of word
    "punctuation!@#$%",         // mutiple punctuation marks at the end of word
    "?@p unctuation.% #multi",   // multiple punctuation marks

    // 257 words - tests that words_initialize does not attempt to handle more than MAXWORDS
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This is a test "
    "This is a test This is a test This is a test This is a test This should not be reached"

};


const char *tests_expected[] = {
    "olleh",
    "tset",
    "woh era uoy",
    "lareves   secaps",
    " ecaps ni tnorf",
    "  secaps ni tnorf",
    "ecaps ta dne ",
    "secaps ta dne   ",
    "bat    lortnoc",
    " ",
    "    ",
    "",
    "?noitautcnup",
    "noitautcnup?",
    "tcnup.noitau",
    "?#.@*noitautcnup",
    "noitautcnup!@#$%",
    "?@p noitautcnu.% #itlum",
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset sihT si a tset "
    "sihT si a tset sihT si a tset sihT si a tset sihT si a tset"

};

Select allOpen in new window