Números con cifras crecientes o decrecientes (2)

Comenzamos las búsquedas donde las dejamos en la entrada anterior, con los cubos.

Cubos con cifras decrecientes

Mediante un proceso similar se pueden encontrar los cubos perfectos que presentan cifras decrecientes (en sentido amplio). En PARI vale todo lo explicado, pero hay que sustituir vecsort(digits(m)), por vecsort(digits(m),,4), que ordena las cifras en sentido contrario.

En este caso sí aparecen infinitos cubos, pero la conjetura que se deduce de ellos es distinta:

Cubos: 0, 1, 8, 64, 1000, 8000, 64000, 1000000, 8000000, 64000000, 1000000000, 8000000000, 64000000000, 1000000000000, 8000000000000, 64000000000000, 1000000000000000, 8000000000000000, 64000000000000000, 1000000000000000000, 8000000000000000000, 64000000000000000000, 1000000000000000000000,…

Conjetura: Todos los cubos con cifras decrecientes (en sentido amplio) en base10 pertenecen a uno de estos tipos: 0, 10^k, 8*10^k, 64*10^k, con k entero mayor o igual a cero.

Como la anterior, la hemos verificado hasta 10^24, por lo que también queda abierta hasta que se encuentre un contraejemplo.

Como curiosidad, por si a alguien le interesa, se reproduce el código de nuestra función CIFRAS_DECRECIENTES, que no requiere más explicaciones:

Función en VBASIC

Public Function cifras_decrecientes(n) As Boolean

Dim j, l

Dim c As Boolean

l = numcifras(n)

c = True

If l > 1 Then

j = l

While j >= 2 And c

If cifra(n, j) < cifra(n, j - 1) Then c = False

j = j - 1

Wend

End If

cifras_decrecientes = c

End Function

Por dar variedad al tema, no repetiremos algunos ejemplos tratados en la entrada anterior. Podemos buscar otros tipos. Por ejemplo, los primos. En Vbasic de Excel puedes usar nuestra función ESPRIMO, muy usada en nuestras publicaciones. Puedes buscar en Google ESPRIMO Roldán hoja. Si solo escribes ESPRIMO te aparecen unos productos informáticos. Con ella y CIFRAS_DECRECIENTES, puedes buscar los primeros ejemplos de primos con cifras decrecientes (en sentido amplio):

2, 3, 5, 7, 11, 31, 41, 43, 53, 61, 71, 73, 83, 97, 211, 311, 331, 421, 431, 433, 443, 521, 541, 631, 641, 643, 653, 661, 733, 743, 751, 761, 773, 811, 821, 853, 863, 877, 881, 883, 887, 911, 941, 953, 971, 977, 983, 991, 997

Los tienes en http://oeis.org/A028867. En esa página figura una versión en PARI de la búsqueda que es mejorable. Proponemos mejor esta otra:

ok(n) = digits(n) == vecsort(digits(n),,4) && isprime(n)

for(i=2,10^3,if(ok(i),print1(i,", ")))

La comprobamos en la página de PARI/GP:

Números de Fibonacci con cifras decrecientes

Otro ejemplo interesante es el de los números de Fibonacci, porque parece que dan lugar también a una sucesión finita:

1, 2, 3, 5, 8, 21, 55, 610, 987

Para hoja de cálculo podemos usar nuestra función ESFIBO, que determina si un número es de Fibonacci o no.

Public Function esfibo(n) As Boolean 'Devuelve verdadero si N es de Fibonacci

Dim f As Boolean

Dim a

f = False

a = 5 * n * n + 4

If escuad(a) Then f = True

a = 5 * n * n - 4

If escuad(a) Then f = True

esfibo = f

End Function

Se basa en popular criterio para saber si un número pertenece a la sucesión de Fibonacci. Lo puedes consultar en Gaussianos:

https://www.gaussianos.com/algunas-curiosidades-sobre-los-numeros-de-fibonacci/

Si aplicamos esta función ESFIBO con CIFRAS_DECRECIENTES llegaremos al resultado presentado.

En estos casos de sucesiones finitas hay que avanzar bastante para plantear una conjetura. Por eso debemos pasar a PARI, que llega más lejos en sus cálculos:

ok(n) = digits(n) == vecsort(digits(n),,4) && (issquare(5*n^2+4) || issquare(5*n^2-4))

for(i=2,10^6,if(ok(i),print1(i,", ")))

Hasta 10^6 devuelve los mismos resultados que la hoja de cálculo, salvo el 1, que se da por supuesto:

Le hemos exigido algo más, que llegue a 10^8, y no ha aparecido ningún ejemplo más.

Podemos intentar generar los números de Fibonacci según su definición. Con este otro algoritmo hemos recorrido los 10^4 primeros con el mismo resultado:

m=1;n=1;for(i=1,10^4,p=m+n;m=n;n=p;if(digits(p) == vecsort(digits(p),,4),print1(p,", ")))

En la sucesión  A273046, el colaborador  Charles R Greathouse IV, llega a la misma conclusión de que es probable que no existan más ejemplos.

Es interesante que en una misma cuestión hayamos presentado tres sucesiones finitas. Es una especie de probabilidad decreciente, de tal forma que, al crecer mucho los números, la misma tiende a cero, perdiendo la posibilidad de aparición de ejemplos nuevos. Como esto es solo una explicación no matemática, se quedarán en conjeturas.

Números de Bouncy

Son aquellos números tales que sus cifras no son crecientes ni decrecientes. Como siempre queda la duda de si hablamos de orden en sentido amplio o estricto, diremos que, en el segundo caso, están publicados en http://oeis.org/A152054, con orden estricto. Probemos con el orden amplio. Bastará unir las funciones que hemos usado (para crecientes y para decrecientes) mediante las conectivas lógicas NOT y AND:

NOT CIFRAS_CRECIENTES(N) AND NOT CIFRAS_DECRECIENTES(N)

Como era de esperar, casi todos los números aparecen:

101, 102, 103, 104, 105, 106, 107, 108, 109, 120, 121, 130, 131, 132, 140, 141, 142, 143, 150, 151, 152, 153, 154, 160, 161, 162, 163, 164, 165, 170, 171, 172, 173, 174, 175, 176, 180, 181, 182, 183, 184, 185, 186, 187, 190, 191, 192, 193, 194, 195, 196, 197

No obtenemos números de una o dos cifras porque todos son crecientes o decrecientes en sentido amplio. Existirán diferencias entre los dos tipos de orden, como por ejemplo con el número 1133 que no es creciente en sentido estricto, pero sí lo es en el amplio.

En OEIS, para evitar ambigüedades, al amplio lo identifican como nonincreasing o nondecreasing.

Son tantos estos números que no merece la pena dividirlos entre los distintos tipos.

Números con cifras crecientes o decrecientes (1)

En este estudio nos dedicaremos a cuestiones derivadas del orden de las cifras de un número. Serán desarrollos sin mucha trascendencia, pues tan solo se pretende efectuar ejercicios de creación de funciones o de búsquedas. Al igual que nos ocurrió en otros desarrollos, en este comenzaremos con distintos tipos de números y sus propiedades respecto al orden de sus cifras, y seguiremos investigando con temas afines hasta constatar que pierden interés.

En todas las cuestiones deberemos concretar el tipo de orden, que puede ser creciente, en sentido amplio, con cifras repetidas, o en sentido estricto, en el que no se permiten cifras consecutivas iguales. Igualmente, en el orden decreciente también usaremos los dos sentidos. Como el tema es amplio, daremos preferencia a las cifras crecientes.

Tipos de números y orden de sus cifras

Están publicadas muchas sucesiones que relacionan tipos de números con sus cifras. Unos ejemplos:

Triangulares con cifras crecientes (sentido amplio)

Están publicados en http://oeis.org/A234848:

0, 1, 3, 6, 15, 28, 36, 45, 55, 66, 78, 136, 378, 666, 1128, 1225, 1378, 2278, 2346, 2556, 5778, 12246, 13366, 22366, 22578,…

Aprovechamos esta sucesión para presentar nuestra función en VBasic destinada a detectar este tipo de orden creciente:

Function cifras_crecientes(n) As Boolean

Dim j, l

Dim c As Boolean

l = numcifras(n) ‘Cuenta las cifras del número

c = True

If l > 1 Then ‘Si tiene una cifra, no lo estudiamos

j = l

While j >= 2 And c

If cifra(n, j) > cifra(n, j - 1) Then c = False ‘Si una cifra rompe el orden, no es creciente (se estudia de derecha a izquierda)

j = j - 1

Wend

End If

cifras_crecientes = c

End Function

 

La función NUMCIFRAS se define como

Function numcifras(n)

Dim nn, a

a = 1: nn = 0

While a <= n

a = a * 10: nn = nn + 1

Wend

numcifras = nn

End Function

 

Y la función CIFRA como

Function cifra(m, n)

Dim a, b

If n > numcifras(m) Then

  cifra = -1

  Else

  a = 10 ^ (n - 1)

  b = Int(m / a) - 10 * Int(m / a / 10)

  cifra = b

  End If

End Function

Vemos que extrae las cifras en el orden desde las unidades hasta las decenas, centenas…

Con estas funciones es fácil encontrar los triangulares que tienen sus cifras en orden creciente amplio. El criterio sería

ESTRIANGULAR(N) AND CIFRAS_CRECIENTES(N)

La primera función la hemos usado mucho. Puedes usar la búsqueda estriangular( hoja en Google. Exige que 8*n+1 sea cuadrado.

El resultado sería:

Es evidente que coincide con lo publicado. Esto solo ha sido la comprobación de que nuestra función está correctamente diseñada.

En PARI la detección de cifras crecientes es brevísima. Basta plantear

digits(m)==vecsort(digits(m))

Es una solución muy ingeniosa, porque viene a decir que las cifras actuales coinciden con las cifras ordenadas. Si se desea orden estricto, sin repeticiones, ha de incorporarse el parámetro 8 de esta forma: vecsort(digits(m,,8))

Por ejemplo, con esta línea encuentras los triangulares con cifras en orden creciente estricto:

for(i=0,10^3,if(digits(i)==vecsort(digits(i),,8)&&issquare(8*i+1),print1(i,", ")))

Usamos los triangulares como introducción a las técnicas adecuadas. Si deseas practicar o profundizar puedes consultar estas sucesiones:

http://oeis.org/A028864: Primos con cifras crecientes.

http://oeis.org/A028820: Ídem cuadrados.

http://oeis.org/A273045: Números de Fibonacci.

Como los números oblongos, del tipo N(N+1) son olvidados fácilmente, los rescataremos aquí:

Oblongos con cifras crecientes

Un número oblongo es el doble de un triangular, luego si en estos 8*n+1 ha de ser cuadrado, en los oblongos lo será 4*n+1. En esto se basa nuestra función ESOBLONGO, y con ella podemos investigar en Excel junto a CIFRAS_CRECIENTES. El resultado es

Con PARI podemos llegar más lejos:

0, 2, 6, 12, 56, 156, 1122, 2256, 4556, 11556, 111222, 445556, 11112222, 44455556, 222233556, 1111122222, 4444555556, 111111222222, 444445555556, 11111112222222, 44444455555556, 1111111122222222, 4444444555555556, 111111111222222222,

Primera versión: generar los oblongos a partir del 2, sumando luego 4, 6, 8. 10. El inconveniente es que hay que partir siempre del 2, no se puede iniciar, por ejemplo en 10^10. Es muy rápido al principio, pero luego ralentiza.

m=2;k=2;while(m<10^8,if(digits(m)==vecsort(digits(m)),print1(m,", "));k+=2;m+=k)

Lo hemos probado en https://pari.math.u-bordeaux.fr/gp.html

 

Segunda versión: construir m(m+1) y después aplicar el criterio. Es más lento, porque tiene que multiplicar en cada caso

 for(i=10^3,10^7,m=i*(i+1);if(digits(m)==vecsort(digits(m)),print(m)))

Lo hemos probado con GP/PARI CALCULATOR con este resultado, que comprende los valores incluidos para m, 10^3 a 10^7: 

Tercera versión: Es la más lenta, porque, como en Excel, aplica el criterio de que sea cuadrada la expresión (4*n+1). Lo comprobamos para números no muy grandes en la web de PARI:

ok(n)=digits(n)==vecsort(digits(n))&&issquare(4*n+1)

for(i=0,10^6,if(ok(i),print(i)))

Potencias perfectas con cifras crecientes

En este tipo nos limitaremos a presentar el resultado, para animar a los lectores a intentar reproducirlo. Como pista, en PARI habría que usar la función ispower:

4, 8, 9, 16, 25, 27, 36, 49, 125, 128, 144, 169, 225, 256, 289, 1156, 1225, 1369, 1444, 4489, 6889, 11236, 11449, 13456, 13689, 27889, 33489, 111556, 112225, 113569, 134689, 146689, 344569, 444889, 2666689, 2778889, 11115556, 11122225, 11135569, 11336689, 11444689, 13446889,…

Cubos

Aquí nos detendremos, porque su número es, al parecer, finito. Sólo se han encontrado los cubos 0, 1, 8, 27 y 125 con cifras crecientes en sentido amplio (en el estricto tendríamos menos posibilidades).

Empleando diversas técnicas y lenguajes, no ha sido posible encontrar más ejemplos de cubos con cifras crecientes, por lo que se puede enunciar la conjetura:

Sólo existen cinco cubos perfectos con sus cifras crecientes en sentido amplio en base 10.

Con hoja de cálculo podemos usar la función ESCUBO junto a la de cifras crecientes. Por el problema de los decimales, no es fácil determinar si un número desconocido es un cubo. Hemos usado esta versión:

Function escubo(n)

Dim a

a = Int(n ^ (1 / 3) + 10 ^ (-6))

If a * a * a = n Then escubo = True Else escubo = False

End Function

Buscamos, por ejemplo, entre 0 y 10^6, y conseguiremos tan solo esos cinco casos:

En PARI se pueden plantear dos puntos de vista: en el primero usar una función que detecte la propiedad directamente en un número cualquiera, y en el segundo se trata de ir construyendo los cubos uno a uno y esperar a que se cumpla la condición en uno de ellos.

Función directa

ok(n)=digits(n)==vecsort(digits(n))&&ispower(n,3)

Se entiende fácilmente con lo explicado con anterioridad. Esta función, aplicada a un número natural, indica si es un cubo (ispower(n,3)) y si sus cifras crecen (digits(n)==vecsort(digits(n)).

Es muy directa y sencilla, pero resulta bastante lenta, por tener que probar todos los números, sean cubos o no.

Construcción de cubos

Para encontrar cubos es preferible construirlos desde 0. Esto es lo que efectúa esta otra variante:

for(i=0,1000,m=i^3;if(digits(m)==vecsort(digits(m)),print1(m,”, “)))

Es tres veces más veloz que la función anterior, porque la variable m siempre será un cubo. He aquí el resultado:

Hemos llegado de varias formas hasta 10^24, sin detectar otro cubo con cifras crecientes, por lo que podemos dar por cierta la conjetura hasta que alguien descubra un contraejemplo.

Lo dejamos aquí por hoy. En la siguiente entrada estudiaremos algunos ejemplos con cifras decrecientes.

Los pandigitales completos

Se llaman pandigitales a los números que presentan en su representación todas las cifras posibles en una base de numeración. Aquí nos restringiremos a base 10 y a aquellos números que contienen todas las cifras del 0 al 9 (completos), pero sin repetición. Es el concepto más simple y útil respecto a otras variantes.

Es claro que el pandigital más pequeño de este tipo será 1023456789, y el mayor 9876543210. Como no consideramos repeticiones de cifras, su número será 10!=3628800 si admitimos el cero inicial, y 10!-9!= 3265920 si no lo admitimos.

Ningún número pandigital de este tipo puede ser un número primo, porque cumple el criterio de divisibilidad entre 9 y 3, al sumar sus cifras 45

Reconocimiento de pandigitales

No es fácil reconocer mediante un algoritmo si un número (del que no conocemos en principio su expresión decimal) es pandigital o no. Es evidente que normalmente conocemos sus cifras, pero en una búsqueda no. Por ejemplo, si buscamos un pandigital que sea triangular, no conocemos sus cifras hasta que lo encontremos.

Aquí, como es costumbre, estudiaremos dos versiones, una para hoja de cálculo y otra para PARI.

Proceso en PARI

La segunda es muy fácil de entender:

 pandigi(n)= #vecsort(digits(m), , 8)==10

Literalmente nos dice, que si ordenamos el vector formado por las cifras (vecsort(digits), eliminamos repetidos (parámetro 8), y luego las contamos (signo #), ha de resultar un número igual a 10, que sería el número de cifras sin repetición.

Un ejemplo de uso de esta función es el de encontrar el primer pandigital cuadrado. Tomamos la menor base cuyo cuadrado tiene diez cifras, que es  31623, y vamos avanzando cuadrados hasta encontrar un pandigital. Sería así:

pandigi(m)=#vecsort(digits(m), , 8)==10

m=31623;q=m^2;while(pandigi(q)==0,m+=1;q=m^2);print(m)

En primer lugar define la función pandigi, para reconocer pandigitales, y después avanza los cuadrados en un bucle while hasta encontrar un valor de pandigi que no sea cero.

El resultado es 1026753849=32043^2

El resto de los pandigitales cuadrados los puedes consultar en http://oeis.org/A036745

Proceso en hojas de cálculo

En este caso perdemos la potencia del lenguaje PARI, pero podemos imitar nuestro reconocimiento de un pandigital:

Nosotros iríamos recorriendo las cifras del número, y si falta una, lo rechazaríamos, y si existe una repetición, también. Después contaríamos que estuvieran las diez cifras.

Pues algo así realizaremos con VBasic. Para ello prepararemos diez memorias que alojen las frecuencias de las cifras. Cada vez que aparezca una incrementamos la memoria correspondiente. Podemos organizar todo con esta función:

Public Function pandigital(a) As Boolean

Dim ci(10)

Dim i

Dim t As Boolean

t = True

For i = 0 To 9: ci(i) = 0: Next i ‘Preparamos diez memorias

If numcifras(a)<>10 then pandigital=false:exit function

For i = 1 To 10

ci(cifra(a, i)) = ci(cifra(a, i)) + 1  ’Anotamos cada cifra

‘Si la frecuencia es mayor que 1, se rechaza el número

If ci(cifra(a, i)) > 1 Then pandigital = False: Exit Function

Next i

s = 0

For i = 0 To 9

If ci(i) = 0 Then t = False ‘Si queda una memoria vacía, se rechaza

Next i

pandigital = t ‘Devuelve verdadero o falso

End Function

Con esta función es fácil obtener un listado de los primeros pandigitales:

Podemos usar esta función para encontrar, por ejemplo, el primer número pandigital triangular. Partimos de 1000006281, primer triangular de 10 cifras, de orden 44721, y vamos recorriendo triangulares hasta encontrar un pandigital. Todo se basa en la fórmula de los triangulares, N(N+1)/2.

Function panditrian(n)

Dim m

m = n

Do Until pandigital(m * (m + 1) / 2)

m = m + 1

Loop

panditrian = m * (m + 1) / 2

End Function

Con esta función encontramos el primer pandigital triangular, 1062489753, de orden 46097. Está publicado en http://oeis.org/A241812, pero es interesante volverlo a encontrar con nuestros propios medios.

De esta forma podemos encontrar cubos, oblongos y otros que sean pandigitales sin repetición.

Por ejemplo, el menor oblongo de diez cifras es 1000045752=31623*31624. Con un pequeño cambio en la función de arriba obtenemos 1492083756=38627*38628 como el menor oblongo pandigital. No está publicado.

En el caso de los cubos, no hemos encontrado ningún ejemplo.

Los tipos que hemos buscado tienen forma polinómica, lo que ha acelerado el proceso. En otros casos la búsqueda sería mucho más lenta.

Existen muchos casos en los que un pandigital es múltiplo de otro, pero su búsqueda es lenta y no la abordaremos. Sí es sencillo buscar un múltiplo pandigital de cualquier otro número menor. En casi todos los casos se encuentra con éxito, e incluso circula por ahí la conjetura de que todos los números poseen un múltiplo pandigital, pero no es cierta, ya que los números terminados en 00 no lo tienen, y también muchos múltiplos de 25.

Con este código PARI encuentras fácilmente un múltiplo pandigital de otro cualquiera menor que 10^9:

multipan(n)={my(e=0,i=1,m=n);while(m<=10^10&&e==0,m=n*i;if(#vecsort(digits(m), , 8)==10,e=m);i+=1);e}

print(multipan(23322))

En el ejemplo se busca el múltiplo de 23322, y resulta ser 1053967824=45192*23322

Si cambias 23322 por otro número, obtendrás su múltiplo pandigital. Si no existe, te devolverá un cero. Prueba con un número terminado en dos ceros.

 

 

Regresos 4: Doblado pitagórico

Ampliamos en esta entrada el contenido de otra similar publicada en este blog en el año 2010:

https://hojaynumeros.blogspot.com/2010/10/1-7-17-23-31-41-47-49-71-73-79-89-97.html

Si tomamos un segmento de longitud 31 cm. y lo doblamos por cierto punto en forma de ángulo recto, podemos completar un triángulo rectángulo cuya hipotenusa tiene medida entera. No es difícil averiguar por dónde se puede doblar: basta hacerlo con un segmento de medida 7, con lo que el otro trozo mediría 24 y la hipotenusa 25, pues 7²+24²=25²

Existen otros números con la misma propiedad: 7, descompuesto en 3 y 4, 23, doblado por 8 y 15, y otros muchos.

Además de 7, 23 o 31, ¿qué otros números tienen la propiedad de engendrar un triángulo rectángulo de medidas enteras con un simple “doblado”?

Podríamos extender el tipo de doblado a conseguir una hipotenusa y un cateto, o bien, con dos dobleces, conseguir los tres lados, que es lo que se efectuó en la Antigüedad para conseguir un ángulo recto con un doblado 3+4+5=12.

Comenzamos:

Doblado en dos catetos

Para poder estudiar simultáneamente varios casos, asignaremos una función a cada uno. Usaremos, siguiendo una metodología reciente en este blog, funciones que nos devuelvan los resultados en forma de string, para poder ver las soluciones, y no un simple SÍ o NO. En este primer caso usaremos esta función:

Function doblado$(n)

Dim i, j, k, m

Dim s$

 

m = 0

s = ""

For i = 1 To n / 2 ‘Llegamos a n/2 buscando un cateto

j = n – i ‘El otro posible cateto

k = i ^ 2 + j ^ 2 ‘Vemos si forman terna pitagórica

If escuad(k) Then m = m + 1: s = s + " ##" + Str$(i) + " " + Str$(j) + " " + Str$(Sqr(k)) ‘En caso afirmativo, incorporamos a la solución

Next i

If s = "" Then s = "NO" Else s = Str$(m) + s ‘Añadimos número de soluciones

doblado = s

End function

Si recorremos con esta función los primeros números, obtendremos las primeras soluciones, que ya publicamos en la entrada de hace doce años:

Como era de esperar, este listado ya está publicado en http://oeis.org/A118905:

7, 14, 17, 21, 23, 28, 31, 34, 35, 41, 42, 46, 47, 49, 51, 56, 62, 63, 68, 69, 70, 71, 73, 77, 79, 82, 84, 85, 89, 91, 92, 93, 94, 97, 98, 102, 103, 105, 112, 113, 115, 119, 123, 124, 126, 127, 133, 136, 137, 138, 140, 141, 142, 146, 147, 151, 153, 154, 155, 158, 161, 164, 167, 168, 170, 175, 178, 182, 184, 186, 187, 188

Hemos observado que el número 49 admite dos soluciones, (9, 40, 41) y (21, 28, 35). La primera terna es primitiva, pero la segunda no.

Podemos extraer los primeros números que presentan dos o más soluciones:

El máximo de soluciones de la tabla anterior ha sido 4, pero existen números con más ternas posibles. Por ejemplo, los números 833, 1127, 1519 y 1666 presentan siete.

Aquí deberemos parar un poco. Observando la tabla, es fácil ver que muchas ternas no son primitivas. Si solo nos interesan estas, en la función de más arriba, además de exigir que k = i ^ 2 + j ^ 2 sea un cuadrado, deberemos añadir que estos lados sean primos entre sí, o que su MCD sea 1. Podría quedar así:

Function doblado$(n)

Dim i, j, k, m, p

Dim s$

m = 0

s = ""

For i = 1 To n / 2

j = n - i

k = i ^ 2 + j ^ 2

If escuad(k) Then

p = Sqr(k)

If mcd(i, mcd(j, p)) = 1 Then m = m + 1: s = s + " ##" + Str$(i) + " " + Str$(j) + " " + Str$(p)

End If

Next i

If s = "" Then s = "NO" Else s = Str$(m) + s

doblado = s

End Function

Con esta modificación, obtenemos un listado más restringido:

También estas soluciones están ya publicadas en http://oeis.org/A120681 con distinto orden. En esa misma página se remite a una prueba de que los factores de los números de la lista (la mayoría son primos) tienen factores primos del tipo 8k+1 o 8k-1 (el desarrollo está en http://oeis.org/A001132)

La razón de esta propiedad es que estos números, al ser suma de catetos en una terna primitiva, se pueden escribir de la forma u²-v²+2uv, con u y v primos entre sí y uno de ellos par (ver, por ejemplo Wikipedia). Esto los convierte en soluciones de (u+v)²-2v²=k, es decir una ecuación del tipo x²-2y²=k.

La consideración anterior los convierte también en soluciones de diferencia de catetos, porque u²-v²-2uv=(u-v)²-2v²=2x²-y², es decir, la misma ecuación. Este hecho se refleja en

http://oeis.org/A058529.

Podemos hacer explícita esta equivalencia. Si una suma de catetos proviene de dos valores u y v, su equivalente como diferencia se basa en los valores u+2v, v. Es fácil verlo:

Suma de catetos: (u+v)²-2v²

Diferencia equivalente: (u+2v-v)²-2v²

Es fácil verificarlo con dos ejemplos:

7 es suma de catetos en la terna (3, 4, 5), que corresponde a u=2, v=1. Los valores para que sea diferencia son u+2v=4 y v=1, que forman la terna (2*4*1, 4²-1², 4²+1²,)=(8, 15, 17), en la que la diferencia de catetos es también 7.

Otro ejemplo: En la terna (5, 12, 13), u=3 y v=2 con suma de catetos 17

El equivalente es (7-2)²-2*2*2=17, que es diferencia de catetos en la terna (7²-2², 2*7*2, 7²+2²)=(45, 28, 53), y 45-28=17.

Doblado en hipotenusa y cateto

En lugar de exigir una suma de catetos podemos estar interesados en suma de hipotenusa y un cateto. Para ello bastará cambiar algún signo en los códigos de Excel y PARI y modificar las cotas de los datos. Puede quedar de esta forma:

Function doblado$(n)

Dim i, j, k, m, p

Dim s$

m = 0

s = ""

For i = 1 To n

j = n - i

If j < i And j > 0 Then ‘Acotamos el cateto

k = i ^ 2 - j ^ 2 ‘En lugar de sumar, restamos

If escuad(k) Then

p = Sqr(k)

If mcd(i, mcd(j, p)) = 1 Then m = m + 1: s = s + " ##" + Str$(i) + " " + Str$(j) + " " + Str$(p) ‘Seguimos buscando primitivas

End If

End If

Next i

If s = "" Then s = "NO" Else s = Str$(m) + s

doblado = s

End Function

Al hacer uso del MCD indicamos que deseamos soluciones sobre ternas primitivas. Buscamos números con esta función y los primeros que encontramos son estos:

A primera vista comprobamos que existen muchas más soluciones múltiples. En la imagen ya aparece la primera con 6, el 169.

Otro hecho que se descubre es que todas las soluciones son  cuadrados o dobles de un cuadrado. La razón es sencilla, ya que al sumar una hipotenusa y un cateto en una terna primitiva, podemos encontrarnos con dos posibilidades:

Sumar u²+v²+2uv: En ese caso obtendríamos el cuadrado (u+v)²

Sumar u²+v²+u²-v², lo que os llevaría a 2u², el doble de un cuadrado.

Este razonamiento nos llevaría a pensar, como en el caso de los dos catetos, que estos números también serán diferencias entre hipotenusas y catetos, y en efecto, u²+v²-2uv es un cuadrado y u²+v²-u²+v² el doble de un cuadrado. Esta propiedad se refleja en http://oeis.org/A096033

Doblado en tres lados

El número que consideremos se podrá descomponer en tres lados, es decir, de forma que sea el perímetro de un triángulo rectángulo. Hay varias formas de plantearlo, pero por seguir los métodos de búsqueda anteriores, ampliamos las funciones usadas para que admitan una variable más. La función doblado quedaría así:

Function doblado$(n)

Dim i, j, k, m

Dim s$

m = 0

s = ""

For i = 1 To n - 2 'Llegamos a n-2 buscando la hipotenusa

For j = 1 To i - 1 'Primer cateto

If j < i Then

k = n - i - j 'El otro posible cateto

If i ^ 2 = j ^ 2 + k ^ 2 And k < j And k > 0 Then m = m + 1: s = s + " ##" + Str$(i) + " " + Str$(j) + " " + Str$(k) 'En caso afirmativo, incorporamos a la solución

End If

Next j

Next i

If s = "" Then s = "NO" Else s = Str$(m) + s 'Añadimos número de soluciones

doblado = s

End Function

En este caso, la búsqueda nos devolvería estos primeros resultados:

 Las soluciones se han publicado en  http://oeis.org/A010814

Si incorporamos la condición de que los tres lados, catetos e hipotenusa, sean primos entre sí, obtendremos las soluciones para ternas primitivas, que serán iguales a las anteriores o divisores de ellas, pues es sabido que el perímetro de una terna siempre es múltiplo de otro correspondiente a una primitiva. Lo hemos efectuado así, resultando:

Están publicados en http://oeis.org/A024364

Según los párrafos anteriores, la expresión de estos resultados vendrá dada por u²+v²+u²-v²+2uv=2u²+2uv=2u(u+v), donde u y u+v son primos entre sí. Por ello, si u es par, o lo es u+v, la solución será un número múltiplo de 4, y solo de 2 en caso contrario.

Por ejemplo, en la terna (5, 4, 3), u=2, v=1, u²+v²=5, u²-v²=3 y 2uv=4, el perímetro es 12=5+4+3, y es múltiplo de 4 por ser u par.

Sin embargo, en la terna (13, 12, 5), u=3, v=2, u²+v²=13, u²-v²=5 y 2uv=12. En este caso, u es impar, y u+v también, lo que significa que el perímetro 30 es múltiplo de 2, pero no de 4.

A la vista de los resultados podría parecer que cada solución se corresponde con una sola terna primitiva, pero no es así, pues, por ejemplo, 1716 se corresponde con dos:

1716=725+627+364 y 725^2=627^2+364^2; MCD(725, 627, 364)=1

1716=773+748+195 y 773^2=748^2+195^2; MCD(773, 748, 195)=1

Se puede detectar esto mediante un algoritmo en PARI, similar a este:

for(u=2,30,for(v=1,29,if(gcd(u,v)==1&&(u+v)%2==1&&u>v,write("final.txt",2*u*(u+v)))))

Engendra las soluciones buscando los valores de u y v adecuados.

Vuelca la solución en un archivo, al que hemos dado el nombre de “final.txt”. Las soluciones se escribirán en columna, pero desordenadas. Habrá que copiarlas en una hoja de cálculo, ordenar la columna y detectar los duplicados. Es otra forma de actuar.