| Revisión actual |
Tu texto |
| Línea 35: |
Línea 35: |
|
| |
|
| elem :: forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool | | elem :: forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool |
|
| |
|
| |
| == Ejercicio 2 ==
| |
| Definir las siguientes funciones:
| |
| a. valorAbsoluto :: Float → Float, que dado un n ́umero devuelve su valor absoluto.
| |
|
| |
| b. bisiesto :: Int → Bool, que dado un n ́umero que representa un a ̃no, indica si el mismo es bisiesto.
| |
|
| |
| c. factorial :: Int → Int, definida ́unicamente para enteros positivos, que computa el factorial.
| |
|
| |
| d. cantDivisoresPrimos :: Int → Int, que dado un entero positivo devuelve la cantidad de divisores primos.
| |
|
| |
| valorAbsoluto :: Float -> Float
| |
| valorAbsoluto x = if x < 0 then x * (-1) else x
| |
| {- Soluciones Alternativas
| |
| abs :: Int -> Int
| |
| abs n | n >= 0 = n
| |
| | otherwise = -n
| |
| myabs :: Int -> Int
| |
| myabs n = if n >= 0 then n else -n
| |
| -}
| |
| bisiesto :: Int -> Bool
| |
| bisiesto x = (mod x 4 == 0) && (mod x 100 /= 0) || (mod x 400 == 0)
| |
| {- Solucion Alternativa Mas legible
| |
| isLeapYear :: Year -> Bool
| |
| isLeapYear y = divisibleBy 400 || (divisibleBy 4 && not (divisibleBy 100))
| |
| where
| |
| divisibleBy x = mod y x == 0
| |
| -}
| |
| factorial :: Int -> Int
| |
| factorial 0 = 1
| |
| factorial x = x * factorial (x-1)
| |
| {- Solucion Alternativa
| |
| fac :: (Integral a) => a -> a
| |
| fac n = product [1..n]
| |
| -}
| |
| -- Creditos a https://stackoverflow.com/questions/21276844/prime-factors-in-haskell
| |
| prime_factors :: Int -> [Int]
| |
| prime_factors n =
| |
| case factors of
| |
| [] -> [n]
| |
| _ -> factors ++ prime_factors (n `div` (head factors))where factors = take 1 $ filter (\x -> (n `mod` x) == 0) [2 .. n-1]
| |
| cantDivisoresPrimos :: Int -> Int
| |
| cantDivisoresPrimos x = length (prime_factors x)
| |
|
| |
|
| |
| -- TESTS
| |
| valorAbsoluto (-5) == 5
| |
| bisiesto 2024 == True
| |
| bisiesto 1 == False
| |
| bisiesto 400 == True
| |
| factorial 2 == 2
| |
| factorial 3 == 6
| |
| factorial 0 == 1
| |
| cantDivisoresPrimos 1 == 1
| |
| cantDivisoresPrimos 2 == 1
| |
| cantDivisoresPrimos 10 == 2
| |
|
| |
| == Ejercicio 3 ==
| |
| Contamos con los tipos Maybe y Either definidos como sigue:
| |
|
| |
| data Maybe a = Nothing | Just a
| |
|
| |
| data Either a b = Left a | Right b
| |
|
| |
| a. Definir la función inverso :: Float → Maybe Float que dado un número devuelve su inverso multiplicativo si está definido, o Nothing en caso
| |
| contrario.
| |
|
| |
| b. Definir la función aEntero :: Either Int Bool → Int que convierte a entero una expresi ́on que puede ser
| |
| booleana o entera. En el caso de los booleanos, el entero que corresponde es 0 para False y 1 para True.
| |
|
| |
|
| |
| import Data.Maybe
| |
| inverso :: Float -> Maybe Float
| |
| inverso x = case x of
| |
| 0 -> Nothing
| |
| x -> Just (1/x)
| |
|
| |
| fromJust (inverso 2) == 0.5
| |
| inverso 0 == Nothing
| |
|
| |
|
| |
| aEntero :: Either Int Bool -> Int
| |
| aEntero x = case x of
| |
| Left x -> x
| |
| Right True -> 1
| |
| Right False -> 0
| |
|
| |
| aEntero (Right True) == 1
| |
| aEntero (Right False) == 0
| |
| aEntero (Left 5) == 5
| |
|
| |
| == Ejercicio 4 ==
| |
| Definir las siguientes funciones sobre listas:
| |
|
| |
| a. limpiar :: String → String → String, que elimina todas las apariciones de cualquier car ́acter de la primera cadena en la segunda. Por ejemplo,
| |
| limpiar ‘‘susto’’ ‘‘puerta’’ eval ́ua a ‘‘pera’’. Nota: String es un renombre de [Char]. La notaci ́on ‘‘hola’’ es equivalente a [‘h’,‘o’,‘l’,‘a’] y a ‘h’:‘o’:‘l’:‘a’:[].
| |
|
| |
| b. difPromedio :: [Float] → [Float] que dada una lista de n ́umeros devuelve la diferencia de cada uno con el promedio general. Por ejemplo,
| |
| difPromedio [2, 3, 4] eval ́ua a [-1, 0, 1].
| |
|
| |
| c. todosIguales :: [Int] → Bool que indica si una lista de enteros tiene todos sus elementos iguales.
| |
|
| |
| limpiar:: String -> String -> String
| |
| limpiar xs = filter (not.(`elem` xs))
| |
|
| |
| limpiar "susto" "puerta" == "pera"
| |
|
| |
| difPromedio :: [Float] -> [Float]
| |
| difPromedio xs = map (subtract promedio) xs
| |
| where promedio = sum xs/ fromIntegral (length xs)
| |
|
| |
| difPromedio [2,4,6] == [-2,0,2]
| |
|
| |
| todosIguales :: [Int] -> Bool
| |
| todosIguales [] = True
| |
| todosIguales (x:ns) = all (== x) ns
| |
| --Usando foldr
| |
| safeHead :: (Foldable t, Eq a) => t a -> Maybe a
| |
| safeHead = foldr (\a _ -> Just a) Nothing
| |
| todosIguales2 :: (Foldable t, Eq a) => t a -> Bool
| |
| todosIguales2 xs = case safeHead xs of
| |
| Nothing -> True
| |
| Just a -> all (==a) xs
| |
|
| |
| todosIguales [1,1,1] == True
| |
| todosIguales [1,2,1] == False
| |
| todosIguales2 [1,1,1] == True
| |
| todosIguales2 [1,2,1] == False
| |
|
| |
| == Ejercicio 5 ==
| |
| Dado el siguiente modelo para ́arboles binarios:
| |
|
| |
| data AB a = Nil | Bin (AB a) a (AB a)
| |
|
| |
| definir las siguientes funciones:
| |
|
| |
| a. vacioAB :: AB a → Bool que indica si un ́arbol es vac ́ıo (i.e. no tiene nodos).
| |
|
| |
| b. negacionAB :: AB Bool → AB Bool que dado un ́arbol de booleanos construye otro formado por la negaci ́on de cada uno de los nodos.
| |
|
| |
| c. productoAB :: AB Int → Int que calcula el producto de todos los nodos del ́arbol.
| |
|
| |
|
| |
|
| |
| data AB a = Nil | Bin (AB a) a (AB a)
| |
| vacioAB :: AB a -> Bool
| |
|
| |
| instance Eq a => Eq (AB a) where
| |
| Nil == Nil = True
| |
| (Bin r1 c1 l1) == (Bin r2 c2 l2) = l1==l2 && c1==c2 && r1==r2
| |
| _==_ = False
| |
| vacioAB Nil = True
| |
| vacioAB _ = False
| |
| negacionAB :: AB Bool -> AB Bool
| |
| negacionAB Nil = Nil
| |
| negacionAB (Bin l c r) = Bin (negacionAB l) (not c) (negacionAB r)
| |
| productoAB :: AB Int -> Int
| |
| productoAB Nil = 1
| |
| productoAB (Bin l c r) = (productoAB l) * c * productoAB r
| |
|
| |
| productoAB l * c
| |
| arbol1 = Bin Nil True Nil
| |
| arbol2 = Bin (Bin Nil False Nil) True ( Bin Nil False Nil)
| |
| arbol42 = Bin (Bin Nil 7 Nil) 2 ( Bin Nil 3 Nil)
| |
| vacioAB Nil == True
| |
| vacioAB arbol1 == False
| |
| negacionAB Nil == Nil
| |
| negacionAB arbol1 == (Bin Nil False Nil)
| |
| negacionAB arbol2 == (Bin (Bin Nil True Nil) False ( Bin Nil True Nil))productoAB arbol42 == 42
| |
