Normalizing the frequency of letters in a given .txt file - c

Question

The problem: Given a txt file, find the normalized frequencies of all the letters in the document.
For example if given letters.txt containing "aaabb"
Output would be:
Letter | Frequency
a 0.6
b 0.4
Non-letters or numbers should be ignored.
My solution so far:
Since they want to input a text file, my main() should receive command line arguments.
int main (int argc, char* argv[]){
I've made an EOF check using getchar()
while ((c=getchar()) != EOF){
and an if statement that checks if the char that getchar() is within the ASCII values for a->z or A->Z
if (argv[1][c] >= 'a' && argv[1][c] <= 'z' || argv[1][c] >= 'A' && argv[1]<= 'Z')
2 things here - I dont know if argv[1][c] is the right way to go about writing this but intuitively it made sense to me.
Once the check is satisfied, I want the corresponding letter to update a count specifically for its # position in the alphabet. Therefore needing a declared array that iterates for that letter each time it is found.
count[26];
Here is where I'm having troubles associating the letter a or A to position count[0] in the count array. I don't know how to code this part.

Answer 1

Why not create an int array that is of size 52 and have the first half of the array be for lower-case character counts and the upper half be for uppercase?
So in pseudocode:
#define ALPHA_COUNTS (52)
#define UPPER_OFFSET (26)
int counts[ALPHA_COUNTS] = {0};
for (char c : the_file_stream) {
if (c is an alphabet character) {
if (c is a lowercase character){
++counts[c - 'a'];
} else {
++counts[c - 'A' + UPPER_OFFSET];
}
}
}
Even easier would be to just create a table for all ASCII characters and just populate it for alphabet characters:
#define ASCII_COUNT (127)
int counts[ASCII_COUNT] = {0};
for (char c : the_file_stream) {
if (c is an alphabet character) {
++counts[c];
}
}
Then later on, you could just iterate through the set of [Aa-Zz] and check the counts of each of the characters.

Answer 2

Simplify the statistics gathering by counting the occurrence of all input.
Non-letters or numbers should be ignored in the result.
unsigned long long count[UCHAR_MAX + 1] = {0};
int ch;
while ((ch=getchar()) != EOF){
count[ch]++;
}
Now only sum the ones that are letters
unsigned long long sum = 0;
for (int i=0; i<=UCHAR_MAX; i++) {
if (isalpha(i)) {
sum += count[i];
// fold into lower case
if (isupper(i)) {
count[tolower(i)] += count[i];
count[i] = 0;
}
}
}
Print their frequency
for (int i=0; i<=UCHAR_MAX; i++) {
if (isalpha(i) && count[i] > 0) {
printf("%c %f\n", i, 1.0*count[i]/sum);
}
}

Answer 3

There are a number of different ways to approach the problem. You can make use the the functions provided in ctype.h (e.g. isalpha, tolower, toupper, etc.), or for the limited number of tests required, you can simply test the characters directly using arithmetic or basic bitwise operations. For example, you can test if a value is between 'a' and 'z' for lower-case, and for all characters the 6th-bit in 7-bit ASCII is the case-bit, so simply toggling the case-bit will change a character from upper-to-lower or vice versa.
The read then analyze approach chux outlined is an excellent approach to take. Any time you can separate input/output from processing data, you provide yourself a great deal of flexibility.
Using that logic, an example of using arithmetic and simple bitwise operations to analyze the frequency of alpha-characters ([A-Za-z]) which occur in a file can be written similar to the following. Note, the program will read from the filename provided as the first argument (or from stdin by default if no filename is given:
#include <stdio.h>
#include <limits.h>
int main (int argc, char **argv) {
unsigned long long count[UCHAR_MAX + 1] = {0}, sum = 0;
int c, i;
FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;
if (!fp) { /* validate file open for reading */
fprintf (stderr, "error: file open failed '%s'.\n", argv[1]);
return 1;
}
while ((c = fgetc(fp)) != EOF) count[c]++; /* fill count */
for (i = 0; i <= UCHAR_MAX; i++) {/* freq of only chars */
if ('A' <= i && i <= 'Z') { /* fold upper-case */
count[i ^ (1u << 5)] += count [i]; /* into lower */
count[i] = 0; /* zero index */
}
if ('a' <= i && i <= 'z') /* if lower-case */
sum += count[i]; /* add to sum */
}
printf ("\n total characters [A-Za-z]: %llu\n\n", sum);
for (i = 0; i <= UCHAR_MAX; i++)
if (count[i] > 0 && ('a' <= i && i <= 'z'))
printf (" %c%c : %.2f\n", i ^ (1u << 5), i, 1.0 * count[i]/sum);
putchar ('\n');
if (fp != stdin) fclose (fp); /* close if not stdin */
return 0;
}
Examples Use/Output
Using your example of 'aaabb' the program produces the following:
$ ./bin/char_freq < <(echo "aaabb")
total characters [A-Za-z]: 5
Aa : 0.60
Bb : 0.40
A slightly longer example shows the full character selection of only [A-Za-z]:
$ ./bin/char_freq < <(echo "*(a)123A_a/B+4b.")
total characters [A-Za-z]: 5
Aa : 0.60
Bb : 0.40
Look over this answer as well as all the others and let me know if you have additional questions.