I’m a fan of the online game Spelling Bee. In this game, you use a combination of seven letters to spell various words. Each word is at least four-letters long and must contain a special letter, shown in the center of Figure 1. When you create a word that contains all seven letters, you’ve discovered a pangram.

Figure 1. Seven tiles from the Spelling Bee game. One of the pangrams is WARPING, which uses all seven letters.

The Spelling Bee puzzle shown in Figure 1 has 34 correct answers. Each one contains at least four of the shown letters and all include the W, the center tile. It’s a fun game that inspires me to wonder how many words in English are pangrams?

According to the Spelling Bee rules, the answers cannot be proper nouns. They can occasionally be foreign words, though this rule seems inconsistent. Regardless, I’m inspired. I cobbled together code from last week’s Lesson to look for 7-letter words. Then I added an update to this month’s Exercise solution to look for unique characters in 7-letter words. Here is the result:

2023_11_18-Lesson.c

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

/* this code assumes the following path is valid */
#define DICTIONARY "/usr/share/dict/words"
#define SIZE 32
#define LENGTH 7
#define TRUE 1
#define FALSE 0

int char_scan(char *a)
{
    int size,x,y;

    /* obtain size */
    size = strlen(a) + 1;
    /* scan the characters */
    for( x=0; x<size-2; x++ )
    {
        for( y=x+1; y<size-1; y++ )
        {
            if( a[x] == a[y] )
            {
                /* not unique */
                return(FALSE);
            }
        }
    }
    return(TRUE);
}

int main()
{
    FILE *dict;
    int unique;
    char word[SIZE],*r;

    /* open the dictionary */
    dict = fopen(DICTIONARY,"r");
    if( dict==NULL )
    {
        fprintf(stderr,"Unable to open %s\n",DICTIONARY);
        exit(1);
    }

    /* scan for LENGTH-letter words */
    unique = 0;
    while( !feof(dict) )
    {
        memset(word,'\0',SIZE);        /* clear buffer */
        r = fgets(word,SIZE,dict);    /* read a word */
        if( r==NULL )
            break;
        if( word[LENGTH-2]=='\'' )            /* skip possessives */
            continue;
        if( word[LENGTH]=='\n' )            /* 7-letter word */
        {
            if( char_scan(word) )
            {
                printf("%s",word);
                unique++;
            }
        }
    }
    printf("I found %d pangrams!\n",unique);

    /* close */
    fclose(dict);

    return(0);
}

The char_scan() function is an update to digit_scan() from this month’s Exercise solution. The snprintf() function isn’t required as a string (a) is passed directly. I retained the size variable, though all strings should be 7-characters long. Otherwise, the function works the same as from this month’s Exercise solution.

The main() function scans for LENGTH size words, where LENGTH is 7 characters. For words of that size, the char_scan() function is called and, when TRUE, the pangram word is output and a tally kept.

When I ran the program without checking for pangrams, it reported 11,945 7-letter words in the dictionary file. After adding the char_scan() function, the output showed 4,078 pangrams.

The program isn’t perfect. For example, it flags the word vicuña as being 7-letters long. It’s probably interpreting the ñ as two-letters. Further, the Spelling Bee game tries to avoid plurals, where my program makes no such attempt.

All Spelling Bee puzzles have at least one pangram solution. Sometimes the pangrams can be quite long. For next week’s Lesson, I scan the digital dictionary to look for all possible pangram words seven letters or longer.