Haskell

Ejercicios de Haskell resueltos – Parte 2

Seguimos con la segunda parte de ejercicios de Haskell resueltos sobre listas, usando el recorrido recursivo.
Para ver la primera parte deben seguir el siguiente enlace: http://programacionextrema.com/2015/12/16/ejercicios-de-haskell-resueltos-parte-1/.

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.

AboutJosé Di Meglio

Apasionado de la tecnología y programación. Aportando información gratuita sobre el mundo de la informática.

6 comments

  1. Hola, me podrÍas explicar cómo resolver este problema en haskell con recursividad, construir una función que dada una lista de listas de enteros identifique la lista con el segmento constante más largo:
    seg[[1,2,2,3,3,3 ],[2,2,2,2,2,1,4,5,5 ],[1,4,4 ] ]=[ 2,2,2,2,2,1,4,5,5]

  2. Hola, me podrías explicar cómo resolver este problema en haskell con recursividad, construir una función que dada una lista de listas de enteros identifique la lista con el segmento constante más largo: si tenermos la lista de listas [[1,1,1,3,4,65 ],[ 3,4,5,5,5],[2,2,2,2,2,1,1,4 ] ] entonces el programa debe arrojar [2,2,2,2,2,1,1,4 ], debído a que la lista contiene 5 veces el dos.

  3. Lo hago de esta manera pero no me da la cantidad total de caracteres
    Main> ocurrencias ‘C’ “CasCo” 5

    ocurrencias c lista = length [c | c <- lista, c `elem` lista]

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *