Questão 15: Crie uma função remover_impares ( n ) que retorne um novo número contendo apenas os dígitos pares de n , na ordem em que aparecem.
Exemplo: remover_impares(123456) deve retornar 246.

Passo 1

O enunciado pede para criar uma função chamada remover_impares( n) que retorne um novo número contendo apenas os dígitos pares de n, mantendo a ordem em que aparecem os dígitos em n.
Informações dadas e/ou assumidas:
  • A entrada é um inteiro n. (Vou tratar também o caso de n negativo de forma natural — isso não foi explicitado, mas deixa a função mais robusta.)
  • Exemplo dado: remover_impares( 123456) deve retornar 246.
  • Não foi dito o que fazer se não houver dígitos pares; adotarei o comportamento razoável: retornar 0.

Passo 2

Visão geral do método escolhido (sem começar a calcular ainda): usar manipulação de string é a forma mais direta e fácil de entender. A ideia geral:
  1. Transformar \,n em string para percorrer os dígitos da esquerda para a direita — isso preserva a ordem original automaticamente.
  2. Para cada caractere (dígito) verificar se é par. Se for, concatenar ao resultado parcial (string).
  3. Ao final, converter a string resultante para inteiro e devolver. Se nenhum dígito par existir, devolver 0.
    Essa abordagem é simples, fácil de implementar em prova e não exige raciocínio extra para manter a ordem dos dígitos.

Passo 3

Conceitos necessários (bem mastigados):
  • Dígito: cada caractere em uma representação decimal. Por exemplo, em 123 os dígitos são 1, 2, 3.
  • Paridade: um dígito d é par quando o resto da divisão de d por 2 é 0. Em notação, d é par se d \bmod 2 = 0. Exemplos: 0 é par, 2 é par, 4 é par; 1,3,5 são ímpares.
  • Converter caractere para número: em Python usamos int(caractere) para transformar, por exemplo, o caractere '4' em \,4.
  • Converter número para string: str( n) dá a representação decimal de \,n, por exemplo str( 123) = "123".

Passo 4

Escrevendo o algoritmo em palavras passo a passo (já detalhado para você poder reproduzir na prova):
  1. Se n for negativo, guardar o sinal e trabalhar com |n| (valor absoluto), para não complicar a análise dos caracteres. No final, reaplicar o sinal se fizer sentido.
  2. Fazer s \leftarrow str( |n|). Agora s é a sequência de caracteres dos dígitos, por exemplo para n=123456 temos s = "123456".
  3. Inicializar uma string vazia resultado: res\_str \leftarrow "".
  4. Para cada caractere c em s, faça:
    • Converter para inteiro: d \leftarrow int( c).
    • Checar paridade: se d \bmod 2 = 0 então concatenar c ao res\_str.
  5. Depois do laço, se res\_str estiver vazia isso significa que não havia dígitos pares; retornar 0.
  6. Caso contrário, converter res\_num \leftarrow int( res\_str) e retornar res\_num (se n original era negativo e res\_num > 0, podemos retornar -res\_num, mas -0 é 0, então não há problema).
Observações:
  • Ao converter a string final para inteiro, quaisquer zeros à esquerda são automaticamente removidos (por exemplo, se res\_str = "024" o int vira 24). Isso faz sentido porque a saída pedida é um número.
  • Se quiser garantir que quando n=0 a função retorne 0, o algoritmo acima já cobre isso: str( |0|) = “0”, int(“0”) = 0, e como 0 é par, o resultado é 0.

Passo 5

Implementação detalhada em Python (cada linha comentada para você entender e lembrar na hora da prova):
def remover_impares(n):
    # Lidar com o sinal: se n for negativo, lembra e usa o absoluto
    sign = -1 if n < 0 else 1
    s = str(abs(n))             # s é a string dos dígitos de |n|
    res_str = ""                # vamos construir a string dos dígitos pares

    for c in s:                 # percorre dígito por dígito, da esquerda para a direita
        d = int\text{(c)}              # converte o caractere para o número correspondente
        if d % 2 == 0:          # checa se o dígito é par (resto da divisão por 2 igual a 0)
            res_str += c        # concatena o caractere na string resultado

    if res_str == "":           # se não encontrou nenhum dígito par
        return 0
    res_num = int(res_str)      # converte a string resultante para inteiro
    return sign * res_num       # reaplica o sinal (se houver); note que sign*0 = 0

Passo 6

Executando o exemplo passo a passo para fixar:
  • Entrada: n = 123456. Então s = "123456".
  • Iteração:
    • c='1' d=1 1 \bmod 2 = 1 (ímpar) → não concatena.
    • c='2' d=2 2 \bmod 2 = 0 (par) → res\_str = "2".
    • c='3' d=3 → ímpar → não concatena.
    • c='4' d=4 → par → res\_str = "24".
    • c='5' → ímpar → não concatena.
    • c='6' → par → res\_str = "246".
  • Ao final, res\_str = "246" res\_num = int(“246”) = 246 → retorna 246. Confere com o exemplo pedido.

Passo 7

Casos especiais e justificativas (pra tu não tropeçar na prova):
  • Se n não tiver dígitos pares (por exemplo, n=13579), o laço deixa res\_str = "" e retornamos 0. Isso é uma escolha lógica: não existe número formado por nenhum dígito, então 0 é um retorno neutro e numérico.
  • Se n tiver zeros entre os dígitos (por exemplo, n=10203), zeros são dígitos pares; no processo res\_str pode começar com “0” — na conversão final para inteiro o zero à esquerda some: ex.: “02” → 2. Isso está de acordo com o pedido que a saída seja um número.
  • Se quiseres uma versão que retorne uma string em vez de número (mantendo zeros à esquerda), é só devolver res\_str sem converter; mas o enunciado pediu “novo número”, então convertemos para inteiro.

Passo 8

Alternativa sem usar strings (apenas para saber): extrair dígitos com operações aritméticas dá os dígitos do fim para o começo. Então, para preservar ordem, devemos:
  1. Repetidamente fazer: pegar último dígito com d = n \bmod 10, dividir n \leftarrow n // 10.
  2. Se d for par, empilhar (por exemplo, adicionar a uma lista).
  3. Ao final, a lista está na ordem inversa; inverter a lista e reconstruir o número dígito a dígito.
    Esse método funciona e evita strings, mas é um pouco mais verboso — por isso em prova a solução por string costuma ser preferida por ser mais direta.

Resposta

def remover_impares(n):
sign = -1 if n < 0 else 1
s = str(abs(n))
res_str = “”
for c in s:
d = int(c)
if d % 2 == 0:
res_str += c
if res_str == “”:
return 0
res_num = int(res_str)
return sign * res_num

Exercícios relacionados