📐 Definições Matemáticas Precisas
😊 Números Felizes (Happy Numbers)
Definição formal: Um número natural \(n\) é dito feliz se, aplicando repetidamente a função
$$f(n) = \sum_{i=1}^{k} d_i^2$$
onde \(d_i\) são os dígitos de \(n\) na base 10, eventualmente obtém-se o valor 1. Caso contrário, é dito infeliz.
Teorema 1 (Pontos Fixos e Ciclos): No processo de iteração da função \(f(n)\), todo número natural eventualmente atinge 1 ou entra no ciclo:
$$4 \rightarrow 16 \rightarrow 37 \rightarrow 58 \rightarrow 89 \rightarrow 145 \rightarrow 42 \rightarrow 20 \rightarrow 4$$
Implementação em Wolfram Mathematica (mais precisa):
HappyList[n_] := NestWhileList[Total[IntegerDigits[#]^2] &, n, UnsameQ, All]
HappyNumber[n_] := NestWhile[Total[IntegerDigits[#]^2] &, n, UnsameQ, All]
HappyQ[n_] := HappyNumber[n] == 1
Exemplo: HappyList[19] = {19, 82, 68, 100, 1, 1}
🎓 Números Educados
Definição formal: Um número natural \(n\) é dito educado se pode ser escrito como soma de dois ou mais inteiros positivos consecutivos:
$$n = k + (k+1) + (k+2) + \ldots + (k+m-1) = \frac{m(2k + m - 1)}{2}$$
onde \(m \geq 2\) (número de termos) e \(k \geq 1\) (primeiro termo).
Teorema Fundamental: Um número é educado se, e somente se, não for uma potência de 2. O número de representações distintas é igual ao número de divisores ímpares de \(n\) maiores que 1.
🔷 Primos Felizes
Definição: Um primo feliz é um número primo que também é feliz.
Exemplos: 7, 13, 19, 23, 31, 79, 97, 103, 109, 139, ...
Tabela de Números Felizes até 100:
| 1, 7, 10, 13, 19, 23, 28, 31, 32, 44, 49, 68, 70, 79, 82, 86, 91, 94, 97, 100 |
Conjuntos Notáveis
Números que atingem cada valor:
Union[HappyNumber /@ Range[0, 10^5]] = {0, 1, 4, 16, 20, 37, 42, 58, 89, 145}
Pares de Números Felizes Consecutivos
Existem infinitos pares de números felizes consecutivos. Os primeiros são:
| Par |
Diferença |
| (31, 32) | 1 |
| (129, 130) | 1 |
| (192, 193) | 1 |
| (262, 263) | 1 |
Triplas de Números Felizes Consecutivos
São mais raras. As primeiras são:
| Tripla |
| (1880, 1881, 1882) |
| (4780, 4781, 4782) |
| (4870, 4871, 4872) |
✏️ Exercícios
1. Use a definição HappyList para verificar se 97 é feliz.
Ver solução
HappyList[97] = {97, 130, 10, 1, 1} → É feliz! 😊
2. Encontre todas as representações de 21 como soma de inteiros consecutivos.
Ver solução
21 = 10+11 = 6+7+8 = 1+2+3+4+5+6 (3 sequências)
3. Prove que 2 não é educado usando a definição formal.
Ver solução
2 é potência de 2. Pelo teorema fundamental, potências de 2 não são educadas.
📓 Código Wolfram Mathematica
Fonte: Weisstein, Eric W. "Happy Number." From MathWorld--A Wolfram Web Resource.
Definições Fundamentais
(* Happy Number - Definições precisas *)
HappyList[n_] := NestWhileList[Total[IntegerDigits[#]^2] &, n, UnsameQ, All]
HappyNumber[n_] := NestWhile[Total[IntegerDigits[#]^2] &, n, UnsameQ, All]
HappyQ[n_] := HappyNumber[n] == 1
Exemplos de Uso
(* Testando números *)
HappyList[19] (* {19, 82, 68, 100, 1, 1} *)
HappyQ[7] (* True *)
HappyQ[4] (* False *)
(* Encontrando todos os números que os primeiros 100 números atingem *)
Union[HappyNumber /@ Range[0, 100]]
(* {0, 1, 4, 16, 20, 37, 42, 58, 89, 145} *)
(* Verificando que o conjunto é o mesmo para números maiores *)
Union[HappyNumber /@ Range[0, 10^5]]
(* {0, 1, 4, 16, 20, 37, 42, 58, 89, 145} *)
Gerando Números Felizes
(* Gerando os primeiros 30 números felizes *)
happy = Select[Range[10^6], HappyQ];
Take[happy, 30]
(* {1, 7, 10, 13, 19, 23, 28, 31, 32, 44, 49, 68, 70, 79, 82, 86, 91, 94, 97, 100, 103, 109, 129, 130, 133, 139, 167, 176, 188, 190} *)
Visualizando Sequências
(* Mostra as sequências dos primeiros 5 números felizes *)
HappyList /@ Take[happy, 5] // ColumnForm
(*
{1, 1}
{7, 49, 97, 130, 10, 1, 1}
{10, 1, 1}
{13, 10, 1, 1}
{19, 82, 68, 100, 1, 1}
*)
(* Número de iterações (excluindo o 1 final) *)
Length /@ HappyList /@ Take[happy, 20] - 2
(* {0, 5, 1, 2, 4, 3, 3, 2, 3, 4, 4, 2, 5, 3, 3, 2, 4, 4, 3, 1} *)
Gráficos
(* Gráfico do número de iterações *)
ListPlot[Length /@ HappyList /@ Take[happy, All] - 2, PlotStyle -> Red]
(* Distribuição dos números felizes *)
ListPlot[MapIndexed[{#1, #2[[1]]} &, happy], PlotStyle -> Red]
Contagem de Números Felizes
(* Quantos números felizes existem até 10^n? *)
Table[Count[happy, _?(# <= 10^n &)], {n, 6}]
(* {3, 20, 143, 1442, 14377, 143071} *)
(* Aproximadamente 1/7 dos números são felizes *)
N[% / 10^{1,2,3,4,5,6}]
(* {0.3, 0.2, 0.143, 0.1442, 0.14377, 0.143071} *)
Primos Felizes
(* Encontrando primos felizes *)
Select[Prime /@ Range[1000], HappyQ]
(* 7, 13, 19, 23, 31, 79, 97, 103, 109, 139, ... *)
Números Felizes Consecutivos
(* Pares de números felizes consecutivos *)
Select[Partition[happy, 2, 1], Subtract @@ # == -1 &]
(* Triplas de números felizes consecutivos *)
Select[Partition[happy, 3, 1], #[[-1]] - #[[1]] == 2 &]
(* {{1880, 1881, 1882}, {4780, 4781, 4782}, {4870, 4871, 4872}, ...} *)
🐍 Código Python (Baseado nas definições do Mathematica)
from typing import List, Tuple, Set, Dict
import math
def soma_quadrados_digitos(n: int) -> int:
"""Implementa Total[IntegerDigits[#]^2] & do Mathematica"""
return sum(int(d) ** 2 for d in str(n))
def happy_list(n: int) -> List[int]:
"""Implementa HappyList do Mathematica: NestWhileList[..., UnsameQ, All]"""
sequencia = []
vistos = set()
atual = n
while atual not in vistos:
vistos.add(atual)
sequencia.append(atual)
atual = soma_quadrados_digitos(atual)
sequencia.append(atual)
return sequencia
def happy_number(n: int) -> int:
"""Implementa HappyNumber do Mathematica: NestWhile[..., UnsameQ, All]"""
vistos = set()
atual = n
while atual not in vistos:
vistos.add(atual)
atual = soma_quadrados_digitos(atual)
return atual
def happy_q(n: int) -> bool:
"""Implementa HappyQ do Mathematica"""
return happy_number(n) == 1
_cache_happy: Dict[int, bool] = {}
def happy_q_com_cache(n: int) -> bool:
"""HappyQ com memorização para melhor performance"""
if n in _cache_happy:
return _cache_happy[n]
vistos = set()
atual = n
while atual != 1 and atual not in vistos:
vistos.add(atual)
atual = soma_quadrados_digitos(atual)
resultado = (atual == 1)
for num in vistos:
_cache_happy[num] = resultado
return resultado
def gerar_numeros_felizes(limite: int) -> List[int]:
"""Retorna todos os números felizes até 'limite'"""
return [n for n in range(1, limite + 1) if happy_q_com_cache(n)]
def valores_atingidos(limite: int) -> Set[int]:
"""Retorna o conjunto de todos os valores que os números até 'limite' atingem"""
return {happy_number(n) for n in range(limite + 1)}
def pares_consecutivos(happy_numbers: List[int]) -> List[Tuple[int, int]]:
"""Encontra pares de números felizes consecutivos"""
return [(happy_numbers[i], happy_numbers[i+1])
for i in range(len(happy_numbers)-1)
if happy_numbers[i+1] - happy_numbers[i] == 1]
def triplas_consecutivas(happy_numbers: List[int]) -> List[Tuple[int, int, int]]:
"""Encontra triplas de números felizes consecutivos"""
return [(happy_numbers[i], happy_numbers[i+1], happy_numbers[i+2])
for i in range(len(happy_numbers)-2)
if happy_numbers[i+2] - happy_numbers[i] == 2]
if __name__ == "__main__":
print(f"HappyList[19] = {happy_list(19)}")
print(f"HappyQ[7] = {happy_q(7)}")
print(f"HappyQ[4] = {happy_q(4)}")
print(f"Valores atingidos (0-100): {sorted(valores_atingidos(100))}")
felizes = gerar_numeros_felizes(200)
print(f"Primeiros 20 números felizes: {felizes[:20]}")
print(f"Pares consecutivos: {pares_consecutivos(felizes)[:5]}")
Números Educados em Python
def divisores_impares(n: int) -> List[int]:
"""Retorna todos os divisores ímpares de n maiores que 1"""
divisores = []
limite = int(math.sqrt(n))
for i in range(1, limite + 1, 2):
if n % i == 0:
if i > 1 and i % 2 == 1:
divisores.append(i)
outro = n // i
if outro != i and outro > 1 and outro % 2 == 1:
divisores.append(outro)
return sorted(divisores)
def sequencias_educadas(n: int) -> List[List[int]]:
"""
Encontra todas as sequências de inteiros consecutivos que somam n.
Baseado no teorema: n = m(2k + m - 1)/2
"""
if n < 3:
return []
sequencias = []
dobro = 2 * n
divisores = divisores_impares(dobro)
for d in divisores:
outro = dobro // d
if d < outro:
m = d
soma_extremos = outro
else:
m = outro
soma_extremos = d
k = (soma_extremos - m + 1) // 2
if m >= 2 and k >= 1:
sequencia = list(range(k, k + m))
if sum(sequencia) == n:
sequencias.append(sequencia)
return sorted(sequencias, key=lambda x: (len(x), x[0]))
def eh_potencia_de_2(n: int) -> bool:
"""Verifica se n é potência de 2"""
return n > 0 and (n & (n - 1)) == 0
n = 45
print(f"\nAnálise do número {n}:")
print(f"É potência de 2? {eh_potencia_de_2(n)}")
print(f"Divisores ímpares de 2n: {divisores_impares(2*n)}")
print(f"Sequências: {sequencias_educadas(n)}")