C Program to Implements a dictionary's functionality.

C Program to Implements a dictionary's functionality.

How to write a C Program to Implements a dictionary's functionality in C Programming Language ?


Solution:

  1. /*Implements a dictionary's functionality.*/
  3. #include <stdbool.h>
  4. #include <string.h>
  5. #include <stdio.h>
  6. #include <ctype.h>
  8. #include "dictionary.h"
  10. // root node of trie, pointing to nothing
  11. node* root = NULL;
  13. // word counter, keep track of read words, set to zero
  14. int word_count = 0;
  16. /**
  17.  * Returns true if word is in dictionary else false.
  18.  */
  19. bool check(const char* word)
  20. {
  21.     // iterate through word char-by-char
  22.     for (int index = 0, n = strlen(word); index < n; index++)
  23.     {
  24.         // conver each letter of word into lower case
  25.         char c = tolower(word[index]);
  26.        
  27.         // to store index of children array
  28.         int i = 0;
  30.         if (c == '\'')
  31.         {
  32.             // is apostrophy (') detected, give it last index of the array
  33.             // i.e. size of array - 1
  34.             i = SIZE - 1;
  35.         }
  36.        
  37.         else
  38.         {
  39.             // convert letter into 0-25 from a-z
  40.             i = c - 'a';
  41.         }
  42.        
  43.         // create a tracker pointer to go through trie to check
  44.         node* tracker = root;
  45.        
  46.         if (tracker->children[i] == NULL)
  47.         {
  48.             // ith letter of word is not poiting to anything
  49.             // means word is not in dictionary
  50.             return false;
  51.         }
  52.        
  53.         else if (tracker->children[i] != NULL)
  54.         {
  55.             // poiting to something, so move to the next node
  56.             tracker = tracker->children[i];
  57.         }
  59.         // end of the word from text
  60.         if (index == n - 1)
  61.         {
  62.             return true;
  63.         }
  64.     }
  65.     return false;
  66. }
  68. /**
  69.  * Loads dictionary into memory.  Returns true if successful else false.
  70.  */
  71. bool load(const char* dictionary)
  72. {
  73.     // open dictionary in read only mode, sanity check
  74.     FILE* inptr = fopen(dictionary, "r");
  75.     if (inptr == NULL)
  76.     {
  77.         printf("Error! Couldn't open file.\n");
  78.         return false;
  79.     }
  80.    
  81.     // give root node something to point to, do sanity check
  82.     root = malloc(sizeof(node));
  83.     if (root == NULL)
  84.     {
  85.         printf("Error! Out of Memory.\n");
  86.         fclose(inptr);
  87.         return false;
  88.     }
  89.    
  90.     // to traverse through dictionary, tracker pointer poiting to root
  91.     node* tracker = root;
  92.    
  93.     // read dictionary char-by-char to end of file
  94.     for (char c = fgetc(inptr); c != EOF; c = fgetc(inptr))
  95.     {
  96.         // set is_word flag to false
  97.         tracker->is_word = false;
  98.        
  99.         // to store index of children array
  100.         int i = 0;
  101.        
  102.         // to convert char into lowercase, make it easy to index
  103.         c = tolower(c);
  104.        
  105.         // indexing
  106.         if (islower(c))
  107.         {
  108.             // if lower alpha, convert it into 0-25 from a-z
  109.             i = c - 'a';
  110.         }
  111.        
  112.         else if (c == '\'')
  113.         {
  114.             // if char is apostrophe (') give it last index of the array
  115.             // i.e. size of array - 1
  116.             i = SIZE - 1;
  117.         }
  118.        
  119.         else if (c == '\n')
  120.         {
  121.             // if char is \n, indicator of new word, flag is_word = true
  122.             tracker->is_word = true;
  123.            
  124.             // update word counter
  125.             word_count++;
  126.            
  127.             // reset tracker to root
  128.             tracker = root;
  129.         }
  130.        
  131.         else
  132.         {
  133.             // if any of above char is not detected, error in word reading
  134.             i = -1;
  135.             break;
  136.         }
  137.         // end of the indexing
  138.        
  139.         // use index to follow a path in trie
  140.         if (tracker->children[i] == NULL)
  141.         {
  142.             // tracker isn't pointing to anything
  143.             // create a new node to point to, do sanity check
  144.             node* new = malloc(sizeof(node));
  145.             if (new == NULL)
  146.             {
  147.                 printf("Error! Out of Memory.\n");
  148.                 fclose(inptr);
  149.                 return false;
  150.             }
  151.            
  152.             // make tracker to point to new node
  153.             tracker->children[i] = new;
  154.            
  155.             // move tracker to point to next node
  156.             tracker = tracker->children[i];
  157.            
  158.         }
  159.        
  160.         else if (tracker->children[i] != NULL)
  161.         {
  162.             // pointer tracker is pointing to something
  163.             // move tracker to point to next node
  164.             tracker = tracker->children[i];
  165.         }
  166.     }
  167.    
  168.     // close opened files
  169.     fclose(inptr);
  170.    
  171.     // if everything goes fine
  172.     return true;
  173. }
  175. /**
  176.  * Returns number of words in dictionary if loaded else 0 if not yet loaded.
  177.  */
  178. unsigned int size(void)
  179. {
  180.     // return number if word that are read
  181.     return word_count;
  182. }
  184. /**
  185.  * Unloads dictionary from memory.  Returns true if successful else false.
  186.  */
  187. bool unload(void)
  188. {
  189.     // TODO
  190.     return false;
  191. }


Learn More :

Function

Learn More Multiple Choice Question :