Escreva um programa que pede ao usuário para digitar um inteiro n, em seguida lê um arquivo chamado texto.txt e então imprime na tela todas as palavras do arquivo com um número de caracteres maior ou igual a n, mantendo a ordem com que as palavras aparecem no texto.

Passo 1

O enunciado pede o seguinte (resumido e claro):
  • O programa deve pedir ao usuário que digite um inteiro \,n.
  • Em seguida o programa deve ler um arquivo chamado “texto.txt”.
  • O programa deve imprimir na tela todas as palavras do arquivo cujo número de caracteres seja maior ou igual a \,n, mantendo a ordem em que as palavras aparecem no texto.
Informações relevantes que o enunciado dá:
  • Existe um valor inteiro de entrada \,n.
  • O arquivo a ser lido chama-se “texto.txt”.
  • A saída é a lista (na ordem do texto) de palavras com comprimento \ge n.
Observação importante (sem resolver ainda): o enunciado não especifica exatamente o que considera “palavra” (por exemplo: se “coração,” com vírgula é palavra “coração” ou inclui a vírgula). Vou seguir a definição prática e robusta que usarei na implementação: palavra = sequência contígua de letras (ou seja, caracteres para os quais o método padrão de linguagem considera letra). Explico e justifico isso nos próximos passos.

Passo 2

Escolha do método e da linguagem:
  • Linguagem escolhida: Python 3. Motivos: sintaxe simples, leitura de arquivos fácil, manipulação de strings fácil e é a escolha mais prática para uma tarefa de texto numa prova de programação introdutória.
  • Método de tokenização (transformar texto em palavras): percorrer o texto caractere a caractere e agrupar sequências de caracteres alfabéticos em “palavras”. Este método evita contar sinais de pontuação como parte da palavra e funciona bem para letras acentuadas (em Python, .isalpha() aceita letras acentuadas).
  • Verificaremos a condição de tamanho usando a função \text{len}(\text{palavra}) e comparando com \,n via \ge.
Por que esta escolha?
  • É simples (pode ser feito com construção básica de strings).
  • Não depende de bibliotecas extras (por ex. regex), então é seguro para prova.
  • Tratamento de pontuação e quebras de linha fica correto (pontuação é separador).

Passo 3

Rascunho do algoritmo passo a passo (alto nível):
  1. Ler a entrada do usuário e converter para inteiro: n = inteiro digitado.
  2. Tentar abrir “texto.txt” no modo leitura com codificação UTF-8; se o arquivo não existir, avisar e encerrar.
  3. Ler o conteúdo do arquivo (pode ser todo de uma vez para textos de tamanho normal).
  4. Converter o conteúdo em uma lista de palavras usando tokenização por sequência de letras.
    • Percorrer o texto caractere por caractere, acumulando letras em uma “palavra atual”.
    • Ao encontrar um separador (qualquer caractere que não seja letra), finalizar a palavra atual (se existir) e adicioná-la à lista.
  5. Percorrer a lista de palavras na ordem encontrada; para cada palavra, se \text{len}(\text{palavra}) \ge n, imprimir a palavra (uma por linha, por exemplo).
  6. Finalizar.

Passo 4

Detalhes de implementação (explicando conceitos e funções usados):
  • input() — lê uma linha do teclado como string. Para obter inteiro, usar \text{int}(\text{input}()). Isso pode lançar \text{ValueError} se o usuário não digitar um inteiro; por isso devemos tratar essa exceção para dar mensagem amigável.
  • with open(“texto.txt”, “r”, encoding=“utf-8”) as f: — abre o arquivo de forma segura; ao sair do bloco, o arquivo é fechado automaticamente.
  • str.isalpha() — método que retorna True se todos os caracteres da string forem letras (inclui letras acentuadas e letras de outros alfabetos). Quando iteramos caractere a caractere, podemos usar \text{ch.isalpha}() para decidir se \text{ch} faz parte de uma palavra.
  • len(s) — retorna o número de caracteres da string s. A condição pedida é \text{len}(\text{palavra}) \ge n.
  • Impressão: vou imprimir cada palavra selecionada em uma linha separada, para ficar claro e simples.
  • Erros tratados: arquivo não encontrado e entrada inválida do usuário. Em prova esses tratamentos costumam ser valorizados.

Passo 5

Implementação da função de tokenização (explicação passo a passo):
  • Objetivo: transformar uma string grande (o conteúdo do arquivo) numa lista de palavras, onde cada palavra é uma sequência contígua de letras.
  • Pseudocódigo da tokenização:
    1. Criar lista vazia \text{words} = [] e acumulador \text{current} = [] (lista de caracteres).
    2. Para cada caractere \text{ch} do texto:
      • Se \text{ch.isalpha()} == \text{True}: adicionar \text{ch} a \text{current}.
      • Senão: se \text{current} não estiver vazia, juntar os caracteres de \text{current} formando uma string, adicionar à \text{words} e esvaziar \text{current}.
    3. Ao final, se \text{current} não estiver vazia, juntar e adicionar à \text{words}.
  • Resultado: \text{words} contém as palavras na ordem em que aparecem no texto.
  • Observação: essa tokenização remove números e pontuação; se quiser incluir palavras que contenham dígitos, bastaria testar \text{ch.isalnum()} em vez de \text{isalpha()}.

Passo 6

Fluxo principal e complexidade:
  • Complexidade de tempo: linear no número de caracteres do arquivo (cada caractere é lido e processado uma vez).
  • Memória: armazenamos todo o conteúdo do arquivo numa string (no exemplo). Se o arquivo for gigantesco e memória for problema, poderíamos processá-lo em blocos ou linha a linha; mas para uma prova geralmente ler tudo é aceitável.
  • Ordem preservada: a tokenização proposta não altera a ordem das palavras; apenas as separa e filtra pelo comprimento.

Passo 7

Exemplo prático (curto) para fixar a ideia:
  • Suponha que “texto.txt” contenha: Olá, mundo! Eu tenho 2 cães.
  • Tokenização com \text{isalpha()} dá: [“Olá”, “mundo”, “Eu”, “tenho”, “cães”] (o “2” é ignorado).
  • Se n=4, as palavras com \text{len}(\text{palavra}) \ge 4 são: “mundo”, “tenho”.
  • O programa imprimiria:
    mundo
    tenho

Passo 8

Agora o código completo (explicação linha a linha foi feita acima; abaixo o programa final que atende ao enunciado). Rode em Python 3. Se necessário adaptar para processar palavras com números ou hífens, trocar a condição de caractere conforme explicado.

Resposta

#!/usr/bin/env python3
def tokenize(text):
“”“Retorna lista de palavras encontradas em text.
Palavra = sequência contígua de letras (ch.isalpha() == True).”""
words = []
current = []
for ch in text:
if ch.isalpha():
current.append(ch)
else:
if current:
words.append(’’.join(current))
current = []
if current:
words.append(’’.join(current))
return words
def main():
try:
n = int(input("Digite um inteiro n: "))
except ValueError:
print(“Entrada inválida: digite um inteiro.”)
return
try:
    with open("texto.txt", "r", encoding="utf-8") as f:
        text = f.read()
except FileNotFoundError:
    print("Arquivo 'texto.txt' não encontrado.")
    return
except OSError as e:
    print("Erro ao abrir o arquivo:", e)
    return

words = tokenize(text)
for w in words:
    if len(w) >= n:
        print(w)
if name == “main”:
main()

Exercícios relacionados