Pangram in C using functions

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

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;
}

Answer 3

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 4

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 5

To check if a string is a Pangram ie whether it contains all the letters in the English alphabet then you can check the steps below on how you can achieve that in C.

1. Initialize an array of Booleans of size 26 for all the characters in the English alphabet to false.
2. Loop through the characters in your input string and set the index corresponding the index of that character to true in the array we declared above.
3. Loop through the modified Boolean array above and check if any value is false. If a value at any index is false then the input string is not a pangram
4. Return a true Boolean value outside the loop above, which is a statement that will be reached if all the indices in the array have a true value which means the input string is a pangram.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>

//implement pangram function
bool isPangram(char * chr){
    /*1. declare an array of booleans equal to the size of the English alphabet 
      2. each index represents a corresponding character in the English alphabet
      3. When the boolean value in an index is set to true then that means, the character for that index in the alphabet exists in the input string 
    */
    bool alphas[26] = {false};
    //loop through characters in that string and update its value in the array
    for(int i=0;chr[i]!='\0';i++){
        //get the char at this index
        char c = chr[i];
        //check if its in the alphabet
        if(c>='a' && c<='z'){
            //get the index of that letter 
            int index = c-'a';
            //set that index to true in our array
            alphas[index] = true;
          //process capital letters
        }else if(c>='A' && c<='Z'){
            int index = c-'A';
            //set that index to true
            alphas[index] = true;   
        }
    }
    //loop through the boolean array and check for false(es) if any
    for(int i=0;i<26;i++){
        if(alphas[i]== false){
            return false;
        }
    }
    return true;
}
int main(int argc, char *argv[])
{
    //initialize an input string 
    char buff[1000];
    //read input from the user
    fgets(buff, sizeof(buff),stdin);
    //check if string is pangram
    if(isPangram(buff)){
        printf("%s %s",buff, " is a pangram");
    }else{
            printf("%s %s",buff, " is not a pangram");
    }
}

The most common input string you can use to check if the input string is a pangram is The quick brown fox jumps over the lazy dog.

NB:My code is limited to ASCII characters and won't work on a system using a different system of characters.