Programa de práctica de escritura utilizando C

Introducción

Este proyecto te guiará en la creación de un programa de práctica de escritura a máquina utilizando el lenguaje de programación C. Aprenderás cómo realizar diversos ejercicios de escritura, incluyendo entrenamiento con cadenas individuales, múltiples cadenas y escritura basada en la disposición del teclado. Estos programas te ayudarán a mejorar tu velocidad y precisión al escribir.

👀 Vista previa

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

🎯 Tareas

En este proyecto, aprenderás:

• Cómo crear un programa de práctica de escritura a máquina utilizando C.
• Cómo implementar ejercicios para escribir cadenas individuales, múltiples cadenas y asociaciones de disposición del teclado.
• Cómo utilizar la biblioteca curses para operaciones de entrada y salida de pantalla.
• Cómo mezclar el orden de las preguntas para dar variedad a la práctica.

🏆 Logros

Después de completar este proyecto, podrás:

• Crear un programa en C para simular la práctica de escritura a máquina.
• Manejar la entrada del usuario y validar su corrección.
• Generar preguntas aleatorias y mezclar el orden de las preguntas.
• Utilizar la biblioteca curses para operaciones avanzadas de entrada y salida de pantalla.

Skills Graph

Entorno del proyecto

El proyecto requiere el uso de la biblioteca curses. Instálala utilizando los siguientes comandos:

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

El propósito del archivo de encabezado getputch.h en el código es proporcionar una biblioteca de funciones de entrada y salida de pantalla multiplataforma, asegurando que el programa pueda realizar correctamente operaciones de entrada y salida de pantalla en diferentes sistemas operativos y entornos de compilación, especialmente el manejo de la salida del carácter de nueva línea.

A continuación, introduciremos ejercicios básicos de escritura a máquina, que principalmente involucran punteros, arreglos de cadenas y estructuras de bucle en el lenguaje C.

Demostraremos la aplicación de arreglos de cadenas, comenzando desde la entrada básica de un solo carácter hasta la práctica con múltiples palabras desordenadas.

Ingresar un carácter

Navega hasta el directorio ~/project y crea el archivo del proyecto typing1a.c:

cd ~/project
touch typing1a.c

A continuación, necesitamos escribir código en C para crear un software de práctica de escritura a máquina que permita la entrada de una cadena. El programa es el siguiente:

#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;
}

Se requiere que el jugador ingrese la cadena a la que apunta el puntero str: How do you do?. Por la intercambiabilidad de punteros y arreglos, los caracteres 'H', 'o',..., '?' dentro de la cadena pueden representarse secuencialmente como str[0], str[1],..., str[13].

Además, la variable len representa la longitud de la cadena str y tiene un valor inicial de 14. strlen() se utiliza para obtener la longitud de la cadena.

El bucle for incrementa el valor de la variable i desde 0, 1, 2,... durante len iteraciones para recorrer secuencialmente los caracteres dentro de la cadena desde el principio hasta el final. Durante cada iteración, el carácter str[i] es 'H', 'o',..., '?', que son los caracteres a ingresar. Esta práctica de escritura no acepta caracteres incorrectos (el programa no pasará al siguiente carácter hasta que el jugador ingrese el carácter correcto). Este control se asegura mediante el bucle do, y se realizan las siguientes acciones dentro del bucle:

• Asignar el carácter de entrada (el valor de retorno de la función getch) a la variable ch.
• Si el carácter ch es un carácter imprimible, mostrarlo utilizando la función putch (excluyendo caracteres no visibles como salto de línea y tabulación).
• Si el carácter ch no es igual al carácter a ingresar str[i], se muestra el carácter de retroceso '\b' para mover el cursor un espacio hacia atrás. Esto asegura que el siguiente carácter de entrada se muestre en la misma posición.

Después de completar los pasos mencionados anteriormente, se evalúa la expresión de control del bucle do (ch!= str[i]). Cuando se ingresa un carácter incorrecto (cuando ch no es igual a str[i]), el bucle do se reinicia. En este momento, el programa no pasa al siguiente carácter sino que ejecuta de nuevo la parte relevante dentro del bucle do... while. Después de ingresar el carácter correcto, el valor de i se incrementa por el bucle for y el programa pasa al siguiente carácter. Después de ingresar todos los caracteres, el programa mostrará el tiempo que ha tardado el jugador.

Compila y ejecuta utilizando los siguientes comandos:

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

Puedes practicar varias veces para mejorar tu velocidad. Si encuentras aburrido practicar con How do you do?, también puedes elegir otra cadena para practicar.

Eliminación de caracteres ingresados

Navega hasta el directorio ~/project y crea el archivo del proyecto typing1b.c:

cd ~/project
touch typing1b.c

Ahora echemos un vistazo al programa. El código es el siguiente:

#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;
}

Este programa es ligeramente diferente al anterior. Cada vez que se ingresa el carácter correcto, un carácter desaparecerá y los caracteres siguientes se moverán hacia adelante. Del mismo modo, el programa no pasará al siguiente carácter a menos que el jugador ingrese la tecla correcta. Cuando el jugador ingrese correctamente todos los caracteres, todos los caracteres desaparecerán y el programa terminará.

Aunque la operación realizada aquí es más "avanzada" que la del programa anterior, el programa en realidad es más corto. El cuerpo de la instrucción for consta de solo dos instrucciones cortas.

• El &str[i] pasado a la función printf en la instrucción printf("%s \r", &str[i]); es un puntero a str[i]. Dado que el valor de la variable i es 0, el puntero &str[i] apuntará al carácter 'H', lo que hará que la pantalla muestre la cadena How do you do? comenzando con str[0], como se muestra en la figura anterior. El programa luego mostrará caracteres de espacio en blanco y un retorno de carro \r inmediatamente después de esta cadena, y devolverá el cursor a la posición del 'H' al principio de la línea.
• Si el carácter ingresado (el valor de retorno de la función getch) no es igual a str[i], es decir, el carácter de entrada no es 'H', la instrucción while se repetirá continuamente hasta que el jugador ingrese el carácter correcto, momento en el cual la instrucción while terminará.
• El valor de la variable i se convertirá en 1 a través de la influencia de la instrucción for. Como se muestra en la figura anterior, la instrucción printf("%s \r", &str[i]); mostrará la cadena ow do you do? comenzando con str[1], luego mostrará caracteres de espacio en blanco y un retorno de carro, y devolverá el cursor a la posición del 'o' al principio. Después, con el efecto de la siguiente instrucción while, esperará a que el jugador ingrese correctamente 'o'.

Compila y ejecuta utilizando los siguientes comandos:

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

Ingreso de múltiples cadenas

A continuación, extendamos el programa anterior para permitir al jugador practicar el ingreso de múltiples cadenas.

Navega hasta el directorio ~/project y crea un archivo de proyecto llamado typing2a.c:

cd ~/project
touch typing2a.c

Ahora echemos un vistazo al programa. El código es el siguiente:

#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;
}

En este programa, después de ingresar una cadena, la siguiente cadena se mostrará en la misma línea para que el jugador la ingrese. Hay un total de 12 cadenas disponibles para la práctica.

Este programa se basa en su mayoría en el programa anterior, pero hay algunas diferencias:

1. La instrucción for se ha anidado.

• Dado que el número de palabras en la pregunta ha cambiado de 1 a 12, se ha agregado una instrucción for exterior. Esta instrucción for itera QNO veces, comenzando desde 0, para la variable stage. El bucle for interno después de strlen(str[stage]) es equivalente al bucle for en el programa anterior.
• La cadena a ingresar en cada iteración es str[stage] (equivalente a str en el programa anterior). El número de caracteres a ingresar varía según la cadena, por lo que la instrucción strlen(str[stage]) calcula la longitud de la cadena str[stage] utilizada para la pregunta y la almacena en la variable len.

2. El carácter a ingresar ya no es str[i], sino str[stage][i].

En el bucle for interno, el carácter a ingresar es str[stage][i], que es equivalente a str[i] en el programa anterior.

Compila y ejecuta utilizando los siguientes comandos:

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

Mezclar el orden de las preguntas (Método 1)

Después de practicar varias veces con el programa anterior, la siguiente cadena que aparece en la pregunta se te ocurrirá automáticamente, lo que debilita el efecto de entrenamiento. Ahora, mezclemos el orden de las preguntas.

Navega hasta el directorio ~/project y crea el archivo del proyecto typing2b.c:

cd ~/project
touch typing2b.c

Ahora echemos un vistazo al programa. El código es el siguiente:

#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;
}

Para mezclar el orden de las preguntas, el programa introduce una nueva matriz llamada qno con tipo de elemento int y tamaño QNO (que es el número de cadenas en las preguntas, es decir, 12).

Antes de comenzar la práctica de escritura, los dos primeros bucles for se utilizan para asignar valores a cada elemento de la matriz qno en el orden de 0, 1, 2,..., 11.

Similar al programa anterior, todas las apariciones de str[stage] se han reemplazado por str[qno[stage]], porque en cada ciclo de este programa, la pregunta a realizar se basa en str[qno[stage]].

• Cuando stage es 0; dado que el valor de qno[0] es 2, la pregunta mostrada por el programa será str[2], que es default.
• Cuando stage es 1; dado que el valor de qno[1] es 1, la pregunta mostrada por el programa será str[1], que es computer.

Y así sucesivamente. Después de practicar con las 12 cadenas, el programa terminará.

Compila y ejecuta utilizando los siguientes comandos:

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

Mezclar el orden de las preguntas (Método 2)

El siguiente programa mezcla el orden de las preguntas utilizando un método diferente sin usar una matriz. Este programa requiere menos variables y es más conciso en comparación con el programa anterior.

Navega hasta el directorio ~/project y crea el archivo del proyecto typing2c.c:

cd ~/project
touch typing2c.c

Ahora echemos un vistazo al programa. El código es el siguiente:

#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;
}

Cada elemento de la matriz str apunta a las cadenas book, computer, default,.... Después de intercambiar los valores de str[0] y str[2], str[0] apunta a default y str[2] apunta a book.

El primer bucle for en el programa (código anterior) se encarga de reordenar los punteros, que son los valores de los elementos en la matriz str, mezclando así los elementos. Dado que los objetos que se intercambian son punteros, el primer argumento asignado a la macro de función swap es char *.

En el segundo bucle for en la parte principal del programa, cada etapa de las preguntas se devuelve a str[stage] (que es str[qno[stage]] en la Lista 8 - 4, que es más complejo). Esto se debe a que la matriz str se ha reordenado aleatoriamente, y al mostrar str[0], str[1],..., str[QNO - 1] en orden, se obtiene un orden aleatorio de preguntas.

Una desventaja de este método es que una vez que se mezcla el orden de las palabras, no se puede restaurar. Tenga esto en cuenta.

Compila y ejecuta utilizando los siguientes comandos:

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

Escritura asociativa con el layout del teclado

A continuación, vamos a desarrollar un software que permita a los jugadores practicar la escritura mientras recuerdan la posición de cada tecla en el teclado. A diferencia de los ejercicios de escritura regulares, los jugadores tendrán que ingresar caracteres sin ningún tipo de indicio. Además, diferentes teclados tienen diferentes layouts, y aquí usaremos el layout del teclado mostrado en el siguiente diagrama como referencia.

En el layout del teclado mostrado en el diagrama, incluso cuando se mantiene presionada la tecla [Shift] mientras se presiona la tecla [0], no se ingresará ninguna información.

Con respecto al layout de este teclado, podemos observar los siguientes puntos:

• Está compuesto por 4 capas de teclas.
• Cada capa se divide en teclas para la mano izquierda y teclas para la mano derecha, donde la mano izquierda presiona las teclas negras y la mano derecha presiona las teclas azules.
• Hay teclas que no requieren que se mantenga presionada la tecla [Shift] al presionarlas, y hay teclas que sí requieren que se mantenga presionada la tecla [Shift] al presionarlas.

Llamamos "bloques" a los diversos conjuntos clasificados por capa/manos/si se presiona la tecla [Shift], y el teclado completo consta de 4 × 2 × 2 = 16 bloques en total.

Por ejemplo, el bloque de teclas para la mano izquierda con la tecla [Shift] presionada en la 3ª capa es [A], [S], [D], [F], [G] (manejadas respectivamente por el meñique, el anular, el dedo medio, el índice y el índice).

En este software de entrenamiento, se presenta un bloque como pregunta, pero el software usará "?" para ocultar un carácter dentro de este bloque. Por ejemplo, para la siguiente pregunta, el jugador debe asociar el "?" oculto con la letra mayúscula D y luego ingresar la letra.

A S? F G

Código y resultado de ejecución

Navega hasta el directorio ~/project y crea un archivo de proyecto llamado typing3.c:

cd ~/project
touch typing3.c

El programa escrito de acuerdo con las pautas anteriores se muestra a continuación:

#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;
}

La macro KTYPE representa el número de bloques, que es 16, y la matriz kstr se utiliza para almacenar las cadenas formadas por los caracteres de cada bloque dispuestos de izquierda a derecha.

En términos de propósitos de entrenamiento, la pregunta no contendrá el carácter ?, por lo que la última cadena declarada para el bloque es NM<> _ en lugar de NM<>?_ (dado que el programa no utiliza la tecla de espacio para generar preguntas, no producirá un error).

Si el layout de tu teclado es diferente al mostrado en este ejemplo, modifica la declaración de la matriz kstr en consecuencia.

El primer bucle do while se encarga de generar la pregunta.

• La variable k indica de qué bloque se generará la pregunta. Dado que este valor corresponde al índice de la matriz kstr, se establece como un número aleatorio mayor o igual a 0 y menor que KTYPE.

  Dado que el número de bloques KTYPE es 16, el número aleatorio generado estará en el rango de 0 a 15.

• La variable p indica qué carácter dentro del bloque debe ocultarse para generar la pregunta. Dado que este valor corresponde al índice de la cadena utilizada para generar la pregunta dentro del bloque, se establece como un número aleatorio mayor o igual a 0 y menor que el número de caracteres dentro del bloque.

  Suponiendo que k es 0, el bloque consta de 5 caracteres, '12345', por lo que p se establece como un número aleatorio en el rango de 0 a 4. Además, si k es 3, el bloque consta de 8 caracteres, '&'()=~|', por lo que p se establece como un número aleatorio en el rango de 0 a 7.

• La variable key representa el carácter oculto.

Por ejemplo, si k es 0 y p es 2, el carácter '3' en el bloque '12345' es la key. Dado que el programa ya ha asignado el carácter de espacio '' a los caracteres que no deben utilizarse para generar preguntas, se utiliza el bucle do-while para regenerar la pregunta si el carácter oculto key es un carácter de espacio.

A continuación, la función strcpy copia kstr[k] a temp, y asigna '?' a temp[p]. Esto genera la cadena 12?45 que se mostrará en la pantalla.

Si el programa es capaz de mostrar la cadena temp y leer el carácter key ingresado desde el teclado, es correcto. Al igual que los programas de ejercicios de escritura anteriores, este programa no acepta caracteres mal escritos. Después de 30 rondas de entrenamiento, el programa terminará su ejecución.

Compila y ejecuta utilizando los siguientes comandos:

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

Resumen

En este proyecto, has aprendido cómo crear un programa de práctica de escritura utilizando el lenguaje de programación C. Este programa de práctica de escritura ofrece a los usuarios una plataforma interactiva versátil para mejorar sus habilidades de escritura, ya sea para la programación o la comunicación general. Proporciona una herramienta valiosa para mejorar la velocidad y la precisión de la escritura.