He aquí una función que escribe los números naturales menores que otro prefijado y dado, t,

Transcripción

1 natural Llamamos números naturales a los que usamos para contar objetos de cualquier naturaleza: 1, 2, 3,. Se suele considerar al 1 como el primer número natural. El 2 se obtiene sumando 1 al 1, y continuando este proceso indefinidamente. He aquí una función que escribe los números naturales menores que otro prefijado y dado, t, def naturales(t): # escribe naturales menores que t > 0 print n, Para ver los naturales menores de 100, por ejemplo, añadimos, bajo el código de la función la siguiente sentencia y ejecutamos el programa, naturales(100) Si en lugar de que la función escriba directamente los números, queremos que los retorne en un arreglo, la modificamos, def naturales(t): # naturales menores que t > 0 nn = [] # números naturales nn.append(n) return nn Para ver los números naturales menores que 100, por ejemplo, debajo del código de esta función añadimos la sentencia, print naturales(100) En lo adelante, salvo casos muy especiales que lo ameriten, una función no escribirá los resultados que obtenga, sino que los retornará, dejando así al programador que use la función, la libertad de usar los valores retornados a su conveniencia. Por ejemplo, la diferencia entre el máximo de los naturales obtenidos para t = 100 (99) se puede obtener con la sentencia, print max(naturales(100)) ecabrera, sdqdr, septiembre

2 par Los números naturales pares son 2, 4, 6,.. A partir del 2, cada par siguiente se obtiene sumando 2 al par anterior. Una función que obtiene los naturales pares menores que un t >0, prefijado, def pares(t): # pares menores que t > 2 p = 2 # par np = [] # pares while p < t: np.append(p) p = p + 2 return np Notamos que se asume que el programador que invoca esta función en su código le pasa un valor de 3 en adelante, como indica el comentario. Si esto no se cumple, no hay garantía del comportamiento correcto de la función. Como la función lo asume, no lo verifica, pues se deja como tarea al programador que use la función correctamente. Si lo verificara, entonces no lo estaría asumiendo, lo cual sería una contradicción. Al invocar y ejecutar la función par() para t = 100, con la sentencia print pares(100), obtenemos [2, 4,,96, 98], que son los naturales pares menores que 100. Otra forma en que podemos obtener los pares naturales menores que t > 2, es generando todos los naturales menores que 100 y tomando sólo los que dejan un residuo 0 al dividirlo por 2, def pares(t): # pares menores que t > 2 p = [] # pares while p < t: if n%2 == 0: np.append(n) Esta forma de obtener pares es más lenta que la anterior, pero tiene la ventaja de que podemos generalizarla más fácil para una amplia variedad de problemas. Por ahora la eficiencia no es prioritaria. Veamos los múltiplos de 3 menores que t, def multitres(t): # múltiplos de 3 menores que t > 3 m = [] # múltiplos if n%3 == 0: m.append(n) return m ecabrera, sdqdr, septiembre

3 múltiplo Los pares son naturales múltiplos de 2, y para determinar si un natural es múltiplo de 2 verificamos si el residuo de n con respecto a 2 es 0, if n%2 == 0, y lo propio para ver si es múltiplo de 3. Entonces demos el salto y redactemos una función que obtenga los múltiplos de k menores que t > 0, con k < t, def multiplos(k, t): # múltiplos de k menores que t > 0, m < t m = [] # múltiplos if n%k == 0: m.append(n) return m Para k = 5 probamos la función con print múltiplos(5, 100), que nos da [5, 10,,90, 95], los múltiplos de 5 menores que 100, como queremos. Ahora podemos invocar la función con distintos valores de k y de t, siempre que k < t y t > 0. Supongamos que queremos obtener la suma de los múltiplos de 3 ó de 5 que son menores que t > 0, def multiplosij(i, j, t): # suma múltiplos de i ó de j menores que t > 0; i < j < t > 0 s = 0 # suma if n%i == 0: s = s + n if n%j == 0: s = s + n return s Si probamos esta función con print multiplosij(3, 5, 20) da 93, que es erróneo. Y el error está en que 15 se suma dos veces porque es múltiplo de 3 y de 5. Esto se corrige sumando los valores múltiplos de i y de j una sola vez, def multiplosij(i, j, t): # suma múltiplos de i ó de j menores que t > 0; i < j < t > 0 s = 0 # suma if n%i == 0 or n%j == 0: s = s + n return s Ahora tenemos 78, el valor correcto, pues números como 15, se suman una sola vez. ecabrera, sdqdr, septiembre

4 factor Cuando decimos que n es múltiplo de m, también es cierto que m es un factor de n. Por ejemplo, 15 es múltiplo de , por lo que son factores de 15. Si excluimos a 15 de la lista de factores, llamamos factores propios a los otros porque son factores menores que el número, y se dice que son propios. Una función que obtiene la suma de los factores propios de un natural n, def sumafactores(n): # suma factores propios de n > 1 s = 0 # suma d = 1 # divisor while d < n: s = s + d return s Un natural es deficiente si es mayor que la suma de sus factores propios, def deficiente(n): # si n > 1 es deficiente d = 0 # deficiente if n > sumafactores(n): d = 1 return d Se asume que n no es deficiente asignando 0 (falso) a d, pero si resulta que n es mayor que la suma de sus factores propios, se cambia la d a 1 (verdadero) significando que n resultó ser deficiente. Se dice que un número es perfecto si es igual a la suma de sus factores propios, como sucede con 6 = También 28 = , es perfecto. Una función que obtiene los perfectos menores que t, def perfectos(t): # perfectos menores que t > 0 p = [] # perfectos if sumafactores(n) == 0: p.append(n) Al probar esta función con print perfectos(1000) produce [6, 28, 496], que muestra que los perfectos son algo escasos entre los naturales. Por ejemplo, hasta sólo hay 4: [6, 28, 496, 8128]. Si se prueba esta función hasta t = se tiene que esperar un buen rato para ver los perfectos obtenidos. Por cierto, 496 y 8128 tienen ambos la suma de sus dígitos igual a 19. Conduciría esto a una conjetura útil sobre los números perfectos? ecabrera, sdqdr, septiembre

5 amigables Se dice que dos números naturales, a y b, son una pareja de números amigables si la suma de los factores propios de a es igual a b y la suma de los factores propios de b es igual a b, con a b (porque en tal caso a y b no forman una pareja, sino que se trata de un número perfecto solitario). Una función que obtiene la suma de las parejas de números amigables menores que t > 1, def amigables(t): # amigables menores t > 1 a = [] # amigables if amigable(n, t): a.append(n) return a Se recorren todos los naturales menores que t y cada uno es enviado a la función amigable() que también recibe a t, ya que si n tiene un amigable que es mayor que t, la pareja no está completa y por tanto n no debe incluirse. La función amigable() podría ser, def amigable(n, t): # si n tiene un amigable menor que t > 1 a = 0 # amigable b = sumafactores(n) c = sumafactores(b) if n == c and n <> b and b < t: a = 1 return a Como c es la suma de los factores propios de n, si n y c son iguales, hay chance de que n tenga un amigable, que sería b. Pero n tiene que ser distinto de b, porque entonces n sería perfecto por ser igual a la suma de sus factores propios y entonces n tendría amigable. Pero b, el posible amigable de n debe ser menor que t para que la pareja esté completa. Si probamos esta función con print amigables(10000), produce [220, 284, 1184, 1210, 2620, 2924, 5020, 5564, 6232, 6368], donde pareciera que las parejas están en orden, pero no es seguro, porque los valores de n se van añadiendo uno a uno, pero la pareja se va ignorando hasta que sea encontrada más tarde. Esto se puede investigar usando la función sumafactores(). Un problema interesante relacionado con éste es encontrar las cadenas de números amigables, en que a es amigable de b, b de c, y de c de a. En tal caso a, b y c forman una cadena de 3 números amigables. Podría ser fascinante explorar qué tan largas pueden ser estas cadenas y que números las conforman. ecabrera, sdqdr, septiembre

6 primo Se dice que un número natural n es primo si tiene exactamente dos divisores, 1 y n. El 1 no es primo porque tiene sólo un divisor, 1. Los primeros 10 naturales primos son Para determinar si n es primo mostramos que no tiene otro factor aparte de 1. También podemos mostrar que no es primo mostrando que tiene al menos un factor propio aparte del 1. Elegimos la segunda forma, def primo(n): # si n es primo, n > 1 p = 1 # primo d = 2 # divisor while p and d < n: return n Se asume que n es primo asignando 1 a p. Se inicia d en 2 y se mantiene menor que n porque todo natural es divisible por 1 y por n. Pero si para alguno d n%2 es cero, entonces hemos encontrado un factor propio de n que no es 1, y concluimos que n no es primo asignando 0 a p. El ciclo se abandona luego de incrementar a d porque entonces ya p es falso. Si probamos esta función con print primo(5) y print primo(6), nos da 1 y 0, indicando que 5 es primo y 6 no. Pero sabemos que si n es par n/2 es factor de n ya que n(n/2) = n, por lo que n/2 es el máximo factor propio de n. Si n no es par, sino, digamos, múltiplo de 3, entonces n(n/3) = n, y entonces el máximo factor propio de n seria n/3, menor que n/2. Y cuanto mayor el menor factor propio, menor el mayor factor propio. Por tanto, no hay factores propios de n mayores que n/2. Esto permite mejorar la función primo, def primo(n): # si n es primo, n > 1 p = 1 # primo d = 2 # divisor while p and d <= n/2: return n También sabemos que el máximo factor primo de n es menor o igual a la raíz cuadrada de n. Por ejemplo, el máximo factor de 360 es 180 = 360/2. Pero 180 es múltiplo de 5, que es el máximo factor primo de 360. Por tanto, no tiene objeto buscar factores propios de n mayores que raíz cuadrada de n. Y esto nos permite acelerar aún más la función primo, como haremos a seguidas. ecabrera, sdqdr, septiembre

7 primos Una función mejorada para determinar si el natural n > 1 es primo, def primo(n): # si n es primo, n > 1 p = 1 # primo d = 2 # divisor while p and d <= n**0.5: Notemos que en la primera versión de primo() d podía llegar hasta n-1, en la segunda a n/2 y ahora a raíz cuadrada de n (n**0.5). Esto significa que si n es , en la primera podía llegar hasta , en la segunda a , y ahora tan sólo a Una ganancia considerable. Mejorado la función primo() antes de redactar una función que obtenga los primos menores que t > 1, def primos(t): # primos menores que t > 1 n = 2 # natural p = [] # primos if primo(n): p.append(n) Notemos la restricción de que t>1 y n empieza en 2, no en 1. Sabemos que 1 no es primo, pero si inadvertidamente se pasa 1 a primos(), se podría pasar 1 a primo(), y entonces se obtendría que 1 es primo según primos() ya que primo() asume que n>1 y retornaría 1 para n = 1 ya que el ciclo se salta y s retorna el valor por omisión, 1. Pero esto es incorrecto. Por tanto, lo que procede es habilitar a primo() para que en caso de n = 1, retorne falso, def primo(n): # si n es primo, n > 0 p = 1 # primo d = 2 # divisor if n < 2: while p and d <= n**0.5: Ahora primo() funciona correctamente para todo n natural. Y podemos empezar con n = 1 en primos(). ecabrera, sdqdr, septiembre

8 primeros Consideramos la función primos() para obtener los primos menores que t>1. Consideremos una función que obtenga los primeros t>1 primos, un enunciado distinto, def primprimos(t): # primeros t>1 primos c = 0 # cantidad p = [] # primos while c < t: if primo(n): p.append(n) c = c + 1 Si probamos print primos(10) nos da [2, 3, 5, 7], que son los primos menores que 10. Pero si probamos print primprimos(10) nos da [2, 3, 5, 7, 11, 13, 17, 19, 23, 29], que son los primeros 10 primos. En primos() hay un solo contador, n, que obtiene los naturales que se va verificar si son primos. En primprimos() hay un segundo contador, c, para contar cuántos primos se han encontrado y el ciclo no concluye hasta encontrar t primos, y c solo se incrementa cuando aparece un primo, mientras que n se incrementa cada vez que se ejecuta el ciclo. Consideremos la función primeros(), que obtiene los primeros t naturales que cumplen una propiedad cuyo nombre le pasemos como parámetro y que corresponda a una función existente que determine si un natural la cumple, def primeros(t, propiedad): # primeros t>1 cumplen propiedad c = 0 # cantidad a = [] # arreglo de los que cumplen while c < t: if propiedad(n): a.append(n) c = c + 1 return a Si probamos esta función con print primeros(10, primo) nos da [2, 3, 5, 7, 11, 13, 17, 19, 23, 29], que son los primeros 10 primos. Pero si la probamos con print primeros(4, perfecto) nos da [6, 28, 496, 8128], que son los primeros 4 perfectos, generalizando la obtención de los primeros naturales que cumplen una propiedad especificada disponible. A esto se le llama esquema. ecabrera, sdqdr, septiembre

9 perfecto Se habrá notado que para la función primeros() asumimos que existía la función perfecto(), la cual no hemos discutido, sino que al discutir la función perfectos() usamos el hecho de que si n = sumafactores(n), n es perfecto, pero no llegamos a redactar la función perfecto() propiamente dicha, def perfecto(n): # si n > 1 es perfecto # perfecto if n == sumafactores(n): p = 1 Este código implementa un abordaje de fuerza bruta ya que se determina si n es perfecto calculando la suma de los factores propios de n, lo cual vimos que es muy intenso para obtener más allá del cuarto perfecto, pero esa es la forma que adoptamos por ahora. Hay otras propiedades de los números naturales que discutiremos en otro momento. Basten las presentadas hasta ahora para abrir el apetito del lector para investigar por su cuenta éstas y otras que andan por ahí. Aquí terminan los apuntes disponibles sobre propiedades de los números naturales. ecabrera, sdqdr, septiembre