gistfile1.c

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>

#define ARRAY_SIZE(a) sizeof(a)/sizeof(a[0])
#define ALPHABET_SIZE (26)
// Converts key current character into index
// use only 'a' through 'z' and lower case
#define CHAR_TO_INDEX(C) ((int)C - (int)'A')
#define INDEX_TO_CHAR(IX) ('A' + IX)


char words[3000][40]={{0}};
int counters[3000]={0};
int wordnr=0;

typedef struct trie_node trie_node_t;
struct trie_node
{
    int counter;
    trie_node_t *children[ALPHABET_SIZE];
};

typedef struct trie trie_t;
struct trie
{
    trie_node_t *root;
    int count;
};

// Returns new trie node
trie_node_t *getNode(void)
{
    trie_node_t *pNode = NULL;

    pNode = (trie_node_t *)malloc(sizeof(trie_node_t));

    if( pNode )
    {
        int i;

        pNode->counter = 0;

        for(i = 0; i < ALPHABET_SIZE; i++)
        {
            pNode->children[i] = NULL;
        }
    }

    return pNode;
}

// Initializes trie
void initialize(trie_t *pTrie)
{
    pTrie->root = getNode();
    pTrie->count = 0;
}

void setorder_rec(trie_node_t *pCrawl, char *str, int n)
{
    if (pCrawl == NULL) return;

    if (pCrawl->counter) {
        str[n]='\0';
        strcpy(words[wordnr],str);
        words[wordnr][strlen(str)]='\0';
        counters[wordnr]=pCrawl->counter;
        wordnr++;
    }

    for (int i = 0; i < ALPHABET_SIZE; i++) {
        str[n] = INDEX_TO_CHAR(i);
        setorder_rec(pCrawl->children[i], str, n + 1);
    }
}

void setorder(trie_t *pTrie)
{
    char tempword[40] = {0};

    setorder_rec(pTrie->root, tempword, 0);
}

void insert(trie_t *pTrie, char key[])
{
    int level;
    int length = strlen(key);
    int index;
    trie_node_t *pCrawl;


    pTrie->count++;
    pCrawl = pTrie->root;

    for( level = 0; level < length; level++ )
    {
        index = CHAR_TO_INDEX(key[level]);
        if( !pCrawl->children[index] )
        {
            pCrawl->children[index] = getNode();
        }
        pCrawl = pCrawl->children[index];
    }

    pCrawl->counter++;
}

void bubble_sort(int n)
{
    int i,j,temp;
    char tempwordy[40]={0};


    for(i=1;i< n;i++)
    {
        for(j=0;j< n-1;j++)
        {
            if(counters[j]>counters[j+1])
            {  
                temp=counters[j];
                counters[j]=counters[j+1];
                counters[j+1]=temp;

		strcpy(tempwordy,words[j]);
		strcpy(words[j],words[j+1]);
		strcpy(words[j+1],tempwordy);
            }
         }
    }
}


void freeNode(trie_node_t *pCrawl) 
{
    if (pCrawl == NULL) return;

    for (int i = 0; i < ALPHABET_SIZE; i++) 
        freeNode(pCrawl->children[i]);
    
    free(pCrawl);
}



int main(int argc, char *argv[])
{
    trie_t trie;

printf("argc=%d argv[%d]=%s\n",argc, 1, argv[1]);
printf("argv[%d]=%s\n", 2, argv[2]);
printf("argv[%d]=%s\n", 3, argv[3]);
printf("argv[%d]=%s\n", 4, argv[4]);
printf("argv[%d]=%s\n", 5, argv[5]);
    printf("\n");


    initialize(&trie);
    printf("tu");
    // Construct trie
    for(int i = 1; i < argc; i++)
    {
        insert(&trie, argv[i]);
    }

    setorder(&trie);
    bubble_sort(argc);

    for(int i=argc-1; i>=0; i--)
    {
        printf("#%d %s=%d\n", i, words[i], counters[i]);
    }

    freeNode((&trie)->root);

    return 0;
}

gistfile2.c

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>

int main (int argc, char **argv)
{
    int c;
    char *input = argv[1];
    FILE *input_file;

    input_file = fopen(input, "r");

    if (input_file == 0)
    {
        //fopen returns 0, the NULL pointer, on failure
        perror("Canot open input file\n");
        exit(-1);
    }
    else
    {
        int found_word = 0;

        while ((c =fgetc(input_file)) != EOF )
        {
            //if it's an alpha, convert it to lower case
            if (isalpha(c))
            {
                found_word = 1;
                c = toupper(c);
                putchar(c);
            }
            else {
                if (found_word) {
                    putchar('\n');
                    found_word=0;
                }
            }

        }
    }

    fclose(input_file);

    printf("\n");

    return 0;
}

gistfile3.txt

THE
PROJECT
GUTENBERG
EBOOK
OF
THE
KING
JAMES
BIBLE
THIS
EBOOK
IS
FOR
THE
USE
OF
ANYONE
ANYWHERE
AT
NO
COST
AND
WITH
ALMOST
NO
RESTRICTIONS
WHATSOEVER
YOU
MAY
COPY
IT
GIVE
IT
AWAY
OR
RE
USE
IT
UNDER
THE
TERMS
OF
THE
PROJECT
GUTENBERG
LICENSE
INCLUDED
WITH
THIS
EBOOK
OR
ONLINE
AT
WWW
GUTENBERG
ORG
TITLE
THE
KING
JAMES
BIBLE
RELEASE
DATE
MARCH
EBOOK
THIS
KING
JAMES
BIBLE
WAS
ORGINALLY
POSTED
BY
PROJECT
GUTENBERG
IN
LATE
LANGUAGE
ENGLISH
START
OF
THIS
PROJECT
GUTENBERG
EBOOK
THE
KING
JAMES
BIBLE
THE
OLD
TESTAMENT
OF
THE
KING
JAMES
VERSION
OF
THE
BIBLE
THE
FIRST
BOOK
OF
MOSES
CALLED
GENESIS
IN
THE
BEGINNING
GOD
CREATED
THE
HEAVEN
AND
THE
EARTH
AND
THE
EARTH
WAS
WITHOUT
FORM
AND
VOID
AND
DARKNESS
WAS
UPON
THE
FACE
OF
THE
DEEP
AND
THE
SPIRIT
OF
GOD
MOVED
UPON
THE
FACE
OF
THE
WATERS
AND
GOD
SAID
LET
THERE
BE
LIGHT
AND
THERE
WAS
LIGHT
AND
GOD
SAW
THE
LIGHT
THAT
IT
WAS
GOOD
AND
GOD
DIVIDED
THE
LIGHT
FROM
THE
DARKNESS
AND
GOD
CALLED
THE
LIGHT
DAY
AND
THE
DARKNESS
HE
CALLED
NIGHT
AND
THE
EVENING
AND
THE
MORNING
WERE
THE
FIRST
DAY
AND
GOD
SAID
LET
THERE
BE
A
FIRMAMENT
IN
THE
MIDST
OF
THE
WATERS
AND
LET
IT
DIVIDE
THE
WATERS
FROM
THE
WATERS
AND
GOD
MADE
THE
FIRMAMENT
AND
DIVIDED
THE
WATERS
WHICH
WERE
UNDER
THE
FIRMAMENT
FROM
THE
WATERS
WHICH
WERE
ABOVE
THE
FIRMAMENT
AND
IT
WAS
SO
AND
GOD
CALLED
THE
FIRMAMENT
HEAVEN
AND
THE
EVENING
AND
THE
MORNING
WERE
THE
SECOND
DAY
AND
GOD
SAID
LET
THE
WATERS
UNDER
THE
HEAVEN
BE
GATHERED
TOGETHER
UNTO
ONE
PLACE
AND
LET
THE
DRY
LAND
APPEAR
AND
IT
WAS
SO
AND
GOD
CALLED
THE
DRY
LAND
EARTH
AND
THE
GATHERING
TOGETHER
OF
THE
WATERS
CALLED
HE
SEAS
AND
GOD
SAW
THAT
IT
WAS
GOOD
AND
GOD
SAID
LET
THE
EARTH
BRING
FORTH
GRASS
THE
HERB
YIELDING
SEED
AND
THE
FRUIT
TREE
YIELDING
FRUIT
AFTER
HIS
KIND
WHOSE
SEED
IS
IN
ITSELF
UPON
THE
EARTH
AND
IT
WAS
SO
AND
THE
EARTH
BROUGHT
FORTH
GRASS
AND
HERB
YIELDING
SEED
AFTER
HIS
KIND
AND
THE
TREE
YIELDING
FRUIT
WHOSE
SEED
WAS
IN
ITSELF