Implemente uma função chamada conta_digitos( n ) que receba um número inteiro n e retorne a quantidade de dígitos que ele possui.
A função deve atender aos seguintes requisitos:
  • Utilizar apenas estruturas de repetição (por exemplo, while) - não use conversão para str.
  • Considerar corretamente o caso \mathrm{n}=0.
  • Desconsiderar o sinal em números negativos (isto é, conta_digitos(-230) deve retornar 3).
Exemplo de execução:
print(conta_digitos(50230)) # deve exibir 5
print(conta_digitos(-8)) # deve exibir 1
print(conta_digitos(0)) # deve exibir 1

Passo 1

O que o enunciado pede e o que foi dado:
  • Pedem uma função chamada conta_digitos que recebe um inteiro n.
  • A função deve retornar a quantidade de dígitos de n.
  • Regras importantes que devo obedecer:
    • Usar apenas estruturas de repetição (por exemplo while) — não posso converter para str.
    • Tratar corretamente o caso n=0.
    • Ignorar o sinal quando n for negativo (por exemplo, \text{conta\_digitos}(-230) = 3).
  • Exemplos que o enunciado mostrou (para checagem de resultados):
    • \text{conta\_digitos}(50230) deve retornar 5.
    • \text{conta\_digitos}(-8) deve retornar 1.
    • \text{conta\_digitos}(0) deve retornar 1.

Passo 2

Ideia básica do método (explicação simples e por que funciona):
  • Para contar dígitos sem converter para string, usamos divisão inteira por 10.
  • Observação: quando dividimos um número inteiro positivo por 10 com divisão inteira (no Python: //), eliminamos o último dígito. Ex.: 50230 // 10 = 5023.
  • Repetindo isso e contando quantas vezes conseguimos dividir até n virar 0, obtemos o número de dígitos.
  • Exemplo conceitual: pegando n=50230,
    • 50230 // 10 = 5023 (contador = 1)
    • 5023 // 10 = 502 (contador = 2)
    • 502 // 10 = 50 (contador = 3)
    • 50 // 10 = 5 (contador = 4)
    • 5 // 10 = 0 (contador = 5) → paramos; resultado 5.
  • Por isso o laço termina quando n fica igual a 0 e o próprio número de iterações é a quantidade de dígitos.

Passo 3

Tratamento de sinais e do caso n=0:
  • Se n for negativo, devemos “desconsiderar o sinal”. A forma mais direta é transformar n em seu valor absoluto antes de contar: se n<0 então fazer n \leftarrow -n.
  • Se n=0, o laço que divide por 10 nunca rodaria (porque já começa em 0), mas por definição 0 tem 1 dígito. Então é um caso especial: se n=0 retornamos 1 imediatamente.

Passo 4

Detalhes sobre a implementação com while (passo a passo do algoritmo em pseudo-linguagem):
  • Receber n.
  • Se n<0 então n \leftarrow -n.
  • Se n=0 então retornar 1.
  • Inicializar um contador em 0.
  • Enquanto n>0:
    • Fazer n \leftarrow n \mathbin{//} 10.
    • Incrementar o contador: contador \leftarrow contador +1.
  • Quando o laço terminar, retornar o contador.

Passo 5

Por que usamos divisão inteira // e não divisão normal /:
  • A divisão normal n/10 em muitas linguagens produz um número com parte fracionária (float). Para “remover” o último dígito queremos um inteiro.
  • A operação // em Python faz divisão inteira (pisa a parte fracionária), exatamente o que precisamos para reduzir n dígito a dígito sem usar strings.

Passo 6

Complexidade e comportamento em números grandes:
  • Cada iteração elimina um dígito. Logo o número de iterações é proporcional ao número de dígitos de n. A complexidade é O(d), onde d é a quantidade de dígitos.
  • Usa memória constante (apenas algumas variáveis).

Passo 7

Implementação em Python (respeitando as restrições: apenas while, sem conversão para str, trata 0 e negativos):
def conta_digitos(n):
# Desconsiderar o sinal
if n < 0:
n = -n
# Caso especial: zero tem 1 dígito
if n == 0:
return 1
contador = 0
# Enquanto houver dígitos, vamos “removendo” o último com divisão inteira
while n > 0:
n = n // 10
contador += 1
return contador

Resposta

def conta_digitos(n):
# Desconsiderar o sinal
if n < 0:
n = -n
# Caso especial: zero tem 1 dígito
if n == 0:
return 1
contador = 0
# Enquanto houver dígitos, vamos “removendo” o último com divisão inteira
while n > 0:
n = n // 10
contador += 1
return contador

Exercícios relacionados