Markov Text Generator, ou générer des phrases aléatoires

void separe_mots (char * txt, char tab[][101], int * nb_mots) {
    int i;
    char mot[101]; // Mot que l'on étudie

    for (i = 0; i <= strlen(txt); ++i) { // On parcourt le texte
        if (txt[i] == ' ' || txt[i] == '\0') { // Si on tombe sur un espace ou sur la fin du texte
            strcat(mot, "\0"); // On indique la fin du mot
            strcpy(tab[*nb_mots], mot); // On insère le mot dans le tableau
            sprintf(mot, ""); // On réinitialise mot
            *nb_mots += 1; // Permet de modifier la variable en dehors de la fonction
        } else {
            sprintf(mot, "%s%c", mot, txt[i]); // On ajoute le caractère au mot
        }
    }
}

char text[101][101]; // Contient les mots de la phrase complète
int nb_mots = 0; // Nombre de mots dans le tableau

separe_mots(t, text, &nb_mots);

typedef struct markov {
    char ngram[101]; // Le n-gramme (texte) qu'on étudie
    int  number_chains; // Le nombre de mots trouvés
    char chain[101][101]; // Un tableau contenant les mots trouvés
} markov;

markov chaines[101]; // Chaîne de Markov contenant les n-grammes
                     //  et les mots qui leur sont associés
int nb_chaines = 0; // Nombre de n_grammes
char n_gramme[101]; // N-gramme que l'on étudit

int i; // N-gramme que l'on étudit
int j; // Un des mots associés au n-gramme étudié

for (i = 0; i <= nb_mots-d-1; ++i) {
    sprintf(n_gramme, ""); // On initialise le texte du n-gramme

    // On recompose le n-gramme à partir des données du tableau contenant la phrase complète
    for (j = 0; j < d-1; ++j) {
        strcat(n_gramme, text[i+j]);
        strcat(n_gramme, " ");
    }
    strcat(n_gramme, text[i+d-1]);
    strcat(n_gramme, "\0");

    j = 0;
    while (strcmp(n_gramme, chaines[j].ngram) && (j < nb_chaines)) {
    // On parcourt le tableau tant que l'on a pas trouvé le bon n-gramme
        ++j;
    }

    if (j == nb_chaines) { // Si on n'a pas trouvé un n-gramme correspondant
        strcpy(chaines[j].ngram, n_gramme); // On crée un nouveau n-gramme...
        strcpy(chaines[j].chain[chaines[j].number_chains], text[i+d]); // ... et on y associe le mot trouvé.
        chaines[j].number_chains = 1;
        nb_chaines += 1;
    } else { // Si on a trouvé un n-gramme correspondant
        strcat(chaines[j].chain[chaines[j].number_chains], text[i+d]); // On associe au n-gramme le mot trouvé.
        chaines[j].number_chains += 1;
    }
}

int random_seed = 0; // Variable globale nécessaire pour le bon fonctionnement de la fonction

int pick_option_index(int nb_options) {
    random_seed += 7; // Valeur arbitraire pour créer du pseudo-aléatoire
    return random_seed % nb_options;
}

char result[101][101]; // Tableau contenant le phrase finale
int nb_mots_result = 0; // Nombre de mots dans la phrase finale
int mk; // Element de la chaîne de Markov que l'on étudit
int ind_aleatoire; // Indice aléatoire du mot choisi
char n_gramme_result[101]; // N-gramme du résultat que l'on étudit

separe_mots(s, result, &nb_mots_result);

while (nb_mots_result < l) { // Tant que l'on n'a a pas la bonne longueur
    sprintf(n_gramme_result, ""); // On initialise le texte du n-gramme

    // On recompose le n-gramme à partir des données du tableau contenant la phrase complète
    for (i = nb_mots_result-d; i < nb_mots_result; ++i){
        strcat(n_gramme_result, result[i]);
        if (i < nb_mots_result-1) {
            strcat(n_gramme_result, " ");
        }
    }

    mk = 0;
    while (strcmp(n_gramme_result, chaines[mk].ngram)) { // On parcourt le tableau tant que l'on a pas trouvé le bon n-gramme
        ++mk;
    }

    ind_aleatoire = pick_option_index(chaines[mk].number_chains); // On choisit un indice aléatoire
    strcpy(result[nb_mots_result], chaines[mk].chain[ind_aleatoire]); // On ajoute le mot trouvé dans la phrase finale
    nb_mots_result += 1;
}

sprintf(s, ""); // On initialise la phrase finale

// On recompose la phrase finale à partir des données du tableau
for (i = 0; i < nb_mots_result; ++i){
    strcat(s, result[i]);
    if (i < nb_mots_result-1) {
        strcat(s, " ");
    }
}

printf("%s\n", s);

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

<<struct_markov>>

<<func_aleatoire>>
<<func_separe_mots>>

int main() {
    char t[1001]; // Phrase complète
    scanf("%[^\n]", t);
    int d; // Taille du n-gramme
    scanf("%d", &d);
    int l; // Longueur de la phrase finale
    scanf("%d", &l); fgetc(stdin);
    char s[1001]; // Texte de départ
    scanf("%[^\n]", s);

    <<separe_mots_phrase_complete>>

    <<creer_markov>>

    <<separe_mots_resultat>>
    <<choisir_mots_aleatoires>>

    <<ecrire_phrase>>

    return 0;
}