último Una función que obtiene la suma de los dígitos de n>0:

Transcripción

1 último Si tomamos el residuo de n natural respecto a 2, n%2, los posibles resultados son 0, 1. Si lo hacemos con respecto a 3, tenemos 0, 1, 2. Y si lo hacemos con respecto a 10, tenemos 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. De hecho, n%10 nos el ultimo digito actual de n, porque cualquier digito de n es siempre menor que 10, incluyendo el último, por lo que el residuo con respecto a 10 es lo que sobra al dividir por 10. Este hecho tan simple en apariencia resulta de una utilidad difícil de exagerar, como veremos. Por otro lado, n/10, nos da el cociente entero de n sobre 10, por lo que obtenemos el mismo n, pero sin el último dígito, ya dividir n por 10 se corre el punto decimal una posición a la izquierda, quedando una parte decimal constituida precisamente por lo que era el último dígito, que se trunca ya que n/10 es un número entero. Una función que obtiene la suma de los dígitos de n>0: def sumadigitos(n): # suma dígitos de n>0 s = s + n%10, return s Se inicia la s en cero y el ciclo una vez por cada digito de n ya que cada vez se remplaza n por n/10, que corta; el ultimo dígito actual de n. Cuando ya no quedan más dígitos a n, se abandona el ciclo, pero ya en s están acumulada la suma de los dígitos de n, en orden inverso, pero exacta ya que la suma es conmutativa. Si se prueba esta función con print sumadigitos(1234) nos da 10, que la suma de Podemos calcular la suma de los cubos de los dígitos de n, def sumacubosdigitos(n): # suma cubos dígitos de n>0 u = n%10 s = s + u**3, return s Si probamos esta función con print sumacubosdigitos(1) da 1, que es el caso trivial. Y con print sumacubosdigitos(350) da 152. Pero es curioso que sumacubosdigitos(370)da 370 y sumacubosdigitos(371) da 371, pues significa que estos 1, 370 y 371 se reflejan en la suma de los cubos de sus dígitos. A estos números se les llama cubos narcisistas. Y se dice que solo hay cinco cubos narcisistas en todo el universo conocido. ecabrera, sdqdr, septiembre

2 narcisistas Una función que determine si n es un cubo narcisista, def narcisista (n): # si n>0 es un cubo narcisista c = 0 # cubo narcisista if n == sumacubosdigitos(n): c = 1 return c Los cinco narcisistas los podemos obtener con la función esquema, primeros() con print primeros(5, narcisista), que da [1, 153, 370, 371, 407]. Por lo que ciertamente es ventajoso disponer de este esquema, y otros que veremos para explorar la matemática con Python. Si se intenta primeros(6, narcisista)la computadora se queda buscando indefinidamente porque, como dijimos, sólo hay cinco cubos narcisistas. Generalicemos sumacubosdigitos() para una potencia p, def sumapotenciadigitos(n, p): # suma potencias p de dígitos de n>0 u = n%10 s = s + u**p, return s Los cubos narcisistas son un caso especial de los llamados invariantes digitales, def invariante(n, p): # si n>0 es un invariante digital i = 0 # invariante if n == sumapotenciadigitos(n, p): i = 1 return i Pero no podemos usar directamente el esquema primeros() porque la propiedad invariante tiene dos parámetros y no uno. Asi que adaptamos primeros() para dos parámetros, def primeros2(t, propiedad, p): # primeros t>1 cumplen propiedad con 2do parámetro p n = 1 # natural c = 0 # cantidad a = [] # arreglo de los que cumplen while c < t: if propiedad(n, p): a.append(n) c = c + 1 n = n + 1 return a ecabrera, sdqdr, septiembre

3 invariantes Si probamos print primeros2(5, invariante, 3) queremos obtener los primeros 5 invariantes con potencia 3, es decir, los primeros 5 narcisistas. Pero si probamos print primeros2(3, invariante, 4) entramos en terreno desconocido porque queremos los primeros 3 invariantes con potencia 4, que nos da [1, 1634, 8208]! Podemos probar aumentando poco a poco el primer parámetro hasta que el programa se detenga mucho tiempo. Con 5 se detuvo, pero print primeros2(4, invariante, 4) da [1, 1634, 8208, 9474], que son los primeros invariantes digitales para p = 4. El que el programa se detenga no significa necesariamente que no hay más invariantes digitales para p = 4, pero sí que al menos están muy distantes de Habría que probar formalmente si no hay más invariantes digitales para p = 4, pero eso escapa al objetivo de este texto. Mientras tanto, podemos probar con valores mayores de p y ver qué sucede. Sorprendentemente, print primeros2(7, invariante, 5) da [1, 4150, 4151, 54748, 92727, 93084, ], lo que podría significar que hay más invariantes digitales para p = 5 que para p = 4. Ssi dispone de acceso a una súper computadora, sus exploraciones empíricas se vuelven más interesantes pues el tiempo de espera se reduce significativamente. Una regla que parece emerger de lo poco mostrado aquí es que el número de los primeros invariantes digitales es mayor para p impar que impar. bueno Se dice que un número natural es bueno si la cantidad de unos que tiene en su expansión en base 2, binario, es impar. Según esto, 1 = 1b, 2 = 10b, 4 = 100b, 7 = 111b, 8 = 1000b, son los primeros 5 números buenos. Una función que determina si n>0 es bueno, def bueno(n): # si n es bueno (número impar de 1s en binario) b = 0 # bueno c = 0 # cantidad de 1s if n%2: c = c + 1 n = n/2 if c%2: b = 1 return b Se asume que n no es bueno y que la cantidad inicial de 1s es cero. En el ciclo se incrementa a c cuando n%2 es verdadero,1. Al abandonar el ciclo se cambia la premisa a verdadero, b = 1, si resulta que c%2 es 1, verdadero. Con el esquela podríamos encontrar los números buenos menores que t>0, y con otro los primeros m números buenos. ecabrera, sdqdr, septiembre

4 volteado Diremos que el número natural v es el volteado de n si v tiene los mismos dígitos que n pero en orden inverso. Si n es 1234, el volteado de n es Una función que voltea a n, def volteado(n): # voltea a n (mismos dígitos en orden inverso) v = 0 # volteado v = 10*v + n%10 return v Se inicia v en 0 y en el ciclo, para cada dígito de n, n%10, el valor anterior de v se multiplica por 10 para colocarle un cero al final y al sumarle el ultimo digito actual de n, se va siendo el volteado de n ya los dígitos de n van cayendo en orden inverso. palíndromo Decimos que un número natural es palíndromo si se lee igual en ambas direcciones, estos es, si coincide con su volteado. Una función que determina si n es palíndromo, def palindromo(n): # si n es palíndromo (se lee igual en ambos sentidos) p = 0 # palíndromo if n == volteado(n): p = 1 return p Claro, no hace falta redactar una función para determinar si n es palíndromo, ya que n == volteado(n) es verdadera si esto ocurre. palíndromo Si empezamos con un número natural, digamos 197 y le sumamos su volteado, obtenemos, = 988; = 1877; = 9658; = 18227; = 90508; = = [8 pasos]. Detenemos el proceso por llegamos a un palíndromo, Una función que empezando con un natural n obtiene el palíndromo al que se arriba y la cantidad de sumas a realizar de n con su reverso en cada etapa, def volteasuma(n): # palindromo y pasos reversando y sumando p = 0 # pasos s = 1 # sigue while s: n = n + volteado(n) if n = volteado(n) s = 0 p = p + 1 return n, p ecabrera, sdqdr, septiembre

5 factorial Se dice que 0! = 1! = 1, y para n> 1, n! = 1(2) (n-1)n. Una función que obtiene n!, n 0, def factorial(n): # n! (n factorial) f = 1 # factorial f = f*n n = n - 1 return f Para n = 0 el ciclo se salta porque 0 no es mayor que 0, porque f es f, que es correcto. Para n > 0, se entra al ciclo. Si n = 1, se ejecuta una vez porque 1 1 = 0 en una ejecución, y f = 1, que es correcto. Para valores de n mayores que 1 se acumula en f el producto 1(n)(n-1) 1, que es correcto. Si queremos determinar si un número natural es igual a la suma de los factoriales de sus dígitos, como algunos dígitos se repiten y nunca vamos a necesitar un factorial mayor a 9!, podemos pre-calcular los factoriales de los dígitos de 0 a 9, def factodigs(): # factoriales dígitos de 0 a 9 f = [1 for i in range(10)] # factorials i = 0 # índice while i < 10: f[i] = factorial(i) i = i + 1 return f Se retorna un arreglo, f, con los factoriales de los dígitos de 0 a 9. Se puede calcular más rápido si se hacen 1 factorial de 0 y de ahí en adelante se van asignando a cada posición el producto acumulado, def factodigs(): # factoriales dígitos de 0 a 9 f = [1 for i in range(10)] # factoriales p = 1 # producto i = 2 # índice while i < 10: p = p * i f[i] = p i = i + 1 return f Se coloca un 1 en cada posición de f, se inicia p en 1 y el índice en 2. Entonces en el ciclo se van calculando los factoriales en p mediante productos sucesivos que se van guardando en f. No se requiere, por tanto, la función factorial() y cada factorial no se tiene que calcular desde cero cada vez, logrando mayor eficiencia. ecabrera, sdqdr, septiembre

6 factoriales Una función que determina si un natural es igual a la suma de los factoriales de sus dígitos podría ser, def sisumfacdig(n): # si n es igual a suma factoriales de sus dígitos c = 0 # cumple r = n # respaldo de n f = factodigs() s = s + f[n%10] if r == s: c = 1 return c Si deseamos obtener los naturales menores que t > 0 que son iguales a la suma de los factoriales de sus dígitos, def sumfacdigs(t): # naturales iguales a suma factoriales de sus dígitos menores que t > 0 sf = [] # suma igual a factoriales sus dígitos n = 10 # natural while n < t: if sisumfacdig(n): sf.append(n) n = n + 1 return sf Para t = cumplen [145, 40585]. Estos números parecen escasos. Aquí terminan los apuntes disponibles sobre tratamiento de dígitos. ecabrera, sdqdr, septiembre