Programme d'entraînement à la frappe en utilisant le langage C

Introduction

Ce projet vous guidera dans la création d'un programme d'entraînement à la frappe au clavier en utilisant le langage de programmation C. Vous apprendrez à effectuer divers exercices de frappe, notamment des entraînements avec des chaînes de caractères simples, des chaînes multiples et des exercices de frappe basés sur la disposition du clavier. Ces programmes vous aideront à améliorer votre vitesse et votre précision de frappe.

👀 Aperçu

Start typing association exercises.
Please enter the hidden character indicated by '?'.
Press the space key to start.
AS?FG
?m,./\
67890-?\
?XCVB
zx?vb
!"?$%
ZXC?B
hjk?;:]
...(omit)...

🎯 Tâches

Dans ce projet, vous apprendrez :

• Comment créer un programme d'entraînement à la frappe en utilisant le langage C.
• Comment implémenter des exercices de frappe pour des chaînes de caractères simples, des chaînes multiples et des associations basées sur la disposition du clavier.
• Comment utiliser la bibliothèque curses pour les opérations d'entrée et de sortie écran.
• Comment mélanger l'ordre des questions pour varier les entraînements.

🏆 Réalisations

Après avoir terminé ce projet, vous serez en mesure de :

• Créer un programme en C pour simuler un entraînement à la frappe.
• Gérer les entrées utilisateur et valider leur exactitude.
• Générer des questions aléatoires et mélanger l'ordre des questions.
• Utiliser la bibliothèque curses pour des opérations avancées d'entrée et de sortie écran.

Skills Graph

Environnement du projet

Le projet nécessite l'utilisation de la bibliothèque curses. Installez-la en utilisant les commandes suivantes :

sudo apt-get update
sudo apt-get install libncurses5-dev

Le but du fichier d'en-tête getputch.h dans le code est de fournir une bibliothèque de fonctions d'entrée et de sortie écran multiplateforme, garantissant que le programme peut effectuer correctement les opérations d'entrée et de sortie écran dans différents systèmes d'exploitation et environnements de compilation, en particulier la gestion de l'affichage des caractères de nouvelle ligne.

Ensuite, nous allons présenter des exercices de frappe de base, qui impliquent principalement les pointeurs, les tableaux de chaînes de caractères et les structures de boucle dans le langage C.

Nous allons démontrer l'application des tableaux de chaînes de caractères, en commençant par l'entrée de base d'un seul caractère jusqu'à la pratique avec plusieurs mots désordonnés.

Entrer un caractère

Accédez au répertoire ~/project et créez le fichier de projet typing1a.c :

cd ~/project
touch typing1a.c

Ensuite, nous devons écrire du code C pour créer un logiciel d'entraînement à la frappe permettant d'entrer une chaîne de caractères. Le programme est le suivant :

#include <time.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include "getputch.h"

int main(void)
{
    int    i;
    char   *str = "How do you do?";     /* La chaîne de caractères à saisir */
    int    len = strlen(str);           /* Nombre de caractères dans la chaîne */

    init_getputch();
    printf("Please type as shown.\n");
    printf("%s\n", str);                /* Afficher la chaîne de caractères à saisir */
    fflush(stdout);

    for (i = 0; i < len; i++) {
        int ch;
        do {
            ch = getch();                 /* Lire l'entrée depuis le clavier */
            if (isprint(ch)) {
                putch(ch);                /* Afficher la touche pressée */
                if (ch!= str[i])         /* Si une mauvaise touche est pressée */
                    putch('\b');          /* Déplacer le curseur d'un espace en arrière */
            }
        } while (ch!= str[i]);
    }

    term_getputch();
    return 0;
}

Le joueur est invité à saisir la chaîne de caractères pointée par le pointeur str : How do you do?. Grâce à l'interchangeabilité des pointeurs et des tableaux, les caractères 'H', 'o',..., '?' de la chaîne peuvent être représentés séquentiellement comme str[0], str[1],..., str[13].

De plus, la variable len représente la longueur de la chaîne str et a une valeur initiale de 14. strlen() est utilisée pour obtenir la longueur de la chaîne.

La boucle for incrémente la valeur de la variable i de 0, 1, 2,... pour len itérations afin de parcourir séquentiellement les caractères de la chaîne du début à la fin. À chaque itération, le caractère str[i] est 'H', 'o',..., '?', qui sont les caractères à saisir. Cet entraînement à la frappe n'accepte pas les caractères incorrects (le programme ne passe pas au caractère suivant tant que le joueur n'a pas saisi le bon caractère). Ce contrôle est assuré par la boucle do, avec les actions suivantes effectuées à l'intérieur de la boucle :

• Affecter le caractère saisi (la valeur de retour de la fonction getch) à la variable ch.
• Si le caractère ch est un caractère imprimable, l'afficher à l'aide de la fonction putch (en excluant les caractères non affichables tels que les sauts de ligne et les tabulations).
• Si le caractère ch n'est pas égal au caractère à saisir str[i], afficher le caractère de retour arrière '\b' pour déplacer le curseur d'un espace en arrière. Cela garantit que le prochain caractère saisi sera affiché à la même position.

Après avoir effectué les étapes ci-dessus, l'expression de contrôle de la boucle do (ch!= str[i]) est évaluée. Lorsqu'un caractère incorrect est saisi (lorsque ch n'est pas égal à str[i]), la boucle do recommence. À ce moment, le programme ne passe pas au caractère suivant mais exécute à nouveau la partie pertinente de la boucle do... while. Après avoir saisi le bon caractère, la valeur de i est incrémentée par la boucle for, et le programme passe au caractère suivant. Après avoir saisi tous les caractères, le programme affichera le temps mis par le joueur.

Compilez et exécutez le programme en utilisant les commandes suivantes :

cd ~/project
gcc -o typing1a typing1a.c -lcurses
./typing1a

Vous pouvez vous entraîner plusieurs fois pour améliorer votre vitesse. Si vous trouvez l'entraînement avec How do you do? ennuyeux, vous pouvez également choisir une autre chaîne de caractères pour vous entraîner.

Suppression des caractères saisis

Accédez au répertoire ~/project et créez le fichier de projet typing1b.c :

cd ~/project
touch typing1b.c

Maintenant, regardons le programme. Le code est le suivant :

#include <time.h>
#include <stdio.h>
#include <string.h>
#include "getputch.h"

int main(void)
{
    int     i;
    char    *str = "How do you do?";    /* La chaîne de caractères à saisir */
    int     len = strlen(str);          /* Le nombre de caractères dans la chaîne str */

    init_getputch();
    printf("Please type as shown.\n");

    for (i = 0; i < len; i++) {
        /* Afficher les caractères après str[i] et ramener le curseur au début */
        printf("%s \r", &str[i]);
        fflush(stdout);
        while (getch()!= str[i])
            ;
    }

    term_getputch();
    return 0;
}

Ce programme est légèrement différent du précédent. Chaque fois que le bon caractère est saisi, un caractère disparaît et les caractères suivants se déplacent vers l'avant. De même, le programme ne passe pas au caractère suivant tant que le joueur n'a pas saisi la bonne touche. Lorsque le joueur a correctement saisi tous les caractères, tous les caractères disparaissent et le programme se termine.

Bien que l'opération effectuée ici soit plus "avancée" que dans le programme précédent, le programme est en fait plus court. Le corps de l'instruction for ne comporte que deux instructions courtes.

• Le &str[i] passé à la fonction printf dans l'instruction printf("%s \r", &str[i]); est un pointeur vers str[i]. Étant donné que la valeur de la variable i est 0, le pointeur &str[i] pointera vers le caractère 'H', faisant afficher à l'écran la chaîne How do you do? commençant par str[0], comme indiqué dans la figure ci-dessus. Le programme affichera ensuite des caractères d'espace et un retour chariot \r immédiatement après cette chaîne, et ramènera le curseur à la position du 'H' au début de la ligne.
• Si le caractère saisi (la valeur de retour de la fonction getch) n'est pas égal à str[i], c'est-à-dire que le caractère saisi n'est pas 'H', l'instruction while bouclera continuellement jusqu'à ce que le joueur saisisse le bon caractère, moment auquel l'instruction while se terminera.
• La valeur de la variable i deviendra ensuite 1 sous l'influence de l'instruction for. Comme indiqué dans la figure ci-dessus, l'instruction printf("%s \r", &str[i]); affichera la chaîne ow do you do? commençant par str[1], puis affichera des caractères d'espace et un retour chariot, et ramènera le curseur à la position du 'o' au début. Ensuite, sous l'effet de l'instruction while suivante, le programme attendra que le joueur saisisse correctement 'o'.

Compilez et exécutez le programme en utilisant les commandes suivantes :

cd ~/project
gcc -o typing1b typing1b.c -lcurses
./typing1a

Saisie de plusieurs chaînes de caractères

Ensuite, étendons le programme précédent pour permettre au joueur de s'entraîner à saisir plusieurs chaînes de caractères.

Accédez au répertoire ~/project et créez un fichier de projet appelé typing2a.c :

cd ~/project
touch typing2a.c

Maintenant, regardons le programme. Le code est le suivant :

#include <time.h>
#include <stdio.h>
#include <string.h>
#include "getputch.h"

#define QNO	    12      /* Nombre de questions */

int main(void)
{
    char *str[QNO] = {"book",   "computer", "default",  "comfort",
                      "monday", "power",    "light",    "music",
                      "programming", "dog", "video",    "include"};
    int i, stage;

    init_getputch();
    printf("Start typing practice.\n");
    printf("Press the spacebar to begin.\n");
    while (getch()!= ' ')          /* Attendre jusqu'à */
        ;                           /* que le joueur appuie sur la barre d'espace */

    for (stage = 0; stage < QNO; stage++) {
        int len = strlen(str[stage]);   /* Nombre de caractères dans la chaîne str[stage] */
        for (i = 0; i < len; i++) {
            /* Afficher les caractères après str[stage][i] et ramener le curseur au début */
            printf("%s \r", &str[stage][i]);

            fflush(stdout);
            while (getch()!= str[stage][i])
                ;
        }
    }

    term_getputch();

    return 0;
}

Dans ce programme, après avoir saisi une chaîne de caractères, la chaîne suivante s'affiche sur la même ligne pour que le joueur puisse la saisir. Il y a au total 12 chaînes disponibles pour l'entraînement.

Ce programme est en grande partie basé sur le programme précédent, mais il y a quelques différences :

1. L'instruction for est imbriquée.

• Étant donné que le nombre de mots dans la question est passé de 1 à 12, une instruction for externe a été ajoutée. Cette instruction for itère QNO fois, en commençant par 0, pour la variable stage. La boucle for interne après strlen(str[stage]) est équivalente à la boucle for du programme précédent.
• La chaîne de caractères à saisir à chaque itération est str[stage] (équivalente à str dans le programme précédent). Le nombre de caractères à saisir varie selon la chaîne, donc l'instruction strlen(str[stage]) calcule la longueur de la chaîne str[stage] utilisée pour la question et la stocke dans la variable len.

2. Le caractère à saisir n'est plus str[i], mais str[stage][i].

Dans la boucle for interne, le caractère à saisir est str[stage][i], qui est équivalent à str[i] dans le programme précédent.

Compilez et exécutez le programme en utilisant les commandes suivantes :

cd ~/project
gcc -o typing2a typing2a.c -lcurses
./typing2a

Mélanger l'ordre des questions (Méthode 1)

Après avoir pratiqué plusieurs fois avec le programme précédent, la chaîne suivante qui apparaît dans la question vient automatiquement à l'esprit, affaiblissant l'effet d'entraînement. Maintenant, mélangeons l'ordre des questions.

Accédez au répertoire ~/project et créez le fichier de projet typing2b.c :

cd ~/project
touch typing2b.c

Maintenant, regardons le programme. Le code est le suivant :

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "getputch.h"

#define QNO     12      /* Nombre de questions */

#define swap(type, x, y)    do { type t = x; x = y; y = t; } while (0)

int main(void)
{
    char *str[QNO] = {"book",   "computer", "default",  "comfort",
                      "monday", "power",    "light",    "music",
                      "programming", "dog", "video",    "include"};
    int i, stage;
    int qno[QNO];                   /* Ordre des questions */

    init_getputch();
    srand(time(NULL));              /* Définir la graine pour les nombres aléatoires */
    for (i = 0; i < QNO; i++)
        qno[i] = i;
    for (i = QNO - 1; i > 0; i--) {
        int j = rand() % (i + 1);
        if (i!= j)
            swap(int, qno[i], qno[j]);
	}
    printf("Start typing practice.\n");
    printf("Press the spacebar to begin.\n");
    while (getch()!= ' ')          /* Attendre jusqu'à */
        ;                           /* que le joueur appuie sur la barre d'espace */

    for (stage = 0; stage < QNO; stage++) {
        int len = strlen(str[qno[stage]]); /* Nombre de caractères dans la chaîne str[qno[stage]] */
        for (i = 0; i < len; i++) {
            /* Afficher les caractères après str[qno[stage]][i] et ramener le curseur au début */
            printf("%s \r", &str[qno[stage]][i]);
            fflush(stdout);
            while (getch()!= str[qno[stage]][i])
                ;
        }
    }

    term_getputch();
    return 0;
}

Afin de mélanger l'ordre des questions, le programme introduit un nouveau tableau nommé qno de type d'élément int et de taille QNO (qui est le nombre de chaînes dans les questions, soit 12).

Avant de commencer l'entraînement à la frappe, les deux premières boucles for sont utilisées pour assigner des valeurs à chaque élément du tableau qno dans l'ordre 0, 1, 2,..., 11.

Comme dans le programme précédent, toutes les occurrences de str[stage] ont été remplacées par str[qno[stage]], car dans chaque boucle de ce programme, la question à poser est basée sur str[qno[stage]].

• Lorsque stage est égal à 0 ; puisque la valeur de qno[0] est 2, la question affichée par le programme sera str[2], qui est default.
• Lorsque stage est égal à 1 ; puisque la valeur de qno[1] est 1, la question affichée par le programme sera str[1], qui est computer.

Et ainsi de suite. Après avoir pratiqué avec les 12 chaînes, le programme se terminera.

Compilez et exécutez le programme en utilisant les commandes suivantes :

cd ~/project
gcc -o typing2b typing2b.c -lcurses
./typing2b

Mélanger l'ordre des questions (Méthode 2)

Le programme suivant mélange l'ordre des questions en utilisant une méthode différente sans utiliser de tableau. Ce programme nécessite moins de variables et est plus concis que le programme précédent.

Accédez au répertoire ~/project et créez le fichier de projet typing2c.c :

cd ~/project
touch typing2c.c

Maintenant, regardons le programme. Le code est le suivant :

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "getputch.h"

#define QNO 12   /* Nombre de questions */

#define swap(type, x, y)    do { type t = x; x = y; y = t; } while (0)

int main(void)
{
    char *str[QNO] = {"book",   "computer", "default",  "comfort",
                      "monday", "power",    "light",    "music",
                      "programming", "dog", "video",    "include"};
    int i, stage;

    init_getputch();
    srand(time(NULL));              /* Définir la graine aléatoire */

    for (i = QNO - 1; i > 0; i--) {  /* Mélanger le tableau str */
        int j = rand() % (i + 1);
        if (i!= j)
            swap(char *, str[i], str[j]);
    }

    printf("Start Typing Practice.\n");
    printf("Press the spacebar to begin.\n");
    while (getch()!= ' ')          /* Attendre jusqu'à */
        ;                           /* que le joueur appuie sur la barre d'espace */

    for (stage = 0; stage < QNO; stage++) {
        int len = strlen(str[stage]);	/* Nombre de caractères dans la chaîne str[stage] */
        for (i = 0; i < len; i++) {
            /* Afficher les caractères après str[stage][i] et ramener le curseur au début */
            printf("%s \r", &str[stage][i]);
            fflush(stdout);
            while (getch()!= str[stage][i])
                ;
        }
    }

    term_getputch();
    return 0;
}

Chaque élément du tableau str pointe vers les chaînes book, computer, default,.... Après avoir échangé les valeurs de str[0] et str[2], str[0] pointe vers default et str[2] pointe vers book.

La première boucle for du programme (code ci-dessus) est chargée de réorganiser les pointeurs, qui sont les valeurs des éléments du tableau str, mélangeant ainsi les éléments. Étant donné que les objets échangés sont des pointeurs, le premier argument assigné à la macro-fonction swap est char *.

Dans la deuxième boucle for de la partie principale du programme, chaque étape des questions est ramenée à str[stage] (qui est str[qno[stage]] dans la liste 8 - 4, qui est plus complexe). Cela est dû au fait que le tableau str a été réorganisé aléatoirement, et en affichant str[0], str[1],..., str[QNO - 1] dans l'ordre, on obtient un ordre de questions aléatoire.

Un inconvénient de cette méthode est que une fois l'ordre des mots mélangé, il ne peut pas être restauré. Veuillez en tenir compte.

Compilez et exécutez le programme en utilisant les commandes suivantes :

cd ~/project
gcc -o typing2c typing2c.c -lcurses
./typing2c

Entraînement à la frappe associée au layout du clavier

Ensuite, nous allons développer un logiciel qui permet aux joueurs de s'entraîner à taper tout en se rappelant la position de chaque touche sur le clavier. Contrairement aux exercices de frappe classiques, les joueurs devront saisir des caractères sans aucune indication. De plus, différents claviers ont des layouts différents, et ici, nous utiliserons le layout de clavier montré dans le diagramme ci-dessous comme référence.

Dans le layout de clavier montré dans le diagramme, même si la touche [Shift] est maintenue enfoncée lors de l'appui sur la touche [0], aucune information ne sera saisie.

Concernant le layout de ce clavier, nous pouvons observer les points suivants.

• Il est composé de 4 rangées de touches.
• Chaque rangée est divisée en touches frappées avec la main gauche et touches frappées avec la main droite, la main gauche frappant les touches noires et la main droite frappant les touches bleues.
• Il y a des touches qui ne nécessitent pas de maintenir la touche [Shift] enfoncée lors de la frappe, et il y a des touches qui nécessitent de maintenir la touche [Shift] enfoncée lors de la frappe.

Nous appelons les différents ensembles classés par rangée / mains / si la touche [Shift] est enfoncée des "blocs", et l'ensemble du clavier est composé de 4 × 2 × 2 = 16 blocs au total.

Par exemple, le bloc des touches frappées avec la main gauche avec la touche [Shift] enfoncée dans la 3ème rangée est [A], [S], [D], [F], [G] (gérées respectivement par l'auriculaire, l'annulaire, le majeur, l'index, l'index).

Dans ce logiciel d'entraînement, un bloc est présenté comme une question, mais le logiciel utilisera le symbole "?" pour masquer un caractère dans ce bloc. Par exemple, pour la question suivante, le joueur doit associer le "?" masqué à la lettre majuscule D, puis saisir la lettre.

A S? F G

Code et résultat d'exécution

Accédez au répertoire ~/project et créez un fichier de projet nommé typing3.c :

cd ~/project
touch typing3.c

Le programme écrit selon les directives ci-dessus est montré ci-dessous :

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "getputch.h"

#define	NO			30			/* Nombre d'exercices */
#define	KTYPE		16			/* Nombre de blocs */

int main(void)
{
    char *kstr[] = {"12345",  "67890-^\\",  /* Rangée 1         */
                    "!\"#$%", "&'() =~|",   /* Rangée 1 [Shift] */
                    "qwert",  "yuiop@[",    /* Rangée 2         */
                    "QWERT",  "YUIOP`{",    /* Rangée 2 [Shift] */
                    "asdfg",  "hjkl;:]",    /* Rangée 3         */
                    "ASDFG",  "HJKL+*}",    /* Rangée 3 [Shift] */
                    "zxcvb",  "nm,./\\",    /* Rangée 4         */
                    "ZXCVB",  "NM<> _",	    /* Rangée 4 [Shift] */
                    };
    int i, stage;
    clock_t	start, end;         /* Temps de début et de fin */

    init_getputch();
    srand(time(NULL));          /* Définir la graine pour la génération de nombres aléatoires */

    printf("Start typing association exercises.\n");
    printf("Please enter the hidden character indicated by '?'.\n");
    printf("Press the space key to start.\n");
    fflush(stdout);
    while (getch()!= ' ')
        ;

    start = clock();            /* Temps de début */

    for (stage = 0; stage < NO; stage++) {
        int  k, p, key;
        char temp[10];

        do {
            k = rand() % KTYPE;
            p = rand() % strlen(kstr[k]);
            key = kstr[k][p];
        } while (key == ' ');

        strcpy(temp, kstr[k]);
        temp[p] = '?';
        printf("%s", temp);
        fflush(stdout);
        while (getch()!= key)
            ;
        putchar('\n');
    }

    end = clock();              /* Temps de fin */
    printf("Time taken: %.1f seconds.\n", (double)(end - start) / CLOCKS_PER_SEC);

    term_getputch();
    return 0;
}

La macro KTYPE représente le nombre de blocs, qui est de 16, et le tableau kstr est utilisé pour stocker les chaînes de caractères composées des caractères de chaque bloc disposés de gauche à droite.

En termes de but d'entraînement, la question ne contiendra pas le caractère ?, donc la dernière chaîne pour le bloc déclaré est NM<> _ et non NM<>?_ (puisque le programme n'utilise pas la touche espace pour générer les questions, il ne produira pas d'erreur).

Si le layout de votre clavier est différent de celui montré dans cet exemple, veuillez modifier la déclaration du tableau kstr en conséquence.

La première boucle do while est chargée de générer la question.

• La variable k indique à partir de quel bloc générer la question. Étant donné que cette valeur correspond à l'indice du tableau kstr, elle est définie comme un nombre aléatoire supérieur ou égal à 0 et inférieur à KTYPE.

  Étant donné que le nombre de blocs KTYPE est de 16, le nombre aléatoire généré sera compris entre 0 et 15.

• La variable p indique quel caractère dans le bloc doit être masqué pour générer la question. Étant donné que cette valeur correspond à l'indice de la chaîne de caractères utilisée pour générer la question dans le bloc, elle est définie comme un nombre aléatoire supérieur ou égal à 0 et inférieur au nombre de caractères dans le bloc.

  En supposant que k soit égal à 0, le bloc est composé de 5 caractères, '12345', donc p est défini comme un nombre aléatoire compris entre 0 et 4. De plus, si k est égal à 3, le bloc est composé de 8 caractères, '&'()=~|', donc p est défini comme un nombre aléatoire compris entre 0 et 7.

• La variable key représente le caractère masqué.

Par exemple, si k est égal à 0 et p est égal à 2, le caractère '3' dans le bloc '12345' est la key. Étant donné que le programme a déjà assigné le caractère espace '' aux caractères qui ne doivent pas être utilisés pour générer les questions, la boucle do - while est utilisée pour régénérer la question si le caractère masqué key est un caractère espace.

Ensuite, la fonction strcpy copie kstr[k] dans temp, et assigne '?' à temp[p]. Cela génère la chaîne 12?45 à afficher à l'écran.

Si le programme est capable d'afficher la chaîne temp et de lire le caractère key saisi au clavier, c'est correct. Comme les programmes d'entraînement à la frappe précédents, ce programme n'accepte pas les caractères mal saisis. Après 30 rounds d'entraînement, le programme mettra fin à son exécution.

Compilez et exécutez le programme en utilisant les commandes suivantes :

cd ~/project
gcc -o typing3 typing3.c -lcurses
./typing3

Start typing association exercises.
Please enter the hidden character indicated by '?'.
Press the space key to start.
AS?FG
?m,./\
67890-?\
?XCVB
zx?vb
!"?$%
ZXC?B
hjk?;:]
…(omission)…

Résumé

Dans ce projet, vous avez appris à créer un programme d'entraînement à la frappe en utilisant le langage de programmation C. Ce programme d'entraînement à la frappe offre aux utilisateurs une plateforme interactive polyvalente pour améliorer leurs compétences en frappe, que ce soit pour le codage ou la communication générale. Il constitue un outil précieux pour améliorer la vitesse et la précision de frappe.