I1M2011: 3º examen de la evaluación continua
En la clase de hoy de Informática de 1º del Grado en Matemáticas se ha realizado el 3º examen de la evaluación continua.
A continuación se muestra el examen junto con su solució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 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 |
-- Informática (1º del Grado en Matemáticas) -- 3º examen de evaluación continua (25 de enero de 2012) -- --------------------------------------------------------------------- -- --------------------------------------------------------------------- -- Ejercicio 1.1. [2 puntos] Un número es muy compuesto si tiene más -- divisores que sus anteriores. Por ejemplo, 12 es muy compuesto porque -- tiene 6 divisores (1, 2, 3, 4, 6, 12) y todos los números del 1 al 11 -- tienen menos de 6 divisores. -- -- Definir la función -- esMuyCompuesto :: Int -> Bool -- tal que (esMuyCompuesto x) se verifica si x es un número muy -- compuesto. Por ejemplo, -- esMuyCompuesto 24 == True -- esMuyCompuesto 25 == False -- Calcular el menor número muy compuesto de 4 cifras. -- --------------------------------------------------------------------- esMuyCompuesto :: Int -> Bool esMuyCompuesto x = and [numeroDivisores y < n | y <- [1..x-1]] where n = numeroDivisores x -- (numeroDivisores x) es el número de divisores de x. Por ejemplo, -- numeroDivisores 24 == 8 numeroDivisores :: Int -> Int numeroDivisores = length . divisores -- (divisores x) es la lista de los divisores de x. Por ejemplo, -- divisores 24 == [1,2,3,4,6,8,12,24] divisores :: Int -> [Int] divisores x = [y | y <- [1..x], mod x y == 0] -- Los primeros números muy compuestos son -- ghci> take 14 [x | x <- [1..], esMuyCompuesto x] -- [1,2,4,6,12,24,36,48,60,120,180,240,360,720] -- El cálculo del menor número muy compuesto de 4 cifras es -- ghci> head [x | x <- [1000..], esMuyCompuesto x] -- 1260 -- --------------------------------------------------------------------- -- Ejercicio 1.2. [1 punto] Definir la función -- muyCompuesto :: Int -> Int -- tal que (muyCompuesto n) es el n-ésimo número muy compuesto. Por -- ejemplo, -- muyCompuesto 10 == 180 -- --------------------------------------------------------------------- muyCompuesto :: Int -> Int muyCompuesto n = [x | x <- [1..], esMuyCompuesto x] !! n -- --------------------------------------------------------------------- -- Ejercicio 2.1. [2 puntos] [Problema 37 del proyecto Euler] Un número -- primo es truncable si los números que se obtienen eliminado cifras, -- de derecha a izquierda, son primos. Por ejemplo, 599 es un primo -- truncable porque 599, 59 y 5 son primos; en cambio, 577 es un primo -- no truncable porque 57 no es primo. -- -- Definir la función -- primoTruncable :: Int -> Bool -- tal que (primoTruncable x) se verifica si x es un primo -- truncable. Por ejemplo, -- primoTruncable 599 == True -- primoTruncable 577 == False -- --------------------------------------------------------------------- primoTruncable :: Int -> Bool primoTruncable x | x < 10 = primo x | otherwise = primo x && primoTruncable (x `div` 10) -- (primo x) se verifica si x es primo. primo :: Int -> Bool primo x = x == head (dropWhile (<x) primos) -- primos es la lista de los números primos. primos :: [Int ] primos = criba [2..] where criba :: [Int] -> [Int] criba (p:xs) = p : criba [x | x <- xs, x `mod` p /= 0] -- --------------------------------------------------------------------- -- Ejercicio 2.2. [1.5 puntos] Definir la función -- sumaPrimosTruncables :: Int -> Int -- tal que (sumaPrimosTruncables n) es la suma de los n primeros primos -- truncables. Por ejemplo, -- sumaPrimosTruncables 10 == 249 -- Calcular la suma de los 20 primos truncables. -- --------------------------------------------------------------------- sumaPrimosTruncables :: Int -> Int sumaPrimosTruncables n = sum (take n [x | x <- primos, primoTruncable x]) -- El cálculo es -- ghci> sumaPrimosTruncables 20 -- 2551 -- --------------------------------------------------------------------- -- Ejercicio 3.1. [2 puntos] Los números enteros se pueden ordenar como -- sigue -- 0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5, -6, 6, -7, 7, ... -- Definir la constante -- enteros :: [Int] -- tal que enteros es la lista de los enteros con la ordenación -- anterior. Por ejemplo, -- take 10 enteros == [0,-1,1,-2,2,-3,3,-4,4,-5] -- --------------------------------------------------------------------- enteros :: [Int] enteros = 0 : concat [[-x,x] | x <- [1..]] -- Otra definicición, por iteración, es enteros_1 :: [Int] enteros_1 = iterate siguiente 0 where siguiente x | x >= 0 = -x-1 | otherwise = -x -- --------------------------------------------------------------------- -- Ejercicio 3.2. [1.5 puntos] Definir la función -- posicion :: Int -> Int -- tal que (posicion x) es la posición del entero x en la ordenación -- anterior. Por ejemplo, -- posicion 2 == 4 -- --------------------------------------------------------------------- posicion :: Int -> Int posicion x = length (takeWhile (/=x) enteros) -- Definición por recursión posicion_1 :: Int -> Int posicion_1 x = aux enteros 0 where aux (y:ys) n | x == y = n | otherwise = aux ys (n+1) -- Definición por comprensión posicion_2 :: Int -> Int posicion_2 x = head [n | (n,y) <- zip [0..] enteros, y == x] -- Definición directa posicion_3 :: Int -> Int posicion_3 x | x >= 0 = 2*x | otherwise = 2*(-x)-1 |