Definir la función
agrupa :: Ord c => (a -> c) -> [a] -> Map c [a]
tal que (agrupa f xs) es el diccionario obtenido agrupando los elementos de xs según sus valores mediante la función f. Por ejemplo,
λ> agrupa length ["hoy", "ayer", "ana", "cosa"] fromList [(3,["hoy","ana"]),(4,["ayer","cosa"])] λ> agrupa head ["claro", "ayer", "ana", "cosa"] fromList [('a',["ayer","ana"]),('c',["claro","cosa"])]
Los 15 primeros números primos son
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47
Las distancias entre los elementos consecutivos son
1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4
La distribución de las distancias es
(1,1), (2,6), (4,5), (6,2)
(es decir, el 1 aparece una vez, el 2 aparece 6 veces, etc.) La frecuencia de las distancias es
(1,7.142857), (2,42.857143), (4,35.714287), (6,14.285714)
(es decir, el 1 aparece el 7.142857%, el 2 el 42.857143% etc.)
Definir las funciones
cuentaDistancias :: Int -> [(Int,Int)] frecuenciasDistancias :: Int -> [(Int,Float)] graficas :: [Int] -> IO () distanciasMasFrecuentes :: Int -> [Int]
tales que
λ> cuentaDistancias 15 [(1,1),(2,6),(4,5),(6,2)] λ> cuentaDistancias 100 [(1,1),(2,25),(4,26),(6,25),(8,7),(10,7),(12,4),(14,3),(18,1)]
λ> frecuenciasDistancias 15 [(1,7.142857),(2,42.857143),(4,35.714287),(6,14.285714)] λ> frecuenciasDistancias 30 [(1,3.4482758),(2,34.482758),(4,34.482758),(6,24.137932),(8,3.4482758)]
(graficas [10,20,30]) dibuja
(graficas [x*10^3 | x <- [1,2,3]]) dibuja
y (graficas [x*10^5 | x <- [1,2,3]]) dibuja
distanciasMasFrecuentes 15 == [2] distanciasMasFrecuentes 26 == [2,4] distanciasMasFrecuentes 32 == [4] distanciasMasFrecuentes 41 == [2,4,6] distanciasMasFrecuentes 77 == [6] distanciasMasFrecuentes 160 == [4,6]
Comprobar con QuickCheck si para todo n > 160 se verifica que (distanciasMasFrecuentes n) es [6].
Las rotaciones de 928160 son 928160, 281609, 816092, 160928, 609281 y 92816. De las cuales, las divisibles por 4 son 928160, 816092, 160928 y 92816.
Definir la función
nRotacionesDivisibles :: Integer -> Int
tal que (nRotacionesDivisibles n) es el número de rotaciones del número n divisibles por 4. Por ejemplo,
nRotacionesDivisibles 928160 == 4 nRotacionesDivisibles 44 == 2 nRotacionesDivisibles (1234^50000) == 38684 nRotacionesDivisibles (1234^300000) == 231853
Un número natural n es una potencia perfecta si existen dos números naturales m > 1 y k > 1 tales que n = m^k. Las primeras potencias perfectas son
4 = 2², 8 = 2³, 9 = 3², 16 = 2⁴, 25 = 5², 27 = 3³, 32 = 2⁵, 36 = 6², 49 = 7², 64 = 2⁶, ...
Definir la sucesión
potenciasPerfectas :: [Integer]
cuyos términos son las potencias perfectas. Por ejemplo,
take 10 potenciasPerfectas == [4,8,9,16,25,27,32,36,49,64] potenciasPerfectas !! 100 == 6724
Definir el procedimiento
grafica :: Int -> IO ()
tal que (grafica n) es la representación gráfica de las n primeras potencias perfectas. Por ejemplo, para (grafica 30) dibuja
!Potencias perfectas](/images/Potencias_perfectas.png)
El número 6 se puede descomponer de 4 formas distintas como suma con sumandos distintos:
6 = 1 + 2 + 3 6 = 1 + 5 6 = 2 + 4 6 = 6
y también se puede descomponer de 4 formas distintas como suma con sumandos impares:
6 = 1 + 1 + 1 + 1 + 1 + 1 6 = 1 + 1 + 1 + 3 6 = 1 + 5 6 = 3 + 3
Definir las siguientes funciones
sumasSumandosDistintos :: Integer -> [[Integer]] nSumasSumandosDistintos :: Integer -> Int sumasSumandosImpares :: Integer -> [[Integer]] nSumasSumandosImpares :: Integer -> Int igualdadDeSumas :: Integer -> Bool
tales que
sumasSumandosDistintos 5 == [[1,4],[2,3],[5]] sumasSumandosDistintos 6 == [[1,2,3],[1,5],[2,4],[6]]
nSumasSumandosDistintos 6 == 4 nSumasSumandosDistintos 7 == 5
sumasSumandosImpares 5 == [[1,1,1,1,1],[1,1,3],[5]] sumasSumandosImpares 6 == [[1,1,1,1,1,1],[1,1,1,3],[1,5],[3,3]]
nSumasSumandosImpares 6 == 4 nSumasSumandosImpares 7 == 5
igualdadDeSumas 40 == True
Una progresión aritmética es una sucesión de números tales que la diferencia de dos términos sucesivos cualesquiera de la sucesión es constante.
Definir la función
ausente :: Integral a => [a] -> a
tal que (ausente xs) es el único término ausente de la progresión aritmética xs. Por ejemplo,
ausente [3,7,9,11] == 5 ausente [3,5,9,11] == 7 ausente [3,5,7,11] == 9 ausente ([1..9]++[11..]) == 10 ausente2 ([1..10^6] ++ [2+10^6]) == 1000001
Nota. Se supone que la lista tiene al menos 3 elementos, que puede ser infinita y que sólo hay exactamente un término de la progresión aritmética que no está en la lista.
El problema del reciclado del reciclado N P consiste en lo siguiente: un grupo de personas disponen de N botellas de refresco vacía y las llevan a reciclar obteniendo una botella llena por cada P vacías; se beben inmediatamente el contenido de las botellas obtenidas y sus botellas vacías, junto con las no recicladas anteriormente, las canjean por botellas llenas. El proceso continúa hasta que no tienen suficientes botellas para canjear. El objetivo del problema es calcular el número de botellas que se han bebido.
Por ejemplo, si disponen de 10 botellas y por cada 2 obtienen 1, se producen cuatro canjeos:
Por tanto, se han bebido 9 y le quedan 1 que no pueden canjear.
Definir la función
reciclado :: Int -> Int -> Int
tal que (reciclado n p) es el número de botellas que se beben en el reciclado comenzado con n botellas y canjeando p botellas vacías por una llena. Por ejemplo,
reciclado 9 3 == 4 reciclado 10 2 == 9
Dada una lista de cadenas ordenadas por longitud, se puede ordenar de manera simétrica colocando la primera cadena en primer lugar, la segunda en el último, la tercera en el segundo, la cuarta en el penúltimo y así sucesivamente.
Por ejemplo, dada la lista
Pi Eva Luis Paula Alberto Francisco
su ordenación simétrica es
Pi Luis Alberto Francisco Paula Eva
Definir la función
simetrica :: [String] -> [String]
tal que (simetrica xs) es la ordenación simétrica de la lista de cadenas (ordenada por longitud) xs. Por ejemplo,
λ> simetrica ["Pi","Eva","Luis","Paula","Alberto","Francisco"] ["Pi","Luis","Alberto","Francisco","Paula","Eva"] λ> minimum $ simetrica2 [replicate k 'a' | k <- [1..2*10^6]] "a"
Nota: Este ejercicio está basado en el problema Symmetric order de Kattis.
Un mapa con dos tipos de regiones (por ejemplo, tierra y mar) se puede representar mediante una matriz de ceros y unos.
Para los ejemplos usaremos los mapas definidos por
type Punto = (Int,Int) type Mapa = Array Punto Int mapa1, mapa2 :: Mapa mapa1 = listArray ((1,1),(3,4)) [1,1,0,0, 0,1,0,0, 1,0,0,0] mapa2 = listArray ((1,1),(10,20)) [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0, 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1, 0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
Definir las funciones
alcanzables :: Mapa -> Punto -> [Punto] esAlcanzable :: Mapa -> Punto -> Punto -> Bool
tales que
alcanzables mapa1 (1,1) == [(2,2),(1,2),(1,1)] alcanzables mapa1 (1,2) == [(2,2),(1,1),(1,2)] alcanzables mapa1 (1,3) == [(3,2),(3,4),(3,3),(2,3),(2,4),(1,4),(1,3)] alcanzables mapa1 (3,1) == [(3,1)]
esAlcanzable mapa1 (1,4) (3,2) == True esAlcanzable mapa1 (1,4) (3,1) == False esAlcanzable mapa2 (2,3) (8,16) == True esAlcanzable mapa2 (8,1) (7,3) == True esAlcanzable mapa2 (1,1) (10,20) == False
Nota: Este ejercicio está basado en el problema 10 kinds of people de Kattis.
Definir las funciones
nDigitosFact :: Integer -> Integer graficas :: [Integer] -> IO ()
tales que
nDigitosFact 0 == 1 nDigitosFact 4 == 2 nDigitosFact 5 == 3 nDigitosFact 10 == 7 nDigitosFact 100 == 158 nDigitosFact 1000 == 2568 nDigitosFact 10000 == 35660 nDigitosFact 100000 == 456574 nDigitosFact 1000000 == 5565709
Nota: Este ejercicio está basado en el problema How many digits? de Kattis en donde se impone la restricción de calcular, en menos de 1 segundo, el número de dígitos de los factoriales de 10.000 números del rango [0,1.000.000].
Se puede simular como sigue
λ> import System.Random λ> xs <- sequence [randomRIO (0,10^6) | _ <- [1..10^3]] λ> maximum (map nDigitosFact4 xs) 5561492 λ> xs <- sequence [randomRIO (0,10^6) | _ <- [1..10^3]] λ> maximum (map nDigitosFact4 xs) 5563303