Escreva um programa que pede ao usuário para digitar um inteiro
, 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 menor ou igual a
, mantendo a ordem com que as palavras aparecem no texto.
Passo 1
O que o enunciado pede e o que nos foi dado (resumindo claramente):
- Pedir ao usuário um inteiro
. - Ler um arquivo chamado “texto.txt”.
- Imprimir na tela todas as palavras do arquivo cujo número de caracteres seja menor ou igual a
. - Manter a ordem em que as palavras aparecem no texto.
Observação importante (decisão que tomei para resolver): vou considerar “palavra” como cada token separado por espaços em branco no arquivo (ou seja, o que surge de usar a operação de split em linhas). Para evitar contar pontuação final/ inicial como parte da palavra (ex.: “casa,” vira “casa”), vou remover sinais de pontuação que estiverem nas extremidades do token. Não vou perguntar nada mais — essa é a escolha prática para um programa desse tipo.
Passo 2
Entrada do usuário e validação: ler
e garantir que é um inteiro.
- Em Python, a função input() lê uma linha do teclado como string.
- Para transformar essa string em inteiro usa-se int(s). Se o usuário digitar algo que não é inteiro, int() lança uma exceção ValueError.
- Estratégia didática: tentar converter com int() dentro de um bloco try/except; se ocorrer ValueError, informar o usuário e encerrar (ou pedir novamente, se preferir um loop).
Exemplo rápido (conceito): ao ler a string “5\n”, int(“5”) resulta no inteiro 5. Se a string for “abc”, int(“abc”) dá erro.
Passo 3
Abrir e ler o arquivo “texto.txt”.
- Em Python a forma segura de abrir arquivo é usar with open(“texto.txt”, “r”, encoding=“utf-8”) as f: assim o arquivo é fechado automaticamente ao sair do bloco.
- Se o arquivo não existir, open lança FileNotFoundError; devemos capturar isso e informar o usuário.
- Ler linha a linha é eficiente e preserva a ordem do texto. Para cada linha, vamos separar em tokens.
Conceito: ler linha a linha evita carregar arquivos gigantes inteiros na memória e preserva ordem cronológica do texto.
Passo 4
Separar o texto em palavras (tokens) e tratar pontuação.
- A função str.split() sem argumentos separa por qualquer sequência de espaços em branco e retorna os tokens na ordem em que aparecem.
- Exemplo: a linha “Olá, mundo! Tudo bem?” com split() gera os tokens [“Olá,”, “mundo!”, “Tudo”, “bem?”].
- Para não contar a vírgula e o ponto de exclamação como parte da palavra, removeremos pontuação nas extremidades do token com token.strip(string.punctuation), onde string.punctuation é uma string com sinais como ‘!"#$%&’()*+,-./:;<=>?@[\]^_`{|}~’.
- Isso remove apenas pontuação das extremidades; sinais internos (por exemplo apóstrofo em “don’t”) permanecem.
Passo 5
Contar caracteres da palavra e filtrar por
.
- Em Python, len(s) dá o número de caracteres (códigos Unicode) da string
. Para a maioria dos textos acadêmicos isso é suficiente para contar caracteres. - Depois de limpar a pontuação nas extremidades e verificar que o token não ficou vazio, comparar se len(palavra) <=
. - Se a condição for verdadeira, imprimir a palavra na tela.
Dica prática: imprimir uma palavra por linha costuma ficar legível e mantém ordem; também poderia imprimir separadas por espaços — escolha feita: imprimir uma por linha.
Passo 6
Tratamento de casos especiais e robustez.
- Se o token, após remover pontuação, ficar vazio (por exemplo o token era apenas “…” ou “—”), ignorar.
- Se o arquivo contiver caracteres Unicode (acentos, cedilha), open(…, encoding=“utf-8”) e len() funcionam razoavelmente (len conta pontos de código, que na maioria dos casos coincide com caracteres visíveis).
- Decidir como lidar com hífens ou contrações: como strip só remove extremidades, palavras com hífen no meio continuam com o hífen e seu comprimento inclui esse hífen. Isto é consistente com a definição prática de “palavra” adotada.
Passo 7
Fluxo geral do programa (pseudocódigo alto nível, sem o código final completo):
- Ler string do usuário e converter para inteiro
(com try/except). - Abrir “texto.txt” com with open(…).
- Para cada linha no arquivo:
- Fazer line.split() para obter tokens.
- Para cada token:
- Fazer word = token.strip(string.punctuation).
- Se word não for vazia e len(word) <=
, imprimir word.
- Tratar exceção FileNotFoundError para caso o arquivo não exista.
Passo 8
Complexidade e comportamento: o algoritmo percorre cada caractere do arquivo uma vez (mais pequenas sobrecargas para split e strip), então a complexidade é linear no tamanho do arquivo — rápido para arquivos de texto típicos.
Passo 9
Exemplo ilustrativo (para fixar o raciocínio):
- Conteúdo de “texto.txt”: “Olá, mundo! Eu gosto de Python3.”
- Se
, tokens após limpeza: “Olá”, “mundo”, “Eu”, “gosto”, “de”, “Python3” - Palavras com comprimento <= 3: “Eu”, “de”
- Saída (uma por linha):
Eu
de
Passo 10
Motivação da escolha da solução: usei Python porque é direto, portátil e tem suporte nativo a operações de string e arquivo, permitindo fazer a tarefa com pouco código e lógica clara — ideal para uma questão de prova onde importa entender e aplicar conceitos básicos (entrada do usuário, I/O de arquivos, manipulação de strings e laços).
Resposta
#!/usr/bin/env python3
import string
def main():
try:
n_str = input("Digite um inteiro n: ")
n = int(n_str)
except ValueError:
print("Entrada inválida: digite um inteiro.")
return
try:
with open("texto.txt", "r", encoding="utf-8") as f:
for line in f:
for token in line.split():
word = token.strip(string.punctuation)
if not word:
continue
if len(word) <= n:
print(word)
except FileNotFoundError:
print("Arquivo 'texto.txt' não encontrado.")
if __name__ == "__main__":
main()