Questão 13: Crie uma função encontrar_maior_digito(n) que retorne qual é o maior dígito que compõe o número n .

Passo 1

O enunciado pede: criar uma função chamada encontrar_maior_digito(n) que retorne qual é o maior dígito que compõe o número n. Informações e condições que vamos considerar (sem te perguntar nada, assumo o mais natural para a questão):
  • A entrada n é um número inteiro (pode ser negativo ou positivo).
  • O objetivo é retornar um único inteiro entre 0 e 9: o maior dígito presente em n.
  • Ex.: se n=27091 a função deve retornar 9.
    Nada mais é pedido explicitamente; vamos resolver com essa interpretação.

Passo 2

Escolha do método (por que e qual usar):
  • Existem duas abordagens simples para obter dígitos: converter o número para string e inspecionar caracteres, ou usar operações aritméticas (resto e divisão inteira) para extrair dígitos.
  • Vou usar a abordagem aritmética (módulo e divisão inteira) porque:
    • É a técnica “matemática básica” que costuma ser exigida em provas (sem depender de funções de string).
    • É eficiente e fácil de justificar passo a passo no caderno.
    • Não usa recursos “mágicos” e mostra compreensão de operações com inteiros.
  • Então o método será: trabalhar com |n| (valor absoluto), extrair dígitos usando resto por 10 e atualizar o máximo.

Passo 3

Conceitos essenciais que você precisa entender (aula rápida):
  • Resto da divisão por 10: para um inteiro positivo x, o valor x \bmod 10 (em Python x % 10) dá o último dígito de x. Ex.: para x=274, 274 \bmod 10 = 4.
  • Divisão inteira por 10: dividir por 10 e tomar a parte inteira (em Python x // 10) remove o último dígito. Ex.: para x=274, 274 // 10 = 27.
  • Usando essas duas operações repetidamente conseguimos percorrer todos os dígitos de um número: pegar último dígito, remover último dígito, repetir até o número ficar 0.

Passo 4

Algoritmo em palavras, passo a passo (o que escrever na prova):
  1. Receber n.
  2. Substituir n por |n| (valor absoluto), porque o sinal não altera os dígitos.
  3. Se n=0, retornar 0 (caso especial: o único dígito é 0).
  4. Inicializar maior = 0.
  5. Enquanto n > 0:
    • calcular d = n % 10 (o último dígito),
    • se d > maior, atualizar maior = d,
    • se maior == 9, podemos parar cedo e retornar 9 (porque não existe dígito maior que 9),
    • reduzir n = n // 10.
  6. Ao terminar o laço, retornar maior.
    Esse é o passo-a-passo que você pode escrever em pseudo-código na prova e depois traduzir para Python.

Passo 5

Exemplo detalhado (vamos mastigar com n=27091):
  • Começamos com n=27091. Tomamos |n|=27091.
  • maior = 0.
  • Iteração 1: d = 27091 % 10 = 1. Como 1>0, maior = 1. n = 27091 // 10 = 2709.
  • Iteração 2: d = 2709 % 10 = 9. Como 9>1, maior = 9. Agora maior == 9, então já sabemos que não existe dígito maior — podemos devolver 9 imediatamente.
    Resultado final: 9.
    Isso ilustra a ideia de extrair dígitos e atualizar o máximo; note a otimização de sair cedo quando encontramos 9.

Passo 6

Casos especiais e validações rápidas (o que escrever também na prova):
  • Se n=0, o loop não começa; devemos devolver 0.
  • Se n é negativo, trabalhar com |n|.
  • Se n é um inteiro de um único dígito (por exemplo 7), o algoritmo retorna esse dígito.
  • Se por acaso a entrada não for inteira (ex.: uma string, float), em prova normalmente especifica-se que n é inteiro; aqui assumimos inteiro. Em código prático podemos converter com int(n) se necessário.

Passo 7

Complexidade (o que anotar rápido para a prova):
  • O algoritmo percorre cada dígito do número uma vez. Se o número tem d dígitos, o tempo é O(d). Em termos de valor de n, d \approx \log_{10} n.
  • Espaço extra é O(1): apenas algumas variáveis auxiliares.

Passo 8

Implementação em Python (explicando cada linha):
  • Vou explicar o código que vou devolver no final:
    • n = abs(int(n)): garante que n é inteiro e não-negativo.
    • if n == 0: return 0: caso especial.
    • maior = 0: inicializa o maior dígito encontrado.
    • while n:: enquanto n for diferente de zero.
    • d = n % 10: pega o último dígito.
    • if d > maior: maior = d: atualiza máximo.
    • if maior == 9: return 9: otimização — não existe dígito maior.
    • n //= 10: remove o último dígito.
    • return maior: devolver resultado final.

Passo 9

Dicas rápidas para a prova (motivação estilo amigo):
  • Se estiver sem tempo, escreva primeiro o caso especial n=0, porque é simples e evita erro.
  • Mostre claramente que pegou o valor absoluto |n| se o enunciado não falar do sinal.
  • Se preferir, você pode usar conversão para string na prova: transformar em str(abs(n)) e pegar o máximo de caracteres convertendo cada um para inteiro; é aceitável e mais curto, mas a abordagem aritmética demonstra mais “controle” sobre o que acontece.
  • Respira, escreve o passo-a-passo e depois codifica. Você consegue — eu também já fiquei nervoso, mas esse tipo de problema é direto quando se domina resto/divisão.

Resposta

def encontrar_maior_digito(n):
    n = abs(int(n))
    if n == 0:
        return 0
    maior = 0
    while n:
        d = n % 10
        if d > maior:
            maior = d
            if maior == 9:
                return 9
        n //= 10
    return maior

Exercícios relacionados