Определить количество букв, слов и строк

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#define DELIMS " .,!?\t\n;:-'""
 
int main() {
    
    FILE *fp = fopen("C:\\file.txt","r");
    int count[26], num, letter,qtyStr=0;
    char str[512];
    char word1[256];
    char word2[256];    
    char *pstr;
    size_t size,i,j;
 
    if (fp == NULL) {
        printf("File not found!\n");
        return 0;
    }
    
    fgets(str,1024,fp);
    printf("%s\n", str);    
        
    // How many times any letters occured
    for (i=0; i < 26; i++)
    count[i]=0;
    for (i=0;i<strlen(str);i++){
    num=-1;
    if (str[i] >= 'a' && str[i] <='z')
    num = str[i] - 'a';
    if (str[i] >= 'A' && str[i] <='Z')
    num = str[i] - 'A';
    if (num >= 0) count[num]++;
    }
    
    for (i=0;i<26;i++){
        if (count[i] > 0)
        printf("%c - %d\n", 'A'+i, count[i]);
    }
 
    
    /*  while (pstr = strtok(str,DELIMS), pstr != NULL, pstr = strtok(NULL,DELIMS)){    
        }
    */
        getch();
    
    fclose(fp);
    system("pause");
    return 0;
}

#define DELIMS " .,!?\t\n;:-'""

char str[512];

fgets(str,1024,fp);

for (i=0;i<strlen(str);i++){

  i < strlen(str)

str[i] != '\0'

struct NODE {
    const char * key;
    int value;
    struct NODE * left;
    struct NODE * right;
};
 
struct NODE * node_new(const char * wrd) {
    struct NODE * ptr = malloc(sizeof(struct NODE));
 
    if ( ! ptr )
        return NULL;
 
    ptr->key = wrd; // только надо помнить, что нельзя освобождать память, выделенную под строку, пока вся эта затея с деревом не кончится
                              // ну или дублировать то, что по указателю, функцией strdup или подобной самоделкой, но потом не забывать память возвращать
    ptr->value = 1;
    ptr->left = NULL;
    ptr->right = NULL;
 
    return ptr;
}
 
int node_add(struct NODE ** ptr, const char * wrd) {
    if ( ! *ptr )
        if ( ( *ptr = node_new(wrd) ) == NULL )
            return -1;
    else {
        int cmp = strcmp((*ptr)->key, wrd);
        if ( cmp < 0 )
            return node_add(&((*ptr)->right), wrd);
        else if ( cmp > 0 )
            return node_add(&((*ptr)->left), wrd);
        else
            (*ptr)->value += 1;
    }
    return 0;
}

void kill_tree(struct NODE * root) {
    if ( root ) {
        kill_tree(root->left);
        kill_tree(root->right);
        free(root);
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
 
struct node {
    struct node* left;
    struct node* right;
    const char*  key;
    unsigned int cnt;
    int cost;
};
 
typedef struct {
    struct node* root;
} rtree;
 
static struct node* new_node(const char* key);
static struct node* r_insert_root(struct node* ptr, const char* key);
static struct node* r_rotate(struct node* p, int left);
static void r_fixsize(struct node* p);
static void r_print(FILE* _out, struct node* p);
static void r_clear(struct node* p);
static struct node* r_insert(struct node* p, const char* key);
void rtree_init(rtree* tr) { tr->root = NULL; }
void rtree_add(rtree* tr, const char* key);
void rtree_print(FILE* _out, rtree* tr);
void rtree_clear(rtree* tr);
char* readfile(const char* filename);
 
int main(void){
    rtree tr;
    char* buf, *p;
    const char delim[] = " \r\n\t,.!?-;:";
    
    if((buf = readfile("file.txt")) == NULL)
        return 1;
 
    rtree_init(&tr);
    p = strtok(buf, delim);
    while(p != NULL){
        rtree_add(&tr, p);
        p = strtok(NULL, delim);
    }
 
    rtree_print(stdout, &tr);
    rtree_clear(&tr);
    free(buf);
    getchar();
    return 0;
}
 
void rtree_add(rtree* tr, const char* key){
    tr->root = r_insert(tr->root, key);
}
 
void rtree_print(FILE* _out, rtree* tr){
    if(tr->root != NULL)
        r_print(_out, tr->root);
}
 
void rtree_clear(rtree* tr){
    if(tr->root != NULL)
        r_clear(tr->root);
    tr->root = NULL;
}
 
//печать
static void r_print(FILE* _out, struct node* p){
    if(p->left != NULL)
        r_print(_out, p->left);
    fprintf(_out, "%s(%u)\n", p->key, p->cnt);
    if(p->right != NULL)
        r_print(_out, p->right);
}
 
//удаление всех
static void r_clear(struct node* p){
    if(p->left != NULL)
        r_clear(p->left);
    if(p->right != NULL)
        r_clear(p->right);
    free(p);
}
 
//вставка
static struct node* r_insert(struct node* p, const char* key){
    int ret;
    if(p == NULL)
        return new_node(key);
 
    ret = strcmp(key, p->key);
    if(ret == 0){
        p->cnt += 1;
        return p;
    }
 
    if(!(rand() % (p->cost + 1)))
        return r_insert_root(p, key);
 
    if(ret < 0)
        p->left = r_insert(p->left, key);
    else
        p->right = r_insert(p->right, key);
    r_fixsize(p);
    return p;
}
 
// вставка узла в корень дерева
static struct node* r_insert_root(struct node* p, const char* key){
    int ret;
    if(p == NULL)
        return new_node(key);
 
    ret = strcmp(key, p->key);
    if(ret == 0){
        p->cnt += 1;
        return p;
    } else if(ret < 0)
        p->left  = r_insert_root(p->left, key);
    else
        p->right = r_insert_root(p->right, key);
    return r_rotate(p, ret < 0);
}
 
//вращение
static struct node* r_rotate(struct node* p, int left){
    struct node* t = (left) ? p->right : p->left;
    if(t == NULL)
        return p;
 
    if(left){ // левый поворот вокруг узла
        p->right = t->left;
        t->left  = p;
    } else {  // правый поворот вокруг узла
        p->left  = t->right;
        t->right = p;
    }
    t->cost = p->cost;
    r_fixsize(p);
    return t;
}
 
static void r_fixsize(struct node* p){
    if(p != NULL){
        p->cost  = (p->left  != NULL) ? p->left->cost  : 0;
        p->cost += (p->right != NULL) ? p->right->cost : 0;
        p->cost += 1;
    }
}
 
static struct node* new_node(const char* key){
    struct node* p = (struct node*)malloc(sizeof(struct node));
    if(p != NULL){
        p->key  = key;
        p->cost = 1;
        p->cnt  = 1;
        p->left = p->right = NULL;
    }   
    return p;
}
 
//загрузка файла
char* readfile(const char* filename){
    long   m;
    char*  s  = NULL;
    FILE*  fp = fopen(filename, "rb");
    if(fp == NULL)
        return NULL;
 
    fseek(fp, 0L, SEEK_END);
    if((m = ftell(fp)) <= 0L)
        goto err;
    if((s = (char*)malloc((m + 1) * sizeof(char))) == NULL)
        goto err;
 
    fseek(fp, 0L, SEEK_SET);
    if(fread(s, 1, (size_t)m, fp) != (size_t)m)
        goto err;
 
    fclose(fp);
    s[m] = '\0';
    return s;
err:
    fclose(fp);
    if(s != NULL)
        free(s);
    return NULL;
}

#include <glib.h>
#include <gio/gio.h>
 
#define DELIM " \t\n,.!?()\'\"-"
 
gboolean print_counter(gpointer key, gpointer val, gpointer width) {
    g_print("%-*s | %d\n", GPOINTER_TO_INT(width), (char*)key, GPOINTER_TO_INT(val));
    return FALSE;
}
 
const int DEFAULT_WIDTH = 20;
 
int main(int argc, char ** argv) {
    if ( argc < 2 ) {
        g_print("Usage: %s <input_file>\n", *argv);
        return 1;
    }
    
    GFile * fin = g_file_new_for_path(argv[1]);
    char * buf;
    gsize length;
    GError * err = NULL;
    
    if ( ! g_file_load_contents(fin, NULL, &buf, &length, NULL, &err) ) {
        g_print("%s: can't read input file: %s\n", *argv, ( err ) ? err->message : "unknown reason");
        return 1;
    }
    
    g_object_unref(fin);
    
    char ** tokens = g_strsplit_set(buf, DELIM, -1);
    GTree * counters = g_tree_new((GCompareFunc)g_strcmp0);
    
    for ( char ** tok = tokens; *tok; ++tok )
        if ( **tok )
            g_tree_insert(counters, *tok, GINT_TO_POINTER(GPOINTER_TO_INT(g_tree_lookup(counters, *tok)) + 1));
    
    g_print("%-*s | %s\n", DEFAULT_WIDTH, "WORD", "MEETS");
    g_tree_foreach(counters, print_counter, GINT_TO_POINTER(DEFAULT_WIDTH));
    
    g_tree_destroy(counters);
    g_strfreev(tokens);
    g_free(buf);
    
    return 0;
}

#include <glib.h>
#include <gio/gio.h>
 
#define DELIM " \t\n,.!?()'`-"
 
typedef struct WCNT {
    const char * wrd;
    int cnt;
} wcnt_t;
 
wcnt_t * wcnt_new(const char * w) {
    wcnt_t * p = g_new(wcnt_t, 1);
    
    p->wrd = w;
    p->cnt = 1;
    
    return p;
}
 
int wcnt_compare_words(const wcnt_t * a, const wcnt_t * b) {
    return g_strcmp0(a->wrd, b->wrd);
}
 
int wcnt_compare_counters(const wcnt_t * a, const wcnt_t * b) {
    return a->cnt - b->cnt;
}
 
void wcnt_dump(const wcnt_t * p, const void * w) {
    g_print("%-*s | %d\n", GPOINTER_TO_INT(w), p->wrd, p->cnt);
}
 
const int DEFAULT_WIDTH = 20;
 
int main(int argc, char ** argv) {
    if ( argc < 2 ) {
        g_print("Usage: %s <input_file>\n", *argv);
        return 1;
    }
    
    GFile * fin = g_file_new_for_path(argv[1]);
    char * buf;
    gsize length;
    GError * err = NULL;
    
    if ( ! g_file_load_contents(fin, NULL, &buf, &length, NULL, &err) ) {
        g_print("%s: can't read input file: %s\n", *argv, ( err ) ? err->message : "unknown reason");
        return 1;
    }
    
    g_object_unref(fin);
    
    char ** tokens = g_strsplit_set(buf, DELIM, -1);
    g_free(buf);
    
    GList * list = NULL;
    
    for ( char ** token = tokens; *token; ++token ) {
        if ( **token ) {
            wcnt_t * p = wcnt_new(*token);
            GList * iter = g_list_find_custom(list, p, (GCompareFunc)wcnt_compare_words);
            if ( iter ) {
                ((wcnt_t*)(iter->data))->cnt += 1;
                g_free(p);
            }
            else
                list = g_list_prepend(list, p);
        }
    }
    list = g_list_sort(list, (GCompareFunc)wcnt_compare_counters);
    
    g_print("%-*s | %s\n", DEFAULT_WIDTH, "WORD", "MEETS");
    g_list_foreach(list, (GFunc)wcnt_dump, GINT_TO_POINTER(DEFAULT_WIDTH));
    
    g_list_free_full(list, g_free);
    g_strfreev(tokens);
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define DELIMS " .,!?\t\n;:-\'"""
 
// word control
typedef struct word {
    struct word *next;              // linked list pointer
    char *str;                      // pointer to word string
    int count;                      // word frequency count
} word_t;
 
word_t wordlist;                    // list of words
 
// cleanword -- strip chaff and clean up word
void
cleanword(char *dst,const char *src)
{
    int chr;
 
    // NOTE: using _two_ buffers in much easier than trying to clean one buffer in-place
    for (chr = *src++;  chr != 0;  chr = *src++) {
        if (! isalpha(chr))
            continue;
        chr = tolower(chr);
        *dst++ = chr;
    }
 
    *dst = 0;
}
 
// addword -- add unique word to list and keep count of number of words
void
addword(const char *str)
{
    word_t *cur;
    word_t *prev;
    char word[1000];
 
    // get the cleaned up word
    cleanword(word,str);
 
    // find a match to a previous word [if it exists]
    prev = NULL;
    for (cur = wordlist.next;  cur != NULL;  cur = cur->next) {
        if (strcmp(cur->str,word) == 0)
            break;
        prev = cur;
    }
 
    // found a match -- just increment the count (i.e. do _not_ create a
    // duplicate that has to be removed later)
    if (cur != NULL) {
        cur->count += 1;
        return;
    }
 
    // new unique word
    cur = malloc(sizeof(word_t));
    if (cur == NULL)
        printf("Malloc failure!\n");
 
    cur->count = 1;
    cur->next = NULL;
 
    // save off the word string
    cur->str = strdup(word);
    if (cur->str == NULL)
        printf ("Strdup failure!\n");
 
    // add the new word to the end of the list
    if (prev != NULL)
        prev->next = cur;
 
    // add the first word
    else
        wordlist.next = cur;
}
 
main(int argc,char **argv)
{
    FILE *fp;
    char buf[1000];
    char *cp;
    char *bp;
    word_t *cur;
 
 
    fp = fopen("input.txt","r");
    if (fp == NULL)
       printf("Can not to open file!\n");
 
    while (1) {
        // get next line
        cp = fgets(buf,sizeof(buf),fp);
        if (cp == NULL)
            break;
 
        // loop through all words on a line
        bp = buf;
        while (1) {
            cp = strtok(bp,DELIMS);
            bp = NULL;
 
            if (cp == NULL)
                break;
 
            // add this word to the list [avoiding duplicates]
            addword(cp);
        }
    }
 
    fclose(fp);
 
    // print the words and their counts
    for (cur = wordlist.next;  cur != NULL;  cur = cur->next)
        printf("%s %d\n",cur->str,cur->count);
 
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
typedef struct WCNT {
    char * wrd;
    size_t cnt;
} wcnt_t;
 
wcnt_t * wcnt_new(const char * wrd) {
    wcnt_t * ptr = malloc(sizeof(wcnt_t));
    assert(ptr);
    ptr->wrd = malloc(strlen(wrd) + 1);
    assert(ptr->wrd);
    strcpy(ptr->wrd, wrd);
    ptr->cnt = 1;
 
    return ptr;
}
 
void wcnt_free(wcnt_t * ptr) {
    free(ptr->wrd);
    free(ptr);
}
 
typedef struct WCNT_LIST {
    wcnt_t * counter;
    struct WCNT_LIST * next;
} wcnt_list_t;
 
void wcnt_list_append(wcnt_list_t ** listPtr, const char * wrd) {
    if ( ! *listPtr ) {
        *listPtr = malloc(sizeof(wcnt_list_t));
        assert(*listPtr);
        (*listPtr)->counter = wcnt_new(wrd);
        (*listPtr)->next = NULL;
    }
    else if ( strcmp((*listPtr)->counter->wrd, wrd) == 0 )
        (*listPtr)->counter->cnt += 1;
    else
        wcnt_list_append(&((*listPtr)->next), wrd);
}
 
void wcnt_list_sort_by_cnt(wcnt_list_t * list) {
    wcnt_list_t * nextPtr, * minPtr = list;
 
    if ( ! minPtr )
        return;
 
    for ( nextPtr = list->next; nextPtr; nextPtr = nextPtr->next )
        if ( nextPtr->counter->cnt < minPtr->counter->cnt )
            minPtr = nextPtr;
 
    if ( minPtr != list ) {
        wcnt_t * tmp = minPtr->counter;
        minPtr->counter = list->counter;
        list->counter = tmp;
    }
 
    wcnt_list_sort_by_cnt(list->next);
}
 
void wcnt_list_free(wcnt_list_t * list) {
    while ( list ) {
        wcnt_list_t * next = list->next;
        wcnt_free(list->counter);
        free(list);
        list = next;
    }
}
 
/******************************************************************************/
/********************************* MAIN ***************************************/
/******************************************************************************/
 
#define DELIM " ,.!?\t\n"
#define WORD_FIELD 20
 
int main(int argc, char *argv[]) {
    FILE * f;
    char buf[BUFSIZ], * wptr;
    wcnt_list_t * lptr, * list = NULL;
 
    if ( argc != 2 ) {
        fprintf(stderr, "USAGE: %s <input_file_name>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
 
    if ( ( f = fopen(argv[1], "r") ) == NULL ) {
        fprintf(stderr, "%s: can't open input file!\n", argv[0]);
        exit(EXIT_FAILURE);
    }
 
    while ( fgets(buf, BUFSIZ, f) )
        for ( wptr = strtok(buf, DELIM); wptr; wptr = strtok(NULL, DELIM) )
            wcnt_list_append(&list, wptr);
 
    fclose(f);
 
    if ( ! list ) {
        fprintf(stderr, "%s: no words found!\n", argv[0]);
        exit(EXIT_FAILURE);
    }
 
    wcnt_list_sort_by_cnt(list);
 
    printf("%-*s | %s\n", WORD_FIELD, "WORD", "COUNT");
    for ( lptr = list; lptr; lptr = lptr->next )
        printf("%-*s | %u\n", WORD_FIELD, lptr->counter->wrd, (unsigned)lptr->counter->cnt);
 
    wcnt_list_free(list);
    exit(EXIT_SUCCESS);
}