{"id":7893,"date":"2023-02-19T13:24:47","date_gmt":"2023-02-19T12:24:47","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=7893"},"modified":"2023-02-19T13:26:48","modified_gmt":"2023-02-19T12:26:48","slug":"18-feb-23","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/18-feb-23\/","title":{"rendered":"La semana en Exercitium (18 de febrero de 2023)"},"content":{"rendered":"<p>Esta semana he publicado en <a href=\"http:\/\/bit.ly\/2sqPtGs\">Exercitium<\/a> las soluciones de los siguientes problemas sobre el tipo abstracto de las colas:<\/p>\n<ul>\n<li><a href=\"#ej1\">1. Todos los elementos de la cola verifican una propiedad<\/a><\/li>\n<li><a href=\"#ej2\">2. Alg\u00fan elemento de la cola verifica una propiedad<\/a><\/li>\n<li><a href=\"#ej3\">3. Extensi\u00f3n de colas<\/a><\/li>\n<li><a href=\"#ej4\">4. Intercalado de dos colas<\/a><\/li>\n<li><a href=\"#ej5\">5. Agrupaci\u00f3n de colas<\/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. Todos los elementos verifican una propiedad<\/h3>\n<p>Utilizando el <a href=\"https:\/\/bit.ly\/3QWTsRL\">tipo abstracto de datos de las colas<\/a>, definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   todosVerifican :: (a -> Bool) -> Cola a -> Bool\n<\/pre>\n<p>tal que <code>todosVerifican p c<\/code> se verifica si todos los elementos de la cola <code>c<\/code> cumplen la propiedad <code>p<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   todosVerifican (>0) (inserta 3 (inserta 2 vacia))    == True\n   todosVerifican (>0) (inserta 3 (inserta (-2) vacia)) == False\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\nimport TAD.Cola (Cola, vacia, inserta, primero, resto, esVacia)\nimport Transformaciones_colas_listas (colaAlista, listaAcola)\nimport Test.QuickCheck.HigherOrder\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\ntodosVerifican1 :: (a -> Bool) -> Cola a -> Bool\ntodosVerifican1 p c\n  | esVacia c = True\n  | otherwise = p pc && todosVerifican1 p rc\n  where pc = primero c\n        rc = resto c\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\ntodosVerifican2 :: (a -> Bool) -> Cola a -> Bool\ntodosVerifican2 p c =\n  all p (colaAlista c)\n\n-- La funci\u00f3n colaAlista est\u00e1 definida en el ejercicio\n-- \"Transformaciones entre colas y listas\" que se encuentra en\n-- https:\/\/bit.ly\/3Xv0oIt\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_todosVerifican :: (Int -> Bool) -> [Int] -> Bool\nprop_todosVerifican p xs =\n  todosVerifican1 p c == todosVerifican2 p c\n  where c = listaAcola xs\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck' prop_todosVerifican\n--    +++ OK, passed 100 tests.\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom copy import deepcopy\nfrom typing import Callable, TypeVar\n\nfrom hypothesis import given\n\nfrom src.TAD.cola import (Cola, colaAleatoria, esVacia, inserta, primero,\n                          resto, vacia)\nfrom src.transformaciones_colas_listas import colaAlista\n\nA = TypeVar('A')\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef todosVerifican1(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    if esVacia(c):\n        return True\n    pc = primero(c)\n    rc = resto(c)\n    return p(pc) and todosVerifican1(p, rc)\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef todosVerifican2(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    return all(p(x) for x in colaAlista(c))\n\n# La funci\u00f3n colaAlista est\u00e1 definida en el ejercicio\n# \"Transformaciones entre colas y listas\" que se encuentra en\n# https:\/\/bit.ly\/3Xv0oIt\n\n# 3\u00aa soluci\u00f3n\n# ===========\n\ndef todosVerifican3Aux(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    if c.esVacia():\n        return True\n    pc = c.primero()\n    c.resto()\n    return p(pc) and todosVerifican3Aux(p, c)\n\ndef todosVerifican3(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    _c = deepcopy(c)\n    return todosVerifican3Aux(p, _c)\n\n# 4\u00aa soluci\u00f3n\n# ===========\n\ndef todosVerifican4Aux(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    if c.esVacia():\n        return True\n    pc = c.primero()\n    c.resto()\n    return p(pc) and todosVerifican4Aux(p, c)\n\ndef todosVerifican4(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    _c = deepcopy(c)\n    return todosVerifican4Aux(p, _c)\n\n# 5\u00aa soluci\u00f3n\n# ===========\n\ndef todosVerifican5Aux(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    while not c.esVacia():\n        if not p(c.primero()):\n            return False\n        c.resto()\n    return True\n\ndef todosVerifican5(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    _c = deepcopy(c)\n    return todosVerifican5Aux(p, _c)\n\n# Comprobaci\u00f3n de equivalencia\n# ============================\n\n# La propiedad es\n@given(c=colaAleatoria())\ndef test_filtraPila(c: Cola[int]) -> None:\n    r = todosVerifican1(lambda x: x > 0, c)\n    assert todosVerifican2(lambda x: x > 0, c) == r\n    assert todosVerifican3(lambda x: x > 0, c) == r\n    assert todosVerifican4(lambda x: x > 0, c) == r\n    assert todosVerifican5(lambda x: x > 0, c) == r\n\n# La comprobaci\u00f3n es\n#    src> poetry run pytest -q todosVerifican.py\n#    1 passed in 0.25s\n<\/pre>\n<p><a name=\"ej2\"><\/a><\/p>\n<h3>2. Alg\u00fan elemento de la cola verifica una propiedad<\/h3>\n<p>Utilizando el <a href=\"https:\/\/bit.ly\/3QWTsRL\">tipo abstracto de datos de las colas<\/a>, definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   algunoVerifica :: (a -> Bool) -> Cola a -> Bool\n<\/pre>\n<p>tal que <code>algunoVerifica p c<\/code> se verifica si alguno de los elementos de la cola <code>c<\/code> cumplen la propiedad <code>p<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   algunoVerifica (< 0) (inserta 3 (inserta (-2) vacia)) == True\n   algunoVerifica (< 0) (inserta 3 (inserta 2 vacia))    == False\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\nimport TAD.Cola (Cola, vacia, inserta, primero, resto, esVacia)\nimport Transformaciones_colas_listas (colaAlista, listaAcola)\nimport Test.QuickCheck.HigherOrder\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nalgunoVerifica1 :: (a -> Bool) -> Cola a -> Bool\nalgunoVerifica1 p c\n  | esVacia c = False\n  | otherwise = p pc || algunoVerifica1 p rc\n  where pc = primero c\n        rc = resto c\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nalgunoVerifica2 :: (a -> Bool) -> Cola a -> Bool\nalgunoVerifica2 p c =\n  any p (colaAlista c)\n\n-- La funci\u00f3n colaAlista est\u00e1 definida en el ejercicio\n-- \"Transformaciones entre colas y listas\" que se encuentra en\n-- https:\/\/bit.ly\/3Xv0oIt\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_algunoVerifica :: (Int -> Bool) -> [Int] -> Bool\nprop_algunoVerifica p xs =\n  algunoVerifica1 p c == algunoVerifica2 p c\n  where c = listaAcola xs\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck' prop_algunoVerifica\n--    +++ OK, passed 100 tests.\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom copy import deepcopy\nfrom typing import Callable, TypeVar\n\nfrom hypothesis import given\n\nfrom src.TAD.cola import (Cola, colaAleatoria, esVacia, inserta, primero,\n                          resto, vacia)\nfrom src.transformaciones_colas_listas import colaAlista\n\nA = TypeVar('A')\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef algunoVerifica1(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    if esVacia(c):\n        return False\n    pc = primero(c)\n    rc = resto(c)\n    return p(pc) or algunoVerifica1(p, rc)\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef algunoVerifica2(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    return any(p(x) for x in colaAlista(c))\n\n# La funci\u00f3n colaAlista est\u00e1 definida en el ejercicio\n# \"Transformaciones entre colas y listas\" que se encuentra en\n# https:\/\/bit.ly\/3Xv0oIt\n\n# 3\u00aa soluci\u00f3n\n# ===========\n\ndef algunoVerifica3Aux(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    if c.esVacia():\n        return False\n    pc = c.primero()\n    c.resto()\n    return p(pc) or algunoVerifica3Aux(p, c)\n\ndef algunoVerifica3(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    _c = deepcopy(c)\n    return algunoVerifica3Aux(p, _c)\n\n# 4\u00aa soluci\u00f3n\n# ===========\n\ndef algunoVerifica4Aux(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    if c.esVacia():\n        return False\n    pc = c.primero()\n    c.resto()\n    return p(pc) or algunoVerifica4Aux(p, c)\n\ndef algunoVerifica4(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    _c = deepcopy(c)\n    return algunoVerifica4Aux(p, _c)\n\n# 5\u00aa soluci\u00f3n\n# ===========\n\ndef algunoVerifica5Aux(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    while not c.esVacia():\n        if p(c.primero()):\n            return True\n        c.resto()\n    return False\n\ndef algunoVerifica5(p: Callable[[A], bool], c: Cola[A]) -> bool:\n    _c = deepcopy(c)\n    return algunoVerifica5Aux(p, _c)\n\n# Comprobaci\u00f3n de equivalencia\n# ============================\n\n# La propiedad es\n@given(c=colaAleatoria())\ndef test_filtraPila(c: Cola[int]) -> None:\n    r = algunoVerifica1(lambda x: x > 0, c)\n    assert algunoVerifica2(lambda x: x > 0, c) == r\n    assert algunoVerifica3(lambda x: x > 0, c) == r\n    assert algunoVerifica4(lambda x: x > 0, c) == r\n    assert algunoVerifica5(lambda x: x > 0, c) == r\n\n# La comprobaci\u00f3n es\n#    src> poetry run pytest -q algunoVerifica.py\n#    1 passed in 0.31s\n<\/pre>\n<p><a name=\"ej3\"><\/a><\/p>\n<h3>3. Extensi\u00f3n de colas<\/h3>\n<p>Utilizando el <a href=\"https:\/\/bit.ly\/3QWTsRL\">tipo abstracto de datos de las colas<\/a>, definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   extiendeCola :: Cola a -> Cola a -> Cola a\n<\/pre>\n<p>tal que <code>extiendeCola c1 c2<\/code> es la cola que resulta de poner los elementos de la cola <code>c2<\/code> a continuaci\u00f3n de los de la cola de <code>c1<\/code>. Por<br \/>\nejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> ej1 = inserta 3 (inserta 2 vacia)\n   \u03bb> ej2 = inserta 5 (inserta 3 (inserta 4 vacia))\n   \u03bb> ej1\n   2 | 3\n   \u03bb> ej2\n   4 | 3 | 5\n   \u03bb> extiendeCola ej1 ej2\n   2 | 3 | 4 | 3 | 5\n   \u03bb> extiendeCola ej2 ej1\n   4 | 3 | 5 | 2 | 3\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\nimport TAD.Cola (Cola, vacia, inserta, primero, resto, esVacia)\nimport Transformaciones_colas_listas (colaAlista, listaAcola)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nextiendeCola :: Cola a -> Cola a -> Cola a\nextiendeCola c1 c2\n  | esVacia c2 = c1\n  | otherwise  = extiendeCola (inserta pc2 c1) rq2\n  where pc2 = primero c2\n        rq2 = resto c2\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nextiendeCola2 :: Cola a -> Cola a -> Cola a\nextiendeCola2 c1 c2 =\n  listaAcola (colaAlista c1 ++ colaAlista c2)\n\n-- Las funciones colaAlista y listaAcola est\u00e1n definidas en el ejercicio\n-- \"Transformaciones entre colas y listas\" que se encuentra en\n-- https:\/\/bit.ly\/3Xv0oIt\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_extiendeCola :: Cola Int -> Cola Int -> Bool\nprop_extiendeCola p c =\n  extiendeCola p c == extiendeCola2 p c\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_extiendeCola\n--    +++ OK, passed 100 tests.\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom copy import deepcopy\nfrom typing import TypeVar\n\nfrom hypothesis import given\n\nfrom src.TAD.cola import (Cola, colaAleatoria, esVacia, inserta, primero,\n                          resto, vacia)\nfrom src.transformaciones_colas_listas import colaAlista, listaAcola\n\nA = TypeVar('A')\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef extiendeCola(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    if esVacia(c2):\n        return c1\n    pc2 = primero(c2)\n    rc2 = resto(c2)\n    return extiendeCola(inserta(pc2, c1), rc2)\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef extiendeCola2(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    return listaAcola(colaAlista(c1) + colaAlista(c2))\n\n# Las funciones colaAlista y listaAcola est\u00e1n definidas en el ejercicio\n# \"Transformaciones entre colas y listas\" que se encuentra en\n# https:\/\/bit.ly\/3Xv0oIt\n\n# 3\u00aa soluci\u00f3n\n# ===========\n\ndef extiendeCola3Aux(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    if c2.esVacia():\n        return c1\n    pc2 = c2.primero()\n    c2.resto()\n    return extiendeCola(inserta(pc2, c1), c2)\n\ndef extiendeCola3(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    _c2 = deepcopy(c2)\n    return extiendeCola3Aux(c1, _c2)\n\n# 4\u00aa soluci\u00f3n\n# ===========\n\ndef extiendeCola4Aux(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    r = c1\n    while not esVacia(c2):\n        r = inserta(primero(c2), r)\n        c2 = resto(c2)\n    return r\n\ndef extiendeCola4(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    _c2 = deepcopy(c2)\n    return extiendeCola4Aux(c1, _c2)\n\n# 5\u00aa soluci\u00f3n\n# ===========\n\ndef extiendeCola5Aux(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    r = c1\n    while not c2.esVacia():\n        r.inserta(primero(c2))\n        c2.resto()\n    return r\n\ndef extiendeCola5(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    _c1 = deepcopy(c1)\n    _c2 = deepcopy(c2)\n    return extiendeCola5Aux(_c1, _c2)\n\n# Comprobaci\u00f3n de equivalencia\n# ============================\n\n# La propiedad es\n@given(c1=colaAleatoria(), c2=colaAleatoria())\ndef test_extiendeCola(c1: Cola[int], c2: Cola[int]) -> None:\n    r = extiendeCola(c1, c2)\n    assert extiendeCola2(c1, c2) == r\n    assert extiendeCola3(c1, c2) == r\n    assert extiendeCola4(c1, c2) == r\n\n# La comprobaci\u00f3n es\n#    src> poetry run pytest -q extiendeCola.py\n#    1 passed in 0.32s\n<\/pre>\n<p><a name=\"ej4\"><\/a><\/p>\n<h3>4. Intercalado de dos colas<\/h3>\n<p>Utilizando el <a href=\"https:\/\/bit.ly\/3QWTsRL\">tipo abstracto de datos de las colas<\/a>, definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   intercalaColas :: Cola a -> Cola a -> Cola a\n<\/pre>\n<p>tal que <code>intercalaColas c1 c2<\/code> es la cola formada por los elementos de <code>c1<\/code> y <code>c2<\/code> colocados en una cola, de forma alternativa, empezando por los elementos de c1. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> ej1 = inserta 3 (inserta 5 vacia)\n   \u03bb> ej2 = inserta 0 (inserta 7 (inserta 4 (inserta 9 vacia)))\n   \u03bb> intercalaColas ej1 ej2\n   5 | 9 | 3 | 4 | 7 | 0\n   \u03bb> intercalaColas ej2 ej1\n   9 | 5 | 4 | 3 | 7 | 0\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\nimport TAD.Cola (Cola, vacia, inserta, primero, resto, esVacia)\nimport Transformaciones_colas_listas (colaAlista, listaAcola)\nimport ExtiendeCola (extiendeCola)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nintercalaColas :: Cola a -> Cola a -> Cola a\nintercalaColas c1 c2\n  | esVacia c1 = c2\n  | esVacia c2 = c1\n  | otherwise  = extiendeCola (inserta pc2 (inserta pc1 vacia))\n                              (intercalaColas rc1 rc2)\n  where pc1 = primero c1\n        rc1 = resto c1\n        pc2 = primero c2\n        rc2 = resto c2\n\n-- La funci\u00f3n extiendeCola est\u00e1 definida en el ejercicio\n-- \"Extensi\u00f3n de colas\" que se encuentra en\n-- https:\/\/bit.ly\/3XIJJ4m\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nintercalaColas2 :: Cola a -> Cola a -> Cola a\nintercalaColas2 c1 c2 = aux c1 c2 vacia\n  where\n    aux d1 d2 c\n      | esVacia d1 = extiendeCola c d2\n      | esVacia d2 = extiendeCola c d1\n      | otherwise  = aux rd1 rd2 (inserta pd2 (inserta pd1 c))\n      where pd1 = primero d1\n            rd1 = resto d1\n            pd2 = primero d2\n            rd2 = resto d2\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\nintercalaColas3 :: Cola a -> Cola a -> Cola a\nintercalaColas3 c1 c2 =\n  listaAcola (intercalaListas (colaAlista c1) (colaAlista c2))\n\n-- (intercalaListas xs ys) es la lista obtenida intercalando los\n-- elementos de xs e ys. Por ejemplo,\nintercalaListas :: [a] -> [a] -> [a]\nintercalaListas []     ys     = ys\nintercalaListas xs     []     = xs\nintercalaListas (x:xs) (y:ys) = x : y : intercalaListas xs ys\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_intercalaColas :: Cola Int -> Cola Int -> Bool\nprop_intercalaColas c1 c2 =\n  all (== intercalaColas c1 c2)\n      [intercalaColas2 c1 c2,\n       intercalaColas2 c1 c2]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_intercalaColas\n--    +++ OK, passed 100 tests.\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom copy import deepcopy\nfrom typing import TypeVar\n\nfrom hypothesis import given\n\nfrom src.extiendeCola import extiendeCola\nfrom src.TAD.cola import (Cola, colaAleatoria, esVacia, inserta, primero,\n                          resto, vacia)\nfrom src.transformaciones_colas_listas import colaAlista, listaAcola\n\nA = TypeVar('A')\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef intercalaColas(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    if esVacia(c1):\n        return c2\n    if esVacia(c2):\n        return c1\n    pc1 = primero(c1)\n    rc1 = resto(c1)\n    pc2 = primero(c2)\n    rc2 = resto(c2)\n    return extiendeCola(inserta(pc2, inserta(pc1, vacia())),\n                        intercalaColas(rc1, rc2))\n\n# La funci\u00f3n extiendeCola est\u00e1 definida en el ejercicio\n# \"Extensi\u00f3n de colas\" que se encuentra en\n# https:\/\/bit.ly\/3XIJJ4m\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef intercalaColas2(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    def aux(d1: Cola[A], d2: Cola[A], d3: Cola[A]) -> Cola[A]:\n        if esVacia(d1):\n            return extiendeCola(d3, d2)\n        if esVacia(d2):\n            return extiendeCola(d3, d1)\n        pd1 = primero(d1)\n        rd1 = resto(d1)\n        pd2 = primero(d2)\n        rd2 = resto(d2)\n        return aux(rd1, rd2, inserta(pd2, inserta(pd1, d3)))\n\n    return aux(c1, c2, vacia())\n\n# 3\u00aa soluci\u00f3n\n# ===========\n\n# intercalaListas(xs, ys) es la lista obtenida intercalando los\n# elementos de xs e ys. Por ejemplo,\ndef intercalaListas(xs: list[A], ys: list[A]) -> list[A]:\n    if not xs:\n        return ys\n    if not ys:\n        return xs\n    return [xs[0], ys[0]] + intercalaListas(xs[1:], ys[1:])\n\ndef intercalaColas3(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    return listaAcola(intercalaListas(colaAlista(c1), colaAlista(c2)))\n\n# 4\u00aa soluci\u00f3n\n# ===========\n\ndef intercalaColas4Aux(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    if c1.esVacia():\n        return c2\n    if c2.esVacia():\n        return c1\n    pc1 = c1.primero()\n    c1.resto()\n    pc2 = c2.primero()\n    c2.resto()\n    return extiendeCola(inserta(pc2, inserta(pc1, vacia())),\n                        intercalaColas4Aux(c1, c2))\n\ndef intercalaColas4(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    _c1 = deepcopy(c1)\n    _c2 = deepcopy(c2)\n    return intercalaColas4Aux(_c1, _c2)\n\n# 5\u00aa soluci\u00f3n\n# ===========\n\ndef intercalaColas5Aux(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    r: Cola[A] = vacia()\n    while not esVacia(c1) and not esVacia(c2):\n        pc1 = primero(c1)\n        c1.resto()\n        pc2 = primero(c2)\n        c2.resto()\n        r = inserta(pc2, inserta(pc1, r))\n    if esVacia(c1):\n        return extiendeCola(r, c2)\n    return extiendeCola(r, c1)\n\ndef intercalaColas5(c1: Cola[A], c2: Cola[A]) -> Cola[A]:\n    _c1 = deepcopy(c1)\n    _c2 = deepcopy(c2)\n    return intercalaColas5Aux(_c1, _c2)\n\n# Comprobaci\u00f3n de equivalencia\n# ============================\n\n# La propiedad es\n@given(c1=colaAleatoria(), c2=colaAleatoria())\ndef test_extiendeCola(c1: Cola[int], c2: Cola[int]) -> None:\n    r = intercalaColas(c1, c2)\n    assert intercalaColas2(c1, c2) == r\n    assert intercalaColas3(c1, c2) == r\n    assert intercalaColas4(c1, c2) == r\n    assert intercalaColas5(c1, c2) == r\n\n# La comprobaci\u00f3n es\n#    src> poetry run pytest -q intercalaColas.py\n#    1 passed in 0.47s\n<\/pre>\n<p><a name=\"ej5\"><\/a><\/p>\n<h3>5. Agrupaci\u00f3n de colas<\/h3>\n<p>Utilizando el <a href=\"https:\/\/bit.ly\/3QWTsRL\">tipo abstracto de datos de las colas<\/a>, definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   agrupaColas :: [Cola a] -> Cola a\n<\/pre>\n<p>tal que <code>agrupaColas [c1,c2,c3,...,cn]<\/code> es la cola formada mezclando las colas de la lista como sigue: mezcla <code>c1<\/code> con <code>c2<\/code>, el resultado con <code>c3<\/code>, el resultado con <code>c4<\/code>, y as\u00ed sucesivamente. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> ej1 = inserta 2 (inserta 5 vacia)\n   \u03bb> ej2 = inserta 3 (inserta 7 (inserta 4 vacia))\n   \u03bb> ej3 = inserta 9 (inserta 0 (inserta 1 (inserta 6 vacia)))\n   \u03bb> agrupaColas []\n   -\n   \u03bb> agrupaColas [ej1]\n   5 | 2\n   \u03bb> agrupaColas [ej1, ej2]\n   5 | 4 | 2 | 7 | 3\n   \u03bb> agrupaColas [ej1, ej2, ej3]\n   5 | 6 | 4 | 1 | 2 | 0 | 7 | 9 | 3\n<\/pre>\n<p><b>Soluciones<\/b><\/p>\n<p>A continuaci\u00f3n se muestran las <a href=\"#haskell\">soluciones en Haskell<\/a> y las <a href=\"#python\">soluciones en Python<\/a>.<\/p>\n<p><a name=\"haskell\"><\/a><br \/>\n<b>Soluciones en Haskell<\/b><\/p>\n<pre lang=\"haskell\">\nimport TAD.Cola (Cola, vacia, inserta)\nimport IntercalaColas (intercalaColas)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nagrupaColas1 :: [Cola a] -> Cola a\nagrupaColas1 []            = vacia\nagrupaColas1 [c]           = c\nagrupaColas1 (c1:c2:colas) = agrupaColas1 ((intercalaColas c1 c2) : colas)\n\n-- La funci\u00f3n intercalaColas est\u00e1 definida en el ejercicio\n-- \"Intercalado de dos colas\" que se encuentra en\n-- https:\/\/bit.ly\/3XYyjsM\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nagrupaColas2 :: [Cola a] -> Cola a\nagrupaColas2 = foldl intercalaColas vacia\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_agrupaColas :: [Cola Int] -> Bool\nprop_agrupaColas cs =\n  agrupaColas1 cs == agrupaColas2 cs\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheckWith (stdArgs {maxSize=30}) prop_agrupaColas\n--    +++ OK, passed 100 tests.\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom functools import reduce\nfrom typing import TypeVar\n\nfrom hypothesis import given\nfrom hypothesis import strategies as st\n\nfrom src.TAD.cola import (Cola, colaAleatoria, inserta, vacia)\nfrom src.intercalaColas import intercalaColas\n\nA = TypeVar('A')\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef agrupaColas1(cs: list[Cola[A]]) -> Cola[A]:\n    if not cs:\n        return vacia()\n    if len(cs) == 1:\n        return cs[0]\n    return agrupaColas1([intercalaColas(cs[0], cs[1])] + cs[2:])\n\n# La funci\u00f3n intercalaColas est\u00e1 definida en el ejercicio\n# \"Intercalado de dos colas\" que se encuentra en\n# https:\/\/bit.ly\/3XYyjsM\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef agrupaColas2(cs: list[Cola[A]]) -> Cola[A]:\n    return reduce(intercalaColas, cs, vacia())\n\n# Comprobaci\u00f3n de equivalencia\n# ============================\n\n# La propiedad es\n@given(st.lists(colaAleatoria(), max_size=4))\ndef test_extiendeCola(cs: list[Cola[int]]) -> None:\n    assert agrupaColas1(cs) == agrupaColas2(cs)\n\n# La comprobaci\u00f3n es\n#    src> poetry run pytest -q agrupaColas.py\n#    1 passed in 0.50s\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>Esta semana he publicado en Exercitium las soluciones de los siguientes problemas sobre el tipo abstracto de las colas: 1. Todos los elementos de la cola verifican una propiedad 2. Alg\u00fan elemento de la cola verifica una propiedad 3. Extensi\u00f3n de colas 4. Intercalado de dos colas 5. Agrupaci\u00f3n de colas A continuaci\u00f3n se muestran&#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":[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\/7893"}],"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=7893"}],"version-history":[{"count":2,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7893\/revisions"}],"predecessor-version":[{"id":7895,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7893\/revisions\/7895"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=7893"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=7893"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=7893"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}