I1M2012: Ejercicios de definiciones por comprensión (2)
En la clase de hoy del curso Informática (de 1º de Grado en Matemáticas) se han comentado las soluciones de los ejercicios 4 a 6 de la 4ª relación sobre definiciones por comprensión.
Los ejercicios y sus soluciones se muestran a continuació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 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 |
-- --------------------------------------------------------------------- -- Ejercicio 4. Un entero positivo es perfecto si es igual a la suma de -- sus factores, excluyendo el propio número. -- -- Definir por comprensión la función -- perfectos :: Int -> [Int] -- tal que (perfectos n) es la lista de todos los números perfectos -- menores que n. Por ejemplo, -- perfectos 500 == [6,28,496] -- Indicación: Usar la función factores del tema 5. -- --------------------------------------------------------------------- -- La función factores del tema es factores :: Int -> [Int] factores n = [x | x <- [1..n], n `mod` x == 0] -- La definición es perfectos :: Int -> [Int] perfectos n = [x | x <- [1..n], sum (init (factores x)) == x] -- --------------------------------------------------------------------- -- Ejercicio 5. Un número natural n se denomina abundante si es menor -- que la suma de sus divisores propios. Por ejemplo, 12 y 30 son -- abundantes pero 5 y 28 no lo son. -- --------------------------------------------------------------------- -- Ejercicio 5.1. Definir la función numeroAbundante tal que -- (numeroAbundante n) se verifica si n es un número abundante. Por -- ejemplo, -- numeroAbundante 5 == False -- numeroAbundante 12 == True -- numeroAbundante 28 == False -- numeroAbundante 30 == True -- --------------------------------------------------------------------- divisores:: Int -> [Int] divisores n = [m | m <- [1..n-1], n `mod` m == 0] numeroAbundante:: Int -> Bool numeroAbundante n = n < sum (divisores n) -- --------------------------------------------------------------------- -- Ejercicio 5.2. Definir la función numerosAbundantesMenores tal que -- (numerosAbundantesMenores n) es la lista de números abundantes -- menores o iguales que n. Por ejemplo, -- numerosAbundantesMenores 50 == [12,18,20,24,30,36,40,42,48] -- --------------------------------------------------------------------- numerosAbundantesMenores :: Int -> [Int] numerosAbundantesMenores n = [x | x <- [1..n], numeroAbundante x] -- --------------------------------------------------------------------- -- Ejercicio 5.3. Definir la función todosPares tal que (todosPares n) -- se verifica si todos los números abundantes menores o iguales que n -- son pares. Por ejemplo, -- todosPares 10 == True -- todosPares 100 == True -- todosPares 1000 == False -- --------------------------------------------------------------------- todosPares :: Int -> Bool todosPares n = and [even x | x <- numerosAbundantesMenores n] -- --------------------------------------------------------------------- -- Ejercicio 5.4. Definir la constante primerAbundanteImpar que calcule -- el primer número natural abundante impar. Determinar el valor de -- dicho número. -- --------------------------------------------------------------------- primerAbundanteImpar:: Int primerAbundanteImpar = head [x | x <- [1..], numeroAbundante x, odd x] -- Su cálculo es -- ghci> primerAbundanteImpar -- 945 -- --------------------------------------------------------------------- -- Ejercicio 6 (Problema 1 del proyecto Euler) Definir la función -- euler1 :: Integer -> Integer -- (euler1 n) es la suma de todos los múltiplos de 3 ó 5 menores que -- n. Por ejemplo, -- euler1 10 == 23 -- -- Calcular la suma de todos los múltiplos de 3 ó 5 menores que 1000. -- --------------------------------------------------------------------- euler1 :: Integer -> Integer euler1 n = sum [x | x <- [1..n-1], multiplo x 3 || multiplo x 5] where multiplo x y = mod x y == 0 -- Cálculo: -- ghci> euler1 1000 -- 233168 |
Con motivo del último ejercicio se comentó el proyecto Euler.
Finalmente, se propuso el siguiente problema de la IMO (Olimpíada Internacional de Matemáticas) de 1966:
Calcular los últimos dos dígitos de la suma de las octavas potencias de 100 enteros consecutivos.