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.