{"id":7722,"date":"2022-04-24T07:00:49","date_gmt":"2022-04-24T05:00:49","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=7722"},"modified":"2022-04-23T18:34:43","modified_gmt":"2022-04-23T16:34:43","slug":"la-semana-en-exercitium-del-18-al-23-de-abril","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/la-semana-en-exercitium-del-18-al-23-de-abril\/","title":{"rendered":"La semana en Exercitium (del 18 al 23 de abril)"},"content":{"rendered":"<p>Esta semana he publicado en <a href=\"http:\/\/bit.ly\/2sqPtGs\">Exercitium<\/a> las soluciones de los siguientes problemas:<\/p>\n<ul>\n<li><a href=\"#ej1\">1. Emparejamiento de \u00e1rboles<\/a><\/li>\n<li><a href=\"#ej2\">2. Eliminaci\u00f3n de las ocurrencias aisladas<\/a><\/li>\n<li><a href=\"#ej3\">3. Ordenada c\u00edclicamente<\/a><\/li>\n<\/ul>\n<p>A continuaci\u00f3n se muestran las soluciones.<br \/>\n<!--more--><br \/>\n<a name=\"ej1\"><\/a><\/p>\n<h3>1. Emparejamiento de \u00e1rboles<\/h3>\n<p>Los \u00e1rboles se pueden representar mediante el siguiente tipo de datos<\/p>\n<pre lang=\"text\">\n   data Arbol a = N a [Arbol a]\n     deriving (Show, Eq)\n<\/pre>\n<p>Por ejemplo, los \u00e1rboles<\/p>\n<pre lang=\"text\">\n     1               3\n    \/ \\             \/|\\\n   6   3           \/ | \\\n       |          5  4  7\n       5          |     \/\\\n                  6    2  1\n<\/pre>\n<p>se representan por<\/p>\n<pre lang=\"text\">\n   ej1, ej2 :: Arbol Int\n   ej1 = N 1 [N 6 [],N 3 [N 5 []]]\n   ej2 = N 3 [N 5 [N 6 []], N 4 [], N 7 [N 2 [], N 1 []]]\n<\/pre>\n<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   emparejaArboles :: (a -> b -> c) -> Arbol a -> Arbol b -> Arbol c\n<\/pre>\n<p>tal que <code>(emparejaArboles f a1 a2)<\/code> es el \u00e1rbol obtenido aplicando la funci\u00f3n <code>f<\/code> a los elementos de los \u00e1rboles <code>a1<\/code> y <code>a2<\/code> que se encuentran en la misma posici\u00f3n. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> emparejaArboles (+) (N 1 [N 2 [], N 3[]]) (N 1 [N 6 []])\n   N 2 [N 8 []]\n   \u03bb> emparejaArboles (+) ej1 ej2\n   N 4 [N 11 [],N 7 []]\n   \u03bb> emparejaArboles (+) ej1 ej1\n   N 2 [N 12 [],N 6 [N 10 []]]\n<\/pre>\n<h4>Soluciones<\/h4>\n<pre lang=\"haskell\">\nmodule Emparejamiento_de_arboles where\n\nimport Data.Tree (Tree (..))\nimport Control.Monad.Zip (mzipWith)\nimport Test.QuickCheck (Arbitrary, Gen, arbitrary, sublistOf, sized, quickCheck)\n\ndata Arbol a = N a [Arbol a]\n  deriving (Show, Eq)\n\nej1, ej2 :: Arbol Int\nej1 = N 1 [N 6 [],N 3 [N 5 []]]\nej2 = N 3 [N 5 [N 6 []], N 4 [], N 7 [N 2 [], N 1 []]]\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nemparejaArboles1 :: (a -> b -> c) -> Arbol a -> Arbol b -> Arbol c\nemparejaArboles1 f (N x xs) (N y ys) =\n  N (f x y) (zipWith (emparejaArboles1 f) xs ys)\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nemparejaArboles2 :: (a -> b -> c) -> Arbol a -> Arbol b -> Arbol c\nemparejaArboles2 f x y =\n  treeAarbol (mzipWith f (arbolAtree x) (arbolAtree y))\n\narbolAtree :: Arbol a -> Tree a\narbolAtree (N x xs) = Node x (map arbolAtree xs)\n\ntreeAarbol :: Tree a -> Arbol a\ntreeAarbol (Node x xs) = N x (map treeAarbol xs)\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- (arbolArbitrario n) es un \u00e1rbol aleatorio de orden n. Por ejemplo,\n--    \u03bb> generate (arbolArbitrario 5 :: Gen (Arbol Int))\n--    N (-26) [N 8 [N 6 [N 11 []]],N 7 []]\n--    \u03bb> generate (arbolArbitrario 5 :: Gen (Arbol Int))\n--    N 1 []\n--    \u03bb> generate (arbolArbitrario 5 :: Gen (Arbol Int))\n--    N (-19) [N (-11) [],N 25 [],N 19 [N (-27) [],N (-19) [N 17 []]]]\narbolArbitrario :: Arbitrary a => Int -> Gen (Arbol a)\narbolArbitrario n = do\n  x  <- arbitrary\n  ms <- sublistOf [0 .. n `div` 2]\n  as <- mapM arbolArbitrario ms\n  return (N x as)\n\n-- Arbol es una subclase de Arbitraria\ninstance Arbitrary a => Arbitrary (Arbol a) where\n  arbitrary = sized arbolArbitrario\n\n-- La propiedad es\nprop_emparejaArboles :: Arbol Int -> Arbol Int -> Bool\nprop_emparejaArboles x y =\n  emparejaArboles1 (+) x y == emparejaArboles2 (+) x y &&\n  emparejaArboles1 (*) x y == emparejaArboles2 (*) x y\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_emparejaArboles\n--    +++ OK, passed 100 tests.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> a500 <- generate (arbolArbitrario 500 :: Gen (Arbol Int))\n--    \u03bb> emparejaArboles1 (+) a500 a500 == emparejaArboles1 (+) a500 a500\n--    True\n--    (1.92 secs, 1,115,813,352 bytes)\n--    \u03bb> emparejaArboles2 (+) a500 a500 == emparejaArboles2 (+) a500 a500\n--    True\n--    (3.28 secs, 2,212,257,928 bytes)\n--\n--    \u03bb> b500 = arbolAtree a500\n--    \u03bb> mzipWith (+) b500 b500 == mzipWith (+) b500 b500\n--    True\n--    (0.21 secs, 563,503,112 bytes)\n<\/pre>\n<p>El c\u00f3digo se encuentra en <a href=\"https:\/\/github.com\/jaalonso\/Exercitium\/blob\/main\/src\/Emparejamiento_de_arboles.hs\">GitHub<\/a>.<\/p>\n<p>La elaboraci\u00f3n de las soluciones se describe en el siguiente v\u00eddeo<\/p>\n<p><iframe loading=\"lazy\" width=\"560\" height=\"315\" src=\"https:\/\/www.youtube.com\/embed\/RWO2_fadW4g\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe><\/p>\n<p><a name=\"ej2\"><\/a><\/p>\n<h3>2. Eliminaci\u00f3n de las ocurrencias aisladas<\/h3>\n<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   eliminaAisladas :: Eq a => a -> [a] -> [a]\n<\/pre>\n<p>tal que <code>(eliminaAisladas x ys)<\/code> es la lista obtenida eliminando en <code>ys<\/code> las ocurrencias aisladas de <code>x<\/code> (es decir, aquellas ocurrencias de <code>x<\/code> tales que su elemento anterior y posterior son distintos de <code>x<\/code>). Por ejemplo,<\/p>\n<pre lang=\"text\">\n   eliminaAisladas 'X' \"\"                  == \"\"\n   eliminaAisladas 'X' \"X\"                 == \"\"\n   eliminaAisladas 'X' \"XX\"                == \"XX\"\n   eliminaAisladas 'X' \"XXX\"               == \"XXX\"\n   eliminaAisladas 'X' \"abcd\"              == \"abcd\"\n   eliminaAisladas 'X' \"Xabcd\"             == \"abcd\"\n   eliminaAisladas 'X' \"XXabcd\"            == \"XXabcd\"\n   eliminaAisladas 'X' \"XXXabcd\"           == \"XXXabcd\"\n   eliminaAisladas 'X' \"abcdX\"             == \"abcd\"\n   eliminaAisladas 'X' \"abcdXX\"            == \"abcdXX\"\n   eliminaAisladas 'X' \"abcdXXX\"           == \"abcdXXX\"\n   eliminaAisladas 'X' \"abXcd\"             == \"abcd\"\n   eliminaAisladas 'X' \"abXXcd\"            == \"abXXcd\"\n   eliminaAisladas 'X' \"abXXXcd\"           == \"abXXXcd\"\n   eliminaAisladas 'X' \"XabXcdX\"           == \"abcd\"\n   eliminaAisladas 'X' \"XXabXXcdXX\"        == \"XXabXXcdXX\"\n   eliminaAisladas 'X' \"XXXabXXXcdXXX\"     == \"XXXabXXXcdXXX\"\n   eliminaAisladas 'X' \"XabXXcdXeXXXfXx\"   == \"abXXcdeXXXfx\"\n<\/pre>\n<h4>Soluciones<\/h4>\n<pre lang=\"haskell\">\nmodule Elimina_aisladas where\n\nimport Data.List (group)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\neliminaAisladas1 :: Eq a => a -> [a] -> [a]\neliminaAisladas1 _ [] = []\neliminaAisladas1 x [y]\n  | x == y    = []\n  | otherwise = [y]\neliminaAisladas1 x (y1:y2:ys)\n  | y1 \/= x   = y1 : eliminaAisladas1 x (y2:ys)\n  | y2 \/= x   = y2 : eliminaAisladas1 x ys\n  | otherwise = takeWhile (==x) (y1:y2:ys) ++\n                eliminaAisladas1 x (dropWhile (==x) ys)\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\neliminaAisladas2 :: Eq a => a -> [a] -> [a]\neliminaAisladas2 _ [] = []\neliminaAisladas2 x ys\n  | cs == [x] = as ++ eliminaAisladas2 x ds\n  | otherwise = as ++ cs ++ eliminaAisladas2 x ds\n  where (as,bs) = span (\/=x) ys\n        (cs,ds) = span (==x) bs\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\neliminaAisladas3 :: Eq a => a -> [a] -> [a]\neliminaAisladas3 x ys = concat [zs | zs <- group ys, zs \/= [x]]\n\n-- 4\u00aa soluci\u00f3n\n-- ===========\n\neliminaAisladas4 :: Eq a => a -> [a] -> [a]\neliminaAisladas4 x = concat . filter (\/= [x]) . group\n\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_eliminaAisladas :: Int -> [Int] -> Bool\nprop_eliminaAisladas x ys =\n  all (== eliminaAisladas1 x ys)\n      [eliminaAisladas2 x ys,\n       eliminaAisladas3 x ys,\n       eliminaAisladas4 x ys]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_eliminaAisladas\n--    +++ OK, passed 100 tests.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> length (eliminaAisladas1 'a' (take (5*10^6) (cycle \"abca\")))\n--    4999998\n--    (3.86 secs, 2,030,515,400 bytes)\n--    \u03bb> length (eliminaAisladas2 'a' (take (5*10^6) (cycle \"abca\")))\n--    4999998\n--    (3.41 secs, 2,210,516,832 bytes)\n--    \u03bb> length (eliminaAisladas3 'a' (take (5*10^6) (cycle \"abca\")))\n--    4999998\n--    (2.11 secs, 2,280,516,448 bytes)\n--    \u03bb> length (eliminaAisladas4 'a' (take (5*10^6) (cycle \"abca\")))\n--    4999998\n--    (0.92 secs, 1,920,516,704 bytes)\n<\/pre>\n<p>El c\u00f3digo se encuentra en <a href=\"https:\/\/github.com\/jaalonso\/Exercitium\/blob\/main\/src\/Elimina_aisladas.hs\">GitHub<\/a>.<\/p>\n<p>La elaboraci\u00f3n de las soluciones se describe en el siguiente v\u00eddeo<\/p>\n<p><iframe loading=\"lazy\" width=\"560\" height=\"315\" src=\"https:\/\/www.youtube.com\/embed\/7TJAdGjM3Ik\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe><\/p>\n<p><a name=\"ej3\"><\/a><\/p>\n<h3>3. Ordenada c\u00edclicamente<\/h3>\n<p>Se dice que una sucesi\u00f3n x(1), &#8230;, x(n) est\u00e1 ordenada c\u00edclicamente si existe un \u00edndice i tal que la sucesi\u00f3n<\/p>\n<pre lang=\"text\">\n   x(i), x(i+1), ..., x(n), x(1), ..., x(i-1)\n<\/pre>\n<p>est\u00e1 ordenada crecientemente de forma estricta.<\/p>\n<p>Definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   ordenadaCiclicamente :: Ord a => [a] -> Maybe Int\n<\/pre>\n<p>tal que <code>(ordenadaCiclicamente xs)<\/code> es el \u00edndice a partir del cual est\u00e1 ordenada, si la lista est\u00e1 ordenado c\u00edclicamente y <code>Nothing<\/code> en caso contrario. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   ordenadaCiclicamente [1,2,3,4]      ==  Just 0\n   ordenadaCiclicamente [5,8,1,3]      ==  Just 2\n   ordenadaCiclicamente [4,6,7,5,1,3]  ==  Nothing\n   ordenadaCiclicamente [1,0,3,2]      ==  Nothing\n   ordenadaCiclicamente [1,2,0]        ==  Just 2\n   ordenadaCiclicamente \"cdeab\"        ==  Just 3\n<\/pre>\n<p>Nota: Se supone que el argumento es una lista no vac\u00eda sin elementos repetidos.<\/p>\n<h4>Soluciones<\/h4>\n<pre lang=\"haskell\">\nmodule Ordenada_ciclicamente where\n\nimport Test.QuickCheck (Arbitrary, Gen, NonEmptyList (NonEmpty), Property,\n                        arbitrary, chooseInt, collect, quickCheck)\nimport Data.List       (nub, sort)\nimport Data.Maybe      (isJust, listToMaybe)\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nordenadaCiclicamente1 :: Ord a => [a] -> Maybe Int\nordenadaCiclicamente1 xs = aux 0 xs\n  where n = length xs\n        aux i zs\n          | i == n      = Nothing\n          | ordenada zs = Just i\n          | otherwise   = aux (i+1) (siguienteCiclo zs)\n\n-- (ordenada xs) se verifica si la lista xs est\u00e1 ordenada\n-- crecientemente. Por ejemplo,\n--   ordenada \"acd\"   ==  True\n--   ordenada \"acdb\"  ==  False\nordenada :: Ord a => [a] -> Bool\nordenada []     = True\nordenada (x:xs) = all (x <) xs &#038;&#038; ordenada xs\n\n-- (siguienteCiclo xs) es la lista obtenida a\u00f1adiendo el primer elemento\n-- de xs al final del resto de xs. Por ejemplo,\n--   siguienteCiclo [3,2,5]  =>  [2,5,3]\nsiguienteCiclo :: [a] -> [a]\nsiguienteCiclo []     = []\nsiguienteCiclo (x:xs) = xs ++ [x]\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nordenadaCiclicamente2 :: Ord a => [a] -> Maybe Int\nordenadaCiclicamente2 xs =\n  listToMaybe [n | n <- [0..length xs-1],\n                   ordenada (drop n xs ++ take n xs)]\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\nordenadaCiclicamente3 :: Ord a => [a] -> Maybe Int\nordenadaCiclicamente3 xs\n  | ordenada (bs ++ as) = Just k\n  | otherwise           = Nothing\n  where (_,k)   = minimum (zip xs [0..])\n        (as,bs) = splitAt k xs\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_ordenadaCiclicamente1 :: NonEmptyList Int -> Bool\nprop_ordenadaCiclicamente1 (NonEmpty xs) =\n  ordenadaCiclicamente1 xs == ordenadaCiclicamente2 xs\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_ordenadaCiclicamente1\n--    +++ OK, passed 100 tests.\n\n-- La propiedad para analizar los casos de prueba\nprop_ordenadaCiclicamente2 :: NonEmptyList Int -> Property\nprop_ordenadaCiclicamente2 (NonEmpty xs) =\n  collect (isJust (ordenadaCiclicamente1 xs)) $\n  ordenadaCiclicamente1 xs == ordenadaCiclicamente2 xs\n\n-- El an\u00e1lisis es\n--    \u03bb> quickCheck prop_ordenadaCiclicamente2\n--    +++ OK, passed 100 tests:\n--    89% False\n--    11% True\n\n-- Tipo para generar listas\nnewtype Lista = L [Int]\n  deriving Show\n\n-- Generador de listas.\nlistaArbitraria :: Gen Lista\nlistaArbitraria = do\n  x <- arbitrary\n  xs <- arbitrary\n  let ys = x : xs\n  k <- chooseInt (0, length ys)\n  let (as,bs) = splitAt k (sort (nub ys))\n  return (L (bs ++ as))\n\n-- Lista es una subclase de Arbitrary.\ninstance Arbitrary Lista where\n  arbitrary = listaArbitraria\n\n-- La propiedad para analizar los casos de prueba\nprop_ordenadaCiclicamente3 :: Lista -> Property\nprop_ordenadaCiclicamente3 (L xs) =\n  collect (isJust (ordenadaCiclicamente1 xs)) $\n  ordenadaCiclicamente1 xs == ordenadaCiclicamente2 xs\n\n-- El an\u00e1lisis es\n--    \u03bb> quickCheck prop_ordenadaCiclicamente3\n--    +++ OK, passed 100 tests (100% True).\n\n-- Tipo para generar\nnewtype Lista2 = L2 [Int]\n  deriving Show\n\n-- Generador de listas\nlistaArbitraria2 :: Gen Lista2\nlistaArbitraria2 = do\n  x' <- arbitrary\n  xs <- arbitrary\n  let ys = x' : xs\n  k <- chooseInt (0, length ys)\n  let (as,bs) = splitAt k (sort (nub ys))\n  n <- chooseInt (0,1)\n  return (if even n\n          then L2 (bs ++ as)\n          else L2 ys)\n\n-- Lista es una subclase de Arbitrary.\ninstance Arbitrary Lista2 where\n  arbitrary = listaArbitraria2\n\n-- La propiedad para analizar los casos de prueba\nprop_ordenadaCiclicamente4 :: Lista2 -> Property\nprop_ordenadaCiclicamente4 (L2 xs) =\n  collect (isJust (ordenadaCiclicamente1 xs)) $\n  ordenadaCiclicamente1 xs == ordenadaCiclicamente2 xs\n\n-- El an\u00e1lisis es\n--    \u03bb> quickCheck prop_ordenadaCiclicamente4\n--    +++ OK, passed 100 tests:\n--    51% True\n--    49% False\n\n-- La propiedad es\nprop_ordenadaCiclicamente :: Lista2 -> Bool\nprop_ordenadaCiclicamente (L2 xs) =\n  all (== ordenadaCiclicamente1 xs)\n      [ordenadaCiclicamente2 xs,\n       ordenadaCiclicamente3 xs]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_ordenadaCiclicamente\n--    +++ OK, passed 100 tests.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> ordenadaCiclicamente1 ([100..4000] ++ [1..99])\n--    Just 3901\n--    (3.27 secs, 2,138,864,568 bytes)\n--    \u03bb> ordenadaCiclicamente2 ([100..4000] ++ [1..99])\n--    Just 3901\n--    (2.44 secs, 1,430,040,008 bytes)\n--    \u03bb> ordenadaCiclicamente3 ([100..4000] ++ [1..99])\n--    Just 3901\n--    (1.18 secs, 515,549,200 bytes)\n<\/pre>\n<p>El c\u00f3digo se encuentra en <a href=\"https:\/\/github.com\/jaalonso\/Exercitium\/blob\/main\/src\/Ordenada_ciclicamente.hs\">GitHub<\/a>.<\/p>\n<p>La elaboraci\u00f3n de las soluciones se describe en el siguiente v\u00eddeo<\/p>\n<p><iframe loading=\"lazy\" width=\"560\" height=\"315\" src=\"https:\/\/www.youtube.com\/embed\/CI090GISHUc\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Esta semana he publicado en Exercitium las soluciones de los siguientes problemas: 1. Emparejamiento de \u00e1rboles 2. Eliminaci\u00f3n de las ocurrencias aisladas 3. Ordenada c\u00edclicamente A continuaci\u00f3n se muestran las soluciones.<\/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":[337],"tags":[],"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\/7722"}],"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=7722"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7722\/revisions"}],"predecessor-version":[{"id":7723,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7722\/revisions\/7723"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=7722"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=7722"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=7722"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}