Algarismo em Código

Sobre a Matemática

Algarismos são símbolos usados para escrever números. Atualmente, no mundo todo, são usados os algarismos indo-arábico: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

A conversão de um número inteiro para outra base está fundamentada no sistema de numeração posicional. Um número é representado como a soma de potências da base multiplicadas por seus algarismos. Para converter um número da base 10 para outra base 𝑏, utiliza-se o método das divisões sucessivas, no qual o número é dividido repetidamente pela base desejada, e os restos dessas divisões formam os algarismos da nova representação, lidos da última divisão para a primeira. Esse conceito é amplamente utilizado em matemática e computação, permitindo representar números em: Base 2 (binária) – usada internamente pelos computadores, Base 8 (octal), Base 16 (hexadecimal) e outras bases até 36, usando letras para representar valores maiores que 9.

Um palíndromo é um número cuja sequência de algarismos permanece a mesma quando lida da esquerda para a direita ou da direita para a esquerda. Do ponto de vista matemático, trata-se de uma propriedade relacionada à simetria da representação numérica, pois o número possui uma estrutura espelhada em torno do seu centro. Exemplos de números palíndromos: 121, 34443.

Sobre o Código

Na linguagem de programação Python,

import – é usado para trazer módulos ou funções externas para o código, permitindo reutilizar funcionalidades já prontas.

collections – é um módulo da biblioteca padrão que oferece tipos de dados especializados, como counter, deque, defaultdict, etc.

counter – é uma classe do módulo collections que conta automaticamente quantas vezes cada elemento aparece em uma lista, string ou outro iterável.

def – é a palavra-chave usada para definir funções. Indica o incício da criação de uma função.

str() – converte um valor para o tipo string (texto). Ex.: str(123) vira “123”.

. (ponto) – é o operador de acesso. Serve para acessar métodos, atributos ou funções internas de objetos, módulos e classes.

.replace – é o método de string que substitui trechos de texto. Ex.: “casa”.replace(“a”,”e”) -> “cese”

return – finaliza a execução de uma função e envia um valor de volta para quem chamou essa função.

for ... in – é a estrutura de repetição usada para percorrer elementos de um iterável (lista, string, tupla, range…). Ex.: for x in lista:.

if – é uma estrutura condicional. Executa um bloco de código somente quando uma condição é verdadeira.

dict() – cria um dicionário, tipo de dado formado por pares chave-valor. dict(a=1, b=2) -> {“a”:1, “b”:2}.

startswtith – é o método de string que verifica se o texto começa com determinado prefixo. Ex.: “python”.startswith(“py”) → True.

else – é parte opcional de uma estrutura condicional. É executada quando o if (ou elif) não é verdadeiro.

.split – é o método que divide uma string em partes, gerando uma lista. Ex.: “a b c”.split() → [“a”,”b”,”c”].

int() – converte um valor para o tipo inteiro, se possível. Ex.: int(“45”) → 45.

while – é a estrutura de repetição que executa um bloco de código enquanto uma condição for verdadeira.

> (maior) – é o operador relacional que compara dois valores e retorna True quando o primeiro é maior que o segundo.

divmod – é a função que retorna o quociente e o resto de uma divisão inteira. Ex.: divmod(10, 3) → (3, 1).

print() – é a função usada para exibir informações na tela.

f"" (f-string) – é a forma moderna e prática de formatar strings inserindo valores diretamente dentro do texto. Ex.: f”Resultado: {x}”.

# – é usado para criar comentários ao código, que são notas para se entender melhor o que o código faz.

Vamos ao código…

from collections import Counter

def separar_algarismos(numero):
    """
    Recebe um número inteiro ou real (int, float ou string)
    e retorna uma lista com seus algarismos (0–9).
    """
    numero = str(numero).replace("-", "").replace(".", "")
    return [int(c) for c in numero if c.isdigit()]

def soma_algarismos(numero):
    """Retorna a soma dos algarismos do número."""
    return sum(separar_algarismos(numero))

def frequencia_algarismos(numero):
    """Retorna um dicionário com quantas vezes cada dígito aparece."""
    return dict(Counter(separar_algarismos(numero)))

def inverter(numero):
    """
    Inverte a ordem dos algarismos da parte inteira.
    Ex.: 123 → 321 ; -908 → -809
    """
    sinal = "-" if str(numero).startswith("-") else ""
    numero = str(numero).replace("-", "")
    parte_inteira = numero.split(".")[0]
    invertido = parte_inteira[::-1]
    return int(sinal + invertido)

def eh_palindromo(numero):
    """
    Verifica se o número possui a mesma sequência de algarismos
    lida da esquerda para a direita e vice-versa.
    """
    numero = str(numero).replace("-", "").split(".")[0]
    return numero == numero[::-1]

def converter_base(n, base):
    """
    Converte um número inteiro positivo para outra base (2 a 36).
    Aceita bases binária, octal, hexadecimal e outras.
    """
    if n == 0:
        return "0"
        
    algarismos = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    resultado = ""
    
    while n > 0:
        n, resto = divmod(n, base)
        resultado = algarismos[resto] + resultado
    
    return resultado

# =========================================================
# TESTES E DEMONSTRAÇÃO
# =========================================================

numeros = [7, 12345, -908, 1200.45, "00321", -45.067, 1000000]

for n in numeros:
    print(f"===== Número: {n} =====")
    print("Algarismos:", separar_algarismos(n))
    print("Soma dos algarismos:", soma_algarismos(n))
    print("Frequência:", frequencia_algarismos(n))
    print("Invertido:", inverter(n))
    print("É palíndromo?", eh_palindromo(n))
    print()


# Exemplos de conversão de base
print("=== Conversão de Bases ===")
for n in [10, 255, 1024]:
    print(
        f"{n} -> binário: {converter_base(n, 2)}, "
        f"octal: {converter_base(n, 8)}, "
        f"hexadecimal: {converter_base(n, 16)}"
    )

Saída do código (valor de retorno)…

===== Número: 7 =====
Algarismos: [7]
Soma dos algarismos: 7
Frequência: {7: 1}
Invertido: 7
É palíndromo? True

===== Número: 12345 =====
Algarismos: [1, 2, 3, 4, 5]
Soma dos algarismos: 15
Frequência: {1: 1, 2: 1, 3: 1, 4: 1, 5: 1}
Invertido: 54321
É palíndromo? False

===== Número: -908 =====
Algarismos: [9, 0, 8]
Soma dos algarismos: 17
Frequência: {9: 1, 0: 1, 8: 1}
Invertido: -809
É palíndromo? False

===== Número: 1200.45 =====
Algarismos: [1, 2, 0, 0, 4, 5]
Soma dos algarismos: 12
Frequência: {1: 1, 2: 1, 0: 2, 4: 1, 5: 1}
Invertido: 21
É palíndromo? False

===== Número: 00321 =====
Algarismos: [0, 0, 3, 2, 1]
Soma dos algarismos: 6
Frequência: {0: 2, 3: 1, 2: 1, 1: 1}
Invertido: 12300
É palíndromo? False

===== Número: -45.067 =====
Algarismos: [4, 5, 0, 6, 7]
Soma dos algarismos: 22
Frequência: {4: 1, 5: 1, 0: 1, 6: 1, 7: 1}
Invertido: -54
É palíndromo? False

===== Número: 1000000 =====
Algarismos: [1, 0, 0, 0, 0, 0, 0]
Soma dos algarismos: 1
Frequência: {1: 1, 0: 6}
Invertido: 1
É palíndromo? False

=== Conversão de Bases ===
10 -> binário: 1010, octal: 12, hexadecimal: A
255 -> binário: 11111111, octal: 377, hexadecimal: FF
1024 -> binário: 10000000000, octal: 2000, hexadecimal: 400

Fonte:

• Editora Didática Paulista.Ensino Didático 2000: Ensino Fundamental e Ensino Médio. Sorocaba: Editora Didática Paulista, [s.d.].
• Códigos e comentários gerados por ChatGPT com revisão nossa.
• https://docs.python.org/pt-br/3/ [Documentação Oficial do Python]