Pangram in C using functions - c

Question

When I input The quick brown fox jumps over the lazy dog, the following program prints not a pangram. Yet, I expect s to be 26 and printf("pangram") to be executed. What am I doing wrong?
#include <ctype.h>
#include <stdio.h>
#include <string.h>
char findpan(char arr[]) {
int i, j, count = 0;
for (i = 0; i < strlen(arr); i++) {
if (isalpha(arr[i]))
count++;
}
for (i = 0; i < strlen(arr); i++) {
for (j = i + 1; j < strlen(arr); j++) {
if (arr[i] == arr[j])
count--;
}
}
return (count);
}
int main() {
int s;
char str[60];
fgets(str, 60, stdin);
s = findpan(str);
if (s == 26)
printf("pangram");
else
printf("not a pangram");
return 0;
}

Answer 1

If I have understood what you are trying to do then these nested loops
for (i = 0; i < strlen(arr); i++) {
for (j = i + 1; j < strlen(arr); j++) {
if (arr[i] == arr[j])
count--;
}
}
are incorrect. Let's assume that you have string "AAA". So after the preceding loop count will be equal to 3.
Now after these nested loops count will be equal to 0 instead of 1. That is when i = 0 then for j = 1 and j = 2 arr[j] is equal to arr[i]. So count will be decreased two times. When i = 1 then for j = 2 again arr[j] = arr[i] and count will be decreased one more.
Also it seems you should ignore cases of letters.
I can suggest the following function implementation as it is shown in the demonstrative program below.
#include <stdio.h>
#include <ctype.h>
size_t findpan( const char *s )
{
size_t count = 0;
for ( const char *p = s; *p; ++p )
{
if ( isalpha( ( unsigned char ) *p ) )
{
char c = tolower( ( unsigned char )*p );
const char *q = s;
while ( q != p && c != tolower( ( unsigned char )*q ) ) ++q;
if ( q == p ) ++ count;
}
}
return count;
}
int main(void)
{
printf( "%zu\n", findpan( "The quick brown fox jumps over the lazy dog" ) );
return 0;
}
The program output is
26
Without using pointers the function can look the following way
size_t findpan( const char *s )
{
size_t count = 0;
for ( size_t i = 0; s[i] != '\0'; i++ )
{
if ( isalpha( ( unsigned char ) s[i] ) )
{
char c = tolower( ( unsigned char )s[i] );
size_t j = 0;
while ( j != i && c != tolower( ( unsigned char )s[j] ) ) ++j;
if ( j == i ) ++count;
}
}
return count;
}

Answer 2

Simple Solution?
Here a Simple solution, I made the guess that you probably just want to know if it is or it isn't a pangram and so i've changed your function to a boolean one:
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
bool findpan(char arr[]) {
int i,j;
for (i = 'a'; i < 'z'; ++i) { // goes through the alphabet
for (j = strlen(arr); j > 0; j--) // goes through the arr[]
if (tolower(arr[j]) == i) // checks if the letter exists
break; // breaks the inner for-loop if letter found
if (j == 0) // if letter not found
return false;
}
return true;
}
int main() {
bool isPangram;
char str[60];
fgets(str, 60, stdin);
isPangram = findpan(str);
if (isPangram)
printf("pangram");
else
printf("not a pangram");
return 0;
}
Explanation
'a' to 'z' represent the range of the lowercase letters in Decimal numbers, in the ASCII table:
for (i = 'a'; i < 'z'; ++i)
tolower converts arr[j] character to lowercase and then compares it to i:
if (tolower(arr[j]) == i)
stdbool.h is introduced for the use of bool aka boolean:
#include <stdbool.h>

Answer 3

Limiting myself to plain ASCII you can create a simple array, with one element per letter and each element initialized to zero. Then loop over the string, and for each letter convert it to an index into the array and increase the corresponding elements value.
Once done with the input string, you loop over the array, and increase a counter for every non-zero value, and return that.
Perhaps something like this:
#include <stdio.h>
#include <ctype.h>
int main(void)
{
char input[512];
if (!fgets(input, sizeof input, stdin))
return 1; // Failed to read input
int letters[26] = { 0 }; // 26 letters in the English alphabet
for (unsigned i = 0; input[i] != '\0'; ++i)
{
if (isalpha(input[i]))
{
// Limiting myself to e.g. plain ASCII here
++letters[tolower(input[i]) - 'a'];
}
}
// Count the number of non-zero elements in the letters array
unsigned counter = 0;
for (unsigned i = 0; i < 26; ++i)
{
counter += letters[i] != 0;
}
// Print result
printf("Counter = %d\n", counter);
}
With your example input (The quick brown fox jumps over the lazy dog) it outputs
Counter = 26
This does only a single pass over the input string, and then a single pass over the letters array. No nested loop, no multiple passes over the input string.

Answer 4

If we assume 8 bit characters and can stand allocating 256 bytes on the stack temporarily, then this is both readable, compact and fairly efficient:
bool is_pangram (const char* str)
{
char used [256]={0};
for(; *str!='\0'; str++)
{
used[*str]=1;
}
return memchr(&used['a'], 0, 26)==NULL; // 26 letters in the alphabet
}
The 256 byte zero-out might seem inefficient, but the mainstream x86 compilers run that in 16 instructions. This function also makes no assumptions of adjacency of 'a' to 'z'. To add support for upper case, simply do used[tolower(*str)]=1; though that might introduce a lot of branching.
Test code:
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
bool is_pangram (const char* str)
{
char used [256]={0};
for(; *str!='\0'; str++)
{
used[*str]=1;
}
return memchr(&used['a'], 0, 26)==NULL;
}
int main (void)
{
const char* test_cases[] =
{
"",
"hello, world!",
"the quick brown fox jumps over the lazy dog",
"the quick brown cat jumps over the lazy dog",
"junk mtv quiz graced by fox whelps",
"public junk dwarves hug my quartz fox",
};
for(size_t i=0; i<sizeof test_cases/sizeof *test_cases; i++)
{
printf("\"%s\" is %sa pangram\n", test_cases[i], is_pangram(test_cases[i])?"":"not ");
}
return 0;
}