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
, retorne quantos dígitos pares existem no número
. O enunciado diz explicitamente que o dígito
é par.
Informações importantes fornecidas:
Informações importantes fornecidas:
- A função deve receber um número
. - Deve contar quantos dígitos pares aparecem em
. - Exemplo dado: contar_digitos_pares(
) deve retornar (porque os dígitos pares são , e ).
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
(em Python, ) nos dá o último dígito do número. Em notação matemática, o último dígito é . - A divisão inteira por
(em Python, ) “remove” o último dígito; matematicamente isso é .
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
é par se o resto da divisão por for zero. Em notação: é par se . - Assim, para cada dígito extraído
, verificamos se . 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
antes de extrair dígitos. Em Python: . - O número
é um caso especial porque o laço que retira dígitos (while ) não roda para . Mas o dígito de é e ele é par — então o resultado deve ser para . Devemos tratar isso explicitamente. - Resumo do algoritmo (em palavras):
- Converter
para inteiro e tomar . - Se
, retornar . - Enquanto
: extrair último dígito ; se incrementa contador; remover último dígito com . - Retornar o contador.
- Converter
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
: contar_digitos_pares(
).
- Começamos com
. , então vamos ao laço. contador = . - Iteração 1:
. (ímpar) → contador continua . . - Iteração 2:
. (par) → contador . . - Iteração 3:
. (par) → contador . . - Iteração 4:
. (par) → contador . . - Iteração 5:
. é ímpar → contador fica . .
Laço termina e retornamos, como esperado.
Passo 8
Outros exemplos rápidos para fixar:
- contar_digitos_pares(
) → (o único dígito é , que é par). - contar_digitos_pares(
) → (os dígitos são pares). - contar_digitos_pares(
) → (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
(ou seja, , na prática “linear no número de dígitos”). - Espaço:
— usa apenas algumas variáveis extras. - Dica para a prova: escreva rapidamente a versão com resto por
e divisão inteira por . Trate o caso 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
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