{"id":7918,"date":"2023-04-01T18:10:01","date_gmt":"2023-04-01T16:10:01","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=7918"},"modified":"2023-04-01T18:10:01","modified_gmt":"2023-04-01T16:10:01","slug":"01-abr-23","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/01-abr-23\/","title":{"rendered":"La semana en Exercitium (1 de abril de 2023)"},"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. TAD de los conjuntos: Producto cartesiano de dos conjuntos<\/a><\/li>\n<li><a href=\"#ej2\">2. Relaciones binarias<\/a><\/li>\n<li><a href=\"#ej3\">3. Universo y grafo de una relaci\u00f3n binaria<\/a><\/li>\n<li><a href=\"#ej4\">4. Relaciones reflexivas<\/a><\/li>\n<li><a href=\"#ej5\">5. Relaciones sim\u00e9tricas<\/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. TAD de los conjuntos: Producto cartesiano de dos conjuntos<\/h3>\n<p>Utilizando el tipo abstracto de datos de los conjuntos (https:\/\/bit.ly\/3HbB7fo) definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   productoC :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)\n<\/pre>\n<p>tal que <code>productoC c1 c2<\/code> es el producto cartesiano de los conjuntos <code>c1<\/code> y <code>c2<\/code>. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> ej1 = inserta 2 (inserta 5 vacio)\n   \u03bb> ej2 = inserta 9 (inserta 4 (inserta 3 vacio))\n   \u03bb> productoC ej1 ej2\n   {(2,3), (2,4), (2,9), (5,3), (5,4), (5,9)}\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.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)\nimport TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)\nimport TAD_Union_de_dos_conjuntos (union)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nproductoC :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)\nproductoC c1 c2\n  | esVacio c1 = vacio\n  | otherwise  = agrega mc1 c2 `union` productoC rc1 c2\n  where mc1 = menor c1\n        rc1 = elimina mc1 c1\n\n-- (agrega x c) es el conjunto de los pares de x con los elementos de\n-- c. Por ejemplo,\n--    \u03bb> agrega 2 (inserta 9 (inserta 4 (inserta 3 vacio)))\n--    {(2,3), (2,4), (2,9)}\nagrega :: (Ord a, Ord b) => a -> Conj b -> Conj (a,b)\nagrega x c\n  | esVacio c = vacio\n  | otherwise = inserta (x, mc) (agrega x rc)\n  where mc = menor c\n        rc = elimina mc c\n\n-- La funci\u00f3n union est\u00e1 definida en el ejercicio\n-- \"Uni\u00f3n de dos conjuntos\" que se encuentra en\n-- https:\/\/bit.ly\/3Y1jBl8\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nproductoC2 :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)\nproductoC2 c1 c2 =\n  foldr inserta vacio [(x,y) | x <- xs, y <- ys]\n  where xs = conjuntoAlista c1\n        ys = conjuntoAlista c2\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\nproductoC3 :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)\nproductoC3 c1 c2 =\n  listaAconjunto [(x,y) | x <- xs, y <- ys]\n  where xs = conjuntoAlista c1\n        ys = conjuntoAlista c2\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_productoC :: Conj Int -> Conj Int -> Bool\nprop_productoC c1 c2 =\n  all (== productoC c1 c2)\n      [productoC2 c1 c2,\n       productoC3 c1 c2]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_productoC\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 __future__ import annotations\n\nfrom abc import abstractmethod\nfrom copy import deepcopy\nfrom functools import reduce\nfrom typing import Protocol, TypeVar\n\nfrom hypothesis import given\n\nfrom src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,\n                              inserta, menor, vacio)\nfrom src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,\n                                                       listaAconjunto)\nfrom src.TAD_Union_de_dos_conjuntos import union\n\n\nclass Comparable(Protocol):\n    @abstractmethod\n    def __lt__(self: A, otro: A) -> bool:\n        pass\n\nA = TypeVar('A', bound=Comparable)\nB = TypeVar('B', bound=Comparable)\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\n# (agrega x c) es el conjunto de los pares de x con los elementos de\n# c. Por ejemplo,\n#    >>> agrega(2, inserta(9, inserta(4, inserta(3, vacio()))))\n#    {(2, 3), (2, 4), (2, 9)}\ndef agrega(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:\n    if esVacio(c):\n        return vacio()\n    mc = menor(c)\n    rc = elimina(mc, c)\n    return inserta((x, mc), agrega(x, rc))\n\ndef productoC(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:\n    if esVacio(c1):\n        return vacio()\n    mc1 = menor(c1)\n    rc1 = elimina(mc1, c1)\n    return union(agrega(mc1, c2), productoC(rc1, c2))\n\n# La funci\u00f3n union est\u00e1 definida en el ejercicio\n# \"Uni\u00f3n de dos conjuntos\" que se encuentra en\n# https:\/\/bit.ly\/3Y1jBl8\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef productoC2(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:\n    xs = conjuntoAlista(c1)\n    ys = conjuntoAlista(c2)\n    return reduce(lambda bs, a: inserta(a, bs), [(x,y) for x in xs for y in ys], vacio())\n\n# 3\u00aa soluci\u00f3n\n# ===========\n\ndef productoC3(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:\n    xs = conjuntoAlista(c1)\n    ys = conjuntoAlista(c2)\n    return listaAconjunto([(x,y) for x in xs for y in ys])\n\n# 4\u00aa soluci\u00f3n\n# ===========\n\ndef agrega4Aux(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:\n    r: Conj[tuple[A, B]] = vacio()\n    while not esVacio(c):\n        mc = menor(c)\n        c = elimina(mc, c)\n        r = inserta((x, mc), r)\n    return r\n\ndef agrega4(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:\n    _c = deepcopy(c)\n    return agrega4Aux(x, _c)\n\ndef productoC4(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:\n    r: Conj[tuple[A, B]] = vacio()\n    while not esVacio(c1):\n        mc1 = menor(c1)\n        c1 = elimina(mc1, c1)\n        r = union(agrega4(mc1, c2), r)\n    return r\n\n# 5\u00aa soluci\u00f3n\n# ===========\n\ndef agrega5Aux(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:\n    r: Conj[tuple[A, B]] = Conj()\n    while not c.esVacio():\n        mc = c.menor()\n        c.elimina(mc)\n        r.inserta((x, mc))\n    return r\n\ndef agrega5(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:\n    _c = deepcopy(c)\n    return agrega5Aux(x, _c)\n\ndef productoC5(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:\n    r: Conj[tuple[A, B]] = Conj()\n    while not c1.esVacio():\n        mc1 = c1.menor()\n        c1.elimina(mc1)\n        r = union(agrega5(mc1, c2), r)\n    return r\n\n# Comprobaci\u00f3n de equivalencia\n# ============================\n\n# La propiedad es\n@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())\ndef test_productoC(c1: Conj[int], c2: Conj[int]) -> None:\n    r = productoC(c1, c2)\n    assert productoC2(c1, c2) == r\n    assert productoC3(c1, c2) == r\n    assert productoC4(c1, c2) == r\n\n# La comprobaci\u00f3n de las propiedades es\n#    > poetry run pytest -q TAD_Producto_cartesiano.py\n#    1 passed in 0.35s\n<\/pre>\n<p><a name=\"ej2\"><\/a><\/p>\n<h3>2. Relaciones binarias<\/h3>\n<p>Una relaci\u00f3n binaria R sobre un conjunto A se puede  mediante un par (u,g) donde u es la lista de los elementos de tipo A (el universo de R) y g es la lista de pares de elementos de u (el grafo de R).<\/p>\n<p>Definir el tipo de dato (Rel a), para representar las relaciones binarias sobre a, y la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   esRelacionBinaria :: Eq a => Rel a -> Bool\n<\/pre>\n<p>tal que <code>esRelacionBinaria r<\/code> se verifica si <code>r<\/code> es una relaci\u00f3n binaria. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   \u03bb> esRelacionBinaria (R ([1, 3], [(3, 1), (3, 3)]))\n   True\n   \u03bb> esRelacionBinaria (R ([1, 3], [(3, 1), (3, 2)]))\n   False\n<\/pre>\n<p>Adem\u00e1s, definir un generador de relaciones binarias y comprobar que las relaciones que genera son relaciones binarias.<\/p>\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 Data.List (nub)\nimport Test.QuickCheck\n\nnewtype Rel a = R ([a], [(a,a)])\n  deriving (Eq, Show)\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nesRelacionBinaria :: Eq a => Rel a -> Bool\nesRelacionBinaria (R (u, g)) =\n  and [x `elem` u && y `elem` u | (x,y) <- g]\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nesRelacionBinaria2 :: Eq a => Rel a -> Bool\nesRelacionBinaria2 (R (u, g)) =\n  all (\\(x,y) -> x `elem` u && y `elem` u) g\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\nesRelacionBinaria3 :: Eq a => Rel a -> Bool\nesRelacionBinaria3 (R (_, []))         = True\nesRelacionBinaria3 (R (u, (x,y):g)) =\n  x `elem` u &&\n  y `elem` u &&\n  esRelacionBinaria3 (R (u, g))\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- Generador de relaciones binarias. Por ejemplo,\n--    \u03bb> sample (relacionArbitraria :: Gen (Rel Int))\n--    R ([0],[])\n--    R ([0,-1,1],[(0,-1),(0,1),(-1,1),(1,0)])\n--    R ([1],[])\n--    R ([-5,3],[(-5,-5),(-5,3),(3,-5),(3,3)])\n--    R ([-2,-7],[(-7,-7)])\n--    R ([11,-7],[])\n--    R ([0],[])\n--    R ([-13,-11],[(-13,-13)])\nrelacionArbitraria :: (Arbitrary a, Eq a) => Gen (Rel a)\nrelacionArbitraria = do\n  n <- choose (0, 10)\n  u1 <- vectorOf n arbitrary\n  let u = nub u1\n  g <- sublistOf [(x,y) | x <- u, y <- u]\n  return (R (u, g))\n\n-- Relaciones es una subclase de Arbitrary.\ninstance (Arbitrary a, Eq a) => Arbitrary (Rel a) where\n  arbitrary = relacionArbitraria\n\n-- La propiedad es\nprop_esRelacionBinaria :: Rel Int -> Bool\nprop_esRelacionBinaria r =\n  esRelacionBinaria r  &&\n  esRelacionBinaria2 r &&\n  esRelacionBinaria3 r\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_esRelacionBinaria\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 random import choice, randint, sample\nfrom typing import TypeVar\n\nfrom hypothesis import given\nfrom hypothesis import strategies as st\n\nA = TypeVar('A')\n\nRel = tuple[list[A], list[tuple[A, A]]]\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef esRelacionBinaria(r: Rel[A]) -> bool:\n    (u, g) = r\n    return all((x in u and y in u for (x, y) in g))\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef esRelacionBinaria2(r: Rel[A]) -> bool:\n    (u, g) = r\n    if not g:\n        return True\n    (x, y) = g[0]\n    return x in u and y in u and esRelacionBinaria2((u, g[1:]))\n\n# 3\u00aa soluci\u00f3n\n# ===========\n\ndef esRelacionBinaria3(r: Rel[A]) -> bool:\n    (u, g) = r\n    for (x, y) in g:\n        if x not in u or y not in u:\n            return False\n    return True\n\n# Generador de relaciones binarias\n# ================================\n\n# conjuntoArbitrario(n) es un conjunto arbitrario cuyos elementos est\u00e1n\n# entre 0 y n-1. Por ejemplo,\n#    >>> conjuntoArbitrario(10)\n#    [8, 9, 4, 5]\n#    >>> conjuntoArbitrario(10)\n#    [1, 2, 3, 4, 5, 6, 7, 8, 9]\n#    >>> conjuntoArbitrario(10)\n#    [0, 1, 2, 3, 6, 7, 9]\n#    >>> conjuntoArbitrario(10)\n#    [8, 2, 3, 7]\ndef conjuntoArbitrario(n: int) -> list[int]:\n    xs = sample(range(n), randint(0, n))\n    return list(set(xs))\n\n# productoCartesiano(xs, ys) es el producto cartesiano de xs e ys. Por\n# ejemplo,\n#    >>> productoCartesiano([2, 3], [1, 7, 5])\n#    [(2, 1), (2, 7), (2, 5), (3, 1), (3, 7), (3, 5)]\ndef productoCartesiano(xs: list[int], ys: list[int]) -> list[tuple[int, int]]:\n    return [(x, y) for x in xs for y in ys]\n\n# sublistaArbitraria(xs) es una sublista arbitraria de xs. Por ejemplo,\n#    >>> sublistaArbitraria(range(10))\n#    [3, 7]\n#    >>> sublistaArbitraria(range(10))\n#    []\n#    >>> sublistaArbitraria(range(10))\n#    [4, 1, 0, 9, 8, 7, 5, 6, 2, 3]\ndef sublistaArbitraria(xs: list[A]) -> list[A]:\n    n = len(xs)\n    k = randint(0, n)\n    return sample(xs, k)\n\n# relacionArbitraria(n) es una relaci\u00f3n arbitraria tal que los elementos\n# de su universo est\u00e1n entre 0 y n-1. Por ejemplo,\n#    >>> relacionArbitraria(3)\n#    ([0, 1], [(1, 0), (1, 1)])\n#    >>> relacionArbitraria(3)\n#    ([], [])\n#    >>> relacionArbitraria(5)\n#    ([0, 2, 3, 4], [(2, 0), (3, 3), (2, 3), (4, 0), (3, 4), (4, 2)])\ndef relacionArbitraria(n: int) -> Rel[int]:\n    u = conjuntoArbitrario(n)\n    g = sublistaArbitraria(productoCartesiano(u, u))\n    return (u, g)\n\n# Comprobaci\u00f3n de la propiedad\n# ============================\n\n# La propiedad es\n@given(st.integers(min_value=0, max_value=10))\ndef test_esRelacionBinaria(n: int) -> None:\n    r = relacionArbitraria(n)\n    assert esRelacionBinaria(r)\n    assert esRelacionBinaria2(r)\n    assert esRelacionBinaria3(r)\n\n# La comprobaci\u00f3n es\n#    > poetry run pytest -q Relaciones_binarias.py\n#    1 passed in 0.14s\n<\/pre>\n<p><a name=\"ej3\"><\/a><\/p>\n<h3>3. Universo y grafo de una relaci\u00f3n binaria<\/h3>\n<p>Usando el <a href=\"https:\/\/bit.ly\/3IVVqOT\">tipo de las relaciones binarias<\/a>, definir las funciones<\/p>\n<pre lang=\"text\">\n   universo :: Eq a => Rel a -> [a]\n   grafo    :: Eq a => ([a],[(a,a)]) -> [(a,a)]\n<\/pre>\n<p>tales que<\/p>\n<ul>\n<li><code>universo r<\/code> es el universo de la relaci\u00f3n <code>r<\/code>. Por ejemplo,<\/li>\n<\/ul>\n<pre lang=\"text\">\n     \u03bb> r = R ([1, 3],[(3, 1), (3, 3)])\n     \u03bb> universo r\n     [1,3]\n<\/pre>\n<ul>\n<li><code>grafo r<\/code> es el grafo de la relaci\u00f3n r. Por ejemplo,<\/li>\n<\/ul>\n<pre lang=\"text\">\n     \u03bb> grafo r\n     [(3,1),(3,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 Relaciones_binarias\n\nuniverso :: Eq a => Rel a -> [a]\nuniverso (R (u,_)) = u\n\ngrafo :: Eq a => Rel a -> [(a,a)]\ngrafo (R (_,g)) = g\n<\/pre>\n<p><a name=\"python\"><\/a><br \/>\n<b>Soluciones en Python<\/b><\/p>\n<pre lang=\"python\">\nfrom typing import TypeVar\n\nA = TypeVar('A')\n\nRel = tuple[list[A], list[tuple[A, A]]]\n\ndef universo(r: Rel[A]) -> list[A]:\n    return r[0]\n\ndef grafo(r: Rel[A]) -> list[tuple[A, A]]:\n    return r[1]\n<\/pre>\n<p><a name=\"ej4\"><\/a><\/p>\n<h3>4. Relaciones reflexivas<\/h3>\n<p>Usando el <a href=\"https:\/\/bit.ly\/3IVVqOT\">tipo de las relaciones binarias<\/a>, definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   reflexiva :: Eq a => Rel a -> Bool\n<\/pre>\n<p>tal que <code>reflexiva r<\/code> se verifica si la relaci\u00f3n <code>r<\/code> es reflexiva. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   reflexiva (R ([1,3],[(1,1),(1,3),(3,3)]))    ==  True\n   reflexiva (R ([1,2,3],[(1,1),(1,3),(3,3)]))  ==  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\">\nmodule Relaciones_reflexivas where\n\nimport Relaciones_binarias (Rel(R))\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nreflexiva :: Eq a => Rel a -> Bool\nreflexiva (R ([], _))   = True\nreflexiva (R (x:xs, ps)) = (x, x) `elem` ps && reflexiva  (R (xs, ps))\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nreflexiva2 :: Eq a => Rel a -> Bool\nreflexiva2 (R (us,ps)) = and [(x,x) `elem` ps | x <- us]\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\nreflexiva3 :: Eq a => Rel a -> Bool\nreflexiva3 (R (us,ps)) = all (`elem` ps) [(x,x) | x <- us]\n\n-- 4\u00aa soluci\u00f3n\n-- ===========\n\nreflexiva4 :: Eq a => Rel a -> Bool\nreflexiva4 (R (us,ps)) = all (\\x -> (x,x) `elem` ps) us\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_reflexiva :: Rel Int -> Bool\nprop_reflexiva r =\n  all (== reflexiva r)\n      [reflexiva2 r,\n       reflexiva3 r,\n       reflexiva4 r]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_reflexiva\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 random import choice, randint, sample\nfrom typing import TypeVar\n\nfrom hypothesis import given\nfrom hypothesis import strategies as st\n\nfrom src.Relaciones_binarias import Rel, relacionArbitraria\n\nA = TypeVar('A')\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef reflexiva(r: Rel[A]) -> bool:\n    (us, ps) = r\n    if not us:\n        return True\n    return (us[0], us[0]) in ps and reflexiva((us[1:], ps))\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef reflexiva2(r: Rel[A]) -> bool:\n    (us, ps) = r\n    return all(((x,x) in ps for x in us))\n\n# 3\u00aa soluci\u00f3n\n# ===========\n\ndef reflexiva3(r: Rel[A]) -> bool:\n    (us, ps) = r\n    for x in us:\n        if (x, x) not in ps:\n            return False\n    return True\n\n# Comprobaci\u00f3n de equivalencia\n# ============================\n\n# La propiedad es\n@given(st.integers(min_value=0, max_value=10))\ndef test_reflexiva(n: int) -> None:\n    r = relacionArbitraria(n)\n    res = reflexiva(r)\n    assert reflexiva2(r) == res\n    assert reflexiva3(r) == res\n\n# La comprobaci\u00f3n es\n#    > poetry run pytest -q Relaciones_reflexivas.py\n#    1 passed in 0.41s\n<\/pre>\n<p><a name=\"ej5\"><\/a><\/p>\n<h3>5. Relaciones sim\u00e9tricas<\/h3>\n<p>Usando el <a href=\"https:\/\/bit.ly\/3IVVqOT\">tipo de las relaciones binarias<\/a>, definir la funci\u00f3n<\/p>\n<pre lang=\"text\">\n   simetrica :: Eq a => Rel a -> Bool\n<\/pre>\n<p>tal que <code>simetrica r<\/code> se verifica si la relaci\u00f3n <code>r<\/code> es sim\u00e9trica. Por ejemplo,<\/p>\n<pre lang=\"text\">\n   simetrica (R ([1,3],[(1,1),(1,3),(3,1)]))  ==  True\n   simetrica (R ([1,3],[(1,1),(1,3),(3,2)]))  ==  False\n   simetrica (R ([1,3],[]))                   ==  True\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 Relaciones_binarias (Rel(R))\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nsimetrica :: Eq a => Rel a -> Bool\nsimetrica (R (_,g)) = and [(y,x) `elem` g | (x,y) <- g]\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nsimetrica2 :: Eq a => Rel a -> Bool\nsimetrica2 (R (_,g)) = all (\\(x,y) -> (y,x) `elem` g) g\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\nsimetrica3 :: Eq a => Rel a -> Bool\nsimetrica3 (R (_,g)) = aux g\n  where aux [] = True\n        aux ((x,y):ps) = (y,x) `elem` g && aux ps\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_simetrica :: Rel Int -> Bool\nprop_simetrica r =\n  all (== simetrica r)\n      [simetrica2 r,\n       simetrica3 r]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_simetrica\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 typing import TypeVar\n\nfrom hypothesis import given\nfrom hypothesis import strategies as st\n\nfrom src.Relaciones_binarias import Rel, relacionArbitraria\n\nA = TypeVar('A')\n\n# 1\u00aa soluci\u00f3n\n# ===========\n\ndef simetrica(r: Rel[A]) -> bool:\n    (_, g) = r\n    return all(((y, x) in g for (x, y) in g))\n\n# 2\u00aa soluci\u00f3n\n# ===========\n\ndef simetrica2(r: Rel[A]) -> bool:\n    (_, g) = r\n    def aux(ps: list[tuple[A, A]]) -> bool:\n        if not ps:\n            return True\n        (x, y) = ps[0]\n        return (y, x) in g and aux(ps[1:])\n\n    return aux(g)\n\n# 3\u00aa soluci\u00f3n\n# ===========\n\ndef simetrica3(r: Rel[A]) -> bool:\n    (_, g) = r\n    for (x, y) in g:\n        if (y, x) not in g:\n            return False\n    return True\n\n# Comprobaci\u00f3n de equivalencia\n# ============================\n\n# La propiedad es\n@given(st.integers(min_value=0, max_value=10))\ndef test_simetrica(n: int) -> None:\n    r = relacionArbitraria(n)\n    res = simetrica(r)\n    assert simetrica2(r) == res\n    assert simetrica3(r) == res\n\n# La comprobaci\u00f3n es\n#    > poetry run pytest -q Relaciones_simetricas.py\n#    1 passed in 0.11s\n<\/pre>\n","protected":false},"excerpt":{"rendered":"<p>Esta semana he publicado en Exercitium las soluciones de los siguientes problemas: 1. TAD de los conjuntos: Producto cartesiano de dos conjuntos 2. Relaciones binarias 3. Universo y grafo de una relaci\u00f3n binaria 4. Relaciones reflexivas 5. Relaciones sim\u00e9tricas 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\/7918"}],"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=7918"}],"version-history":[{"count":1,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7918\/revisions"}],"predecessor-version":[{"id":7919,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7918\/revisions\/7919"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=7918"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=7918"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=7918"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}