How to count the number of same character in C?

Question

I'm writing a code a that prompts the user to enter a string

&

create a function that is a type void that prints out the character that was used the most

(As in where it appeared more than any other ones)

&

also shows the number of how many times it was in that string.

Therefore here is what I have so far...

#include <stdio.h>
#include <string.h>
/* frequent character in the string along with the length of the string (use strlen from string.h – this will require you to #include <string.h> at the top of your program).*/


/* Use array syntax (e.g. array[5]) to access the elements of your array.
 * Write a program that prompts a user to input a string, 
 * accepts the string as input, and outputs the most
 * You should implement a function called mostfrequent.
 * The function prototype for mostfrequent is: void mostfrequent(int *counts, char *most_freq, int *qty_most_freq, int num_counts);
 * Hint: Consider the integer value of the ASCII characters and how the offsets can be translated to ints.
 * Assume the user inputs only the characters a through z (all lowercase, no spaces). 
 */


void mostfrequent(int *counts, char *most_freq, int *qty_most_freq, int num_counts_)
{
        int array[255] = {0}; // initialize all elements to 0
        int i, index;
        for(i = 0; most_freq[i] != 0; i++)
        {
           ++array[most_freq[i]];
        }
// Find the letter that was used the most

qty_most_freq = array[0];
 for(i = 0; most_freq[i] != 0; i++)
 {
      if(array[most_freq[i]] > qty_most_freq)
           {
               qty_most_freq = array[most_freq[i]];
               counts = i;
           }
        num_counts_++;
}
  printf("The most frequent character was: '%c' with %d occurances \n", most_freq[index], counts);
        printf("%d characters were used \n",  num_counts_);
}
int main()
{
char array[5];
printf("Enter a string ");
scanf("%s", array);
int count = sizeof(array);
mostfrequent(count , array, 0, 0);
        return 0;
}

I'm getting the wrong output too.

output:

Enter a string hello The most frequent character was: 'h' with 2 occurances 5 characters were used

should be

The most frequent character was: 'l' with 2 occurances 5 characters were used

Answer 1

let's do it short (others will correct me if I write something wrong ^_^ ) you declare a int like this:

int var;

use it like this :

var = 3;

you declare a pointer like this :

int* pvar;

and use the pointed value like this:

*pvar = 3;

if you declared a variable and need to pass a pointer to it as function parameters, use the & operator like this :

functionA(&var);

or simply save its address in a pointer var :

pvar = &var;

that's the basics. I hope it will help...

Answer 2

The function prototype you are supposed to use seems to include at least one superfluous parameter. (you have the total character count available in main()). In order to find the most frequently appearing character (at least the 1st of the characters that occur that number of times), all you need to provide your function is:

1. the character string to be evaluated;
2. an array sized so that each element represents on in the range of values you want to find the most frequent (for ASCII characters 128 is fine, for all in the range of unsigned char, 256 will do); and finally
3. a pointer to return the index in your frequency array that holds the index to the most frequently used character (or the 1st character of a set if more than one are used that same number of times).

In your function, your goal is to loop over each character in your string. In the frequency array (that you have initialized all zero), you will map each character to an element in the frequency array and increment the value at that element each time the character is encountered. For example for "hello", you would increment:

frequency['h']++;
frequency['e']++;
frequency['l']++;
frequency['l']++;
frequency['o']++;

Above you can see when you are done, the element frequency['l']; will hold the value of 2. So when you are done you just loop over all elements in frequency and find the index for the element that holds the largest value.

if (frequency[i] > frequency[most])
   most = i;

(which is also why you will get the first of all characters that appear that number of times. If you change to >= you will get the last of that set of characters. Also, in your character count you ignore the 6th character, the '\n', which is fine for single-line input, but for multi-line input you need to consider how you want to handle that)

In your case, putting it altogether, you could do something similar to:

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

enum { CHARS = 255, MAXC = 1024 };      /* constants used below */

void mostfrequent (const char *s, int *c, int *most)
{
    for (; *s; s++)     /* loop over each char, fill c, set most index */
        if (isalpha (*s) && ++c[(int)*s] > c[*most])
            *most = *s;
}

int main (void) {

    char buf[MAXC];
    int c[CHARS] = {0}, n = 0, ndx;

    /* read all chars into buf up to MAXC-1 chars */
    while (n < MAXC-1 && (buf[n] = getchar()) != '\n' && buf[n] != EOF)
        n++;
    buf[n] = 0;     /* nul-terminate buf */

    mostfrequent (buf, c, &ndx);    /* fill c with most freq, set index */
    printf ("most frequent char: %c (occurs %d times, %d chars used)\n",
            ndx, c[ndx], n);
}

(note: by using isalpha() in the comparison it will handle both upper/lower case characters, you can adjust as desired by simply checking upper/lower case or just converting all characters to one case or another)

Example Use/Output

$ echo "hello" | ./bin/mostfreqchar3
most frequent char: l (occurs 2 times, 5 chars used)

(note: if you use "heello", you will still receive "most frequent char: e (occurs 2 times, 6 chars used)" due to 'e' being the first of two character that are seen the same number of times)

There are many ways to handle frequency problems, but in essence they all work in the same manner. With ASCII characters, you can capture both the most frequent character and the number of times it occurs in a single array of int and an int holding the index to where the max occurs. (you don't really need the index either -- it just save looping to find it each time it is needed).

For more complex types, you will generally use a simple struct to hold the count and the object. For example if you were looking for the most frequent word, you would generally use a struct such as:

struct wfreq {
    char *word;
    int count;
}

Then you simply use an array of struct wfreq in the same way you are using your array of int here. Look things over and let me know if you have further questions.

Answer 3

Here is what I came up with. I messed up with the pointers.

void mostfrequent(int *counts, char *most_freq, int *qty_most_freq, int num_counts_)
{
        *qty_most_freq = counts[0];
        *most_freq = 'a';
        int i;
 for(i = 0; i < num_counts_; i++)
 {

      if(counts[i] > *qty_most_freq)
           {
               *qty_most_freq = counts[i];
               *most_freq = 'a' + i;
           }
}
}
/* char string[80]
 * read in string
 * int counts[26]; // histogram
 * zero counts (zero the array)
 * look at each character in string and update the histogram
 */
int main()
{
int i;
int num_chars = 26;
int counts[num_chars];
char string[100];

/*zero out the counts array */
 for(i = 0; i < num_chars; i++)
 {
        counts[i] = 0;
 }
printf("Enter a string ");
scanf("%s", string);

for(i = 0; i < strlen(string); i++)
{
        counts[(string[i] - 'a')]++;
}

int qty_most_freq;
char most_freq;

mostfrequent(counts , &most_freq, &qty_most_freq, num_chars);
printf("The most frequent character was: '%c' with %d occurances \n", most_freq, qty_most_freq);
        printf("%d characters were used \n",  strlen(string));
        return 0;
}