Blog
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.
me ayudan con esto?… necesito hacerlo sin usar las bibliotecas de prelude
Unir dos listas de cadena de caracteres puede elementos repetidos
Modificar la función UnirLista de tal modo que no incluya repetidos