{"id":3109,"date":"2013-03-12T16:20:22","date_gmt":"2013-03-12T16:20:22","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=3109"},"modified":"2013-03-12T16:20:22","modified_gmt":"2013-03-12T16:20:22","slug":"i1m2012-ejercicios-con-tipos-de-datos-algebraicos-en-haskell","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2012-ejercicios-con-tipos-de-datos-algebraicos-en-haskell\/","title":{"rendered":"I1M2012: Ejercicios con tipos de datos algebraicos en Haskell"},"content":{"rendered":"<p>En las clases de ayer y hoy de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-12\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos comentando soluciones de los ejercicios sobre tipos de datos algebraicos en Haskell de la relaciones 18 y 19.<\/p>\n<p>En la relaci\u00f3n 18 se consideran abreviaturas y dos tipos de datos<br \/>\nalgebraicos: los n\u00fameros naturales (para los que se define su<br \/>\nproducto) y los \u00e1rboles binarios, para los que se definen funciones<br \/>\npara calcular: <\/p>\n<ul>\n<li> los puntos m\u00e1s cercanos,\n<li> la ocurrencia de un elemento en el \u00e1rbol,\n<li> el n\u00famero de hojas,\n<li> el car\u00e1cter balanceado de un \u00e1rbol y\n<li> el \u00e1rbol balanceado correspondiente a una lista.\n<\/ul>\n<p>En la relaci\u00f3n 19 se plantean ejercicios sobre \u00e1rboles binarios. En<br \/>\nconcreto, se definen funciones para calcular:<\/p>\n<ul>\n<li> el n\u00famero de hojas de un \u00e1rbol,\n<li> el n\u00famero de nodos de un \u00e1rbol,\n<li> la profundidad de un \u00e1rbol,\n<li> el recorrido preorden de un \u00e1rbol,\n<li> el recorrido postorden de un \u00e1rbol,\n<li> el recorrido preorden de forma iterativa,\n<li> la imagen especular de un \u00e1rbol,\n<li> el sub\u00e1rbol de profundidad dada,\n<li> el \u00e1rbol infinito generado con un elemento y\n<li> el \u00e1rbol de profundidad dada cuyos nodos son iguales a un elemento.\n<\/ul>\n<p>Los ejercicios, y sus soluciones, se muestran a continuaci\u00f3n. Los de la relaci\u00f3n 18 son<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1. Los puntos del plano se pueden representar por pares de\r\n-- n\u00fameros como se indica a continuaci\u00f3n  \r\n--    type Punto = (Double,Double) \r\n-- Definir la funci\u00f3n \r\n--    cercanos :: [Punto] -> [Punto] -> (Punto,Punto)\r\n-- tal que (cercanos ps qs) es un par de puntos, el primero de ps y el\r\n-- segundo de qs, que son los m\u00e1s cercanos (es decir, no hay otro par\r\n-- (p',q') con p' en ps y q' en qs tales que la distancia entre p' y q'\r\n-- sea menor que la que hay entre p y q). Por ejemplo,\r\n--    cercanos [(2,5),(3,6)] [(4,3),(1,0),(7,9)] == ((2.0,5.0),(4.0,3.0))\r\n-- ---------------------------------------------------------------------\r\n\r\ntype Punto = (Double,Double) \r\n\r\ncercanos :: [Punto] -> [Punto] -> (Punto,Punto)\r\ncercanos ps qs = (p,q)\r\n    where (d,p,q) = minimum [(distancia p q, p, q) | p <- ps, q <-qs]\r\n          distancia (x,y) (u,v) = sqrt ((x-u)^2+(y-v)^2)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.1. En los diguientes ejercicios se usar\u00e1 el tipo\r\n-- algebraico de datos de los n\u00fameros naturales definido por\r\n--    data Nat = Cero | Suc Nat\r\n--               deriving (Eq, Show)\r\n-- Definir la funci\u00f3n\r\n--    suma :: Nat -> Nat -> Nat\r\n-- tal que (suma m n) es la suma de los n\u00fameros naturales m y\r\n-- n. Por ejemplo, \r\n--    ghci> suma (Suc (Suc Cero)) (Suc (Suc (Suc Cero)))\r\n--    Suc (Suc (Suc (Suc (Suc Cero))))\r\n-- ---------------------------------------------------------------------\r\n\r\ndata Nat = Cero | Suc Nat\r\n           deriving (Eq, Show)\r\n\r\nsuma :: Nat -> Nat -> Nat\r\nsuma Cero    n = n\r\nsuma (Suc m) n = Suc (suma m n)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2.2. Definir la funci\u00f3n\r\n--    producto :: Nat -> Nat -> Nat\r\n-- tal que (producto m n) es el producto de los n\u00fameros naturales m y\r\n-- n. Por ejemplo, \r\n--    ghci> producto (Suc (Suc Cero)) (Suc (Suc (Suc Cero)))\r\n--    Suc (Suc (Suc (Suc (Suc (Suc Cero)))))\r\n-- ---------------------------------------------------------------------\r\n\r\nproducto :: Nat -> Nat -> Nat\r\nproducto Cero _    = Cero\r\nproducto (Suc m) n = suma n (producto m n)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3. En los apartados de este ejercicio se trabajar\u00e1 con\r\n-- \u00e1rboles binarios definidos como sigue\r\n--    data Arbol = Hoja Int \r\n--               | Nodo Arbol Int Arbol\r\n--               deriving (Show, Eq)\r\n-- Por ejemplo, el \u00e1rbol\r\n--         5 \r\n--        \/ \\\r\n--       \/   \\\r\n--      3     7\r\n--     \/ \\   \/ \\  \r\n--    1   4 6   9  \r\n-- se representa por\r\n--    Nodo (Nodo (Hoja 1) 3 (Hoja 4)) \r\n--         5 \r\n--         (Nodo (Hoja 6) 7 (Hoja 9))\r\n-- ---------------------------------------------------------------------\r\n\r\ndata Arbol = Hoja Int \r\n           | Nodo Arbol Int Arbol\r\n           deriving (Show, Eq)\r\n\r\nejArbol :: Arbol\r\nejArbol = Nodo (Nodo (Hoja 1) 3 (Hoja 4)) \r\n               5 \r\n               (Nodo (Hoja 6) 7 (Hoja 9))\r\n\r\n-- --------------------------------------------------------------------\r\n-- Ejercicio 3.1. Definir la funci\u00f3n\r\n--    ocurre :: Int -> Arbol -> Bool\r\n-- tal que (ocurre x a) se verifica si x ocurre en el \u00e1rbol a como valor\r\n-- de un nodo o de una hoja. Por ejemplo,\r\n--    ocurre  4 ejArbol  ==  True\r\n--    ocurre 10 ejArbol  ==  False\r\n-- ---------------------------------------------------------------------\r\n\r\nocurre :: Int -> Arbol -> Bool\r\nocurre m (Hoja n)     = m == n\r\nocurre m (Nodo i n d) = m == n || ocurre m i || ocurre m d\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3.2. En el preludio est\u00e1 definido el tipo de datos\r\n--    data Ordering = LT | EQ | GT\r\n-- junto con la funci\u00f3n\r\n--    compare :: Ord a => a -> a -> Ordering\r\n-- que decide si un valor en un tipo ordenado es menor (LT), igual (EQ)\r\n-- o mayor (GT) que otro. \r\n-- \r\n-- Usando esta funci\u00f3n, redefinir la funci\u00f3n\r\n--    ocurre :: Int -> Arbol -> Bool\r\n-- del ejercicio anterior. \r\n-- ---------------------------------------------------------------------\r\n\r\nocurre' :: Int -> Arbol -> Bool\r\nocurre' m (Hoja n)     = m == n\r\nocurre' m (Nodo i n d) = case compare m n of\r\n                           LT -> ocurre' m i\r\n                           EQ -> True\r\n                           GT -> ocurre' m d\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4. En los apartados de este ejercicio se trabajar\u00e1 con\r\n-- \u00e1rboles binarios definidos como sigue\r\n--    type ArbolB = HojaB Int \r\n--                | NodoB ArbolB ArbolB \r\n--                deriving Show\r\n-- Por ejemplo, el \u00e1rbol\r\n--         . \r\n--        \/ \\\r\n--       \/   \\\r\n--      .     .\r\n--     \/ \\   \/ \\  \r\n--    1   4 6   9  \r\n-- se representa por\r\n--    NodoB (NodoB (HojaB 1) (HojaB 4)) \r\n--          (NodoB (HojaB 6) (HojaB 9))\r\n-- ---------------------------------------------------------------------\r\n\r\ndata ArbolB = HojaB Int \r\n            | NodoB ArbolB ArbolB\r\n            deriving Show\r\n\r\nejArbolB :: ArbolB\r\nejArbolB = NodoB (NodoB (HojaB 1) (HojaB 4)) \r\n                 (NodoB (HojaB 6) (HojaB 9))\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4.1. Definir la funci\u00f3n \r\n--    nHojas :: ArbolB -> Int\r\n-- tal que (nHojas a) es el n\u00famero de hojas del \u00e1rbol a. Por ejemplo,\r\n--    nHojas (NodoB (HojaB 5) (NodoB (HojaB 3) (HojaB 7)))  ==  3\r\n--    nHojas ejArbolB ==  4\r\n-- ---------------------------------------------------------------------\r\n\r\nnHojas :: ArbolB -> Int\r\nnHojas (HojaB _)     = 1\r\nnHojas (NodoB a1 a2) = nHojas a1 + nHojas a2\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4.2. Se dice que un \u00e1rbol de este tipo es balanceado si es\r\n-- una hoja o bien si para cada nodo se tiene que el n\u00famero de hojas en\r\n-- cada uno de sus sub\u00e1rboles difiere como m\u00e1ximo en uno y sus\r\n-- sub\u00e1rboles son balanceados. Definir la funci\u00f3n \r\n--    balanceado :: ArbolB -> BoolB\r\n-- tal que (balanceado a) se verifica si a es un \u00e1rbol balanceado. Por\r\n-- ejemplo, \r\n--    balanceado ejArbolB\r\n--    ==> True\r\n--    balanceado (NodoB (HojaB 5) (NodoB (HojaB 3) (HojaB 7)))\r\n--    ==> True\r\n--    balanceado (NodoB (HojaB 5) (NodoB (HojaB 3) (NodoB (HojaB 5) (HojaB 7))))\r\n--    ==> False\r\n-- ---------------------------------------------------------------------\r\n \r\nbalanceado :: ArbolB -> Bool\r\nbalanceado (HojaB _)     = True\r\nbalanceado (NodoB a1 a2) = abs (nHojas a1 - nHojas a2) <= 1 &#038;&#038;\r\n                           balanceado a1 &#038;&#038;\r\n                           balanceado a2\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4.3. Definir la funci\u00f3n \r\n--    mitades :: [a] -> ([a],[a]) \r\n-- tal que (mitades xs) es un par de listas que se obtiene al dividir xs\r\n-- en dos mitades cuya longitud difiere como m\u00e1ximo en uno. Por ejemplo,\r\n--    mitades [2,3,5,1,4,7]    ==  ([2,3,5],[1,4,7])\r\n--    mitades [2,3,5,1,4,7,9]  ==  ([2,3,5],[1,4,7,9])\r\n-- ---------------------------------------------------------------------\r\n\r\nmitades :: [a] -> ([a],[a])\r\nmitades xs = splitAt (length xs `div` 2) xs\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4.4. Definir la funci\u00f3n\r\n--    arbolBalanceado :: [Int] -> ArbolB\r\n-- tal que (arbolBalanceado xs) es el \u00e1rbol balanceado correspondiente\r\n-- a la lista xs. Por ejemplo,\r\n--    ghci> arbolBalanceado [2,5,3]\r\n--    NodoB (HojaB 2) (NodoB (HojaB 5) (HojaB 3))\r\n--    ghci> arbolBalanceado [2,5,3,7]\r\n--    NodoB (NodoB (HojaB 2) (HojaB 5)) (NodoB (HojaB 3) (HojaB 7))\r\n-- ---------------------------------------------------------------------\r\n\r\narbolBalanceado :: [Int] -> ArbolB\r\narbolBalanceado [x] = HojaB x\r\narbolBalanceado xs  = NodoB (arbolBalanceado ys) (arbolBalanceado zs)\r\n                      where (ys,zs) = mitades xs\r\n<\/pre>\n<p>Los de la relaci\u00f3n 19 son<\/p>\n<pre lang=\"haskell\">\r\n-- ---------------------------------------------------------------------\r\n-- Importaci\u00f3n de librer\u00edas auxiliares                                  \r\n-- ---------------------------------------------------------------------\r\n\r\nimport Data.List\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Nota. En los siguientes ejercicios se trabajar\u00e1 con los \u00e1rboles\r\n-- binarios definidos como sigue \r\n--    data Arbol a = Hoja \r\n--                 | Nodo a (Arbol a) (Arbol a)\r\n--                 deriving (Show, Eq)\r\n-- En los ejemplos se usar\u00e1 el siguiente \u00e1rbol\r\n--    arbol = Nodo 9\r\n--                   (Nodo 3 \r\n--                         (Nodo 2 Hoja Hoja) \r\n--                         (Nodo 4 Hoja Hoja)) \r\n--                   (Nodo 7 Hoja Hoja)\r\n-- ---------------------------------------------------------------------\r\n\r\ndata Arbol a = Hoja \r\n             | Nodo a (Arbol a) (Arbol a)\r\n             deriving (Show, Eq)\r\n\r\narbol = Nodo 9\r\n               (Nodo 3 \r\n                     (Nodo 2 Hoja Hoja) \r\n                     (Nodo 4 Hoja Hoja)) \r\n               (Nodo 7 Hoja Hoja)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 1. Definir la funci\u00f3n\r\n--    nHojas :: Arbol a -> Int\r\n-- tal que (nHojas x) es el n\u00famero de hojas del \u00e1rbol x. Por ejemplo,\r\n--    ghci> arbol\r\n--    Nodo 9 (Nodo 3 (Nodo 2 Hoja Hoja) (Nodo 4 Hoja Hoja)) (Nodo 7 Hoja Hoja)\r\n--    ghci> nHojas arbol\r\n--    6\r\n-- ---------------------------------------------------------------------\r\n\r\nnHojas :: Arbol a -> Int\r\nnHojas Hoja         = 1\r\nnHojas (Nodo x i d) = nHojas i + nHojas d\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 2. Definir la funci\u00f3n\r\n--    nNodos :: Arbol a -> Int\r\n-- tal que (nNodos x) es el n\u00famero de nodos del \u00e1rbol x. Por ejemplo,\r\n--    ghci> arbol\r\n--    Nodo 9 (Nodo 3 (Nodo 2 Hoja Hoja) (Nodo 4 Hoja Hoja)) (Nodo 7 Hoja Hoja)\r\n--    ghci> nNodos arbol\r\n--    5\r\n-- ---------------------------------------------------------------------\r\n\r\nnNodos :: Arbol a -> Int\r\nnNodos Hoja         = 0\r\nnNodos (Nodo x i d) = 1 + nNodos i + nNodos d\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 3. Definir la funci\u00f3n\r\n--    profundidad :: Arbol a -> Int\r\n-- tal que (profundidad x) es la profundidad del \u00e1rbol x. Por ejemplo,\r\n--    ghci> arbol\r\n--    Nodo 9 (Nodo 3 (Nodo 2 Hoja Hoja) (Nodo 4 Hoja Hoja)) (Nodo 7 Hoja Hoja)\r\n--    ghci> profundidad arbol\r\n--    3\r\n-- ---------------------------------------------------------------------\r\n\r\nprofundidad :: Arbol a -> Int\r\nprofundidad Hoja = 0\r\nprofundidad (Nodo x i d) = 1 + max (profundidad i) (profundidad d)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 4. Definir la funci\u00f3n\r\n--    preorden :: Arbol a -> [a]\r\n-- tal que (preorden x) es la lista correspondiente al recorrido\r\n-- preorden del \u00e1rbol x; es decir, primero visita la ra\u00edz del \u00e1rbol, a\r\n-- continuaci\u00f3n recorre el sub\u00e1rbol izquierdo y, finalmente, recorre el\r\n-- sub\u00e1rbol derecho. Por ejemplo,\r\n--    ghci> arbol\r\n--    Nodo 9 (Nodo 3 (Nodo 2 Hoja Hoja) (Nodo 4 Hoja Hoja)) (Nodo 7 Hoja Hoja)\r\n--    ghci> preorden arbol\r\n--    [9,3,2,4,7]\r\n-- ---------------------------------------------------------------------\r\n\r\npreorden :: Arbol a -> [a]\r\npreorden Hoja         = []\r\npreorden (Nodo x i d) = x : (preorden i ++ preorden d)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 5. Definir la funci\u00f3n\r\n--    postorden :: Arbol a -> [a]\r\n-- tal que (postorden x) es la lista correspondiente al recorrido\r\n-- postorden del \u00e1rbol x; es decir, primero recorre el sub\u00e1rbol\r\n-- izquierdo, a continuaci\u00f3n el sub\u00e1rbol derecho y, finalmente, la ra\u00edz\r\n-- del \u00e1rbol. Por ejemplo,\r\n--    ghci> arbol\r\n--    Nodo 9 (Nodo 3 (Nodo 2 Hoja Hoja) (Nodo 4 Hoja Hoja)) (Nodo 7 Hoja Hoja)\r\n--    ghci> postorden arbol\r\n--    [2,4,3,7,9]\r\n-- ---------------------------------------------------------------------\r\n\r\npostorden :: Arbol a -> [a]\r\npostorden Hoja         = []\r\npostorden (Nodo x i d) = postorden i ++ postorden d ++ [x]\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 6. Definir, usando un acumulador, la funci\u00f3n\r\n--    preordenIt :: Arbol a -> [a]\r\n-- tal que (preordenIt x) es la lista correspondiente al recorrido\r\n-- preorden del \u00e1rbol x; es decir, primero visita la ra\u00edz del \u00e1rbol, a\r\n-- continuaci\u00f3n recorre el sub\u00e1rbol izquierdo y, finalmente, recorre el\r\n-- sub\u00e1rbol derecho. Por ejemplo,\r\n--    ghci> arbol\r\n--    Nodo 9 (Nodo 3 (Nodo 2 Hoja Hoja) (Nodo 4 Hoja Hoja)) (Nodo 7 Hoja Hoja)\r\n--    ghci> preordenIt arbol\r\n--    [9,3,2,4,7]\r\n-- Nota: No usar (++) en la definici\u00f3n\r\n-- ---------------------------------------------------------------------\r\n\r\npreordenIt :: Arbol a -> [a]\r\npreordenIt x = preordenItAux x []\r\n    where preordenItAux Hoja xs         = xs\r\n          preordenItAux (Nodo x i d) xs = \r\n              x : preordenItAux i (preordenItAux d xs)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 7. Definir la funci\u00f3n\r\n--    espejo :: Arbol a -> Arbol a\r\n-- tal que (espejo x) es la imagen especular del \u00e1rbol x. Por ejemplo,\r\n--    ghci> espejo arbol\r\n--    Nodo 9 \r\n--         (Nodo 7 Hoja Hoja) \r\n--         (Nodo 3 \r\n--               (Nodo 4 Hoja Hoja) \r\n--               (Nodo 2 Hoja Hoja))\r\n-- ---------------------------------------------------------------------\r\n\r\nespejo :: Arbol a -> Arbol a\r\nespejo Hoja         = Hoja\r\nespejo (Nodo x i d) = Nodo x (espejo d) (espejo i)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 8. La funci\u00f3n take est\u00e1 definida por\r\n--    take :: Int -> [a] -> [a]\r\n--    take 0            = []\r\n--    take (n+1) []     = []\r\n--    take (n+1) (x:xs) = x : take n xs\r\n-- Definir la funci\u00f3n \r\n--    takeArbol ::  Int -> Arbol a -> Arbol a\r\n-- tal que (takeArbol n t) es el sub\u00e1rbol de t de profundidad n. Por\r\n-- ejemplo,\r\n--    ghci> takeArbol 0 (Nodo 6 Hoja (Nodo 7 (Nodo 5 Hoja Hoja) Hoja))\r\n--    Hoja\r\n--    ghci> takeArbol 1 (Nodo 6 Hoja (Nodo 7 (Nodo 5 Hoja Hoja) Hoja))\r\n--    Nodo 6 Hoja Hoja\r\n--    ghci> takeArbol 2 (Nodo 6 Hoja (Nodo 7 (Nodo 5 Hoja Hoja) Hoja))\r\n--    Nodo 6 Hoja (Nodo 7 Hoja Hoja)\r\n--    ghci> takeArbol 3 (Nodo 6 Hoja (Nodo 7 (Nodo 5 Hoja Hoja) Hoja))\r\n--    Nodo 6 Hoja (Nodo 7 (Nodo 5 Hoja Hoja) Hoja)\r\n--    ghci> takeArbol 4 (Nodo 6 Hoja (Nodo 7 (Nodo 5 Hoja Hoja) Hoja))\r\n--    Nodo 6 Hoja (Nodo 7 (Nodo 5 Hoja Hoja) Hoja)\r\n-- ---------------------------------------------------------------------\r\n \r\ntakeArbol :: Int -> Arbol a -> Arbol a\r\ntakeArbol 0     _  = Hoja\r\ntakeArbol _ Hoja   = Hoja\r\ntakeArbol n (Nodo x i d) = \r\n    Nodo x (takeArbol (n-1) i) (takeArbol (n-1) d)\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 9. La funci\u00f3n\r\n--    repeat :: a -> [a]\r\n-- est\u00e1 definida de forma que (repeat x) es la lista formada por\r\n-- infinitos elementos x. Por ejemplo,\r\n--    repeat 3  ==  [3,3,3,3,3,3,3,3,3,3,3,3,3,...\r\n-- La definici\u00f3n de repeat es\r\n--    repeat x = xs where xs = x:xs\r\n-- Definir la funci\u00f3n\r\n--    repeatArbol :: a -> Arbol a\r\n-- tal que (repeatArbol x) es es \u00e1rbol con infinitos nodos x. Por\r\n-- ejemplo, \r\n--    ghci> takeArbol 0 (repeatArbol 3)\r\n--    Hoja\r\n--    ghci> takeArbol 1 (repeatArbol 3)\r\n--    Nodo 3 Hoja Hoja\r\n--    ghci> takeArbol 2 (repeatArbol 3)\r\n--    Nodo 3 (Nodo 3 Hoja Hoja) (Nodo 3 Hoja Hoja)\r\n-- ---------------------------------------------------------------------\r\n\r\nrepeatArbol :: a -> Arbol a\r\nrepeatArbol x = Nodo x t t\r\n                where t = repeatArbol x\r\n\r\n-- ---------------------------------------------------------------------\r\n-- Ejercicio 10. La funci\u00f3n \r\n--    replicate :: Int -> a -> [a]\r\n-- est\u00e1 definida por \r\n--    replicate n = take n . repeat\r\n-- es tal que (replicate n x) es la lista de longitud n cuyos elementos\r\n-- son x. Por ejemplo,\r\n--    replicate 3 5  ==  [5,5,5]\r\n-- Definir la funci\u00f3n \r\n--    replicateArbol :: Int -> a -> Arbol a\r\n-- tal que (replicate n x) es el \u00e1rbol de profundidad n cuyos nodos son\r\n-- x. Por ejemplo,\r\n--    ghci> replicateArbol 0 5\r\n--    Hoja\r\n--    ghci> replicateArbol 1 5\r\n--    Nodo 5 Hoja Hoja\r\n--    ghci> replicateArbol 2 5\r\n--    Nodo 5 (Nodo 5 Hoja Hoja) (Nodo 5 Hoja Hoja)\r\n-- ---------------------------------------------------------------------\r\n\r\nreplicateArbol :: Int -> a -> Arbol a\r\nreplicateArbol n = takeArbol n . repeatArbol\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>En las clases de ayer y hoy de Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas hemos comentando soluciones de los ejercicios sobre tipos de datos algebraicos en Haskell de la relaciones 18 y 19. En la relaci\u00f3n 18 se consideran abreviaturas y dos tipos de datos algebraicos: los n\u00fameros naturales (para los que se define&#8230;<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"footnotes":"","_jetpack_memberships_contains_paid_content":false},"categories":[1],"tags":[270,298],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_likes_enabled":false,"_links":{"self":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3109"}],"collection":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/comments?post=3109"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3109\/revisions"}],"predecessor-version":[{"id":3110,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/3109\/revisions\/3110"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=3109"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=3109"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=3109"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}