{"id":4506,"date":"2014-10-20T20:35:54","date_gmt":"2014-10-20T18:35:54","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=4506"},"modified":"2014-10-20T20:35:54","modified_gmt":"2014-10-20T18:35:54","slug":"i1m2014-ejercicios-de-definiciones-por-comprension-2","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/i1m2014-ejercicios-de-definiciones-por-comprension-2\/","title":{"rendered":"I1M2014: Ejercicios de definiciones por comprensi\u00f3n"},"content":{"rendered":"<p>En la clase de hoy del curso de <a href=\"http:\/\/www.cs.us.es\/~jalonso\/cursos\/i1m-14\">Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas<\/a> hemos comentado las soluciones de los restantes ejercicios de la 3\u00aa relaci\u00f3n sobre definiciones por comprensi\u00f3n.<\/p>\n<p>Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<br \/>\n<!--more--><\/p>\n<pre lang=\"haskell\">\n-- ---------------------------------------------------------------------\n-- \u00a7 Librer\u00edas auxiliares                                             --\n-- ---------------------------------------------------------------------\n\nimport Test.QuickCheck\n\n-- ---------------------------------------------------------------------\n-- \u00a7 Ejercicios propuestos                                            --\n-- ---------------------------------------------------------------------\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 13. [Del problema 21 del Proyecto Euler]. Sea d(n) la suma\n-- de los divisores propios de n. Si d(a) = b y d(b) = a, siendo a \u2260 b,\n-- decimos que a y b son un par de n\u00fameros amigos. Por ejemplo, los\n-- divisores propios de 220 son 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 y\n-- 110; por tanto, d(220) = 284. Los divisores propios de 284 son 1, 2,\n-- 4, 71 y 142; por tanto,  d(284) = 220.  Luego, 220 y 284 son dos\n-- n\u00fameros amigos. \n-- \n-- Definir la funci\u00f3n \n--    amigos :: Int -> Int -> Bool\n-- tal que (amigos a b) se verifica si a y b son n\u00fameros amigos. Por\n-- ejemplo, \n--    amigos 6 6       == False\n--    amigos 220 248   == False\n--    amigos 220 284   == True\n--    amigos 100 200   == False\n--    amigos 1184 1210 == True\n-- ---------------------------------------------------------------------\n\namigos :: Int -> Int -> Bool\namigos a b = a \/= b && sumaDivisores a == b && sumaDivisores b == a\n    where sumaDivisores n = sum [x | x <- [1..n-1], n `rem` x == 0]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 14. (Problema 211 del proyecto Euler) Dado un entero\n-- positivo n, consideremos la suma de los cuadrados de sus divisores,\n-- Por ejemplo,  \n--    f(10) = 1 + 4 + 25 + 100 = 130\n--    f(42) = 1 + 4 +  9 +  36 + 49 + 196 + 441 + 1764 = 2500\n-- Decimos que n es especial si f(n) es un cuadrado perfecto. En los\n-- ejemplos anteriores, 42 es especial y 10 no lo es.\n-- \n-- Definir la funci\u00f3n \n--    especial:: Int -> Bool\n-- tal que (especial x) se verifica si x es un n\u00famero es especial. Por\n-- ejemplo, \n--    especial 42  ==  True\n--    especial 10  ==  False\n-- Calcular todos los n\u00fameros especiales de tres cifras.\n-- ---------------------------------------------------------------------\n\nespecial:: Int -> Bool\nespecial n = esCuadrado (sum [x^2 | x <- divisores n])\n\n-- (esCuadrado n) se verifica si n es un cuadrado perfecto. Por ejemplo, \n--    esCuadrado 36  ==  True\n--    esCuadrado 40  ==  False\nesCuadrado :: Int -> Bool\nesCuadrado n = y^2 == n\n    where y = floor (sqrt (fromIntegral n))\n\n-- (divisores n) es la lista de los divisores de n. Por ejemplo,\n--    divisores 36  ==  [1,2,3,4,6,9,12,18,36]\ndivisores :: Int -> [Int]        \ndivisores n = [x | x <- [1..n], rem n x == 0]        \n\n-- ---------------------------------------------------------------------\n-- Ejercicio 15. La multiplicidad de x en y es la mayor potencia de x\n-- que divide a y. Por ejemplo, la multiplicidad de 2 en 40 es 3 porque\n-- 40 es divisible por 2^3 y no lo es por 2^4. Adem\u00e1s, la multiplicidad\n-- de 1 en cualquier n\u00famero se supone igual a 1. \n-- \n-- Definir la funci\u00f3n\n--    multiplicidad :: Integer -> Integer -> Integer\n-- tal que (multiplicidad x y) es la\n-- multiplicidad de x en y. Por ejemplo,\n--    multiplicidad 2 40  ==  3\n--    multiplicidad 5 40  ==  1\n--    multiplicidad 3 40  ==  0\n--    multiplicidad 1 40  ==  1\n-- ---------------------------------------------------------------------\n\nmultiplicidad :: Integer -> Integer -> Integer\nmultiplicidad 1 _ = 1\nmultiplicidad x y = \n    head [n | n <- [0..], y `rem` (x^(n+1)) \/= 0] \n\n-- ---------------------------------------------------------------------\n-- Ejercicio 16.1. Sea t una lista de pares de la forma \n--    (nombre, [(asig_1, nota_1),...,(asig_k, nota.k)])\n-- Por ejemplo, \n--    t1 = [(\"Ana\",[(\"Alg\",1),(\"Cal\",3),(\"Inf\",8),(\"Fis\",2)]),\n--          (\"Juan\",[(\"Alg\",5),(\"Cal\",1),(\"Inf\",2),(\"Fis\",9)]),\n--          (\"Alba\",[(\"Alg\",5),(\"Cal\",6),(\"Inf\",6),(\"Fis\",5)]),\n--          (\"Pedro\",[(\"Alg\",9),(\"Cal\",5),(\"Inf\",3),(\"Fis\",1)])]\n-- Definir la funci\u00f3n \n--    calificaciones :: [(String,[(String,Int)])] -> String -> [(String,Int)]\n-- tal que (calificaciones t p) es la lista de las calificaciones de la\n-- persona p en la lista t. Por ejemplo, \n--    ghci> calificaciones t1 \"Pedro\"\n--    [(\"Alg\",9),(\"Cal\",5),(\"Inf\",3),(\"Fis\",1)]\n-- ---------------------------------------------------------------------\n\nt1 :: [(String,[(String,Int)])]\nt1 = [(\"Ana\",[(\"Alg\",1),(\"Cal\",3),(\"Inf\",8),(\"Fis\",2)]),\n      (\"Juan\",[(\"Alg\",5),(\"Cal\",1),(\"Inf\",2),(\"Fis\",9)]),\n      (\"Alba\",[(\"Alg\",5),(\"Cal\",6),(\"Inf\",6),(\"Fis\",5)]),\n      (\"Pedro\",[(\"Alg\",9),(\"Cal\",5),(\"Inf\",3),(\"Fis\",1)])]\n\ncalificaciones :: [(String,[(String,Int)])] -> String -> [(String,Int)]\ncalificaciones t p = head [xs | (x,xs) <- t, x == p]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 16.2. Definir la funci\u00f3n  \n--    todasAprobadas :: [(String,[(String,Int)])] -> String -> Bool\n-- tal que (todasAprobadas t p) se cumple si en la lista t, p tiene\n-- todas las asignaturas aprobadas. Por ejemplo,\n--    todasAprobadas t1 \"Alba\"  ==  True\n--    todasAprobadas t1 \"Pedro\" ==  False\n-- ---------------------------------------------------------------------\n\ntodasAprobadas :: [(String,[(String,Int)])] -> String -> Bool\ntodasAprobadas t p = and [n >= 5 | (_,n) <- calificaciones t p]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 16.3. Definir la funci\u00f3n  \n--    aprobados :: [(String,[(String,Int)])] -> [String]\n-- tal que (aprobados t) es la lista de los alumnos de la lista de notas\n-- t que han aprobado todas las asignaturas.Por ejemplo,\n--    ghci> aprobados t1  ==  [\"Alba\"]\n-- ---------------------------------------------------------------------\n\naprobados :: [(String,[(String,Int)])] -> [String]\naprobados t = [p | (p,_) <- t, todasAprobadas t p]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 17. Un n\u00famero n es de Angelini si n y 2n tienen alg\u00fan\n-- d\u00edgito com\u00fan. Por ejemplo, 2014 es un n\u00famero de Angelini ya que 2014\n-- y su doble (4028) comparten los d\u00edgitos 4 y 0.\n--\n-- Definir la funci\u00f3n\n--    angelini :: Integer -> Bool\n-- tal que (angelini n) se verifica si n es un n\u00famero de Angelini. Por\n-- ejemplo, \n--    angelini 2014  ==  True\n--    angelini 2067  ==  False\n-- ---------------------------------------------------------------------\n\nangelini :: Integer -> Bool\nangelini n = not (null [x | x <- show n, x `elem` show (2*n)])\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 18.1. Definir la funci\u00f3n \n--    unitarios :: Integer -> [Integer]\n-- tal (unitarios n) es la lista de n\u00fameros [n,nn, nnn, ....]. Por\n-- ejemplo.  \n--    take 7 (unitarios 3) == [3,33,333,3333,33333,333333,3333333]\n--    take 3 (unitarios 1) == [1,11,111]\n-- ---------------------------------------------------------------------\n\nunitarios :: Integer -> [Integer]\nunitarios x = [x*(div (10^n-1) 9) | n <- [1 ..]]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 18.2. Definir la funci\u00f3n \n--    multiplosUnitarios :: Integer -> Integer -> Int -> [Integer]\n-- tal que (multiplosUnitarios x y n) es la lista de los n primeros\n-- m\u00faltiplos de x cuyo \u00fanico d\u00edgito es y. Por ejemplo,\n--    multiplosUnitarios 7 1 2  == [111111,111111111111]\n--    multiplosUnitarios 11 3 5 == [33,3333,333333,33333333,3333333333]\n-- ---------------------------------------------------------------------\n\nmultiplosUnitarios :: Integer -> Integer -> Int -> [Integer]\nmultiplosUnitarios x y n = take n [z | z <- unitarios y, mod z x == 0]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 19. Definir la funci\u00f3n \n--    masOcurrentes :: Eq a => [a] -> [a]\n-- tal que (masOcurrentes xs) es la lista de los elementos de xs que\n-- ocurren el m\u00e1ximo n\u00famero de veces. Por ejemplo,\n--    masOcurrentes [1,2,3,4,3,2,3,1,4] == [3,3,3]\n--    masOcurrentes [1,2,3,4,5,2,3,1,4] == [1,2,3,4,2,3,1,4]\n--    masOcurrentes \"Salamanca\"         == \"aaaa\"\n-- ---------------------------------------------------------------------\n\nmasOcurrentes :: Eq a => [a] -> [a]\nmasOcurrentes xs = [x | x <- xs, ocurrencias x xs == m]\n    where m = maximum [ocurrencias x xs | x <-xs]\n\n-- (ocurrencias x xs) es el n\u00famero de ocurrencias de x en xs. Por\n-- ejemplo, \n--    ocurrencias 1 [1,2,3,4,3,2,3,1,4]  ==  2\nocurrencias x xs = length [x' | x' <- xs, x == x']  \n\n-- ---------------------------------------------------------------------\n-- Ejercicio 20. La suma de la serie\n--    1\/1^2 + 1\/2^2 + 1\/3^2 + 1\/4^2 + ...\n-- es pi^2\/6. Por tanto, pi se puede aproximar mediante la ra\u00edz cuadrada\n-- de 6 por la suma de la serie.\n-- \n-- Definir la funci\u00f3n aproximaPi tal que (aproximaPi n) es la aproximaci\u00f3n \n-- de pi obtenida mediante n t\u00e9rminos de la serie. Por ejemplo, \n--    aproximaPi 4    == 2.9226129861250305\n--    aproximaPi 1000 == 3.1406380562059946\n-- ---------------------------------------------------------------------\n\naproximaPi n = sqrt (6 * sum [1\/x^2 | x <- [1..n]])\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 21. Una representaci\u00f3n de 20 en base 2 es [0,0,1,0,1] pues\n-- 20 = 1*2^2 + 1*2^4. Y una representaci\u00f3n de 46 en base 3 es [1,0,2,1]\n-- pues 46 = 1*3^0 + 0*3^1 + 2*3^2 + 1*3^3.\n-- \n-- Definir la funci\u00f3n \n--    deBaseABase10 :: Int -> [Int] -> Int\n-- tal que (deBaseABase10 b xs) es el n\u00famero n tal que su representaci\u00f3n\n-- en base b es xs. Por ejemplo, \n--    deBaseABase10 2 [0,0,1,0,1]      == 20\n--    deBaseABase10 2 [1,1,0,1]        == 11\n--    deBaseABase10 3 [1,0,2,1]        == 46\n--    deBaseABase10 5 [0,2,1,3,1,4,1]  == 29160\n-- ---------------------------------------------------------------------\n\ndeBaseABase10 :: Int -> [Int] -> Int\ndeBaseABase10 b xs = sum [y*b^n | (y,n) <- zip xs [0..]]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 22.1. Definir la funci\u00f3n \n--    conPos :: [a] -> [(a,Int)]\n-- tal que (conPos xs) es la lista obtenida a partir de xs especificando\n-- las posiciones de sus elementos. Por ejemplo, \n--    conPos [1,5,0,7] == [(1,0),(5,1),(0,2),(7,3)]\n-- ---------------------------------------------------------------------\n\nconPos :: [a] -> [(a,Int)]\nconPos xs = zip xs [0..]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 22.2. Definir la \n--    pares :: [a] -> [a]\n-- tal que (pares cs) es la cadena formada por los caracteres en\n-- posici\u00f3n par de cs. Por ejemplo,  \n--    pares \"el cielo sobre berlin\" == \"e il or eln\"\n-- ---------------------------------------------------------------------\n\npares :: [a] -> [a]\npares cs = [c | (c,n) <- conPos cs, even n]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 23. Dos listas xs, ys de la misma longitud son\n-- perpendiculares si el producto escalar de ambas es 0, donde el\n-- producto escalar de dos listas de enteros xs e ys viene\n-- dado por la suma de los productos de los elementos correspondientes.\n-- \n-- Definir la funci\u00f3n \n--    perpendiculares :: (Num a, Eq a) => [a] -> [[a]] -> [[a]]\n-- tal que (perpendiculares xs yss) es la lista de los elementos de yss\n-- que son perpendiculares a xs. Por ejemplo,\n--    ghci> perpendiculares [1,0,1] [[0,1,0], [2,3,1], [-1,7,1],[3,1,0]]\n--    [[0,1,0],[-1,7,1]]\n-- ---------------------------------------------------------------------\n\nperpendiculares :: (Num a, Eq a) => [a] -> [[a]] -> [[a]]\nperpendiculares xs yss = [ys | ys <- yss, productoEscalar xs ys == 0]\n\nproductoEscalar :: Num a => [a] -> [a] -> a\nproductoEscalar xs ys =\n    sum [x*y | (x,y) <- zip xs ys]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 24. Dada una lista de n\u00fameros enteros, definiremos el\n-- mayor salto como el mayor valor de las diferencias (en valor\n-- absoluto) entre n\u00fameros consecutivos de la lista. Por ejemplo, dada\n-- la lista [2,5,-3] las distancias son \n--    3 (valor absoluto de la resta 2 - 5) y\n--    8 (valor absoluto de la resta de 5 y (-3))\n-- Por tanto, su mayor salto es 8. No est\u00e1 definido el mayor salto para\n-- listas con menos de 2 elementos\n--\n-- Definir la funci\u00f3n \n--    mayorSalto :: [Integer] -> Integer\n-- tal que (mayorSalto xs) es el mayor salto de la lista xs. Por\n-- ejemplo, \n--    mayorSalto [1,5]              == 4\n--    mayorSalto [10,-10,1,4,20,-2] == 22\n-- ---------------------------------------------------------------------\n\nmayorSalto :: [Integer] -> Integer\nmayorSalto xs = maximum [abs (x-y) | (x,y) <- zip xs (tail xs)]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 25. Definir la funci\u00f3n\n--    longCamino :: [(Float,Float)] -> Float\n-- tal que (longCamino xs) es la longitud del camino determinado por los\n-- puntos del plano listados en xs. Por ejemplo,\n--    longCamino [(0,0),(1,0),(2,1),(2,0)] == 3.4142137\n-- ---------------------------------------------------------------------\n\nlongCamino :: [(Float,Float)] -> Float\nlongCamino xs = \n    sum [sqrt ((a-c)^2+(b-d)^2)| ((a,b),(c,d)) <- zip xs (tail xs)]\n\nlongCamino2 xs = \n    sum [sqrt ((a-c)^2+(b-d)^2)| ((a,b),(c,d)) <- zip xs (tail xs)]\n\nlongCamino3 :: [(Double,Double)] -> Double\nlongCamino3 xs = \n    sum [sqrt ((a-c)^2+(b-d)^2)| ((a,b),(c,d)) <- zip xs (tail xs)]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 26. Definir la funci\u00f3n\n--    numerosConsecutivos :: (Num a, Eq a) => [a] -> Int\n-- tal que (numeroConsecutivosC xs) es la cantidad de n\u00fameros\n-- consecutivos (es decir, n\u00fameros que son iguales a su predecesor en la\n-- lista m\u00e1s uno) que aparecen en la lista xs. Por ejemplo, \n--    numerosConsecutivos []             ==  0\n--    numerosConsecutivos [5,6,9]        ==  1\n--    numerosConsecutivos [5,6,9,2,3,4]  ==  3\n-- ---------------------------------------------------------------------\n\nnumerosConsecutivos :: (Num a, Eq a) => [a] -> Int\nnumerosConsecutivos xs = \n    length [x | (x,y) <- zip xs (tail xs), y == x+1]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 27. Definir la funci\u00f3n\n--    sumaEquidistantes :: Num a => [a] -> [a]\n-- tal que (sumaEquidistantes xs) es la lista sumando el primer elemento\n-- de xs con el \u00faltimo, el segundo con el pen\u00faltimo y as\u00ed\n-- sucesivamente. Por ejemplo, \n--    sumaEquidistantes [6,5,3,1]              ==  [7,8]\n--    sumaEquidistantes [6,5,3]                ==  [9,10]\n--    sumaEquidistantes [3,2,3,2]              ==  [5,5]\n--    sumaEquidistantes [6,5,3,1,2,0,4,7,8,9]  ==  [15,13,10,5,2]\n-- ---------------------------------------------------------------------\n\nsumaEquidistantes :: Num a => [a] -> [a]\nsumaEquidistantes xs = take n [x+y | (x,y) <- zip xs (reverse xs)]\n    where m = length xs\n          n | even m    = m `div` 2\n            | otherwise = 1 + (m `div` 2)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 28. La distancia entre dos n\u00fameros es el valor absoluto de\n-- su diferencia. Por ejemplo, la distancia entre 2 y 5 es 3. \n-- \n-- Definir la funci\u00f3n\n--    cercanos :: [Int] -> [Int] -> [(Int,Int)]\n-- tal que (cercanos xs ys) es la lista de pares de elementos de xs e ys\n-- cuya distancia es m\u00ednima. Por ejemplo,\n--    cercanos [3,7,2,1] [5,11,9]  ==  [(3,5),(7,5),(7,9)]\n-- ---------------------------------------------------------------------\n\ncercanos :: [Int] -> [Int] -> [(Int,Int)]\ncercanos xs ys =\n    [(x,y) | (x,y) <- pares, abs (x-y) == m]\n    where pares = [(x,y) | x <- xs, y <- ys]\n          m     = minimum [abs (x-y) | (x,y) <- pares]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 29. [De la IMO 1996]. Una sucesi\u00f3n [a(0),a(1),...,a(n)] \n-- se denomina cuadr\u00e1tica si para cada i \u2208 {1, 2,..., n} se cumple que \n--    |a(i) \u2212 a(i\u22121)| = i^2 .\n-- \n-- Definir la funci\u00f3n\n--    esCuadratica :: [Int] -> Bool\n-- tal que (esCuadratica xs) se verifica si xs cuadr\u00e1tica.  Por ejemplo,\n--    esCuadratica [2,1,-3,6]                      == True\n--    esCuadratica [2,1,3,5]                       == False\n--    esCuadratica [3,4,8,17,33,58,94,45,-19,-100] == True\n-- ---------------------------------------------------------------------\n\nesCuadratica :: [Int] -> Bool\nesCuadratica xs = \n    and [abs (y-x) == i^2 | ((x,y),i) <- zip (adyacentes xs) [1..]]\n\nadyacentes xs = zip xs (tail xs)\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 30.1. Definir las funciones  \n--    ultima, primera :: Int -> Int  \n-- tales que\n-- * (ultima n) es la \u00faltima cifra del n\u00famero natural n y\n-- * (primera n) es la primera cifra del n\u00famero natural n.\n-- Por ejemplo,\n--    ultima  711 = 1         \n--    primera 711 = 7\n-- ---------------------------------------------------------------------\n\nultima, primera :: Int -> Int  \nultima n  = n `rem` 10\nprimera n = read [head (show n)]\n\n-- ---------------------------------------------------------------------\n-- Ejercicio 30.2. Definir la funci\u00f3n\n--    encadenadoC :: [Int] -> Bool\n-- tal que (encadenadoC xs) se verifica si xs es una lista de enteros\n-- positivos encadenados (es decir, la \u00faltima cifra de cada n\u00famero\n-- coincide con la primera del siguiente en la lista). Por ejemplo,\n--   encadenadoC [711,1024,413,367]  ==  True\n--   encadenadoC [711,1024,213,367]  ==  False\n-- ---------------------------------------------------------------------\n\nencadenadoC :: [Int] -> Bool\nencadenadoC xs = \n    and [ultima x == primera y | (x,y) <- zip xs (tail xs)]\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>En la clase de hoy del curso de Inform\u00e1tica de 1\u00ba del Grado en Matem\u00e1ticas hemos comentado las soluciones de los restantes ejercicios de la 3\u00aa relaci\u00f3n sobre definiciones por comprensi\u00f3n. Los ejercicios y su soluci\u00f3n se muestran a continuaci\u00f3n<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","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":[238],"tags":[270,305],"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\/4506"}],"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=4506"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/4506\/revisions"}],"predecessor-version":[{"id":4507,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/4506\/revisions\/4507"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=4506"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=4506"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=4506"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}