Para resolver estos ejercicios vamos a utilizar algunas de las funciones auxiliares que vimos en los posts http://programacionextrema.com/2015/12/16/ejercicios-de-haskell-resueltos-parte-2/ y http://programacionextrema.com/2015/12/16/ejercicios-de-haskell-resueltos-parte-1/.

De la siguiente forma vamos a definir el tipo de dato Maybe para utilizar en los ejercicios.

data Maybes a = Nothings | Justs a  deriving Show

1. mLookUp: dada una lista de strings y un string s devuelve la posición de la lista recibida en la que se encuentra s o Nothing si s no se encuentra en la lista.

mLookUp :: [String] -> String -> Maybes Int
mLookUp [] s = Nothings
mLookUp (x:xs) s = Justs (lookUp (x:xs) s)

2. mInit: dada una lista, devuelve una copia de esta sin su último elemento o Nothing si la lista está vacía.

mInit :: [Int] -> Maybes [Int]
mInit[] = Nothings
mInit [n] = Justs []
mInit (xs)= Justs (inits xs)

3. mLast: dada una lista, devuelve su último elemento o Nothing si la lista está vacía.

mLast :: [Int] -> Maybes Int
mLast [] = Nothings
mLast (xs) = Justs (lasts xs)

4. takeExactlyN: dada una lista y un número n, devuelve una lista con los primeros n elementos de lista recibida. Si la lista recibida tuviera menos de n, elementos devuelve Nothing.

takeExactlyN :: [a] -> Int -> Maybes [a]
takeExactlyN [] n = Nothings
takeExactlyN (xs) n | ( length xs)< n = Nothings
                    | otherwise = Justs (takeN xs n)

5. dropExactlyN: dada una lista y un número n, devuelve una lista sin los primeros n elementos de lista recibida. Si la lista recibida tuviera menos de n elementos, devuelve Nothing.

dropExactlyN :: [a] -> Int -> Maybes[a]
dropExactlyN [] n = Nothings
dropExactlyN (xs) n | length (xs)< n = Nothings
                  | otherwise = Justs (dropN xs n)

6. mMaximo: dada una lista de enteros devuelve el máximo. Si la lista es vacía, devuelve Nothing.

mMaximo :: [Int] -> Maybe Int 
mMaximo [] = Nothing
mMaximo (xs)= Just( maximum1 xs)

Bueno gente, esos son todos los ejercicios, si tienen algún problema o creen que pueden mejorar alguno no duden en enviar un comentario.

La entrada Ejercicios de Haskell resueltos – Parte 3 aparece primero en ProgramaciónExtrema.com.

1. append: dadas dos listas devuelve la lista con todos los elementos de la primer lista y todos los elementos de la segunda a continuación.

append :: [a] ->[a] -> [a]
append [] []= []
append (x:xs) (ys) = x : append xs ys
append [] (y:ys) = y : append [] ys

2. snocAlt: dada una lista de enteros xs y un entero i, devuelve la lista resultante de agregar i al final de xs. Nota: utilizar Cons.

snocAlt :: [Int] -> Int -> [Int]
snocAlt [] n = [n]
snocAlt (x:xs) n = x : (snocAlt xs n)

3. init: dada una lista, devuelve una copia de esta sin su último elemento.

inits :: [a] -> [a]
inits [] = []
inits [n] =[]
inits (x:xs) = x : init xs

4. last: dada una lista, devuelve su último elemento.

lasts :: [a] -> a
lasts [] = error "Lista vacia"
lasts [n] = n
lasts (x:xs) = lasts xs 

5. lookUp: dada una lista de strings y un string s devuelve la posición de la lista recibida en la que se encuentra s.

lookUp :: [String] -> String -> Int 
lookUp [] s = error "String no encontrado"
lookUp (x:xs) s | not(x == s) = 1 + (lookUp xs s) 
                | otherwise = 0

6. takeN: dada una lista x y un número n, devuelve una lista con los primeros n elementos de lista recibida. Si la lista recibida tuviera menos de n elementos, devuelve la lista completa.

takeN :: [a] -> Int -> [a]
takeN [] n =[]
takeN (x:xs) n | not( n == 0) = x : takeN xs (n-1)
               | otherwise = []	

7. dropN: dada una lista y un número n, devuelve una lista sin los primeros n elementos de lista recibida. Si la lista recibida tuviera menos de n elementos devuelve la lista vacía

dropN :: [a] -> Int -> [a]
dropN [] n = []
dropN  (x:xs) n | n /= 0 = dropN xs (n-1)
                | otherwise = x:(dropN xs 0)

8. maximum: dada una lista de enteros devuelve el máximo.

maximum1 :: [Int] -> Int
maximum1 []= 0
maximum1 (x:xs) | x > (maximum1 xs)= x
                | otherwise = maximum1 xs

9. aplanar: dada una lista de listas, devuelve una única lista con todos sus elementos.

aplanar :: [[a]] -> [a]
aplanar [] = []
aplanar (xs:xss) =  append xs (aplanar xss) 

Bueno gente, esos son todos los ejercicios de Haskell resueltos de esta segunda parte, espero que les sea de gran utilidad y ante cualquier inconveniente no duden en enviar un comentario.

La entrada Ejercicios de Haskell resueltos – Parte 2 aparece primero en ProgramaciónExtrema.com.

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.

La entrada Ejercicios de Haskell resueltos – Parte 1 aparece primero en ProgramaciónExtrema.com.