Blog
Ejercicios de Haskell resueltos – Parte 1

A continuación varios ejercicios de Haskell resueltos, sobre listas, usando el recorrido recursivo.
1. mapSucesor: dada una lista de enteros, devuelve la lista de los sucesores de cada entero.
mapSucesor :: [Integer] -> [Integer] mapSucesor [] = [] mapSucesor (x:xs) = x+1 : mapSucesor xs
2. filterPositivos: dada una lista de enteros, devuelve una lista con los elementos que son positivos.
filterPositivos :: [Integer] -> [Integer] filterPositivos [] = [] filterPositivos (x:xs) | x>=0 = x : filterPositivos xs |otherwise = filterPositivos xs
3. zipMaximos: dadas dos listas de enteros, devuelve una lista donde el elemento n es el máximo entre el elemento n de la lista 1 y de la lista 2.
zipMaximo :: [Integer] -> [Integer] -> [Integer] zipMaximo [] [] = [] zipMaximo (x:xs) (y:ys) | x>y = x : zipMaximo xs ys | otherwise = y : zipMaximo xs ys zipMaximo (x:xs) ([]) = x : xs zipMaximo ([]) (y:ys) = y : ys
4. zipSort: dadas dos listas de enteros de igual longitud, devuelve una lista de pares (min,max), donde min y max son el mínimo y el máximo entre los elementos de ambas listas en la misma posición.
zipSort :: [Integer] -> [Integer] -> [(Integer,Integer)] zipSort [] [] = [] zipSort (x:xs) (y:ys) | x>y = (x,y) : zipSort xs ys | otherwise = (y,x) : zipSort xs ys
5. mapLongitudes: dada una lista de listas, devuelve la lista de sus longitudes.
mapLonguitudes :: [[a]] -> [Int] mapLonguitudes [] = [] mapLonguitudes (x:xs) = length x : mapLonguitudes xs
6.longitudMayorA: dada una lista de listas y un número n, devuelve la lista de aquellas listas que tienen más de n elementos.
loguitudMayorA :: [[a]] -> Int -> [[a]] loguitudMayorA [] n = [] loguitudMayorA (x:xs) n | (length x) > n = x : (loguitudMayorA xs n) | otherwise = (loguitudMayorA xs n)
7. mapCuadrados: dada una lista de enteros, devuelve la lista de los cuadrados de los elementos positivos, en el mismo orden.
mapCuadrados :: [Integer] -> [Integer] mapCuadrados [] = [] mapCuadrados (x:xs) = mp (filterPositivos xs) where mp [] = [] mp (x:xs) = (x * x) : mp xs
8. sumaPar: dada una lista de pares, devuelve una nueva lista en la que cada elemento es la suma de los elementos de cada par.
sumaPar :: [(Integer,Integer)] -> [Integer] sumaPar [] = [] sumaPar (x:xs) = (fst x + snd x) : sumaPar xs
9. takePersonas: dada una lista de Personas [nombre, apellido y fecha de nacimiento] (también declare un tipo de dato Date) ordenada ascendentemente por fecha de nacimiento; y una fecha, devuelve el segmento más largo de la lista con las personas que nacieron antes dicha fecha.
data Persona = MKP Nombre Apellido Fecha deriving Show data Nombre = MKN String deriving Show data Apellido = MKA String deriving Show data Fecha =MKF Int deriving Show paja :: [Persona] -> [Persona] paja p=[] takePersonas :: [Persona] -> Fecha -> [Persona] takePersonas [] f = [] takePersonas (p:ps) f | esMenor p f = p : (takePersonas ps f) | otherwise = [] esMenor :: Persona -> Fecha -> Bool esMenor (MKP n a (MKF fn)) (MKF f) = fn < f
10. dropPrecio: dada una lista de Pizzas [lista de ingredientes y precio] en orden ascendente por precio, devuelve el segmento más largo de la lista que comienza con la pizza que tiene el menor precio superior a $30.
data Pizza = MKPI [Ingredientes] Precio deriving Show data Ingredientes = Huevo | Queso | Harina | Levadura | Tomate | Jamon | Sal deriving Show data Precio = MKPR Int deriving Show dropPrecio :: [Pizza] -> [Pizza] dropPrecio [] = [] dropPrecio (p:ps) | esPrecioMenor p 30 = p : dropPrecio ps | otherwise = [] esPrecioMenor :: Pizza -> Int -> Bool esPrecioMenor (MKPI is (MKPR pr)) n = pr < n
11. takeNombresPersonas: dada una lista de Personas y una fecha devuelve los nombres de las personas incluidas en segmento más largo de la lista con las personas que nacieron antes dicha fecha.
takeNombresPersonas :: [Persona] -> Fecha -> [Nombre] takeNombresPersonas [] f = [] takeNombresPersonas (p:ps) f | esMenor p f = (getNombre p) : (takeNombresPersonas ps f) | otherwise = [] getNombre :: Persona -> Nombre getNombre (MKP n a f)= n
12. reversa: dada una lista de enteros, devuelve la lista con los mismos elementos de atrás para adelante.
reversa :: [a] -> [a] reversa [] = [] reversa (x:xs) = reversa xs ++ [x]
Bueno gente, esos son todos los ejercicios de Haskell resueltos de esta primera parte, espero que les sea de gran utilidad y ante cualquier problema no duden en dejar un comentario.