Tippübungsprogramm mit C

Einführung

Dieses Projekt wird Sie durch die Erstellung eines Tipptrainingsprogramms mithilfe der Programmiersprache C führen. Sie werden lernen, wie Sie verschiedene Tippübungen durchführen können, einschließlich Übungen mit einzelnen Zeichenketten, mehreren Zeichenketten und Tippübungen basierend auf der Tastaturbelegung. Diese Programme werden Ihnen helfen, Ihre Tippgeschwindigkeit und -genauigkeit zu verbessern.

👀 Vorschau

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)...

🎯 Aufgaben

In diesem Projekt werden Sie lernen:

• Wie Sie ein Tipptrainingsprogramm mit C erstellen.
• Wie Sie Übungen für das Tippen einzelner Zeichenketten, mehrerer Zeichenketten und Tastaturbelegungsassoziationen implementieren.
• Wie Sie die curses-Bibliothek für Bildschirmeingabe- und -ausgabeoperationen verwenden.
• Wie Sie die Reihenfolge der Fragen mischen, um die Übungen abwechslungsreicher zu gestalten.

🏆 Errungenschaften

Nach Abschluss dieses Projekts werden Sie in der Lage sein:

• Ein C-Programm zur Simulation von Tipptrainings zu erstellen.
• Benutzer-Eingaben zu verarbeiten und deren Richtigkeit zu überprüfen.
• Zufällige Fragen zu generieren und die Reihenfolge der Fragen zu mischen.
• Die curses-Bibliothek für erweiterte Bildschirmeingabe- und -ausgabeoperationen zu nutzen.

Skills Graph

Projektumgebung

Das Projekt erfordert die Verwendung der curses-Bibliothek. Installieren Sie sie mit den folgenden Befehlen:

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

Der Zweck der Header-Datei getputch.h im Code besteht darin, eine plattformübergreifende Bibliothek für Bildschirmeingabe- und -ausgabe-Funktionen bereitzustellen. Dadurch wird sichergestellt, dass das Programm in verschiedenen Betriebssystemen und Compilerumgebungen korrekt Bildschirmeingabe- und -ausgabeoperationen durchführen kann, insbesondere bei der Verarbeitung der Ausgabe von Zeilenumbruchzeichen.

Als Nächstes werden wir grundlegende Tippübungen vorstellen, die hauptsächlich Zeiger, Zeichenkettenarrays und Schleifenstrukturen in der Programmiersprache C betreffen.

Wir werden die Anwendung von Zeichenkettenarrays demonstrieren, beginnend mit der grundlegenden Eingabe eines einzelnen Zeichens bis hin zur Übung mit mehreren ungeordneten Wörtern.

Eingabe eines Zeichens

Navigieren Sie in das Verzeichnis ~/project und erstellen Sie die Projekt-Datei typing1a.c:

cd ~/project
touch typing1a.c

Als Nächstes müssen wir C-Code schreiben, um eine Tipptrainingssoftware zu erstellen, die die Eingabe einer Zeichenkette ermöglicht. Das Programm sieht wie folgt aus:

#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?";     /* The string to be input */
    int    len = strlen(str);           /* Number of characters in the string */

    init_getputch();
    printf("Please type as shown.\n");
    printf("%s\n", str);                /* Display the string to be input */
    fflush(stdout);

    for (i = 0; i < len; i++) {
        int ch;
        do {
            ch = getch();                 /* Read input from the keyboard */
            if (isprint(ch)) {
                putch(ch);                /* Display the pressed key */
                if (ch!= str[i])         /* If a wrong key is pressed */
                    putch('\b');          /* Move the cursor back one space */
            }
        } while (ch!= str[i]);
    }

    term_getputch();
    return 0;
}

Der Spieler muss die Zeichenkette eingeben, auf die der Zeiger str zeigt: How do you do?. Aufgrund der Austauschbarkeit von Zeigern und Arrays können die Zeichen 'H', 'o',..., '?' innerhalb der Zeichenkette nacheinander als str[0], str[1],..., str[13] dargestellt werden.

Zusätzlich repräsentiert die Variable len die Länge der Zeichenkette str und hat einen Anfangswert von 14. strlen() wird verwendet, um die Länge der Zeichenkette zu erhalten.

Die for-Schleife erhöht den Wert der Variable i von 0, 1, 2,... für len Iterationen, um die Zeichen innerhalb der Zeichenkette von Anfang bis Ende nacheinander zu durchlaufen. Bei jeder Iteration ist das Zeichen str[i] 'H', 'o',..., '?', die Zeichen, die eingegeben werden müssen. Diese Tippübung akzeptiert keine falschen Zeichen (das Programm geht erst zum nächsten Zeichen über, wenn der Spieler das richtige Zeichen eingegeben hat). Diese Steuerung wird durch die do-Schleife gewährleistet, wobei innerhalb der Schleife die folgenden Aktionen ausgeführt werden:

• Weisen Sie das eingegebene Zeichen (der Rückgabewert der Funktion getch) der Variable ch zu.
• Wenn das Zeichen ch ein druckbares Zeichen ist, zeigen Sie es mit der Funktion putch an (ausschließlich nicht anzeigbarer Zeichen wie Zeilenumbruch und Tabulator).
• Wenn das Zeichen ch nicht gleich dem einzugebenden Zeichen str[i] ist, geben Sie das Rückschrittzeichen '\b' aus, um den Cursor um ein Zeichen zurückzubewegen. Dadurch wird sichergestellt, dass das nächste eingegebene Zeichen an derselben Position angezeigt wird.

Nach Abschluss der obigen Schritte wird der Steuerausdruck der do-Schleife (ch!= str[i]) ausgewertet. Wenn ein falsches Zeichen eingegeben wird (wenn ch nicht gleich str[i] ist), beginnt die do-Schleife erneut. Zu diesem Zeitpunkt geht das Programm nicht zum nächsten Zeichen über, sondern führt den relevanten Teil innerhalb der do... while-Schleife erneut aus. Nachdem das richtige Zeichen eingegeben wurde, wird der Wert von i durch die for-Schleife um 1 erhöht, und das Programm geht zum nächsten Zeichen über. Nachdem alle Zeichen eingegeben wurden, wird das Programm die Zeit anzeigen, die der Spieler benötigt hat.

Kompilieren und ausführen Sie das Programm mit den folgenden Befehlen:

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

Sie können sich mehrmals üben, um Ihre Geschwindigkeit zu verbessern. Wenn Sie es langweilig finden, How do you do? zu üben, können Sie auch eine andere Zeichenkette auswählen, um sich zu üben.

Löschen der eingegebenen Zeichen

Navigieren Sie in das Verzeichnis ~/project und erstellen Sie die Projekt-Datei typing1b.c:

cd ~/project
touch typing1b.c

Schauen wir uns nun das Programm an. Der Code sieht wie folgt aus:

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

int main(void)
{
    int     i;
    char    *str = "How do you do?";    /* The string to be entered */
    int     len = strlen(str);          /* The number of characters in the string str */

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

    for (i = 0; i < len; i++) {
        /* Display the characters after str[i] and return the cursor to the beginning */
        printf("%s \r", &str[i]);
        fflush(stdout);
        while (getch()!= str[i])
            ;
    }

    term_getputch();
    return 0;
}

Dieses Programm unterscheidet sich etwas vom vorherigen. Jedes Mal, wenn das richtige Zeichen eingegeben wird, verschwindet ein Zeichen und die folgenden Zeichen rücken nach vorne. Ebenso geht das Programm nicht zum nächsten Zeichen über, es sei denn, der Spieler gibt die richtige Taste ein. Wenn der Spieler alle Zeichen korrekt eingegeben hat, verschwinden alle Zeichen und das Programm endet.

Obwohl die hier durchgeführte Operation "fortgeschrittener" als beim vorherigen Programm ist, ist das Programm tatsächlich kürzer. Der Körper der for-Anweisung besteht nur aus zwei kurzen Anweisungen.

• Das &str[i], das in der Anweisung printf("%s \r", &str[i]); an die printf-Funktion übergeben wird, ist ein Zeiger auf str[i]. Da der Wert der Variable i 0 ist, wird der Zeiger &str[i] auf das Zeichen 'H' zeigen, wodurch der Bildschirm die Zeichenkette How do you do? ab str[0] anzeigt, wie in der obigen Abbildung gezeigt. Das Programm gibt dann unmittelbar nach dieser Zeichenkette Leerzeichen und einen Wagenrücklauf \r aus und bringt den Cursor an die Position des 'H' am Anfang der Zeile zurück.
• Wenn das eingegebene Zeichen (der Rückgabewert der getch-Funktion) nicht gleich str[i] ist, d. h. das eingegebene Zeichen nicht 'H' ist, wird die while-Anweisung kontinuierlich in einer Schleife ausgeführt, bis der Spieler das richtige Zeichen eingibt. Dann endet die while-Anweisung.
• Der Wert der Variable i wird dann durch die Wirkung der for-Anweisung 1 werden. Wie in der obigen Abbildung gezeigt, wird die Anweisung printf("%s \r", &str[i]); die Zeichenkette ow do you do? ab str[1] ausgeben, dann Leerzeichen und einen Wagenrücklauf ausgeben und den Cursor an die Position des 'o' am Anfang zurückbringen. Danach wartet es mit der Wirkung der nachfolgenden while-Anweisung darauf, dass der Spieler 'o' korrekt eingibt.

Kompilieren und ausführen Sie das Programm mit den folgenden Befehlen:

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

Eingabe mehrerer Zeichenketten

Als Nächstes erweitern wir das vorherige Programm, um es dem Spieler zu ermöglichen, die Eingabe mehrerer Zeichenketten zu üben.

Navigieren Sie in das Verzeichnis ~/project und erstellen Sie eine Projekt-Datei namens typing2a.c:

cd ~/project
touch typing2a.c

Schauen wir uns nun das Programm an. Der Code sieht wie folgt aus:

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

#define QNO	    12      /* Number of 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()!= ' ')          /* Wait until */
        ;                           /* the player presses the spacebar */

    for (stage = 0; stage < QNO; stage++) {
        int len = strlen(str[stage]);   /* Number of characters in string str[stage] */
        for (i = 0; i < len; i++) {
            /* Display the characters after str[stage][i] and return the cursor to the beginning */
            printf("%s \r", &str[stage][i]);

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

    term_getputch();

    return 0;
}

In diesem Programm wird nach der Eingabe einer Zeichenkette die nächste Zeichenkette in derselben Zeile angezeigt, damit der Spieler sie eingeben kann. Insgesamt stehen 12 Zeichenketten für die Übung zur Verfügung.

Dieses Programm basiert größtenteils auf dem vorherigen Programm, es gibt jedoch einige Unterschiede:

1. Die for-Anweisung wurde verschachtelt.

• Da die Anzahl der Wörter in der Aufgabe von 1 auf 12 geändert wurde, wurde eine äußere for-Anweisung hinzugefügt. Diese for-Anweisung iteriert QNO Mal, beginnend bei 0, für die Variable stage. Die innere for-Schleife nach strlen(str[stage]) entspricht der for-Schleife im vorherigen Programm.
• Die einzugebende Zeichenkette für jede Iteration ist str[stage] (entspricht str im vorherigen Programm). Die Anzahl der einzugebenden Zeichen variiert je nach Zeichenkette, daher berechnet die Anweisung strlen(str[stage]) die Länge der für die Aufgabe verwendeten Zeichenkette str[stage] und speichert sie in der Variable len.

2. Das einzugebende Zeichen ist nicht mehr str[i], sondern str[stage][i].

In der inneren for-Schleife ist das einzugebende Zeichen str[stage][i], was str[i] im vorherigen Programm entspricht.

Kompilieren und ausführen Sie das Programm mit den folgenden Befehlen:

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

Mischen der Reihenfolge der Fragen (Methode 1)

Nachdem Sie sich mehrere Male mit dem vorherigen Programm geübt haben, wird Ihnen automatisch die nächste in der Aufgabe erscheinende Zeichenkette einfallen, wodurch der Trainingeffekt geschwächt wird. Jetzt mischen wir die Reihenfolge der Fragen.

Navigieren Sie in das Verzeichnis ~/project und erstellen Sie die Projekt-Datei typing2b.c:

cd ~/project
touch typing2b.c

Schauen wir uns nun das Programm an. Der Code sieht wie folgt aus:

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

#define QNO     12      /* Number of 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];                   /* Order of questions */

    init_getputch();
    srand(time(NULL));              /* Set the seed for random numbers */
    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()!= ' ')          /* Wait until */
        ;                           /* the player presses the spacebar */

    for (stage = 0; stage < QNO; stage++) {
        int len = strlen(str[qno[stage]]); /* Number of characters in the string str[qno[stage]] */
        for (i = 0; i < len; i++) {
            /* Display the characters after str[qno[stage]][i] and return the cursor to the beginning */
            printf("%s \r", &str[qno[stage]][i]);
            fflush(stdout);
            while (getch()!= str[qno[stage]][i])
                ;
        }
    }

    term_getputch();
    return 0;
}

Um die Reihenfolge der Fragen zu mischen, führt das Programm ein neues Array namens qno ein, dessen Elementtyp int ist und dessen Größe QNO beträgt (dies ist die Anzahl der Zeichenketten in den Fragen, also 12).

Bevor die Tippübung beginnt, werden die ersten beiden for-Schleifen verwendet, um jedem Element des Arrays qno die Werte in der Reihenfolge 0, 1, 2,..., 11 zuzuweisen.

Ähnlich wie beim vorherigen Programm wurden alle Vorkommen von str[stage] durch str[qno[stage]] ersetzt, da in jeder Schleife dieses Programms die zu stellende Frage auf str[qno[stage]] basiert.

• Wenn stage 0 ist; da der Wert von qno[0] 2 ist, wird die vom Programm gezeigte Frage str[2] sein, also default.
• Wenn stage 1 ist; da der Wert von qno[1] 1 ist, wird die vom Programm gezeigte Frage str[1] sein, also computer.

Und so weiter. Nach der Übung mit den 12 Zeichenketten endet das Programm.

Kompilieren und ausführen Sie das Programm mit den folgenden Befehlen:

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

Mischen der Reihenfolge der Fragen (Methode 2)

Das folgende Programm mischt die Reihenfolge der Fragen mit einer anderen Methode, ohne ein Array zu verwenden. Im Vergleich zum vorherigen Programm benötigt dieses Programm weniger Variablen und ist kompakter.

Navigieren Sie in das Verzeichnis ~/project und erstellen Sie die Projekt-Datei typing2c.c:

cd ~/project
touch typing2c.c

Schauen wir uns nun das Programm an. Der Code sieht wie folgt aus:

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

#define QNO 12   /* Number of 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));              /* Set random seed */

    for (i = QNO - 1; i > 0; i--) {  /* Shuffle the array 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()!= ' ')          /* Wait until */
        ;                           /* the player presses the spacebar */

    for (stage = 0; stage < QNO; stage++) {
        int len = strlen(str[stage]);	/* Number of characters in the string str[stage] */
        for (i = 0; i < len; i++) {
            /* Display the characters after str[stage][i] and return the cursor to the beginning */
            printf("%s \r", &str[stage][i]);
            fflush(stdout);
            while (getch()!= str[stage][i])
                ;
        }
    }

    term_getputch();
    return 0;
}

Jedes Element des Arrays str zeigt auf die Zeichenketten book, computer, default,.... Nach dem Austauschen der Werte von str[0] und str[2] zeigt str[0] auf default und str[2] auf book.

Die erste for-Schleife im Programm (obenstehender Code) ist für die Neuordnung der Zeiger verantwortlich, die die Werte der Elemente im Array str sind, und mischt somit die Elemente. Da die ausgetauschten Objekte Zeiger sind, ist das erste Argument, das der Funktionsmakro swap zugewiesen wird, char *.

In der zweiten for-Schleife im Hauptteil des Programms wird jede Stufe der Fragen auf str[stage] zurückgeführt (was in Listing 8 - 4 str[qno[stage]] ist, was komplexer ist). Dies liegt daran, dass das Array str zufällig neu angeordnet wurde, und indem str[0], str[1],..., str[QNO - 1] in Reihenfolge ausgegeben werden, wird eine zufällige Reihenfolge der Fragen erhalten.

Ein Nachteil dieser Methode ist, dass sobald die Reihenfolge der Wörter gemischt wurde, sie nicht wiederhergestellt werden kann. Bitte beachten Sie dies.

Kompilieren und ausführen Sie das Programm mit den folgenden Befehlen:

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

Tastaturlayout-assoziatives Tippen

Als Nächstes werden wir eine Software entwickeln, die es Spielern ermöglicht, das Tippen zu üben, während sie sich die Position jeder Taste auf der Tastatur merken. Im Gegensatz zu normalen Tippübungen müssen die Spieler die Zeichen ohne jegliche Hinweise eingeben. Darüber hinaus haben verschiedene Tastaturen unterschiedliche Layouts, und hier verwenden wir das in der folgenden Abbildung gezeigte Tastaturlayout als Referenz.

Im in der Abbildung gezeigten Tastaturlayout wird auch dann, wenn die Taste [Shift] gedrückt gehalten wird und gleichzeitig die Taste [0] gedrückt wird, keine Information eingegeben.

Bezüglich des Layouts dieser Tastatur können wir die folgenden Punkte beobachten.

• Sie besteht aus 4 Tastenebenen.
• Jede Ebene ist in linke und rechte Schlagtasten unterteilt, wobei die linke Hand die schwarzen Tasten und die rechte Hand die blauen Tasten schlägt.
• Es gibt Tasten, die ohne Drücken der Taste [Shift] betätigt werden können, und es gibt Tasten, die nur mit gedrückter Taste [Shift] betätigt werden können.

Wir bezeichnen die verschiedenen nach Ebene/Hände/ob die Taste [Shift] gedrückt wird klassifizierten Gruppen als "Blöcke", und die gesamte Tastatur besteht insgesamt aus 4 × 2 × 2 = 16 Blöcken.

Beispielsweise ist der Block der linken Schlagtasten mit gedrückter Taste [Shift] in der 3. Ebene [A], [S], [D], [F], [G] (jeweils von kleiner Finger, Ringfinger, Mittelfinger, Zeigefinger, Zeigefinger bedient).

In dieser Trainingssoftware wird ein Block als Aufgabe präsentiert, aber die Software wird ein Zeichen innerhalb dieses Blocks mit "?" verbergen. Beispielsweise muss der Spieler bei der folgenden Aufgabe das versteckte "?" mit dem Großbuchstaben D in Verbindung bringen und dann den Buchstaben eingeben.

A S? F G

Code und Laufzeitresultat

Navigieren Sie in das Verzeichnis ~/project und erstellen Sie eine Projekt-Datei namens typing3.c:

cd ~/project
touch typing3.c

Das gemäß den obigen Richtlinien geschriebene Programm ist unten gezeigt:

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

#define	NO			30			/* Number of exercises */
#define	KTYPE		16			/* Number of blocks */

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

    init_getputch();
    srand(time(NULL));          /* Set the seed for random number generation */

    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();            /* Start time */

    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();              /* End time */
    printf("Time taken: %.1f seconds.\n", (double)(end - start) / CLOCKS_PER_SEC);

    term_getputch();
    return 0;
}

Der Makro KTYPE repräsentiert die Anzahl der Blöcke, die 16 beträgt, und das Array kstr wird verwendet, um die Zeichenketten zu speichern, die aus den Zeichen jedes Blocks von links nach rechts angeordnet bestehen.

Im Hinblick auf das Trainingsziel wird die Aufgabe nicht das Zeichen ? enthalten, daher lautet die letzte für den Block deklarierte Zeichenkette NM<> _ und nicht NM<>?_ (da das Programm die Leertaste nicht zur Erstellung von Aufgaben verwendet, wird kein Fehler auftreten).

Wenn Ihr Tastaturlayout sich von dem in diesem Beispiel gezeigten unterscheidet, ändern Sie bitte die Deklaration des Arrays kstr entsprechend.

Die erste do while-Schleife ist für die Erstellung der Aufgabe verantwortlich.

• Die Variable k gibt an, aus welchem Block die Aufgabe generiert werden soll. Da dieser Wert dem Index des Arrays kstr entspricht, wird er als eine Zufallszahl größer oder gleich 0 und kleiner als KTYPE festgelegt.

  Da die Anzahl der Blöcke KTYPE 16 beträgt, wird die generierte Zufallszahl im Bereich von 0 bis 15 liegen.

• Die Variable p gibt an, welches Zeichen innerhalb des Blocks versteckt werden soll, um die Aufgabe zu generieren. Da dieser Wert dem Index der für die Aufgabe verwendeten Zeichenkette innerhalb des Blocks entspricht, wird er als eine Zufallszahl größer oder gleich 0 und kleiner als die Anzahl der Zeichen innerhalb des Blocks festgelegt.

  Angenommen, k ist 0, der Block besteht aus 5 Zeichen, '12345', daher wird p als eine Zufallszahl im Bereich von 0 bis 4 festgelegt. Zusätzlich, wenn k 3 ist, besteht der Block aus 8 Zeichen, '&'()=~|', daher wird p als eine Zufallszahl im Bereich von 0 bis 7 festgelegt.

• Die Variable key repräsentiert das versteckte Zeichen.

Beispielsweise, wenn k 0 und p 2 ist, ist das Zeichen '3' im Block '12345' das key. Da das Programm bereits das Leerzeichen '' für Zeichen zugewiesen hat, die nicht zur Erstellung von Aufgaben verwendet werden sollen, wird die do-while-Schleife verwendet, um die Aufgabe neu zu generieren, wenn das versteckte Zeichen key ein Leerzeichen ist.

Als Nächstes kopiert die Funktion strcpy kstr[k] nach temp und weist temp[p] das Zeichen '?' zu. Dadurch wird die Zeichenkette 12?45 erzeugt, die auf dem Bildschirm angezeigt werden soll.

Wenn das Programm in der Lage ist, die Zeichenkette temp anzuzeigen und das von der Tastatur eingegebene Zeichen key zu lesen, ist es korrekt. Wie bei den vorherigen Tippübungsprogrammen akzeptiert dieses Programm nicht falsch eingegebene Zeichen. Nach 30 Trainingsrunden wird die Ausführung des Programms beendet.

Kompilieren und starten Sie das Programm mit den folgenden Befehlen:

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?;:]
…(omit)…

Zusammenfassung

In diesem Projekt haben Sie gelernt, wie Sie ein Tippübungsprogramm mit der Programmiersprache C erstellen. Dieses Tippübungsprogramm bietet den Benutzern eine vielseitige interaktive Plattform, um ihre Tippfähigkeiten zu verbessern, sei es für das Programmieren oder die allgemeine Kommunikation. Es ist ein wertvolles Werkzeug zur Verbesserung der Tippgeschwindigkeit und -genauigkeit.