strings.c

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

#define CANT_PAL 10 // CANTIDAD DE PALABRAS
#define LONG_PAL 30 // LONGITUD MÁXIMA DE LAS PALABRAS

// AYUDAS
// funciones de caracteres
// #include <ctype.h>
// int isalnum (int c);
// int isalpha (int c);
// int isascii (int c);
// int isblank (int c);
// int iscntrl (int c);
// int isdigit (int c);
// int isgraph (int c);
// int islower (int c);
// int isprint (int c);
// int ispunct (int c);
// int isspace (int c);
// int isupper (int c);
// int isxdigit (int c);

// funciones de strings
// #include <string.h>
// char *strcpy(char *dest, const char *orig);
// char *strcat(char *dest, const char *src);
// char *strstr(const char *haystack, const char *needle);
// size_t strspn(const char *s, const char *acepta);
// size_t strcspn(const char *s, const char *rechaza);

// A) Se tiene un arreglo de strings (arregloPalabras) que contiene 10 palabras de una longitud
// máxima de 30 caracteres. Se pide escribir una función (informaString) que indique cual es
// la palabra que más vocales contiene, en que posición del arreglo se encuentra y cuantas
// vocales posee. No debe hacerse distinción entre mayúsculas y minúsculas. Asumir que no
// hay 2 palabras con igual cantidad de vocales. Usar constantes (CANT_PAL y LONG_PAL) para
// dimensionar arreglo y longitud de los strings respectivamente. Por ultimo se sugiere
// modularizar mediante la función contarVocalesEnPalabra, la cual reciba una palabra y
// devuelva cantidad de vocales que contiene. Esta modularizacion NO es obligatoria.

int contarVocalesEnPalabra(char palabra[LONG_PAL])
{
    // devuelve la cantidad de vocales que tiene el string
    int vocales = 0;
    for (int i = 0; i < strlen(palabra); i++)
    {
        // puede ser vocales A o a, para evitar problemas de mayúsculas
        char letra = tolower(palabra[i]);

        // opciones:
        //  1 - hacer una función "es vocal" que reciba un char y retorne si es o no.
        //  2 - cambiar el if por un switch
        if (letra == 'a' || letra == 'e' || letra == 'i' || letra == 'o' || letra == 'u')
        {
            vocales++;
        }
    }

    return vocales;
}

void informaString(char palabras[CANT_PAL][LONG_PAL])
{

    // que indique:
    // - cual es la palabra que más vocales contiene,
    // - en que posición del arreglo se encuentra
    // - y cuantas vocales posee

    // la posición de la palabra con más vocales
    int posicion = -1;

    // cual es el máximo de vocales actual.
    // inicialmente -1 para que siempre tome la primera palabra.
    int maximaCantidadVocales = -1;

    for (int i = 0; i < CANT_PAL; i++)
    {
        int cantidadVocalesPalabraActual = contarVocalesEnPalabra(palabras[i]);

        if (cantidadVocalesPalabraActual > maximaCantidadVocales)
        {
            posicion = i;
            maximaCantidadVocales = cantidadVocalesPalabraActual;
        }
    }

    // sumo 1 a la posición porque los arreglos arrancan en 0
    // la posición del arreglo es "posicion", pero la posición real es "posición+1"
    printf("La palabra %s contiene %i vocales y esta en la posicion %i\n", palabras[posicion], maximaCantidadVocales, posicion + 1);
}

// B) Se tiene el string PALABRA_OCULTA que contiene una palabra “oculta” para el usuario. Se
// pide escribir una función (adivinarLaPalabra) que inicialmente muestre al mencionado
// usuario la longitud de la palabra y a partir de esa información proceder de la siguiente
// manera:
// • Solicitar al usuario el ingreso de letras (de a una por vez), con el objetivo de adivinar
// al menos 1 perteneciente a la palabra “oculta”. Ingresar cada intento en mayúscula.
// • Se deben permitir tantos intentos como longitud tenga la palabra.
// • Por cada intento informar al usuario si la letra esta contenida en la palabra o no.
// • La función finalmente deberá informar si la palabra fue adivinada o no y en
// cualquier caso mostrarla.
// • Se sugiere modularizar implementando la función:
// int letraEnPalabra(char palabra[LONG_PAL], char letra)
// que reciba la palabra oculta y permita buscar la letra en ella.

int letraEnPalabra(char palabra[LONG_PAL], char letra)
{
    // devuelve la cantidad de veces que aparece una letra en la palabra
    int cantidad = 0;

    for (int i = 0; i < strlen(palabra); i++)
    {
        // pongo ambas letras en mayusuculas para verificar por las dudsa
        if (toupper(palabra[i]) == toupper(letra))
        {
            cantidad++;
        }
    }

    // normalmente en c, "0" es falso
    return cantidad;
}

void adivinarLaPalabraV1(char palabra[LONG_PAL])
{
    // PROBLEMA DE ESTA VERSION:
    //  - si ejecutás varias veces la misma letra, se rompe
    // - el for va desde intentos hasta cero

    printf("La palabra contiene %lu caracteres\n", strlen(palabra));

    //  Se deben permitir tantos intentos como longitud tenga la palabra.
    int intentos = strlen(palabra);

    // se almacenan la cantidad de letras adivinadas
    int adivinadas = 0;

    // este if va desde la cantidad de intentos, hasta 0
    for (int i = intentos; i > 0; i--)
    {
        char letra;

        printf("Ingrese una letra en mayuscula: ");
        fflush(stdin);
        scanf("%c", &letra);
        printf("\n");

        // si la letra aparece más de 1 vez, es porque es esa
        int vecesQueApareceLetra = letraEnPalabra(palabra, letra);
        if (vecesQueApareceLetra > 0)
        {
            adivinadas += vecesQueApareceLetra;

            printf("La letra '%c' se encuentra en la palabra oculta, te quedan por adivinar %i letras\n", letra, intentos - adivinadas);

            if (adivinadas == strlen(palabra))
            {
                // si la cantidad de letras adivinadas
                // es la misma que la cantidad que tiene la palabra es porque adivinó
                printf("ADIVINASTE! la palabra era: %s\n", palabra);

                // salgo porque no necesito verificar más nada
                return;
            }
        }
        else
        {
            // la cantidad de intentos restantes es la variable i
            printf("La letra '%c' NO SE ENCUENTRA en la palabra oculta, te quedan por adivinar %i letras y %i intentos\n", letra, intentos - adivinadas, i);
        }
    }

    // si llegó hasta acá, es porque no adivinó
    printf("NO ADIVINASTE! la palabra era: %s\n, consumiste todos tus intentos, acertaste %i letras\n", palabra, adivinadas);
}

void adivinarLaPalabraV2(char palabra[LONG_PAL])
{
    // PROBLEMA DE ESTA VERSION:
    //  - si ejecutás varias veces la misma letra, se rompe
    // - el for va desde cero hasta intentos

    printf("La palabra contiene %lu caracteres\n", strlen(palabra));

    //  Se deben permitir tantos intentos como longitud tenga la palabra.
    int intentos = strlen(palabra);

    // se almacenan la cantidad de letras adivinadas
    int adivinadas = 0;

    // este if va desde la cantidad de intentos, hasta 0
    for (int i = 0; i < intentos; i++)
    {
        char letra;

        printf("Ingrese una letra en mayuscula: ");
        fflush(stdin);
        scanf("%c", &letra);
        printf("\n");

        // si la letra aparece más de 1 vez, es porque es esa
        int vecesQueApareceLetra = letraEnPalabra(palabra, letra);
        if (vecesQueApareceLetra > 0)
        {
            adivinadas += vecesQueApareceLetra;

            printf("La letra '%c' se encuentra en la palabra oculta, te quedan por adivinar %i letras\n", letra, intentos - adivinadas);

            if (adivinadas == strlen(palabra))
            {
                // si la cantidad de letras adivinadas
                // es la misma que la cantidad que tiene la palabra es porque adivinó
                printf("ADIVINASTE! la palabra era: %s\n", palabra);

                // salgo porque no necesito hacer más nada
                return;
            }
        }
        else
        {
            // la cantidad de intentos restantes en la variable intentos - i, acá se diferencia a la versión 1 (V1)
            printf("La letra '%c' NO SE ENCUENTRA en la palabra oculta, te quedan por adivinar %i letras y %i intentos\n", letra, intentos - adivinadas, intentos - i);
        }
    }

    // si llegó hasta acá, es porque no adivinó
    printf("NO ADIVINASTE! la palabra era: %s\n, consumiste todos tus intentos, acertaste %i letras\n", palabra, adivinadas);
}

int main()
{
    char arregloPalabras[CANT_PAL][LONG_PAL] = {
        "PALABRA",
        "PERRO",
        "COSA",
        "PALABRA",
        "PERRO",
        "COSA",
        "PALABRA",
        "PERRO",
        "COSA",
        "ESTA PALABRA ES TRAMPOSA",
    };

    informaString(arregloPalabras);

    adivinarLaPalabraV1("KADABRA");

    return 0;
}