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ódigo gerado por ChatGPT com revisão nossa.
https://docs.python.org/pt-br/3/ [Documentação Oficial do Python]