Escrever um programa em C que leia uma cadeia de caracteres de tamanho máximo igual a 80 e imprimir quantas vogais tem a cadeia lida. Fazer a diferenciação entre letras maiúsculas e minúsculas. Calcular, também, o percentual do número de vogais com relação ao número total de caracteres da cadeia.

Passo 1

O enunciado pede três coisas principais:
  • Ler uma cadeia de caracteres com tamanho máximo igual a 80.
  • Imprimir quantas vogais há na cadeia lida, diferenciando letras maiúsculas e minúsculas.
  • Calcular e imprimir o percentual do número de vogais em relação ao número total de caracteres da cadeia.
Informações relevantes do enunciado:
  • O tamanho máximo da cadeia é 80 caracteres (portanto precisamos de espaço para o terminador nulo).
  • Devemos distinguir maiúsculas e minúsculas (isso indica que devemos contar separadamente vogais minúsculas e vogais maiúsculas, e também fornecer o total).
  • O percentual deve ser calculado com relação ao número total de caracteres lidos na cadeia (incluindo espaços e símbolos), exceto o terminador de linha que o método de leitura possa deixar.

Passo 2

Escolha da forma de ler a cadeia em C:
  • Não usemos funções inseguras como gets. Vamos usar fgets, que permite limitar quantos caracteres são lidos e evita overflow.
  • Para permitir até 80 caracteres mais o caractere de nova linha e o terminador nulo, vamos declarar um buffer com tamanho 80 + 2 = 82. Em C isso ficará como char s[MAX+2]; com MAX sendo 80.
Explicação didática:
  • fgets(s, sizeof s, stdin) lê até sizeof s - 1 caracteres, guarda um '\0' e, se couber, um '\n' antes do '\0'.
  • Depois de chamar fgets, é comum remover um '\n' final, se presente, para que o comprimento real da cadeia seja o número de caracteres visíveis desejado.

Passo 3

Como medir o número total de caracteres lidos:
  • Vamos usar strlen para obter o comprimento da string lida.
  • Se strlen retorna um valor len e o último caractere for '\n', iremos decrementar len e substituir esse '\n' por '\0', porque não queremos contar a nova linha como caractere da cadeia.
Observação técnica sobre indices:
  • Em C, índices vão de 0 até len-1. Se len for 0 significa string vazia.

Passo 4

Como identificar vogais diferenciando maiúsculas e minúsculas:
  • As vogais em minúsculas são \{ \text{'a'}, \text{'e'}, \text{'i'}, \text{'o'}, \text{'u'} \}.
  • As vogais em maiúsculas são \{ \text{'A'}, \text{'E'}, \text{'I'}, \text{'O'}, \text{'U'} \}.
  • Para cada caractere c da string iremos testar se c é igual a uma das vogais minúsculas (incrementa contador de minúsculas) ou igual a uma das vogais maiúsculas (incrementa contador de maiúsculas). O total de vogais é a soma dos dois contadores.
Explicando opções:
  • Poderíamos usar tolower para transformar tudo em minúsculas e só contar minúsculas, mas como o enunciado exige diferenciação entre maiúsculas e minúsculas, vamos contar separadamente.

Passo 5

Detalhe prático da verificação (estratégia simples e robusta):
  • Para cada caractere c da cadeia (índices i=0 até len-1):
    • Se c == \text{'a'} ou c == \text{'e'} ou c == \text{'i'} ou c == \text{'o'} ou c == \text{'u'} então incrementar count_lower.
    • Senão, se c == \text{'A'} ou c == \text{'E'} ou c == \text{'I'} ou c == \text{'O'} ou c == \text{'U'} então incrementar count_upper.
  • Evita uso de expressões regulares ou tabelas complicadas; é direto e rápido na prova.

Passo 6

Como calcular o percentual de vogais:
  • Se num_vowels é o número total de vogais e total_chars é o número total de caracteres da cadeia (após remoção do '\n'), então o percentual é dado por:
\text{percentual} = \frac{\text{num\_vowels}}{\text{total\_chars}} \times 100
  • Em C devemos tomar cuidado com divisão inteira: se os operandos forem inteiros, o resultado será truncado. Para obter um valor com casas decimais, convertemos ao tipo double antes da divisão. Por exemplo:
    double perc = (double) num_vowels / (double) total_chars * 100.0;
Casos especiais:
  • Se total_chars == 0 (string vazia), não podemos dividir por zero. Nesse caso o percentual não está definido; vamos decidir imprimir 0{,}00\% e avisar que a cadeia está vazia (mas mantendo a saída clara). Na prova, é suficiente proteger a divisão e, se total_chars == 0, definir perc = 0.0.

Passo 7

Formato da saída:
  • Vamos imprimir:
    • Número de vogais minúsculas (por ex.: “Vogais minusculas: 3”).
    • Número de vogais maiúsculas (por ex.: “Vogais maiusculas: 1”).
    • Número total de vogais (por ex.: “Total de vogais: 4”).
    • Percentual com duas casas decimais (por ex.: “Percentual de vogais: 36.36%”).
  • Use printf com %.2f para mostrar duas casas decimais no percentual.

Passo 8

Complexidade e comportamento:
  • O algoritmo faz uma única varredura pela cadeia, portanto tem complexidade linear O(n) onde n é o número de caracteres (no máximo 80).
  • Funciona também com espaços, pontuação e dígitos (estes não são contados como vogais).
  • Está protegido contra overflow do buffer pois usamos fgets com tamanho controlado.

Passo 9

Exemplo prático rápido (para você visualizar):
  • Se a entrada for: “Hello World!” (observe H maiúsculo, "o" minúscula etc.)
    • Vogais minúsculas: 3 (e, o, o)
    • Vogais maiúsculas: 1 (H não é vogal, mas supondo a entrada “AEioU” você veria)
    • Total de caracteres (sem \n): 12
    • Percentual = \dfrac{4}{12}\times 100 = 33{,}33\%

Passo 10

Aqui está o programa em C completo que implementa tudo explicado. Ele lê uma linha (até 80 caracteres), conta vogais minúsculas e maiúsculas, calcula o percentual e imprime os resultados.

Resposta

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

#define MAX 80

int main(void) {
    char s[MAX + 2]; /* espaço para até 80 chars, possível '\n' e '\0' */
    printf("Digite uma cadeia (max %d caracteres):\n", MAX);
    if (fgets(s, sizeof s, stdin) == NULL) {
        /* leitura falhou ou EOF */
        printf("Erro na leitura ou EOF.\n");
        return 1;
    }

    /* remover '\n' final se presente */
    size_t len = strlen(s);
    if (len > 0 && s[len - 1] == '\n') {
        s[len - 1] = '\0';
        len--;
    }

    int count_lower = 0;
    int count_upper = 0;
    for (size_t i = 0; i < len; i++) {
        char c = s[i];
        /* verificar vogais minusculas */
        if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
            count_lower++;
        } else if (c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U') {
            count_upper++;
        }
    }

    int total_vowels = count_lower + count_upper;
    double percent = 0.0;
    if (len > 0) {
        percent = (double) total_vowels / (double) len * 100.0;
    }

    printf("Vogais minusculas: %d\n", count_lower);
    printf("Vogais maiusculas: %d\n", count_upper);
    printf("Total de vogais: %d\n", total_vowels);
    printf("Percentual de vogais: %.2f%%\n", percent);

    return 0;
}

Exercícios relacionados