Escreva um programa que lê um arquivo chamado texto.txt e imprime na tela a linha do arquivo com o maior número de caracteres e a quantidade de caracteres dessa linha.

Passo 1

O que o enunciado pede e quais informações temos.
  • Pedido: escrever um programa que leia um arquivo chamado texto.txt e imprima:
    1. a linha do arquivo com o maior número de caracteres;
    2. a quantidade de caracteres dessa linha.
  • Informações do enunciado:
    • O arquivo chama-se “texto.txt”.
    • Deve-se mostrar a própria linha (texto) com maior comprimento e também o comprimento (número de caracteres).
  • Decisões/assunções que faço (sempre importante deixar claro):
    • Ao contar caracteres, não conto os caracteres de quebra de linha finais. Ou seja, para uma linha que no arquivo termina com \n ou \r\n, eu conto apenas os caracteres visíveis da linha — espaços e tabulações no final da linha são preservados e contados, somente \n/\r são removidos. Em símbolo: para cada linha l eu uso \text{conteúdo} = \text{l.rstrip}('\backslash r\backslash n')ú e o comprimento é \text{len}(\text{conteúdo})ú.
    • Se houver empate (duas ou mais linhas com o mesmo número máximo de caracteres), o programa imprimirá a primeira linha (a que aparece antes no arquivo).
    • Se o arquivo estiver vazio (nenhuma linha), o programa imprimirá uma linha vazia e o número 0 (um jeito simples e previsível de indicar “nenhuma linha”).
    • Se o arquivo não existir, o programa exibirá uma mensagem de erro apropriada.

Passo 2

Ideia geral do método (algoritmo simples e eficiente).
  • Abrir o arquivo “texto.txt” para leitura.
  • Percorrer o arquivo linha a linha (isso não carrega o arquivo inteiro na memória).
  • Para cada linha l:
    • remover apenas os caracteres de quebra de linha finais: s = l.\text{rstrip}('\backslash r\backslash n');
    • calcular o comprimento L = \text{len}(s);
    • se L for maior que o máximo guardado até agora \text{max\_len}, atualizar \text{max\_len} \leftarrow L e guardar \text{max\_line} \leftarrow s.
  • Após terminar a leitura, imprimir \text{max\_line} e em seguida imprimir \text{max\_len}.
Comentários rápidos sobre por que isso é bom:
  • A leitura linha a linha usa pouca memória (somente uma linha em memória por vez).
  • A complexidade de tempo é linear no tamanho total do arquivo ( O(N), sendo N o número de caracteres do arquivo).
  • As operações usadas são básicas e fáceis de implementar em qualquer linguagem.

Passo 3

Explicando as ferramentas básicas que vamos usar (ensinando cada conceito bem mastigado).
  • Como abrir um arquivo para leitura: em muitas linguagens existe uma função para abrir. Em Python usamos open('texto.txt', 'r', encoding='utf-8'). Isso abre o arquivo em modo leitura com codificação UTF-8.
  • Iterar linha a linha: um arquivo é iterável; for line in file: fornece cada linha uma vez, incluindo o caractere de nova linha final (\n) exceto possivelmente na última linha se o arquivo não terminar com \n.
  • Remover apenas o \n final, preservando espaços: usamos line.rstrip('\r\n'). Explicação:
    • rstrip(chars) remove da direita (final) qualquer sequência feita dos caracteres presentes em chars. Com '\r\n' garantimos eliminar \n e/ou \r finais, sem remover espaços ou outras letras.
  • Obter o número de caracteres: len(s) dá a contagem de caracteres da string s. Isso conta espaços, tabulações (\t) e outros caracteres visíveis; não conta o \n que já removemos.
  • Variáveis de controle:
    • \text{max\_len}: guarda o maior comprimento encontrado até agora (inicialmente -1 para sinalizar “nenhuma linha ainda”).
    • \text{max\_line}: guarda a linha correspondente ao \text{max\_len}.
  • Tratamento de arquivo inexistente: capturar a exceção FileNotFoundError e avisar o usuário.

Passo 4

Detalhando o passo a passo que o programa executa (com pseudocódigo explicado linha a linha).
  • Inicialize \text{max\_len} \leftarrow -1 e \text{max\_line} \leftarrow \text{None}.
  • Tente abrir “texto.txt” para leitura:
    • Se falhar (arquivo não existe), terminar imprimindo uma mensagem de erro.
  • Para cada linha l lida do arquivo:
    • calcule s = l.\text{rstrip}('\backslash r\backslash n').
    • calcule L = \text{len}(s).
    • se L > \text{max\_len} então:
      • \text{max\_len} \leftarrow L
      • \text{max\_line} \leftarrow s
  • Depois de terminar a iteração:
    • se \text{max\_line} é None (arquivo vazio), imprimir uma linha vazia e 0;
    • caso contrário, imprimir \text{max\_line} e, em nova linha, \text{max\_len}.
Observação sobre empate: a condição é > (maior estrito), então a primeira linha com comprimento máximo permanece escolhida.

Passo 5

Exemplo pequeno para fixar a ideia (simples e concreto).
Suponha que “texto.txt” tem as linhas (entre aspas para ver espaços):
  1. “Oi\n” (conteúdo “Oi”, comprimento 2)
  2. " Espaço no início \n" (contém espaços, comprimento conta todos eles; por exemplo 20)
  3. “Outra linha\n” (comprimento 11)
    Neste caso o algoritmo:
  • vê a linha 1: \text{max\_len}=2, \text{max\_line}="Oi"
  • vê a linha 2: comprimento 20>2 então atualiza \text{max\_line} para a linha 2
  • vê a linha 3: 11 não é maior que 20, então mantém a linha 2
    Saída: imprime a linha 2 exatamente como conteúdo (sem \n) e depois imprime 20.

Passo 6

Complexidade e observações finais para prova (resuma o que você precisa lembrar na hora).
  • Complexidade de tempo: O(N), onde N é o número total de caracteres no arquivo — cada caractere é lido uma vez.
  • Complexidade de memória: O(1) adicional (apenas armazenamos a maior linha e um contador).
  • Cuidados na prova/implementação:
    • Não remover espaços com strip() — isso tiraria espaços à esquerda/direita que devem ser contados. Use somente rstrip('\r\n') para evitar remover espaços.
    • Decida e documente o que acontece em caso de empate (aqui: primeira linha ganha).
    • Lembre de tratar arquivos com codificação adequada (UTF-8 normalmente).
  • Pronto! Com isso você já sabe a ideia, as ferramentas e como implementar sem complicação.

Passo 7

Código pronto em Python (implementação completa e robusta). Este é o programa que realiza exatamente o que o enunciado pede: lê “texto.txt”, encontra a linha com maior número de caracteres (conforme as regras acima) e imprime a linha seguida do número de caracteres.

Resposta

#!/usr/bin/env python3
def main():
    max_line = None
    max_len = -1
    try:
        with open('texto.txt', 'r', encoding='utf-8') as f:
            for line in f:
                # remove apenas os caracteres de nova linha (\n ou \r\n), preservando espaços
                content = line.rstrip('\r\n')
                length = len(content)
                if length > max_len:
                    max_len = length
                    max_line = content
    except FileNotFoundError:
        print("Arquivo 'texto.txt' não encontrado.")
        return

    if max_line is None:
        # arquivo vazio: imprime linha vazia e 0
        print("")
        print(0)
    else:
        print(max_line)
        print(max_len)

if __name__ == '__main__':
    main()

Exercícios relacionados