Escreva uma função que recebe o nome de um arquivo que contém inteiros e examina o arquivo, imprimindo o maior inteiro que estiver nele. Você não sabe quantos inteiros estão no arquivo.

Passo 1

O problema pede que você escreva uma função que recebe o nome de um arquivo (uma string) que contém inteiros e que examine esse arquivo, imprimindo o maior inteiro que estiver nele. Informações relevantes que o enunciado dá ou que precisamos assumir explicitamente:
  • A entrada da função é o nome do arquivo (por ex., "dados.txt").
  • O arquivo contém inteiros (pode haver vários por linha, separados por espaços ou quebras de linha).
  • Você não sabe quantos inteiros há no arquivo — pode ser nenhum, um, ou muitos.
  • A saída solicitada é: imprimir (mostrar na tela) o maior inteiro presente no arquivo.
  • Precisamos tratar casos especiais: arquivo vazio (ou sem inteiros) e arquivo inexistente.

Passo 2

Decisão do método (o que vamos fazer, sem código ainda):
  • Vamos ler o arquivo linha a linha para não carregar tudo na memória (bom para arquivos grandes).
  • Para cada linha vamos separar os “tokens” usando split() (por padrão separa por espaços/brancos), e tentar converter cada token para inteiro.
  • Mantemos uma variável que guarda o maior inteiro encontrado até agora. Ao encontrar um novo inteiro, comparamos e atualizamos essa variável.
  • No fim, se não encontramos nenhum inteiro, imprimimos uma mensagem informando isso; caso contrário imprimimos o maior inteiro.
    Razões: esse método é simples, linear no número de tokens e usa memória constante (O(1)), adequado para provas e para arquivos grandes.

Passo 3

Conceitos importantes (aula rápida e prática):
  • Abrir arquivo de forma segura: use o construto with open(nome, 'r') as f: — isso garante que o arquivo será fechado automaticamente ao sair do bloco with.
  • Iterar sobre o arquivo: for linha in f: lê o arquivo linha a linha, sem carregar tudo na memória.
  • Separar tokens: linha.split() quebra a linha em substrings separadas por espaços/tab/quebras.
  • Converter para inteiro: a função int(token) tenta transformar a string token em inteiro. Se token não representa um inteiro válido, int() lança ValueError.
  • Tratamento de exceções: use try/except para ignorar tokens que não sejam inteiros (se quiser tolerância) e try/except FileNotFoundError para informar se o arquivo não existe.

Passo 4

Como inicializar e comparar o “maior”:
  • Inicialização: vamos usar uma variável maior = None no começo. A ideia:
    • None indica que ainda não vimos nenhum inteiro.
    • Ao ler um inteiro x, fazemos:
      • se maior is None: então maior = x
      • senão, se x > maior: atualizamos maior = x
  • Por que não iniciar com zero ou com -inf? Porque os inteiros no arquivo podem ser todos negativos; iniciar com 0 seria um erro se todos os valores forem menores que 0. None deixa claro que ainda não há valor inicial.

Passo 5

Tratamento de casos especiais (o que imprimir):
  • Arquivo inexistente: imprimir algo como "Arquivo 'nome' não encontrado.".
  • Arquivo sem inteiros (por exemplo, vazio): imprimir "Nenhum inteiro encontrado no arquivo.".
  • Caso normal: imprimir o maior inteiro encontrado como um número simples (ex.: 42).

Passo 6

Exemplo passo-a-passo com um arquivo hipotético (ajuda a “ver” o algoritmo):
  • Suponha que o arquivo tenha o texto: 3 -5 42 7 (podem estar na mesma linha ou em linhas diferentes).
  • Inicialmente maior = None.
  • Lê token 3: maior era None, então maior = 3.
  • Lê token -5: compara -5 > 3? Não → maior continua 3.
  • Lê token 42: compara 42 > 3? Sim → maior = 42.
  • Lê token 7: compara 7 > 42? Não → maior continua 42.
  • Ao fim, imprime 42.

Passo 7

Complexidade e observações práticas que ajudam na prova:
  • Tempo: O(n) onde n é o número de tokens (cada token é processado uma vez).
  • Espaço adicional: O(1) (apenas algumas variáveis auxiliares), porque lemos linha a linha.
  • Robustez: o algoritmo ignora tokens não inteiros (se preferir, você pode fazer o oposto e fazer o programa falhar ao encontrar dados inválidos; aqui escolhemos ser tolerantes).
  • Importante em prova: explique que usar read().split() carrega todo o arquivo na memória — funciona para arquivos pequenos, mas evite quando o enunciado não informa tamanho.

Passo 8

Dicas de implementação para a prova (o que escrever na folha/código):
  • Usar with open(nome_arquivo, 'r', encoding='utf-8') as f:.
  • Fazer dois loops aninhados: for linha in f: e for token in linha.split():.
  • Envolver int(token) em try/except ValueError para ignorar tokens inválidos.
  • Atualizar maior conforme explicado.
  • Tratar FileNotFoundError com try/except em torno do open ou verificar existência antes.

Resposta

def maior_inteiro_em_arquivo(nome_arquivo):
    """
    Lê inteiros de um arquivo e imprime o maior inteiro encontrado.
    Se o arquivo não existir, imprime mensagem apropriada.
    Se não houver inteiros no arquivo, imprime mensagem apropriada.
    """
    maior = None
    try:
        with open(nome_arquivo, 'r', encoding='utf-8') as f:
            for linha in f:
                for token in linha.split():
                    try:
                        num = int(token)
                    except ValueError:
                        # Ignora tokens que não são inteiros
                        continue
                    if maior is None or num > maior:
                        maior = num
    except FileNotFoundError:
        print(f"Arquivo '{nome_arquivo}' não encontrado.")
        return

    if maior is None:
        print("Nenhum inteiro encontrado no arquivo.")
    else:
        print(maior)

Exercícios relacionados