text processing assignment

The goal of this assignment is to count the number of words in a user entered string, count the number of letters in the shortest and longest word, the average number of letters used, the number of newline characters used, and the number of times each word appears in the text. I have the first 5 parts done and cannot get the last part to work (the part that counts how many times each word appears).

my professor gave us the following function prototype and description:
void addword(char wordarray[][MAXWORD], char *word, int wordcount[], int *numwords);
if the word is present in the word array increment the words count. if it isn't add the word to the array and set the appropriate element in word count to 1.
Parameters:
wordarray - array of words in text
word - word to be processed
wordcount - array of wordcount
numwords - counter for total number of words in the array

I have no idea how to begin to utilize this seeing as i only have a one dimensional input array.



This is my code (I included the whole program because it basically encompasses everything I've learned so far, just to give you all an idea of my programming abilities):

Code:

---

#include <stdafx.h>
#include <stdio.h>
#define MaxData 1000
#define MaxWords 100


int wordcount(char a[MaxData]);
int shortestword(char a[MaxData]);
int longestword(char a[MaxData]);
int averagesize(char a[MaxData], int wordcount);
int newlinecount(char a[MaxData]);
void createnewarray(char a[], char b[MaxWords][MaxData]);


int main(void)
{
        char inputarray[MaxData];
        char newarray[MaxWords][MaxData];
        int counter1 = 0;
        int counter2 = 0;
        int count = 0;
        int shortest = 0;
        int longest = 0;
        int average = 0;
        int newline = 0;


        printf("Input the text to be tested: \n");
        scanf("&#37;[^\0]", inputarray);


        count = wordcount(inputarray);
        shortest = shortestword(inputarray);
        longest = longestword(inputarray);
        average = averagesize(inputarray, count);
        newline = newlinecount(inputarray);

        createnewarray(inputarray, newarray);


        printf("\nThere are %d words in the text.\n", count);
        printf("The shortest word has %d letters in it.\n", shortest);
        printf("The longest word has %d letters in it.\n", longest);
        printf("The average size of a word is %d letters.\n", average);
        printf("There were %d newline characters used.\n", newline);

        for (counter1 = 0; counter1 != count; counter1++)
        {
                printf("\n");
                for(counter2 = 0; newarray[counter1][counter2] != '\0'; counter2++)
                {
                        printf("%c", newarray[counter1][counter2]);
                }
        }


        for(;;);
        return 0;
}


int wordcount(char a[MaxData])
{
        int wordcounter = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                if ((*counter == ' ') || (*counter == '\n'))
                {
                        wordcounter++;
                }
        }
        return wordcounter;
}


int shortestword(char a[MaxData])
{
        int charcounter = 0;
        int shortestword = 500;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                charcounter++;
                if((*counter == ' ') || (*counter == '\n'))
                {
                        charcounter--;
                        if(charcounter < shortestword)
                        {
                                shortestword = charcounter;
                                charcounter = 0;
                        }
                        else
                                charcounter = 0;
                }
        }
        return shortestword;
}


int longestword(char a[MaxData])
{
        int charcounter = 0;
        int longestword = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                charcounter++;
                if((*counter == ' ') || (*counter == '\n'))
                {
                        charcounter--;
                        if(charcounter > longestword)
                        {
                                longestword = charcounter;
                                charcounter = 0;
                        }
                        else
                                charcounter = 0;
                }
        }
        return longestword;
}


int averagesize(char a[MaxData], int wordcount)
{
        int charcounter = 0;
        int averageword = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                charcounter++;
                if((*counter == ' ') || (*counter == '\n'))
                {
                        charcounter--;
                        averageword += charcounter;
                        charcounter = 0;
                }
        }
        averageword = averageword / wordcount;
        return averageword;
}


int newlinecount(char a[MaxData])
{
        int newlinecounter = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                if(*counter == '\n')
                {
                        newlinecounter++;
                }
        }
        return newlinecounter;
}


void createnewarray(char a[], char b[MaxWords][MaxData])
{
        char *counter;
        int bcounter = 0;
        int words = 0;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                if ((*counter == ' ') || (*counter == '\n'))
                {
                        b[words][bcounter] = '\0';
                        words++;
                        bcounter = 0;
                }
                else
                {
                b[words][bcounter] = *counter;
                bcounter++;
                }
        }

}

---

Code:

---

void addword(char wordarray[][MAXWORD], char *word, int wordcount[], int *numwords);

---

He's clearly showing a wordarray of two dimensions, here. You'll need two D's to get words lined up in "rows" and "columns". One dimension won't do.

ok, i tried converting my single dimension array to a two dimensional array with one word stored on each row of the array.

i added the following to main:

Code:

---

        char newarray[MaxWords][MaxData];
        int counter1 = 0;
        int counter2 = 0;


        createnewarray(inputarray, newarray);


        for (counter1 = 0; counter1 != count; counter1++)
        {
                for (counter2 = 0; counter2 != '\0'; counter2++)
                {
                        printf("%c", newarray[counter1][counter2]);
                }
                printf("\n");
        }

---

and I created the following function:

Code:

---

void createnewarray(char a[], char b[MaxWords][MaxData])
{
        char *counter = 0;
        int counter1 = 0;
        int word = 0;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                b[word][counter1] = *counter;
                counter1++;
                if (*counter == ' ')
                {
                        b[word][counter1] = '\0';
                        word++;
                        counter1 = 0;
                }
        }       
}

---

I have the nested for loops to check if my function is working properly but it's not. I get an ouput of just blank lines, it does drop down one line for each word in there but it doesn't print out any of the words.

edit:
I figured out the problem lies in the function, for some reason nothing is being stored in the new array.

I still can't get this to work, I tried creating a one dimensional array of pointers but i'm still having the same problem, nothing is written to the new array.

this is what i added to main:

Code:

---

        char *newarray[MaxWords];
        int counter1 = 0;

        createnewarray(inputarray, newarray);

        for (counter1 = 0; counter1 != count; counter1++)
        {
                printf("%c\n", *newarray[counter1]);
        }

---

and this is the new function:

Code:

---

void createnewarray(char a[], char *b[MaxWords])
{
        int counter = 0;
        int counter1 = 0;
        for (counter = 0; a[counter] != EOF; counter++)
        {
                if ((a[counter] == ' ') || (a[counter] == '\n'))
                {
                        a[counter] = '\0';
                }
        }
        *b[counter1] = a[0];
        counter1++;
        for (counter = 0; a[counter] != EOF; counter++)
        {
                if( a[counter] = '\0')
                {
                        counter++;
                        *b[counter1] = a[counter];
                        counter1++;
                }
        }
}

---

char *newarray[MaxWords];

this is array of not initialized pointers. Do you have somewhere initialization routine?

no I do not, everything in my program is either in the first post, or the third post. Wouldn't an uninitialized pointer work like an uninitialized variable? As long as I set it equal to something before I perform an action on it I should be fine right? I'm not too good with pointers, I read the two chapters in the book on pointers a few times but I guess they're not my strong suit.

Quote:

---

As long as I set it equal to something before I perform an action on it I should be fine right

---

yes... but you do not do it before using it...

that whole new function is how i'm trying to initialize each pointer in the array. I want each one to point to a word, but only one word, in the input. any suggestions on how to make that function do what i'm trying to have it do?

ok I finally got my two dimensional array of words, now I still have no clue how to check how many times each word appears, I updated my code in the first post to show what i currently have.

The very general steps are:

Sort the word set.
Start with the first word and compare the next word. If it is the same, increment a count and compare the next. If it isn't, compare the current word with the word after that and increment some count.
Display the results.

You will have to fill in the other operations depending on where you are confused and what you understand. For example, since you'll likely implement this with loops, you may have to display results before you move on to counting up the number of instances of the next word (that is, whatever caused a mismatch).

Write down a clear set of operations first and then implement.

ok I wrote something that I believe will count the words in the function the way I want it too, but now I have two errors:

text processing error LNK2019: unresolved external symbol "void __cdecl countarray(char (* const)[1000],char (* const)[1000],int * const)" (?countarray@@YAXQAY0DOI@D0QAH@Z) referenced in function _main

text processing fatal error LNK1120: 1 unresolved externals

This assignment is due at 6pm tonight so any help at all is much appreciated.

this is what my program looks like now:

Code:

---

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

#define MaxData 1000
#define MaxWords 100


int wordcount(char a[MaxData]);
int shortestword(char a[MaxData]);
int longestword(char a[MaxData]);
int averagesize(char a[MaxData], int wordcount);
int newlinecount(char a[MaxData]);
void createnewarray(char a[], char b[MaxWords][MaxData]);
void countarray(char a[][MaxData], char b[][MaxData], int c[MaxData], int count);
int stringcompare(char a[MaxData], char b[MaxData]);


int main(void)
{
        char inputarray[MaxData];
        char newarray[MaxWords][MaxData];
        char wordsarray[MaxWords][MaxData];
        int numbersarray[MaxData];
        int counter1 = 0;
        int counter2 = 0;
        int count = 0;
        int shortest = 0;
        int longest = 0;
        int average = 0;
        int newline = 0;


        printf("Input the text to be tested: \n");
        scanf("&#37;[^\0]", inputarray);


        count = wordcount(inputarray);
        shortest = shortestword(inputarray);
        longest = longestword(inputarray);
        average = averagesize(inputarray, count);
        newline = newlinecount(inputarray);

        createnewarray(inputarray, newarray);
        countarray(newarray, wordsarray, numbersarray, count);


        printf("\nThere are %d words in the text.\n", count);
        printf("The shortest word has %d letters in it.\n", shortest);
        printf("The longest word has %d letters in it.\n", longest);
        printf("The average size of a word is %d letters.\n", average);
        printf("There were %d newline characters used.\n", newline);

        for (counter1 = 0; counter1 != count; counter1++)
        {
                printf("\n");
                for(counter2 = 0; wordsarray[counter1][counter2] != '\0'; counter2++)
                {
                        printf("%c", wordsarray[counter1][counter2]);
                }
                printf("\t\t%d", numbersarray[counter1]);
        }



        for(;;);
        return 0;
}


int wordcount(char a[MaxData])
{
        int wordcounter = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                if ((*counter == ' ') || (*counter == '\n'))
                {
                        wordcounter++;
                }
        }
        return wordcounter;
}


int shortestword(char a[MaxData])
{
        int charcounter = 0;
        int shortestword = 500;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                charcounter++;
                if((*counter == ' ') || (*counter == '\n'))
                {
                        charcounter--;
                        if(charcounter < shortestword)
                        {
                                shortestword = charcounter;
                                charcounter = 0;
                        }
                        else
                                charcounter = 0;
                }
        }
        return shortestword;
}


int longestword(char a[MaxData])
{
        int charcounter = 0;
        int longestword = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                charcounter++;
                if((*counter == ' ') || (*counter == '\n'))
                {
                        charcounter--;
                        if(charcounter > longestword)
                        {
                                longestword = charcounter;
                                charcounter = 0;
                        }
                        else
                                charcounter = 0;
                }
        }
        return longestword;
}


int averagesize(char a[MaxData], int wordcount)
{
        int charcounter = 0;
        int averageword = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                charcounter++;
                if((*counter == ' ') || (*counter == '\n'))
                {
                        charcounter--;
                        averageword += charcounter;
                        charcounter = 0;
                }
        }
        averageword = averageword / wordcount;
        return averageword;
}


int newlinecount(char a[MaxData])
{
        int newlinecounter = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                if(*counter == '\n')
                {
                        newlinecounter++;
                }
        }
        return newlinecounter;
}


void createnewarray(char a[], char b[MaxWords][MaxData])
{
        char *counter;
        int bcounter = 0;
        int words = 0;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                if ((*counter == ' ') || (*counter == '\n'))
                {
                        b[words][bcounter] = '\0';
                        words++;
                        bcounter = 0;
                }
                else
                {
                b[words][bcounter] = *counter;
                bcounter++;
                }
        }
}


int stringcompare(char a[MaxData], char b[MaxData])
{
        for (int counter1 = 0 ; a[counter1] != '\0'; counter1++)
        {
                if (a[counter1] == b[counter1])
                {
                }
                else
                {
                        return 0;
                }
        }
        return 1;
}


void countarray(char a[][MaxData], char b[][MaxData], int c[MaxData], int count)
{
        int counter = 0;
        int newwordcount = 0;
        int charcounter = 0;
        int testcounter = 0;
        int same = 0;
        int charcount1 = 0;
        int isthesame = 0;
        int numbers = 0;
        char temparray1[MaxData] = "temp array 1";
        char temparray2[MaxData] = "temp array 2";
        for (charcounter = 0; a[counter][charcounter] != '\0'; charcounter++)
        {
                b[newwordcount][charcounter] = a[counter][charcounter];
        }
        b[newwordcount][charcounter] = '\0';
        c[newwordcount] = 1;
        newwordcount++;
       
        for (counter = 1; counter < count; counter++)
        {
                same = 0;
                for (charcounter = 0; a[counter][charcounter] != '\0'; charcounter++, charcount1++)
                {
                        temparray1[charcounter] = a[counter][charcounter];
                }
                temparray1[charcounter] = '\0';
               
                for (testcounter = 0; testcounter < newwordcount; testcounter++)
                {
                        for (charcounter = 0; b[testcounter][charcounter] != '\0'; charcounter++, charcount1++)
                        {
                                temparray2[charcounter] = b[testcounter][charcounter];
                        }
                        temparray2[charcounter] = '\0';
                       
                        isthesame = stringcompare(temparray1, temparray2);
                       
                        if (isthesame == 0)
                        {
                        }
                        else
                        {
                                numbers = c[newwordcount];
                                c[newwordcount] = numbers + 1;
                                same = 1;
                        }
                }
                if (same == 0)
                {
                        for (charcounter = 0; a[counter][charcounter] != '\0'; charcounter++)
                        {
                                b[newwordcount][charcounter] = a[counter][charcounter];
                        }
                        b[newwordcount][charcounter] = '\0';
                        c[newwordcount] = 1;
                        newwordcount++;
                }
        }
}

---

ok I fixed the unresolved external (was missing an argument in my function call and a parameter in my prototype).

however, it does not work properly, it prints out garbage for a word and a huge negative number for its count.

edit: it works if I enter only one word lol, it tells me that the word appeared one time

Does it print out garbage for every word, or just one word, or what? Do you get any output you like?

this is what i get for input when I enter 1 word, then when I enter more than one word

1 word:
Input the text to be tested:
why
^Z

There are 1 words in the text.
The shortest word has 3 letters in it.
The longest word has 3 letters in it.
The average size of a word is 3 letters.
There were 1 newline characters used.

why 1

multiple words:
Input the text to be tested:
why is this not working
^Z

Unhandled exception at 0x00412628 in text processing.exe: 0xC0000005: Access violation writing location 0x001302b0.

it points to here in my program:
b[newwordcount][charcounter] = a[counter][charcounter];

I tweaked it a bit more and now it doesnt flip out when I enter more than one word (the changes are in my post 3 posts up), but it still gives crap results. here is what it sais when I have more than one word.

Input the text to be tested:
why do I bother
^Z

There are 4 words in the text.
The shortest word has 1 letters in it.
The longest word has 6 letters in it.
The average size of a word is 3 letters.
There were 1 newline characters used.

why 1
do 2
I 2
I 2

Well, that line appears twice. I'm guessing your array indices are getting off somehow -- if you are using Visual Studio, when you hit F5 and your program stops, you should see the current "state of play" of your program, so you can see what all your variables are. Granted, at the moment I don't see how newwordcount gets past 0, so I don't see how a lot of the code actually gets executed.

yea I added a couple of newwordcounter++ in there in my edited post, what do you mean that my array indeces are getting off?

You're adding words every time they miss, not when they miss everything -- so for instance, why and I don't match, so you add I to the list in the third spot; but then do and I don't match, either, so you add I to the fourth spot too; then the third I and the fourth I match, so you add 1 to the third count, and the fourth I and the fourth I match so you add 1 to the fourth count.

I'm not quite sure how to remedy the situation, how exactly can I fix that? I'm assuming I need a break statement somewhere but I don't know where.

Quote:

---

Originally Posted by nellosmomishot

I'm not quite sure how to remedy the situation, how exactly can I fix that? I'm assuming I need a break statement somewhere but I don't know where.

---

That means you can't add words inside that loop. Only after you've tried to match every word so far, and failed on each of them, can you add your word as a new unique word.

wow thanks, that fixed a problem, i'm updating my code to show the changes. It doesn't print the words multiple times anymore, but it doesn't add them up still. this is my output now:

Input the text to be tested:
strings that are longer than three
words work now
that that that
^Z

There are 12 words in the text.
The shortest word has 3 letters in it.
The longest word has 7 letters in it.
The average size of a word is 4 letters.
There were 3 newline characters used.

strings 1
that 1
are 1
longer 1
than 1
three 1
words 1
work 1
now 1
that 1
that 1
that 1

even using strcmp to compare my strings it isn't working. Is there something wrong with my function that creates the two dimensional array? (void createnewarray) I want it to store 1 word on each line terminated by a null statement with no white space. I think that white space is making it into some of the strings in mine right now

But saying "int same = 1" declares a new variable named same -- which means once that close curly brace happens, the new variable is gone and you're back to the original int same, which still has a value of 0.

I changed it around a little more (the updated code is in my post a couple back). Now it goes into an infinite loop any time that I enter a word more than once

Considering all you are doing is gathering statistics I find your code a bit convoluted. I mean really you only need to read what is going on inside your buffer, not keep track of the buffer itself. But that is just my two cents.

I'm not quite sure what you mean by keep track of the buffer, what I need to do is see how many times every word in the string appears and the only way that I was able to figure out how to attempt to do that was the way it is now

okay, i'm wicked close now. It keeps correct count of all the words, outputs them correctly. But now it goes into an infinite loop after it prints out the output. I'm almost positive that the loop is coming from my print statement in main. here is my current code:

Code:

---

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

#define MaxData 1000
#define MaxWords 100


int wordcount(char a[MaxData]);
int shortestword(char a[MaxData]);
int longestword(char a[MaxData]);
int averagesize(char a[MaxData], int wordcount);
int newlinecount(char a[MaxData]);
void createnewarray(char a[], char b[MaxWords][MaxData]);
void countarray(char a[][MaxData], char b[][MaxData], int c[MaxData], int count);
int stringcompare(char a[MaxData], char b[MaxData]);


int main(void)
{
        char inputarray[MaxData];
        char newarray[MaxWords][MaxData];
        char wordsarray[MaxWords][MaxData];
        int numbersarray[MaxData];
        int counter1 = 0;
        int counter2 = 0;
        int count = 0;
        int shortest = 0;
        int longest = 0;
        int average = 0;
        int newline = 0;


        printf("Input the text to be tested: \n");
        scanf("%[^\0]", inputarray);


        count = wordcount(inputarray);
        shortest = shortestword(inputarray);
        longest = longestword(inputarray);
        average = averagesize(inputarray, count);
        newline = newlinecount(inputarray);

        createnewarray(inputarray, newarray);
        countarray(newarray, wordsarray, numbersarray, count);


        printf("\nThere are %d words in the text.\n", count);
        printf("The shortest word has %d letters in it.\n", shortest);
        printf("The longest word has %d letters in it.\n", longest);
        printf("The average size of a word is %d letters.\n", average);
        printf("There were %d newline characters used.\n", newline);

        for (counter1 = 0; counter1 < count; counter1++)
        {
                printf("\n");
                for(counter2 = 0; wordsarray[counter1][counter2] != '\0'; counter2++)
                {
                        printf("%c", wordsarray[counter1][counter2]);
                }
                printf("\t\t%d", numbersarray[counter1]);
        }



        return 0;
}


int wordcount(char a[MaxData])
{
        int wordcounter = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                if ((*counter == ' ') || (*counter == '\n'))
                {
                        wordcounter++;
                }
        }
        return wordcounter;
}


int shortestword(char a[MaxData])
{
        int charcounter = 0;
        int shortestword = 500;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                charcounter++;
                if((*counter == ' ') || (*counter == '\n'))
                {
                        charcounter--;
                        if(charcounter < shortestword)
                        {
                                shortestword = charcounter;
                                charcounter = 0;
                        }
                        else
                                charcounter = 0;
                }
        }
        return shortestword;
}


int longestword(char a[MaxData])
{
        int charcounter = 0;
        int longestword = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                charcounter++;
                if((*counter == ' ') || (*counter == '\n'))
                {
                        charcounter--;
                        if(charcounter > longestword)
                        {
                                longestword = charcounter;
                                charcounter = 0;
                        }
                        else
                                charcounter = 0;
                }
        }
        return longestword;
}


int averagesize(char a[MaxData], int wordcount)
{
        int charcounter = 0;
        int averageword = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                charcounter++;
                if((*counter == ' ') || (*counter == '\n'))
                {
                        charcounter--;
                        averageword += charcounter;
                        charcounter = 0;
                }
        }
        averageword = averageword / wordcount;
        return averageword;
}


int newlinecount(char a[MaxData])
{
        int newlinecounter = 0;
        char *counter;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                if(*counter == '\n')
                {
                        newlinecounter++;
                }
        }
        return newlinecounter;
}


void createnewarray(char a[], char b[MaxWords][MaxData])
{
        char *counter;
        int bcounter = 0;
        int words = 0;
        for (counter = &a[0]; *counter != '\0'; counter++)
        {
                if ((*counter == ' ') || (*counter == '\n'))
                {
                        b[words][bcounter] = '\0';
                        words++;
                        bcounter = 0;
                }
                else
                {
                b[words][bcounter] = *counter;
                bcounter++;
                }
        }
}


int stringcompare(char a[MaxData], char b[MaxData])
{
        for (int counter1 = 0 ; a[counter1] != '\0'; counter1++)
        {
                if (a[counter1] == b[counter1])
                {
                }
                else
                {
                        return 0;
                }
        }
        return 1;
}


void countarray(char a[][MaxData], char b[][MaxData], int c[MaxData], int count)
{
        int counter = 0;
        int newwordcount = 0;
        int charcounter = 0;
        int testcounter = 0;
        int same = 0;
        int charcount1 = 0;
        int isthesame = 0;
        int numbers = 0;
        char temparray1[MaxData] = "temp array 1";
        char temparray2[MaxData] = "temp array 2";
        for (charcounter = 0; a[counter][charcounter] != '\0'; charcounter++)
        {
                b[newwordcount][charcounter] = a[counter][charcounter];
        }
        b[newwordcount][charcounter] = '\0';
        c[newwordcount] = 1;
        newwordcount++;
       
        for (counter = 1; counter < count; counter++)
        {
                same = 0;
                for (charcounter = 0; a[counter][charcounter] != '\0'; charcounter++, charcount1++)
                {
                        temparray1[charcounter] = a[counter][charcounter];
                }
                temparray1[charcounter] = '\0';
               
                for (testcounter = 0; testcounter < newwordcount; testcounter++)
                {
                        for (charcounter = 0; b[testcounter][charcounter] != '\0'; charcounter++, charcount1++)
                        {
                                temparray2[charcounter] = b[testcounter][charcounter];
                        }
                        temparray2[charcounter] = '\0';
                       
                        isthesame = stringcompare(temparray1, temparray2);
                       
                        if (isthesame == 0)
                        {
                        }
                        else
                        {
                                numbers = c[testcounter];
                                c[testcounter] = numbers + 1;
                                same = 1;
                        }
                        if (same == 1)
                        {
                                break;
                        }
                }
                if (same == 0)
                {
                        for (charcounter = 0; a[counter][charcounter] != '\0'; charcounter++)
                        {
                                b[newwordcount][charcounter] = a[counter][charcounter];
                        }
                        b[newwordcount][charcounter] = '\0';
                        c[newwordcount] = 1;
                        newwordcount++;
                }
        }
}

---

I didn't read the entire specification of what the program needed to do... but here is some quick code for you to play with.

Example:

Code:

---

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

int letter_count(const char *buffer, const char **end)
{
  const char *p = buffer;

  while(*p && !isspace(*p))
    ++p;

  if(end)
    *end = p;

  return p - buffer;
}

int space_count(const char *buffer, const char **end)
{
  const char *p = buffer;

  while(*p && isspace(*p))
    ++p;

  if(end)
    *end = p;

  return p - buffer;
}

int main(void)
{
  char buffer[256];
  const char *s;
  int nwords = 0, nchars = 0, min = INT_MAX, max = INT_MIN, last = 0;

  while(fgets(buffer, sizeof(buffer), stdin))
  {
    for(s = buffer; *s;)
    {
      last = letter_count(s, &s);

      if(last)
      {
        ++nwords;

        if(last < min)
          min = last;

        if(last > max)
          max = last;

        nchars += last;
      }

      space_count(s, &s);
    }
  }

  printf("The largest word types was &#37;d characters.\n"
    "The shortest word typed was %d characters.\n"
    "%f characters is the average word length.\n", min, max, (float)nchars/(float)nwords);
 
  return 0;
}

---

Or something to that effect, anyway.

If you are a little clever its not that hard to even maintain track of what the longest and shortest words actually were, for that matter :)