#009 Triplete Pitagórico

1 Entendiendo el Problema

Un triplete pitagórico es un conjunto de tres enteros positivos (a, b, c) que satisfacen el teorema de Pitágoras. El ejemplo más famoso es (3, 4, 5).

a² + b² = c² Teorema de Pitágoras

a + b + c = 1000 Restricción del problema

Verificación manual:

1

Verificar la suma

200 + 375 + 425 = 1000 ✓

2

Verificar Pitágoras

200² + 375² = 40,000 + 140,625 = 180,625

425² = 180,625 ✓

3

Calcular el producto

200 × 375 × 425 = 31,875,000

a

200

b

375

c

425

Respuesta (a × b × c)

31,875,000

Triplete

(200, 375, 425)

2 Fuerza Bruta - 3 Variantes

Probamos combinaciones de a y b, calculando c = 1000 - a - b, y verificamos si es un triplete válido.

Variante A: while True + break

Bucle infinito con break cuando encontramos el triplete.

Python

TARGET = 1000
found = False
a = 1

while True:
    if found:
        break
    if a >= TARGET // 3:
        break

    b = a + 1
    while True:
        if b >= (TARGET - a) // 2:
            break

        c = TARGET - a - b

        if a * a + b * b == c * c:
            print(f"Triplete: ({a}, {b}, {c})")
            print(f"Verificación: {a}² + {b}² = {a*a} + {b*b} = {a*a + b*b}")
            print(f"             {c}² = {c*c}")
            print(f"Producto: {a * b * c}")
            found = True
            break

        b += 1
    a += 1

// Output aparecerá aquí

Variante B: while condición

Condiciones directas en los while.

Python

TARGET = 1000
result = None

a = 1
while a < TARGET // 3 and result is None:
    b = a + 1
    while b < (TARGET - a) // 2 and result is None:
        c = TARGET - a - b

        if a * a + b * b == c * c:
            result = (a, b, c)

        b += 1
    a += 1

if result:
    a, b, c = result
    print(f"Triplete: {result}")
    print(f"Suma: {a} + {b} + {c} = {a + b + c}")
    print(f"Producto: {a * b * c}")

// Output aparecerá aquí

Variante C: for range

Usando for con range para iterar.

Python

def find_pythagorean_triplet(target):
    """Encuentra el triplete pitagórico que suma target."""
    # a < b < c y a + b + c = target
    # Por lo tanto: a < target/3
    for a in range(1, target // 3):
        # b < c y b + c = target - a
        # Por lo tanto: b < (target - a) / 2
        for b in range(a + 1, (target - a) // 2):
            c = target - a - b

            if a * a + b * b == c * c:
                return (a, b, c)

    return None

triplet = find_pythagorean_triplet(1000)

if triplet:
    a, b, c = triplet
    print(f"Triplete: {triplet}")
    print(f"Producto: {a * b * c}")

// Output aparecerá aquí

Análisis de complejidad

Tiempo

O(n²)

Dos bucles anidados hasta n/3 y n/2

Espacio

O(1)

Solo variables auxiliares

3 Enfoque Pythónico

Usando generadores y next() para encontrar el primer triplete válido.

Python

from math import prod

TARGET = 1000

# Generador de tripletes pitagóricos con suma específica
triplet = next(
    (a, b, c)
    for a in range(1, TARGET // 3)
    for b in range(a + 1, (TARGET - a) // 2)
    for c in [TARGET - a - b]  # Truco: "asignar" c dentro de la comprensión
    if a * a + b * b == c * c
)

print(f"Triplete: {triplet}")
print(f"Producto: {prod(triplet)}")

# Alternativa más explícita
def pythagorean_triplets(target):
    """Generador de tripletes pitagóricos que suman target."""
    for a in range(1, target // 3):
        for b in range(a + 1, (target - a) // 2):
            c = target - a - b
            if a * a + b * b == c * c:
                yield (a, b, c)

# Usando el generador
first = next(pythagorean_triplets(1000))
print(f"\nCon generador: {first}")

// Output aparecerá aquí

Herramientas usadas

next() — Obtiene el primer elemento de un iterador
for c in [expr] — Truco para "asignar" en comprensión
yield — Generador perezoso
math.prod() — Producto de iterables

El truco de `for c in [expr]`

En Python no puedes hacer asignaciones dentro de una comprensión. El truco es usar un for sobre una lista de un elemento:

# Esto NO funciona:
# (a, b, c := 1000-a-b)

# Esto SÍ funciona:
for c in [1000 - a - b]

4 Solución Algebraica con Fórmula de Euclides

La fórmula de Euclides genera todos los tripletes pitagóricos primitivos. Con álgebra, podemos reducir el problema a encontrar dos parámetros.

a = m² - n² Cateto menor

b = 2mn Cateto mayor

c = m² + n² Hipotenusa

Derivación algebraica

Sumando los tres términos:

a + b + c = (m² - n²) + 2mn + (m² + n²) = 2m² + 2mn = 2m(m + n)

Si a + b + c = 1000, entonces:

2m(m + n) = 1000 → m(m + n) = 500

Buscamos m, n enteros positivos con m > n tal que m(m + n) = 500

Factorización de 500

500 = 2² × 5³. Buscamos m tal que 500/m - m = n > 0:

m	m + n = 500/m	n	¿Válido?
10	50	40	m < n
20	25	5	✓ m > n
25	20	-5	n < 0

Python — Solución O(√n)

from math import isqrt

def pythagorean_triplet_algebraic(perimeter):
    """
    Encuentra el triplete pitagórico con perímetro dado.

    Usando la fórmula de Euclides:
    a = k(m² - n²), b = k(2mn), c = k(m² + n²)

    El perímetro es: 2km(m + n) = perimeter
    Por lo tanto: km(m + n) = perimeter / 2
    """
    half = perimeter // 2  # = 500

    # m debe ser divisor de half y m² < half
    for m in range(2, isqrt(half) + 1):
        if half % m == 0:
            # m + n = half / m, entonces n = half/m - m
            quotient = half // m  # m + n (posiblemente con factor k)

            # Buscamos k tal que m + n = quotient / k
            # donde n = quotient/k - m > 0 y gcd(m,n) = 1 para primitivo

            # Para el caso más simple (k=1):
            n = quotient - m
            if n > 0 and m > n:
                # Generar triplete
                a = m * m - n * n
                b = 2 * m * n
                c = m * m + n * n

                # Verificar que suma al perímetro
                if a + b + c == perimeter:
                    return sorted([a, b, c])

    return None

triplet = pythagorean_triplet_algebraic(1000)
a, b, c = triplet

print(f"Parámetros de Euclides: m = 20, n = 5")
print(f"a = m² - n² = 400 - 25 = {20*20 - 5*5}")
print(f"b = 2mn = 2 × 20 × 5 = {2*20*5}")
print(f"c = m² + n² = 400 + 25 = {20*20 + 5*5}")
print()
print(f"Triplete: ({a}, {b}, {c})")
print(f"Suma: {a + b + c}")
print(f"Producto: {a * b * c}")

// Output aparecerá aquí

Comparación de rendimiento

Método	Complejidad	Iteraciones (n=1000)
Fuerza bruta	O(n²)	~55,000 iteraciones
Fórmula de Euclides	O(√n)	~22 iteraciones

Nota histórica

La fórmula de Euclides (~300 a.C.) genera todos los tripletes pitagóricos primitivos. Un triplete es primitivo si gcd(a,b,c) = 1. Todo triplete no primitivo es un múltiplo de uno primitivo.

Special Pythagorean Triplet

1 Entendiendo el Problema

Verificación manual:

2 Fuerza Bruta - 3 Variantes

Variante A: while True + break

Variante B: while condición

Variante C: for range

Análisis de complejidad

3 Enfoque Pythónico

Herramientas usadas

El truco de for c in [expr]

4 Solución Algebraica con Fórmula de Euclides

Derivación algebraica

Factorización de 500

Comparación de rendimiento

Nota histórica

El truco de `for c in [expr]`