Title: Getting Started

Where do I start?

The beginning would seem a good place. Think about what constitutes a string.

Letters? Numbers? Punctuation?

Yes. What are all those things called collectively?

Symbols?

But what represents a symbol in C?

A char.

Good, but there are several kinds of char. Which should we use?

I know that there are signed and unsigned ones but how do I choose?

Do you think the concept of a negative character makes sense?

No. So I guess I should choose the unsigned one.

How many different characters might there be in the string?

I have no idea.

Yes you have. Think about unsigned char. How many different symbols can it represent?

It all depends

On what?

Which codes make sense.

OK. Let us assume they all do. What is the largest number? Think about limits.

You mean check limits.h? … UCHAR_MAX.

Almost, but that is the value of the largest. Think about the value of the smallest.

I see. We are counting from zero. So at most there may be UCHAR_MAX+1 different unsigned chars.

Good. So we will need to be able to keep counts for up to that number of characters. Does that give you any ideas?

What about an array of counters? Something like int counters[UCHAR_MAX+1].

Why an int array? Think about the nature of a counter. What is the least value it can have?

You mean it would be better as:

unsigned int counters[UCHAR_MAX + 1];

Yes. But where are we going to put that definition and how should it be initialised?

What is wrong with it as it is?

Nothing until someone else uses your code, or until you recycle it yourself in a few months time. As it is it is a global variable. Despite all you may have been taught, global variables are very bad news in modern code where several processes (threads) may be running at the same time.

OK. Then it will have to be in a function. What about:

int main(void){
  unsigned int counters[UCHAR_MAX + 1];
}

Well that is a start. But you need to initialise your counters. Check out the rules and you will find that you can do better than write a loop.

Yes, I remember that we can brace initialise an array to zeroes.

Good. Now where is that string coming from?

I do not know. But I could delay the decision with a function. Something like:

char * getString();

and use that for a data item in main()

char * data_string = getString();

Excellent. Make a note that we will have to write getString() and make sure that it returns a pointer to a non-local object.

For the next part we will have to tie down the problem a little further. What sort of characters are we going to count? All of them or just letters?

I think that just letters was intended.

OK. But are we to distinguish upper and lower case?

Let us do it the hard way and say no.

Now we need to do some research. How do we identify letters? Be careful because we do not want to miss the accented ones. And how do we collect corresponding upper and lower case ones together. Go and check out the Standard Library.

…OK, I think I have found what we need. isalpha() will identify letters and tolower() will provide the code for lowercase versions of uppercase letters.

Time to write a little more code. Write code to count the letters from your string:

Like this:

int main(void){
  unsigned int counters[UCHAR_MAX + 1] = {0};
  char * data_string = getString();
  unsigned int iter;
  for(  iter = 0; 
      iter <  strlen(data_string);
       ++iter){
    if (isalpha(data_string[iter]) {
      ++counters[tolower(data_string)];
    }
  }
  return 0;
}

Good. You will need some header files, you will need to provide a definition of getString(). I like that simple use of strlen() rather than trying to be clever. I also note that someone has had the sense to tell you to pre-increment for preference (that will work better if you write C++ code)

It is time to consider finding the least often used letter. Think about what the largest value of this could be under the worst circumstances (always a good idea to think about boundary conditions).

The string might contain a single letter repeated. So the largest possible value for the count of the least used letter (that is a mouthful☺) is strlen(data_string);

Exactly. Now just iterate through the counters lowering the limit each time you find a lower but non-zero count.

Like:

unsigned int least=strlen(data_string);
for(iter=0; iter<UCHAR_MAX+1; ++iter){
  if(counters[iter])
    if(counters[iter]<least) {
      least = counters[iter];
    }
  }
}

And I could do the opposite for finding the most frequent.

unsigned int most = 0;
for(iter=0; iter<UCHAR_MAX+1; ++iter){
  if(counters[iter])
    if(counters[iter]<most){
       most = counters[iter];
    }
  }
}

True. What would it mean if least stays as strlen(data_string)?

That the string was all one letter.

Really? Any other possibility? What if if(counters[iter]) always fails?

I see. If there were no letters in the string then the value of least would never be changed. But neither would the value of most. Hey that is useful. The only way that the value of most could be zero is if there were no letters in the string. Perhaps we should count those first.

Fine. Now see if you can go away and write your complete program. It never said in the original spec but I think you should print out all letters that are least frequent and all that are most frequent.