Questão 12: Crie uma função contar_digitos_pares (n) que conte quantos dígitos pares existem no número n. (O dígito 0 é par).
Exemplo: contar_digitos_pares (12085) deve retornar 3 (os dígitos 2, 0, 8).

Passo 1

O enunciado pede para criar uma função chamada contar_digitos_pares que, dada uma entrada n, retorne quantos dígitos pares existem no número n. O enunciado diz explicitamente que o dígito 0 é par.
Informações importantes fornecidas:
  • A função deve receber um número n.
  • Deve contar quantos dígitos pares aparecem em n.
  • Exemplo dado: contar_digitos_pares( 12085) deve retornar 3 (porque os dígitos pares são 2, 0 e 8).

Passo 2

O que significa “contar dígitos” e como extrair dígitos de um número?
  • Cada número inteiro tem dígitos individuais (unidades, dezenas, centenas, …). Para trabalhar com dígitos sem usar strings, usamos duas operações básicas em inteiros: resto da divisão e divisão inteira.
  • O resto da divisão por 10 (em Python, n \% 10) nos dá o último dígito do número. Em notação matemática, o último dígito é d = n \bmod 10.
  • A divisão inteira por 10 (em Python, n // 10) “remove” o último dígito; matematicamente isso é \lfloor n/10 \rfloor.
    Essas duas operações juntas permitem percorrer todos os dígitos de um número da direita para a esquerda.

Passo 3

Como decidir se um dígito é par?
  • Um número inteiro d é par se o resto da divisão por 2 for zero. Em notação: d é par se d \bmod 2 = 0.
  • Assim, para cada dígito extraído d, verificamos se d \bmod 2 = 0. Se sim, incrementamos o contador.

Passo 4

Detalhes práticos e casos especiais que devemos tratar:
  • Números negativos: o sinal não afeta os dígitos, então usamos o valor absoluto |n| antes de extrair dígitos. Em Python: abs(n).
  • O número 0 é um caso especial porque o laço que retira dígitos (while n>0) não roda para n=0. Mas o dígito de 0 é 0 e ele é par — então o resultado deve ser 1 para n=0. Devemos tratar isso explicitamente.
  • Resumo do algoritmo (em palavras):
    1. Converter n para inteiro e tomar |n|.
    2. Se |n| = 0, retornar 1.
    3. Enquanto n > 0: extrair último dígito d = n \% 10; se d \% 2 = 0 incrementa contador; remover último dígito com n //= 10.
    4. Retornar o contador.

Passo 5

Vou mostrar uma implementação em Python seguindo exatamente o algoritmo descrito. O código é curto e é isso que você deve escrever na prova se pedirem a função.

Passo 6

Implementação (cópia direta para usar ou colar em prova/IDE):
def contar_digitos_pares(n):
    n = abs(int(n))
    if n == 0:
        return 1
    contador = 0
    while n > 0:
        d = n % 10
        if d % 2 == 0:
            contador += 1
        n //= 10
    return contador

Passo 7

Vamos fazer um rastreamento passo a passo do exemplo dado para você ver que bate com 3: contar_digitos_pares( 12085).
  • Começamos com n = 12085. n \neq 0, então vamos ao laço. contador = 0.
  • Iteração 1: d = 12085 \% 10 = 5. 5 \bmod 2 = 1 (ímpar) → contador continua 0. n //= 10 \Rightarrow n = 1208.
  • Iteração 2: d = 1208 \% 10 = 8. 8 \bmod 2 = 0 (par) → contador = 1. n = 120.
  • Iteração 3: d = 120 \% 10 = 0. 0 \bmod 2 = 0 (par) → contador = 2. n = 12.
  • Iteração 4: d = 12 \% 10 = 2. 2 \bmod 2 = 0 (par) → contador = 3. n = 1.
  • Iteração 5: d = 1 \% 10 = 1. 1 é ímpar → contador fica 3. n = 0.
    Laço termina e retornamos 3, como esperado.

Passo 8

Outros exemplos rápidos para fixar:
  • contar_digitos_pares( 0) → 1 (o único dígito é 0, que é par).
  • contar_digitos_pares( -246) → 3 (os dígitos 2,4,6 são pares).
  • contar_digitos_pares( 13579) → 0 (nenhum dígito par).

Passo 9

Complexidade e dicas para prova:
  • Tempo: O algoritmo percorre cada dígito exatamente uma vez, então o tempo é proporcional ao número de dígitos de n (ou seja, O(\log_{10} n), na prática “linear no número de dígitos”).
  • Espaço: O(1) — usa apenas algumas variáveis extras.
  • Dica para a prova: escreva rapidamente a versão com resto por 10 e divisão inteira por 10. Trate o caso n=0 ou use uma estrutura que garanta que você conte ao menos uma vez. Evite soluções que transformem em string se a prova exigir raciocínio com inteiros (mas em Python a versão com strings é curta e prática).

Passo 10

Você não está sozinho — esse tipo de problema é bem comum em prova e a técnica “resto por 10 + divisão inteira por 10” resolve muitos exercícios sobre dígitos. Respira, copia a função lá em cima e pratica com uns exemplos. Vai dar certo!

Resposta

def contar_digitos_pares(n):
n = abs(int(n))
if n == 0:
return 1
contador = 0
while n > 0:
d = n % 10
if d % 2 == 0:
contador += 1
n //= 10
return contador

Exercícios relacionados