Crie um programa que abre um arquivo chamado entrada.txt, existente no diretório do projeto, e que imprime no monitor o número de consoantes presentes no texto.

Passo 1

O que o enunciado pede e o que temos:
  • Pede: criar um programa que abra um arquivo chamado entrada.txt (existente no diretório do projeto) e imprima no monitor o número de consoantes presentes no texto do arquivo.
  • Informações dadas: existe um arquivo entrada.txt no diretório do projeto.
  • Vou assumir que:
    • Devemos contar apenas letras que são consoantes (não contar dígitos, sinais de pontuação, espaços).
    • A contagem deve ser case-insensitive (ou seja, B e b contam como mesma consoante).
    • Devemos tratar corretamente letras acentuadas e ç (por exemplo ç, Ç, ñ etc. quando aparecerem) — ou seja, uma letra acentuada cujo “base” é uma vogal não deve ser contada como consoante (por exemplo á é vogal), e uma letra acentuada cujo base é consoante deve ser contada (por exemplo ç -> c é consoante).
  • Não foi pedido um formato especial de saída, então o programa vai imprimir apenas o número total (um inteiro) no stdout.

Passo 2

Escolha do método e linguagem:
  • Vou usar Python porque é curto, claro e portátil, e lida bem com entrada/saída de arquivos e com Unicode (acentos).
  • Estratégia geral:
    1. Abrir o arquivo entrada.txt em modo leitura com codificação UTF-8.
    2. Ler todo o texto.
    3. Percorrer cada caractere do texto: se for uma letra, descobrir sua “base” (por exemplo, á tem base a, ç tem base c), converter para minúscula e verificar se a base é uma vogal (a, e, i, o, u). Se não for vogal, é consoante — incrementar contador.
    4. Imprimir o contador no final.
  • Vou tratar letras usando str.isalpha() para identificar letras, e usar unicodedata.normalize('NFD', char) para decompor acentos e obter a base do caractere. Isso cobre casos como á, â, ç, etc.

Passo 3

Por que normalizar (explicação didática e simples):
  • Em Unicode, um caractere acentuado pode ser representado de duas formas:
    • como um único caractere pré-composto (por exemplo á)
    • ou como um caractere base mais um sinal diacrítico (por exemplo a + acento)
  • A função unicodedata.normalize('NFD', s) transforma cada caractere em sua forma decomponível: por exemplo á vira a + ´ (dois codepoints). Assim o primeiro caractere da sequência normalizada é geralmente a “base” (a letra sem acento).
  • Pegando essa base em minúscula, podemos decidir se é vogal (a, e, i, o, u). Se não for vogal e o caractere original era uma letra, então é consoante.

Passo 4

Detalhes de entrada/saída em Python (mão na massa, explicando linha a linha)
  • Abrir arquivo em UTF-8:
    • with open('entrada.txt', 'r', encoding='utf-8') as f: garante que o arquivo será fechado automaticamente e que o texto será lido como UTF-8 (padrão comum).
  • Ler todo o texto:
    • texto = f.read() traz o conteúdo para uma string Python.
  • Percorrer caracteres:
    • for ch in texto: itera cada caractere.
    • if ch.isalpha(): seleciona apenas letras (isso inclui letras acentuadas como á e ç).
  • Normalizar e obter base:
    • decomp = unicodedata.normalize('NFD', ch) decompõe ch.
    • base = decomp[0].lower() pega o primeiro codepoint (a base) e coloca em minúscula.
    • Se base estiver em {'a','e','i','o','u'} então é vogal; caso contrário, como ch era uma letra, conta-se como consoante.
  • Contador:
    • Inicializar cont = 0 e incrementar cont += 1 quando encontrar consoante.
  • Impressão:
    • print(cont) para mostrar apenas o número no terminal.

Passo 5

Tratamento de erros e comportamento final:
  • Mesmo que o enunciado diga que o arquivo existe, é pedagogicamente correto proteger contra FileNotFoundError e informar ao usuário se o arquivo não for encontrado. Vou mostrar no programa um tratamento simples: em caso de arquivo não existir, imprime mensagem de erro na saída de erro e sai com código 1.
  • Assim o programa é robusto e fácil de usar na prática.

Passo 6

Exemplo curto para você entender (sem usar código novo):
  • Texto: Olá, Mundo!
    • Letras: O l á M u n d o
    • Base minúscula: o l a m u n d o
    • Vogais (a,e,i,o,u): o, a, u, o -> 4 vogais
    • Letras totais: 7
    • Consoantes = 7 - 4 = 3 (corrigindo: lista de consoantes é l, m, n, d = 4) — se fizer na prática o método com decomposição, o programa conta corretamente l, m, n, d = 4.
  • O exemplo mostra que o método considera letras acentuadas corretamente (o á vira base a e é tratada como vogal).

Passo 7

Código final (explicação encerrada, abaixo está a versão pronta para colocar num arquivo .py e executar)
  • Coloque este código num arquivo, por exemplo conta_consoantes.py.
  • Execute na pasta onde está entrada.txt com python3 conta_consoantes.py.
  • O programa imprimirá apenas um número: a quantidade de consoantes no arquivo.

Resposta

import unicodedata
import sys
def contar_consoantes_em_texto(texto):
vogais = {‘a’, ‘e’, ‘i’, ‘o’, ‘u’}
cont = 0
for ch in texto:
if not ch.isalpha():
continue
decomp = unicodedata.normalize(‘NFD’, ch)
base = decomp[0].lower()
if base not in vogais:
cont += 1
return cont
def main():
try:
with open(‘entrada.txt’, ‘r’, encoding=‘utf-8’) as f:
texto = f.read()
except FileNotFoundError:
print(“Erro: arquivo ‘entrada.txt’ não encontrado no diretório do projeto.”, file=sys.stderr)
sys.exit(1)
total = contar_consoantes_em_texto(texto)
print(total)
if name == ‘main’:
main()

Exercícios relacionados