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 menor ou igual a n, 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 n.
  • Ler um arquivo chamado “texto.txt”.
  • Imprimir na tela todas as palavras do arquivo cujo número de caracteres seja menor ou igual a n.
  • 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 n 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 n.
  • Em Python, len(s) dá o número de caracteres (códigos Unicode) da string s. 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) <= n.
  • 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 n (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) <= n, 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 n=3, 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()

Exercícios relacionados