Algoritmos on kenji.blog

La conjetura de Collatz

Tue, 15 Jul 2025 18:03:03 +0900

¿Es cierto que “cualquier número termina en 1”? ── Jugando con la Conjetura de Collatz

¡Hola! Soy kenji.

De repente, si escuchas sobre “una regla donde cualquier número termina finalmente en 1”, ¿no te parece un poco extraño?

Por ejemplo, el 19, el 87 o incluso el 1000000. Si sigues una regla simple y manipulas el número, por alguna razón siempre converge a “1” al final.

Esta historia que parece un sueño es la Conjetura de Collatz (Collatz Conjecture).

Para empezar, ¿qué es la Conjetura de Collatz?

Primero, presentaré la regla.

Inicio: Elige cualquier entero positivo
Operación:
- Si es par → divídelo a la mitad (n → n / 2)
- Si es impar → multiplícalo por 3 y suma 1 (n → 3n + 1)

Si repites esto una y otra vez, la conjetura es que cualquier número finalmente llegará a 1.

Por ejemplo, si empezamos con el 6:

1

6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1

Efectivamente llegó a “1”. ¡Bienvenido de vuelta!

Hagámoslo con código: Collatz en Python

Bueno, en estos casos ¡es más rápido probar con código! Imprimamos la “secuencia de Collatz” en Python.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


def collatz(n):
 steps = [n]
 while n != 1:
 if n % 2 == 0:
 n = n // 2
 else:
 n = 3 * n + 1
 steps.append(n)
 return steps

# Ejemplo: empezando con 19
print(collatz(19))

Al ejecutarlo:

1

[19, 58, 29, 88, 44, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]

Llega perfectamente al 1. Da bastantes rodeos, pero al final ¡alcanza la meta!

Por cierto, incluso si empiezas con 29, también llegará a 1 de la misma manera.

1

pythonprint(collatz(29))

Al ejecutarlo:

1
2
3
4
5
6
7
8


[27, 82, 41, 124, 62, 31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242,
121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350,
175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167,
502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479,
1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911,
2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732,
866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35,
106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1]

¡Vaya, toma 111 pasos!

Y además, hay momentos en los que se infla por encima de 9000. Es un patrón que da muchísimas vueltas antes de llegar a la meta.

Y, al final, ¿qué tiene de increíble?

Lo increíble de esta conjetura es,

Aunque no está comprobada, parece que funciona con cualquier número y termina en 1

Es justo eso.

¿Eh? Entonces, ¿qué pasa con 1 billón, o 1 trillón…?

Si pensaste eso, eres muy perspicaz. De hecho, usando computadoras se ha verificado hasta aproximadamente “2 elevado a 68”, y todos llegan a 1. Increíble…

Pero, no se ha demostrado teóricamente que “todos lo hagan”. Esto es lo que en el mundo de las matemáticas se llama un “problema no resuelto”.

¿Quién es el Sr. Collatz?

Y, al leer hasta aquí, seguro piensas “¿y quién es Collatz?”. ¡Lo presentaré adecuadamente!

Nombre: Lothar Collatz
Nacionalidad: Alemán
Nacimiento: 1910 - 1990
Profesión: Matemático (destacado en análisis funcional y teoría de números)

Propuso esta conjetura en 1937, y después de eso, durante más de 80 años nadie ha podido demostrarla ni refutarla.

Por cierto, este problema es tan simple pero tan profundo, que incluso el famoso Paul Erdős (un matemático súper famoso) dijo:

“Las matemáticas aún no están listas para la conjetura de Collatz”

En otras palabras, la teoría es que las matemáticas de la humanidad aún no han alcanzado este misterio…

No se necesitan “fórmulas matemáticas difíciles”

Lo bueno de la conjetura de Collatz es que cualquiera puede jugar.

Puedes hacerlo si tienes papel y bolígrafo. Si escribes el código en Python, puedes probarlo automáticamente. Y aun así, los matemáticos más avanzados lo están intentando en serio.

No sé, ¿no te emociona?

Bonus: Código para probar de una vez

También dejaré un código para probar varios números a la vez.

1
2
3


for n in range(1, 21):
 steps = collatz(n)
 print(f"{n}: {steps} (pasos: {len(steps)-1})")

Esto imprimirá la secuencia de Collatz del “1 al 20” de una vez.

Conclusión: Este mundo, al final, es misterioso

Así que, la conjetura de Collatz.

Aunque es súper simple
Nadie puede probarlo
Es un gran problema en el mundo de las matemáticas

Es como una masa de misterio.

¡Incluso los principiantes en programación pueden probarlo, así que anímate a jugar!

Enlaces recomendados (para interesados)

Wikipedia: Conjetura de Collatz
Artículo de Terence Tao (en inglés)
¡También es divertido crear una versión visual en Python! (Lo haré si hay peticiones)

Si quieres conocer más de este tipo de temas “Matemáticas misteriosas × Programación”, no dudes en pedirme “cuéntame más”. ¡Pronto te presentaré la Hipótesis de Riemann, historias sobre números primos y muchas cosas más!

📮 ¡Fin!

FizzBuzz

Fri, 18 Apr 2025 00:58:11 +0900

¿Qué es FizzBuzz, al final de cuentas?

¡Hola!

Hoy me gustaría escribir sobre “FizzBuzz”.

Tanto para los que dicen “¡Ah, ya lo conozco!” como para los que piensan “He escuchado de eso, pero no lo entiendo bien”, acompáñenme un momento por favor. Se lee en unos pocos minutos, y quizás terminen diciendo “Ya veo”.

¿Es verdad que “si no puedes escribir FizzBuzz, no sirves como programador”?

FizzBuzz, en resumen, es algo como esto.

1
2
3
4
5
6
7
8
9


for i in range(1, 101):
 if i % 15 == 0:
 print("FizzBuzz")
 elif i % 3 == 0:
 print("Fizz")
 elif i % 5 == 0:
 print("Buzz")
 else:
 print(i)

Sí, este es el famoso “problema de FizzBuzz”.

Se revisan los números del 1 al 100 en orden,
si es múltiplo de 3, se muestra “Fizz”, si es múltiplo de 5, “Buzz”,
y si es múltiplo de ambos, “FizzBuzz”. Es algo extremadamente simple.

Sin embargo, por alguna razón, a menudo es tratado como “la prueba mínima para un programador”. Aparece en entrevistas, y en las redes sociales de vez en cuando se ven actitudes arrogantes como “Alguien que ni siquiera puede escribir FizzBuzz…”.

Pero, un momento.

¿Realmente se puede afirmar que “no poder escribir FizzBuzz = no poder programar”?

No se trata de si puedes hacerlo, sino de si estás en el “estado” para hacerlo

Es cierto que FizzBuzz requiere comprender la sintaxis y el pensamiento lógico básico. Por lo tanto, es comprensible que se use para “comprobar los fundamentos”.

Pero, piénsenlo.

Si el entorno es diferente, el resultado también lo será.

Por ejemplo,

Cuando estás nervioso frente a un entrevistador que ves por primera vez
Cuando de repente te dan una pizarra y no tienes un editor a la mano
Cuando te preguntas “¿Qué era modulo otra vez?” y no te acuerdas al instante

…¿No les ha pasado eso? Somos humanos. Creo que sí pasa.

Por eso, creo que más que “si puedes escribir FizzBuzz”, lo que en realidad es importante es “si puedes llevarte a un estado donde puedas escribir FizzBuzz”.

La trampa del típico consejo “solo entrénate y estarás bien”

Cuando se habla de esto, suele surgir el consejo “¡Por eso debes practicar todos los días!”.

Es cierto que la práctica repetitiva te permite escribir con fluidez, y eso en sí mismo es bueno. Pero si nos basamos en la premisa de que “si no puedes escribir FizzBuzz, estás descalificado”, a veces simplemente se convierte en miedo.

Es decir, se tiende a crear una estructura donde sientes que “cometer un error = no sirvo”.

Por ejemplo, el día que te quedas dormido por la mañana tiendes a pensar “soy un perezoso…”. Pero puede ser simplemente que tu cuerpo estaba cansado.

Con FizzBuzz pasa lo mismo.

A pesar de todo, FizzBuzz también es un buen problema

A pesar de todo, no es que FizzBuzz sea malo.

Al contrario, creo que es un problema muy bien hecho. Las reglas son simples y es fácil de expandir. Por ejemplo, si lo cambias de esta manera, el pensamiento se profundiza más.

1
2
3
4
5
6
7


for i in range(1, 101):
 output = ""
 if i % 3 == 0:
 output += "Fizz"
 if i % 5 == 0:
 output += "Buzz"
 print(output or i)

Este es un ejemplo de que “puedes escribirlo sin usar if-elif-else”. Es un poco más elegante, ¿verdad?

En otras palabras, FizzBuzz no solo sirve para ver “si pudiste hacerlo”, sino que también es una puerta de entrada para ver “cómo lo escribes” y “hasta qué punto lo entiendes”.

En conclusión

Creo que no hay que darle un significado demasiado exagerado a si puedes hacer FizzBuzz o no.

Incluso si no pudiste escribirlo, puede que simplemente “hoy estabas en un mal momento”, y a menudo puedes hacerlo si lo piensas detenidamente después.

Sin apresurarnos, avancemos lentamente.

El código es escrito por humanos. Por ser humanos, a veces olvidamos y a veces nos ponemos nerviosos. Creo que es suficiente si podemos avanzar poco a poco mientras aceptamos eso.

Entonces, escribamos código de manera relajada hoy también.

Código en C para generar números primos

Sat, 24 Aug 2024 09:38:10 +0900

A continuación, se muestra un código en C simple que genera números primos dentro de un rango especificado. En este ejemplo, se enumeran los números primos del 1 al n.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <stdio.h>
#include <stdbool.h>

bool isPrime(int num) {
 if (num <= 1) return false;
 if (num <= 3) return true;
 if (num % 2 == 0 || num % 3 == 0) return false;

 for (int i = 5; i * i <= num; i += 6) {
 if (num % i == 0 || num % (i + 2) == 0) return false;
 }
 return true;
}

void printPrimes(int n) {
 printf("2 ");
 for (int i = 3; i <= n; i += 2) {
 if (isPrime(i)) {
 printf("%d ", i);
 }
 }
 printf("\n");
}

int main() {
 int n;
 printf("Ingrese el valor maximo del rango para generar numeros primos: ");
 scanf("%d", &n);
 printf("Los numeros primos de 1 a %d son los siguientes:\n", n);
 printPrimes(n);
 return 0;
}

Este código funciona de la siguiente manera:

Función isPrime: Determina si un número dado es primo. Por razones de eficiencia, primero verifica si es divisible por 2 y 3, y luego procede a verificar en múltiplos de 6.
Función printPrimes: Imprime los números primos dentro del rango especificado. El 2 se imprime primero, y luego solo se verifican los números impares.
Función main: Pide al usuario que ingrese el valor máximo del rango y luego imprime los números primos dentro de ese rango.

Al compilar y ejecutar este código, se mostrarán los números primos dentro del rango especificado.

Resolver el problema del viajante con Mathematica

Wed, 12 Oct 2022 19:05:58 +0900

Resolver el problema del viajante con Mathematica

Problema

電車でこんな広告を見かけました😁📸 pic.twitter.com/iXEgvtXrpL
— 早稲田大学早水桃子研究室 (@hayamizu_lab) October 11, 2022

Solución

1

d=SparseArray[{{1,2}->10,{2,1}->10,{1,5}->15,{5,1}->15,{1,4}->12,{4,1}->12,{1,3}->20,{3,1}->20,{2,5}->10,{5,2}->10,{3,4}->10,{4,3}->10,{3,8}->30,{8,3}->30,{3,7}->20,{7,3}->20,{3,6}->25,{6,3}->25,{4,5}->15,{5,4}->15,{4,8}->20,{8,4}->20,{5,9}->18,{9,5}->18,{5,8}->15,{8,5}->15,{6,7}->5,{7,6}->5,{7,8}->35,{8,7}->35,{8,9}->12,{9,8}->12},{9,9},Infinity];

La función SparseArray crea una matriz. Cada elemento representa la distancia entre las ciudades de la fila y columna de ese elemento. Por ejemplo, el primer elemento {1,2}->10 significa que la distancia entre 1 y 2 es 10. El penúltimo elemento {9,9} indica el tamaño de la matriz, y el último elemento Infinity significa que la longitud del camino entre ciudades no especificadas es infinita. Es decir, significa que no hay camino.

1

{len,tour}=FindShortestTour[{1,2,3,4,5,6,7,8,9},DistanceFunction->(d[[#1,#2]]&)]

Con la función FindShortestTour, puedes resolver fácilmente el problema del viajante. {1,2,3,4,5,6,7,8,9} representa los números de las ciudades. DistanceFunction->(d[[#1,#2]]&) pasa la matriz d que representa la distancia entre las ciudades.

Salida

1

{137, {1, 2, 5, 9, 8, 7, 6, 3, 4}}

La salida es la distancia más corta y el recorrido en ese momento. La distancia más corta es 137, y el recorrido es 1→2→5→9→8→7→6→3→4→1. Convertido al orden ABC, es A, B, E, I, H, G, F, C, D.

'Enumerando números primos en Rust'

Fri, 09 Sep 2022 07:08:49 +0900

He escrito un programa para enumerar números primos en Rust.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


fn main() {
 let max = 1000;
 let mut primes = vec![2];
 let mut n = 3;
 loop {
 let mut is_prime = true;
 for p in &primes {
 if n % p == 0 {
 is_prime = false;
 break;
 }
 }
 if is_prime {
 primes.push(n);
 }
 n += 2;
 if n > max {
 break;
 }
 }
 for p in &primes {
 println!("{}", p);
 }
}