Haskell y Python

Clausura reflexiva

PorJosé A. Alonso 12-abril-202329-marzo-2023

Usando el tipo de las relaciones binarias, definir la función

   clausuraReflexiva :: Eq a => Rel a -> Rel a

1	clausuraReflexiva :: Eq a => Rel a -> Rel a

tal que clausuraReflexiva r es la clausura reflexiva de r; es decir, la menor relación reflexiva que contiene a r. Por ejemplo,

   λ> clausuraReflexiva (R ([1,3],[(1,1),(3,1)]))
   R ([1,3],[(1,1),(3,1),(3,3)])

1 2	λ> clausuraReflexiva (R ([1,3],[(1,1),(3,1)])) R ([1,3],[(1,1),(3,1),(3,3)])

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Relaciones_binarias (Rel(R))
import Data.List (union)
import Test.QuickCheck (quickCheck)

clausuraReflexiva :: Eq a => Rel a -> Rel a
clausuraReflexiva (R (u,g)) =
  R (u, g `union` [(x,x) | x <- u])

import Relaciones_binarias (Rel(R))

import Data.List (union)

import Test.QuickCheck (quickCheck)

clausuraReflexiva :: Eq a => Rel a -> Rel a

clausuraReflexiva (R (u,g)) =

R (u, g `union` [(x,x) | x <- u])

Soluciones en Python

from typing import TypeVar

from src.Relaciones_binarias import Rel

A = TypeVar('A')

def clausuraReflexiva(r: Rel[A]) -> Rel[A]:
    (u, g) = r
    return (u, list(set(g) | {(x, x) for x in u}))

from typing import TypeVar

from src.Relaciones_binarias import Rel

A = TypeVar('A')

def clausuraReflexiva(r: Rel[A]) -> Rel[A]:

(u, g) = r

return (u, list(set(g) | {(x, x) for x in u}))

Relaciones totales

PorJosé A. Alonso 11-abril-202323-marzo-2023

Usando el tipo de las relaciones binarias, definir la función

   total :: Eq a => Rel a -> Bool

1	total :: Eq a => Rel a -> Bool

tal que total r se verifica si la relación r es total; es decir, si para cualquier par x, y de elementos del universo de r, se tiene que x está relacionado con y o y está relacionado con x. Por ejemplo,

   total (R ([1,3],[(1,1),(3,1),(3,3)]))  ==  True
   total (R ([1,3],[(1,1),(3,1)]))        ==  False
   total (R ([1,3],[(1,1),(3,3)]))        ==  False

total (R ([1,3],[(1,1),(3,1),(3,3)])) == True

total (R ([1,3],[(1,1),(3,1)])) == False

total (R ([1,3],[(1,1),(3,3)])) == False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Relaciones_binarias (Rel(R))
import Test.QuickCheck (quickCheck)

-- 1ª solución
-- ===========

total :: Eq a => Rel a -> Bool
total (R (u,g)) =
  and [(x,y) `elem` g || (y,x) `elem` g | x <- u, y <- u]

-- 2ª solución
-- ===========

total2 :: Eq a => Rel a -> Bool
total2 (R (u,g)) =
  all (relacionados g) (producto u u)

-- (producto xs ys) es el producto cartesiano de xs e ys. Por ejemplo,
--    λ> producto [2,5] [1,4,6]
--    [(2,1),(2,4),(2,6),(5,1),(5,4),(5,6)]
producto :: [a] -> [a] -> [(a,a)]
producto xs ys =
  [(x,y) | x <- xs, y <- ys]

-- (relacionados g (x,y)) se verifica si los elementos x e y están
-- relacionados por la relación de grafo g. Por ejemplo,
--    relacionados [(2,3),(3,1)] (2,3)  ==  True
--    relacionados [(2,3),(3,1)] (3,2)  ==  True
--    relacionados [(2,3),(3,1)] (1,2)  ==  False
relacionados :: Eq a => [(a,a)] -> (a,a) -> Bool
relacionados g (x,y) =
  (x,y) `elem` g || (y,x) `elem` g

-- 3ª solución
-- ===========

total3 :: Eq a => Rel a -> Bool
total3 (R (u,g)) = aux1 u
  where aux1 []       = True
        aux1 (x:xs)   = aux2 x u && aux1 xs
        aux2 _ []     = True
        aux2 x (y:ys) = relacionados g (x,y) && aux2 x ys

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_total :: Rel Int -> Bool
prop_total r =
  all (== total r)
      [total2 r,
       total3 r]

-- La comprobación es
--    λ> quickCheck prop_total
--    +++ OK, passed 100 tests.

import Relaciones_binarias (Rel(R))

import Test.QuickCheck (quickCheck)

-- 1ª solución

-- ===========

total :: Eq a => Rel a -> Bool

total (R (u,g)) =

and [(x,y) `elem` g || (y,x) `elem` g | x <- u, y <- u]

-- 2ª solución

-- ===========

total2 :: Eq a => Rel a -> Bool

total2 (R (u,g)) =

all (relacionados g) (producto u u)

-- (producto xs ys) es el producto cartesiano de xs e ys. Por ejemplo,

-- λ> producto [2,5] [1,4,6]

-- [(2,1),(2,4),(2,6),(5,1),(5,4),(5,6)]

producto :: [a] -> [a] -> [(a,a)]

producto xs ys =

[(x,y) | x <- xs, y <- ys]

-- (relacionados g (x,y)) se verifica si los elementos x e y están

-- relacionados por la relación de grafo g. Por ejemplo,

-- relacionados [(2,3),(3,1)] (2,3) == True

-- relacionados [(2,3),(3,1)] (3,2) == True

-- relacionados [(2,3),(3,1)] (1,2) == False

relacionados :: Eq a => [(a,a)] -> (a,a) -> Bool

relacionados g (x,y) =

(x,y) `elem` g || (y,x) `elem` g

-- 3ª solución

-- ===========

total3 :: Eq a => Rel a -> Bool

total3 (R (u,g)) = aux1 u

where aux1 [] = True

aux1 (x:xs) = aux2 x u && aux1 xs

aux2 _ [] = True

aux2 x (y:ys) = relacionados g (x,y) && aux2 x ys

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_total :: Rel Int -> Bool

prop_total r =

all (== total r)

[total2 r,

total3 r]

-- La comprobación es

-- λ> quickCheck prop_total

-- +++ OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución
# ===========

def total(r: Rel[A]) -> bool:
    (u, g) = r
    return all(((x, y) in g or (y, x) in g for x in u for y in u))

# 2ª solución
# ===========

# producto(xs, ys) es el producto cartesiano de xs e ys. Por ejemplo,
#    >>> producto([2, 5], [1, 4, 6])
#    [(2, 1), (2, 4), (2, 6), (5, 1), (5, 4), (5, 6)]
def producto(xs: list[A], ys: list[A]) -> list[tuple[A,A]]:
    return [(x, y) for x in xs for y in ys]

# relacionados(g, (x, y)) se verifica si los elementos x e y están
# relacionados por la relación de grafo g. Por ejemplo,
#    relacionados([(2, 3), (3, 1)], (2, 3))  ==  True
#    relacionados([(2, 3), (3, 1)], (3, 2))  ==  True
#    relacionados([(2, 3), (3, 1)], (1, 2))  ==  False
def relacionados(g: list[tuple[A,A]], p: tuple[A,A]) -> bool:
    (x, y) = p
    return (x, y) in g or (y, x) in g

def total2(r: Rel[A]) -> bool:
    (u, g) = r
    return all(relacionados(g, p) for p in producto(u, u))

# 3ª solución
# ===========

def total3(r: Rel[A]) -> bool:
    u, g = r
    return all(relacionados(g, (x, y)) for x in u for y in u)

# 4ª solución
# ===========

def total4(r: Rel[A]) -> bool:
    (u, g) = r
    def aux2(x: A, ys: list[A]) -> bool:
        if not ys:
            return True
        return relacionados(g, (x, ys[0])) and aux2(x, ys[1:])

    def aux1(xs: list[A]) -> bool:
        if not xs:
            return True
        return aux2(xs[0], u) and aux1(xs[1:])

    return aux1(u)

# 5ª solución
# ===========

def total5(r: Rel[A]) -> bool:
    (u, g) = r
    for x in u:
        for y in u:
            if not relacionados(g, (x, y)):
                return False
    return True

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.integers(min_value=0, max_value=10))
def test_total(n: int) -> None:
    r = relacionArbitraria(n)
    res = total(r)
    assert total2(r) == res
    assert total3(r) == res
    assert total4(r) == res
    assert total5(r) == res

# La comprobación es
#    > poetry run pytest -q Relaciones_totales.py
#    1 passed in 0.11s

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución

# ===========

def total(r: Rel[A]) -> bool:

(u, g) = r

return all(((x, y) in g or (y, x) in g for x in u for y in u))

# 2ª solución

# ===========

# producto(xs, ys) es el producto cartesiano de xs e ys. Por ejemplo,

# >>> producto([2, 5], [1, 4, 6])

# [(2, 1), (2, 4), (2, 6), (5, 1), (5, 4), (5, 6)]

def producto(xs: list[A], ys: list[A]) -> list[tuple[A,A]]:

return [(x, y) for x in xs for y in ys]

# relacionados(g, (x, y)) se verifica si los elementos x e y están

# relacionados por la relación de grafo g. Por ejemplo,

# relacionados([(2, 3), (3, 1)], (2, 3)) == True

# relacionados([(2, 3), (3, 1)], (3, 2)) == True

# relacionados([(2, 3), (3, 1)], (1, 2)) == False

def relacionados(g: list[tuple[A,A]], p: tuple[A,A]) -> bool:

(x, y) = p

return (x, y) in g or (y, x) in g

def total2(r: Rel[A]) -> bool:

(u, g) = r

return all(relacionados(g, p) for p in producto(u, u))

# 3ª solución

# ===========

def total3(r: Rel[A]) -> bool:

u, g = r

return all(relacionados(g, (x, y)) for x in u for y in u)

# 4ª solución

# ===========

def total4(r: Rel[A]) -> bool:

(u, g) = r

def aux2(x: A, ys: list[A]) -> bool:

if not ys:

return True

return relacionados(g, (x, ys[0])) and aux2(x, ys[1:])

def aux1(xs: list[A]) -> bool:

if not xs:

return True

return aux2(xs[0], u) and aux1(xs[1:])

return aux1(u)

# 5ª solución

# ===========

def total5(r: Rel[A]) -> bool:

(u, g) = r

for x in u:

for y in u:

if not relacionados(g, (x, y)):

return False

return True

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.integers(min_value=0, max_value=10))

def test_total(n: int) -> None:

r = relacionArbitraria(n)

res = total(r)

assert total2(r) == res

assert total3(r) == res

assert total4(r) == res

assert total5(r) == res

# La comprobación es

# > poetry run pytest -q Relaciones_totales.py

# 1 passed in 0.11s

Relaciones antisimétricas

PorJosé A. Alonso 10-abril-202322-marzo-2023

Usando el tipo de las relaciones binarias, definir la función

   antisimetrica :: Eq a => Rel a -> Bool

1	antisimetrica :: Eq a => Rel a -> Bool

tal que antisimetrica r se verifica si la relación r es antisimétrica; es decir, si (x,y) e (y,x) están relacionado, entonces x=y. Por ejemplo,

   antisimetrica (R ([1,2],[(1,2)]))        ==  True
   antisimetrica (R ([1,2],[(1,2),(2,1)]))  ==  False
   antisimetrica (R ([1,2],[(1,1),(2,1)]))  ==  True

antisimetrica (R ([1,2],[(1,2)])) == True

antisimetrica (R ([1,2],[(1,2),(2,1)])) == False

antisimetrica (R ([1,2],[(1,1),(2,1)])) == True

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Relaciones_binarias (Rel(R))
import Test.QuickCheck

-- 1ª solución
-- ===========

antisimetrica :: Eq a => Rel a -> Bool
antisimetrica (R (_,g)) =
  null [(x,y) | (x,y) <- g, x /= y, (y,x) `elem` g]

-- 2ª solución
-- ===========

antisimetrica2 :: Eq a => Rel a -> Bool
antisimetrica2 (R (_,g)) =
  and [(y,x) `notElem` g | (x,y) <- g, x /= y]


-- 3ª solución
-- ===========

antisimetrica3 :: Eq a => Rel a -> Bool
antisimetrica3 (R (_,g)) =
  all (\(x, y) -> (y,x) `notElem` g || x == y) g


-- 4ª solución
-- ===========

antisimetrica4 :: Eq a => Rel a -> Bool
antisimetrica4 (R (u,g)) =
  and [((x,y) `elem` g && (y,x) `elem` g) --> (x == y)
       | x <- u, y <- u]
  where p --> q = not p || q

-- 5ª solución
-- ===========

antisimetrica5 :: Eq a => Rel a -> Bool
antisimetrica5 (R (_,g)) = aux g
  where aux []         = True
        aux ((x,y):g') = ((y,x) `notElem` g || x == y) && aux g'

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_antisimetrica :: Rel Int -> Bool
prop_antisimetrica r =
  all (== antisimetrica r)
      [antisimetrica2 r,
       antisimetrica3 r,
       antisimetrica4 r,
       antisimetrica5 r]

-- La comprobación es
--    λ> quickCheck prop_antisimetrica
--    +++ OK, passed 100 tests.

import Relaciones_binarias (Rel(R))

import Test.QuickCheck

-- 1ª solución

-- ===========

antisimetrica :: Eq a => Rel a -> Bool

antisimetrica (R (_,g)) =

null [(x,y) | (x,y) <- g, x /= y, (y,x) `elem` g]

-- 2ª solución

-- ===========

antisimetrica2 :: Eq a => Rel a -> Bool

antisimetrica2 (R (_,g)) =

and [(y,x) `notElem` g | (x,y) <- g, x /= y]

-- 3ª solución

-- ===========

antisimetrica3 :: Eq a => Rel a -> Bool

antisimetrica3 (R (_,g)) =

all (\(x, y) -> (y,x) `notElem` g || x == y) g

-- 4ª solución

-- ===========

antisimetrica4 :: Eq a => Rel a -> Bool

antisimetrica4 (R (u,g)) =

and [((x,y) `elem` g && (y,x) `elem` g) --> (x == y)

| x <- u, y <- u]

where p --> q = not p || q

-- 5ª solución

-- ===========

antisimetrica5 :: Eq a => Rel a -> Bool

antisimetrica5 (R (_,g)) = aux g

where aux [] = True

aux ((x,y):g') = ((y,x) `notElem` g || x == y) && aux g'

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_antisimetrica :: Rel Int -> Bool

prop_antisimetrica r =

all (== antisimetrica r)

[antisimetrica2 r,

antisimetrica3 r,

antisimetrica4 r,

antisimetrica5 r]

-- La comprobación es

-- λ> quickCheck prop_antisimetrica

-- +++ OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución
# ===========

def antisimetrica(r: Rel[A]) -> bool:
    (u, g) = r
    return [(x, y) for (x, y) in g if x != y and (y, x) in g] == []

# 2ª solución
# ===========

def antisimetrica2(r: Rel[A]) -> bool:
    (u, g) = r
    return all(((y, x) not in g for (x, y) in g if x != y))

# 3ª solución
# ===========

def antisimetrica3(r: Rel[A]) -> bool:
    (u, g) = r
    return all ((not ((x, y) in g and (y, x) in g) or x == y
                 for x in u for y in u))

# 4ª solución
# ===========

def antisimetrica4(r: Rel[A]) -> bool:
    (u, g) = r
    def aux(xys: list[tuple[A, A]]) -> bool:
        if not xys:
            return True
        (x, y) = xys[0]
        return ((y, x) not in g or x == y) and aux(xys[1:])

    return aux(g)

# 5ª solución
# ===========

def antisimetrica5(r: Rel[A]) -> bool:
    (u, g) = r
    for (x, y) in g:
        if (y, x) in g and x != y:
            return False
    return True

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.integers(min_value=0, max_value=10))
def test_antisimetrica(n: int) -> None:
    r = relacionArbitraria(n)
    res = antisimetrica(r)
    assert antisimetrica2(r) == res
    assert antisimetrica3(r) == res
    assert antisimetrica4(r) == res
    assert antisimetrica5(r) == res

# La comprobación es
#    > poetry run pytest -q Relaciones_antisimetricas.py
#    1 passed in 0.13s

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución

# ===========

def antisimetrica(r: Rel[A]) -> bool:

(u, g) = r

return [(x, y) for (x, y) in g if x != y and (y, x) in g] == []

# 2ª solución

# ===========

def antisimetrica2(r: Rel[A]) -> bool:

(u, g) = r

return all(((y, x) not in g for (x, y) in g if x != y))

# 3ª solución

# ===========

def antisimetrica3(r: Rel[A]) -> bool:

(u, g) = r

return all ((not ((x, y) in g and (y, x) in g) or x == y

for x in u for y in u))

# 4ª solución

# ===========

def antisimetrica4(r: Rel[A]) -> bool:

(u, g) = r

def aux(xys: list[tuple[A, A]]) -> bool:

if not xys:

return True

(x, y) = xys[0]

return ((y, x) not in g or x == y) and aux(xys[1:])

return aux(g)

# 5ª solución

# ===========

def antisimetrica5(r: Rel[A]) -> bool:

(u, g) = r

for (x, y) in g:

if (y, x) in g and x != y:

return False

return True

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.integers(min_value=0, max_value=10))

def test_antisimetrica(n: int) -> None:

r = relacionArbitraria(n)

res = antisimetrica(r)

assert antisimetrica2(r) == res

assert antisimetrica3(r) == res

assert antisimetrica4(r) == res

assert antisimetrica5(r) == res

# La comprobación es

# > poetry run pytest -q Relaciones_antisimetricas.py

# 1 passed in 0.13s

Relaciones irreflexivas

PorJosé A. Alonso 7-abril-202318-marzo-2023

Usando el tipo de las relaciones binarias, definir la función

   irreflexiva :: Eq a => Rel a -> Bool

1	irreflexiva :: Eq a => Rel a -> Bool

tal que irreflexiva r se verifica si la relación r es irreflexiva; es decir, si ningún elemento de su universo está relacionado con él mismo. Por ejemplo,

   irreflexiva (R ([1,2,3],[(1,2),(2,1),(2,3)]))  ==  True
   irreflexiva (R ([1,2,3],[(1,2),(2,1),(3,3)]))  ==  False

1 2	irreflexiva (R ([1,2,3],[(1,2),(2,1),(2,3)])) == True irreflexiva (R ([1,2,3],[(1,2),(2,1),(3,3)])) == False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Relaciones_binarias (Rel(R))
import Test.QuickCheck

-- 1ª solución
-- ===========

irreflexiva :: Eq a => Rel a -> Bool
irreflexiva (R (u,g)) = and [(x,x) `notElem` g | x <- u]

-- 2ª solución
-- ===========

irreflexiva2 :: Eq a => Rel a -> Bool
irreflexiva2 (R(u,g)) = all (\x -> (x,x) `notElem` g) u

-- 3ª solución
-- ===========

irreflexiva3 :: Eq a => Rel a -> Bool
irreflexiva3 (R(u,g)) = aux u
  where aux []     = True
        aux (x:xs) = (x,x) `notElem` g && aux xs


-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_irreflexiva :: Rel Int -> Bool
prop_irreflexiva r =
  all (== irreflexiva r)
      [irreflexiva2 r,
       irreflexiva3 r]

-- La comprobación es
--    λ> quickCheck prop_irreflexiva
--    +++ OK, passed 100 tests.

import Relaciones_binarias (Rel(R))

import Test.QuickCheck

-- 1ª solución

-- ===========

irreflexiva :: Eq a => Rel a -> Bool

irreflexiva (R (u,g)) = and [(x,x) `notElem` g | x <- u]

-- 2ª solución

-- ===========

irreflexiva2 :: Eq a => Rel a -> Bool

irreflexiva2 (R(u,g)) = all (\x -> (x,x) `notElem` g) u

-- 3ª solución

-- ===========

irreflexiva3 :: Eq a => Rel a -> Bool

irreflexiva3 (R(u,g)) = aux u

where aux [] = True

aux (x:xs) = (x,x) `notElem` g && aux xs

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_irreflexiva :: Rel Int -> Bool

prop_irreflexiva r =

all (== irreflexiva r)

[irreflexiva2 r,

irreflexiva3 r]

-- La comprobación es

-- λ> quickCheck prop_irreflexiva

-- +++ OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución
# ===========

def irreflexiva(r: Rel[A]) -> bool:
    (u, g) = r
    return all(((x, x) not in g for x in u))

# 2ª solución
# ===========

def irreflexiva2(r: Rel[A]) -> bool:
    (u, g) = r
    def aux(xs: list[A]) -> bool:
        if not xs:
            return True
        return (xs[0], xs[0]) not in g and aux(xs[1:])

    return aux(u)

# 3ª solución
# ===========

def irreflexiva3(r: Rel[A]) -> bool:
    (u, g) = r
    for x in u:
        if (x, x) in g:
            return False
    return True

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.integers(min_value=0, max_value=10))
def test_irreflexiva(n: int) -> None:
    r = relacionArbitraria(n)
    res = irreflexiva(r)
    assert irreflexiva2(r) == res
    assert irreflexiva3(r) == res

# La comprobación es
#    > poetry run pytest -q Relaciones_irreflexivas.py
#    1 passed in 0.12s

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución

# ===========

def irreflexiva(r: Rel[A]) -> bool:

(u, g) = r

return all(((x, x) not in g for x in u))

# 2ª solución

# ===========

def irreflexiva2(r: Rel[A]) -> bool:

(u, g) = r

def aux(xs: list[A]) -> bool:

if not xs:

return True

return (xs[0], xs[0]) not in g and aux(xs[1:])

return aux(u)

# 3ª solución

# ===========

def irreflexiva3(r: Rel[A]) -> bool:

(u, g) = r

for x in u:

if (x, x) in g:

return False

return True

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.integers(min_value=0, max_value=10))

def test_irreflexiva(n: int) -> None:

r = relacionArbitraria(n)

res = irreflexiva(r)

assert irreflexiva2(r) == res

assert irreflexiva3(r) == res

# La comprobación es

# > poetry run pytest -q Relaciones_irreflexivas.py

# 1 passed in 0.12s

Relaciones de equivalencia

PorJosé A. Alonso 6-abril-202318-marzo-2023

Usando el tipo de las relaciones binarias, definir la función

   esEquivalencia :: Ord a => Rel a -> Bool

1	esEquivalencia :: Ord a => Rel a -> Bool

tal que esEquivalencia r se verifica si la relación r es de equivalencia. Por ejemplo,

   λ> esEquivalencia (R ([1,3,5],[(1,1),(1,3),(3,1),(3,3),(5,5)]))
   True
   λ> esEquivalencia (R ([1,2,3,5],[(1,1),(1,3),(3,1),(3,3),(5,5)]))
   False
   λ> esEquivalencia (R ([1,3,5],[(1,1),(1,3),(3,3),(5,5)]))
   False

λ> esEquivalencia (R ([1,3,5],[(1,1),(1,3),(3,1),(3,3),(5,5)]))

True

λ> esEquivalencia (R ([1,2,3,5],[(1,1),(1,3),(3,1),(3,3),(5,5)]))

False

λ> esEquivalencia (R ([1,3,5],[(1,1),(1,3),(3,3),(5,5)]))

False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Relaciones_binarias (Rel(R))
import Relaciones_reflexivas (reflexiva)
import Relaciones_simetricas (simetrica)
import Relaciones_transitivas (transitiva)

esEquivalencia :: Ord a => Rel a -> Bool
esEquivalencia r = reflexiva r && simetrica r && transitiva r

import Relaciones_binarias (Rel(R))

import Relaciones_reflexivas (reflexiva)

import Relaciones_simetricas (simetrica)

import Relaciones_transitivas (transitiva)

esEquivalencia :: Ord a => Rel a -> Bool

esEquivalencia r = reflexiva r && simetrica r && transitiva r

Soluciones en Python

from typing import TypeVar

from src.Relaciones_binarias import Rel, relacionArbitraria
from src.Relaciones_reflexivas import reflexiva
from src.Relaciones_simetricas import simetrica
from src.Relaciones_transitivas import transitiva

A = TypeVar('A')

def esEquivalencia(r: Rel[A]) -> bool:
    return reflexiva(r) and simetrica(r) and transitiva(r)

from typing import TypeVar

from src.Relaciones_binarias import Rel, relacionArbitraria

from src.Relaciones_reflexivas import reflexiva

from src.Relaciones_simetricas import simetrica

from src.Relaciones_transitivas import transitiva

A = TypeVar('A')

def esEquivalencia(r: Rel[A]) -> bool:

return reflexiva(r) and simetrica(r) and transitiva(r)

Relaciones transitivas

PorJosé A. Alonso 5-abril-202313-marzo-2023

Usando el tipo de las relaciones binarias, definir la función

   transitiva :: Ord a => Rel a -> Bool

1	transitiva :: Ord a => Rel a -> Bool

tal que transitiva r se verifica si la relación r es transitiva. Por ejemplo,

   transitiva (R ([1,3,5],[(1,1),(1,3),(3,1),(3,3),(5,5)])) == True
   transitiva (R ([1,3,5],[(1,1),(1,3),(3,1),(5,5)]))       == False

1 2	transitiva (R ([1,3,5],[(1,1),(1,3),(3,1),(3,3),(5,5)])) == True transitiva (R ([1,3,5],[(1,1),(1,3),(3,1),(5,5)])) == False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Relaciones_binarias (Rel(R))
import Reconocimiento_de_subconjunto (subconjunto)
import Universo_y_grafo_de_una_relacion_binaria (grafo)
import Composicion_de_relaciones_binarias_v2 (composicion)
import Test.QuickCheck

-- 1ª solución
-- ===========

transitiva1 :: Ord a => Rel a -> Bool
transitiva1 r@(R (_,g)) = subconjunto (grafo (composicion r r)) g

-- La función subconjunto está definida en el ejercicio
-- "Reconocimiento de subconjunto" que se encuentra en
-- https://bit.ly/427Tyeq
--
-- La función grafo está definida en el ejercicio
-- "Universo y grafo de una relación binaria" que se encuentra en
-- https://bit.ly/3J35mpC
--
-- La función composición está definida en el ejercicio
-- "Composición de relaciones binarias" que se encuentra en
-- https://bit.ly/3JyJrs7

-- 2ª solución
-- ===========

transitiva2 :: Ord a => Rel a -> Bool
transitiva2 (R (_,g)) = aux g
  where
    aux [] = True
    aux ((x,y):g') = and [(x,z) `elem` g | (u,z) <- g, u == y] && aux g'

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_transitiva :: Rel Int -> Bool
prop_transitiva r =
  transitiva1 r == transitiva2 r

-- La comprobación es
--    λ> quickCheck prop_transitiva
--    +++ OK, passed 100 tests.

-- Comparación de eficiencia
-- =========================

-- La comparación es
--    λ> transitiva1 (R ([1..4001],[(x,x+1) | x <- [1..4000]]))
--    False
--    (3.15 secs, 898,932,776 bytes)
--    λ> transitiva2 (R ([1..4001],[(x,x+1) | x <- [1..4000]]))
--    False
--    (0.01 secs, 1,396,720 bytes)
--
--    λ> transitiva1 (R ([1..60], [(x,y) | x <- [1..60], y <- [1..60]]))
--    True
--    (2.71 secs, 852,578,456 bytes)
--    λ> transitiva2 (R ([1..60], [(x,y) | x <- [1..60], y <- [1..60]]))
--    True
--    (9.13 secs, 777,080,288 bytes)

-- En lo sucesivo, usaremos la 1ª definición
transitiva :: Ord a => Rel a -> Bool
transitiva = transitiva1

import Relaciones_binarias (Rel(R))

import Reconocimiento_de_subconjunto (subconjunto)

import Universo_y_grafo_de_una_relacion_binaria (grafo)

import Composicion_de_relaciones_binarias_v2 (composicion)

import Test.QuickCheck

-- 1ª solución

-- ===========

transitiva1 :: Ord a => Rel a -> Bool

transitiva1 r@(R (_,g)) = subconjunto (grafo (composicion r r)) g

-- La función subconjunto está definida en el ejercicio

-- "Reconocimiento de subconjunto" que se encuentra en

-- https://bit.ly/427Tyeq

-- La función grafo está definida en el ejercicio

-- "Universo y grafo de una relación binaria" que se encuentra en

-- https://bit.ly/3J35mpC

-- La función composición está definida en el ejercicio

-- "Composición de relaciones binarias" que se encuentra en

-- https://bit.ly/3JyJrs7

-- 2ª solución

-- ===========

transitiva2 :: Ord a => Rel a -> Bool

transitiva2 (R (_,g)) = aux g

where

aux [] = True

aux ((x,y):g') = and [(x,z) `elem` g | (u,z) <- g, u == y] && aux g'

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_transitiva :: Rel Int -> Bool

prop_transitiva r =

transitiva1 r == transitiva2 r

-- La comprobación es

-- λ> quickCheck prop_transitiva

-- +++ OK, passed 100 tests.

-- Comparación de eficiencia

-- =========================

-- La comparación es

-- λ> transitiva1 (R ([1..4001],[(x,x+1) | x <- [1..4000]]))

-- False

-- (3.15 secs, 898,932,776 bytes)

-- λ> transitiva2 (R ([1..4001],[(x,x+1) | x <- [1..4000]]))

-- False

-- (0.01 secs, 1,396,720 bytes)

-- λ> transitiva1 (R ([1..60], [(x,y) | x <- [1..60], y <- [1..60]]))

-- True

-- (2.71 secs, 852,578,456 bytes)

-- λ> transitiva2 (R ([1..60], [(x,y) | x <- [1..60], y <- [1..60]]))

-- True

-- (9.13 secs, 777,080,288 bytes)

-- En lo sucesivo, usaremos la 1ª definición

transitiva :: Ord a => Rel a -> Bool

transitiva = transitiva1

Soluciones en Python

from sys import setrecursionlimit
from timeit import Timer, default_timer
from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.Composicion_de_relaciones_binarias_v2 import composicion
from src.Reconocimiento_de_subconjunto import subconjunto
from src.Relaciones_binarias import Rel, relacionArbitraria
from src.Universo_y_grafo_de_una_relacion_binaria import grafo

setrecursionlimit(10**6)

A = TypeVar('A')

# 1ª solución
# ===========

def transitiva1(r: Rel[A]) -> bool:
    g = grafo(r)
    return subconjunto(grafo(composicion(r, r)), g)

# La función subconjunto está definida en el ejercicio
# "Reconocimiento de subconjunto" que se encuentra en
# https://bit.ly/427Tyeq
#
# La función grafo está definida en el ejercicio
# "Universo y grafo de una relación binaria" que se encuentra en
# https://bit.ly/3J35mpC
#
# La función composición está definida en el ejercicio
# "Composición de relaciones binarias" que se encuentra en
# https://bit.ly/3JyJrs7

# 2ª solución
# ===========

def transitiva2(r: Rel[A]) -> bool:
    g = grafo(r)
    def aux(g1: list[tuple[A,A]]) -> bool:
        if not g1:
            return True
        (x, y) = g1[0]
        return all(((x, z) in g for (u,z) in g if u == y)) and aux(g1[1:])

    return aux(g)

# 3ª solución
# ===========

def transitiva3(r: Rel[A]) -> bool:
    g = grafo(r)
    g1 = list(g)
    for (x, y) in g1:
        if not all(((x, z) in g for (u,z) in g if u == y)):
            return False
    return True


# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.integers(min_value=0, max_value=10))
def test_simetrica(n: int) -> None:
    r = relacionArbitraria(n)
    res = transitiva1(r)
    assert transitiva2(r) == res
    assert transitiva3(r) == res

# La comprobación es
#    > poetry run pytest -q Relaciones_transitivas.py
#    1 passed in 0.12s

# Comparación de eficiencia
# =========================

def tiempo(e: str) -> None:
    """Tiempo (en segundos) de evaluar la expresión e."""
    t = Timer(e, "", default_timer, globals()).timeit(1)
    print(f"{t:0.2f} segundos")

# La comparación es
#    >>> u1 = range(6001)
#    >>> g1 = [(x, x+1) for x in range(6000)]
#    >>> tiempo("transitiva1((u1, g1))")
#    1.04 segundos
#    >>> tiempo("transitiva2((u1, g1))")
#    0.00 segundos
#    >>> tiempo("transitiva3((u1, g1))")
#    0.00 segundos
#
#    >>> u2 = range(60)
#    >>> g2 = [(x, y) for x in u2 for y in u2]
#    >>> tiempo("transitiva1((u2, g2))")
#    0.42 segundos
#    >>> tiempo("transitiva2((u2, g2))")
#    5.24 segundos
#    >>> tiempo("transitiva3((u2, g2))")
#    4.83 segundos

# En lo sucesivo usaremos la 1ª definición
transitiva = transitiva1

100

101

102

103

104

from sys import setrecursionlimit

from timeit import Timer, default_timer

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.Composicion_de_relaciones_binarias_v2 import composicion

from src.Reconocimiento_de_subconjunto import subconjunto

from src.Relaciones_binarias import Rel, relacionArbitraria

from src.Universo_y_grafo_de_una_relacion_binaria import grafo

setrecursionlimit(10**6)

A = TypeVar('A')

# 1ª solución

# ===========

def transitiva1(r: Rel[A]) -> bool:

g = grafo(r)

return subconjunto(grafo(composicion(r, r)), g)

# La función subconjunto está definida en el ejercicio

# "Reconocimiento de subconjunto" que se encuentra en

# https://bit.ly/427Tyeq

# La función grafo está definida en el ejercicio

# "Universo y grafo de una relación binaria" que se encuentra en

# https://bit.ly/3J35mpC

# La función composición está definida en el ejercicio

# "Composición de relaciones binarias" que se encuentra en

# https://bit.ly/3JyJrs7

# 2ª solución

# ===========

def transitiva2(r: Rel[A]) -> bool:

g = grafo(r)

def aux(g1: list[tuple[A,A]]) -> bool:

if not g1:

return True

(x, y) = g1[0]

return all(((x, z) in g for (u,z) in g if u == y)) and aux(g1[1:])

return aux(g)

# 3ª solución

# ===========

def transitiva3(r: Rel[A]) -> bool:

g = grafo(r)

g1 = list(g)

for (x, y) in g1:

if not all(((x, z) in g for (u,z) in g if u == y)):

return False

return True

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.integers(min_value=0, max_value=10))

def test_simetrica(n: int) -> None:

r = relacionArbitraria(n)

res = transitiva1(r)

assert transitiva2(r) == res

assert transitiva3(r) == res

# La comprobación es

# > poetry run pytest -q Relaciones_transitivas.py

# 1 passed in 0.12s

# Comparación de eficiencia

# =========================

def tiempo(e: str) -> None:

"""Tiempo (en segundos) de evaluar la expresión e."""

t = Timer(e, "", default_timer, globals()).timeit(1)

print(f"{t:0.2f} segundos")

# La comparación es

# >>> u1 = range(6001)

# >>> g1 = [(x, x+1) for x in range(6000)]

# >>> tiempo("transitiva1((u1, g1))")

# 1.04 segundos

# >>> tiempo("transitiva2((u1, g1))")

# 0.00 segundos

# >>> tiempo("transitiva3((u1, g1))")

# 0.00 segundos

# >>> u2 = range(60)

# >>> g2 = [(x, y) for x in u2 for y in u2]

# >>> tiempo("transitiva1((u2, g2))")

# 0.42 segundos

# >>> tiempo("transitiva2((u2, g2))")

# 5.24 segundos

# >>> tiempo("transitiva3((u2, g2))")

# 4.83 segundos

# En lo sucesivo usaremos la 1ª definición

transitiva = transitiva1

Reconocimiento de subconjunto

PorJosé A. Alonso 4-abril-202312-marzo-2023

Definir la función

   subconjunto :: Ord a => [a] -> [a] -> Bool

1	subconjunto :: Ord a => [a] -> [a] -> Bool

tal que subconjunto xs ys se verifica si xs es un subconjunto de ys. Por ejemplo,

   subconjunto [3,2,3] [2,5,3,5]  ==  True
   subconjunto [3,2,3] [2,5,6,5]  ==  False

1 2	subconjunto [3,2,3] [2,5,3,5] == True subconjunto [3,2,3] [2,5,6,5] == False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Reconocimiento_de_subconjunto where

import Data.List (nub, sort)
import Data.Set (fromList, isSubsetOf)
import Test.QuickCheck

-- 1ª solución
-- ===========

subconjunto1 :: Ord a => [a] -> [a] -> Bool
subconjunto1 xs ys =
  [x | x <- xs, x `elem` ys] == xs

-- 2ª solución
-- ===========

subconjunto2 :: Ord a => [a] -> [a] -> Bool
subconjunto2 []     _  = True
subconjunto2 (x:xs) ys = x `elem` ys && subconjunto2 xs ys

-- 3ª solución
-- ===========

subconjunto3 :: Ord a => [a] -> [a] -> Bool
subconjunto3 xs ys =
  all (`elem` ys) xs

-- 4ª solución
-- ===========

subconjunto4 :: Ord a => [a] -> [a] -> Bool
subconjunto4 xs ys =
  fromList xs `isSubsetOf` fromList ys

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_subconjunto :: [Int] -> [Int] -> Bool
prop_subconjunto xs ys =
  all (== subconjunto1 xs ys)
      [subconjunto2 xs ys,
       subconjunto3 xs ys,
       subconjunto4 xs ys]

-- La comprobación es
--    λ> quickCheck prop_subconjunto
--    +++ OK, passed 100 tests.

-- Comparación de eficiencia
-- =========================

-- La comparación es
--    λ> subconjunto1 [1..2*10^4] [1..2*10^4]
--    True
--    (1.81 secs, 5,992,448 bytes)
--    λ> subconjunto2 [1..2*10^4] [1..2*10^4]
--    True
--    (1.83 secs, 6,952,200 bytes)
--    λ> subconjunto3 [1..2*10^4] [1..2*10^4]
--    True
--    (1.75 secs, 4,712,304 bytes)
--    λ> subconjunto4 [1..2*10^4] [1..2*10^4]
--    True
--    (0.04 secs, 6,312,056 bytes)

-- En lo sucesivo, usaremos la 4ª definición
subconjunto :: Ord a => [a] -> [a] -> Bool
subconjunto = subconjunto4

module Reconocimiento_de_subconjunto where

import Data.List (nub, sort)

import Data.Set (fromList, isSubsetOf)

import Test.QuickCheck

-- 1ª solución

-- ===========

subconjunto1 :: Ord a => [a] -> [a] -> Bool

subconjunto1 xs ys =

[x | x <- xs, x `elem` ys] == xs

-- 2ª solución

-- ===========

subconjunto2 :: Ord a => [a] -> [a] -> Bool

subconjunto2 [] _ = True

subconjunto2 (x:xs) ys = x `elem` ys && subconjunto2 xs ys

-- 3ª solución

-- ===========

subconjunto3 :: Ord a => [a] -> [a] -> Bool

subconjunto3 xs ys =

all (`elem` ys) xs

-- 4ª solución

-- ===========

subconjunto4 :: Ord a => [a] -> [a] -> Bool

subconjunto4 xs ys =

fromList xs `isSubsetOf` fromList ys

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_subconjunto :: [Int] -> [Int] -> Bool

prop_subconjunto xs ys =

all (== subconjunto1 xs ys)

[subconjunto2 xs ys,

subconjunto3 xs ys,

subconjunto4 xs ys]

-- La comprobación es

-- λ> quickCheck prop_subconjunto

-- +++ OK, passed 100 tests.

-- Comparación de eficiencia

-- =========================

-- La comparación es

-- λ> subconjunto1 [1..2*10^4] [1..2*10^4]

-- True

-- (1.81 secs, 5,992,448 bytes)

-- λ> subconjunto2 [1..2*10^4] [1..2*10^4]

-- True

-- (1.83 secs, 6,952,200 bytes)

-- λ> subconjunto3 [1..2*10^4] [1..2*10^4]

-- True

-- (1.75 secs, 4,712,304 bytes)

-- λ> subconjunto4 [1..2*10^4] [1..2*10^4]

-- True

-- (0.04 secs, 6,312,056 bytes)

-- En lo sucesivo, usaremos la 4ª definición

subconjunto :: Ord a => [a] -> [a] -> Bool

subconjunto = subconjunto4

Soluciones en Python

from sys import setrecursionlimit
from timeit import Timer, default_timer
from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

setrecursionlimit(10**6)

A = TypeVar('A')

# 1ª solución
# ===========

def subconjunto1(xs: list[A], ys: list[A]) -> bool:
    return [x for x in xs if x in ys] == xs

# 2ª solución
# ===========

def subconjunto2(xs: list[A], ys: list[A]) -> bool:
    if not xs:
        return True
    return xs[0] in ys and subconjunto2(xs[1:], ys)

# 3ª solución
# ===========

def subconjunto3(xs: list[A], ys: list[A]) -> bool:
    return all(elem in ys for elem in xs)

# 4ª solución
# ===========

def subconjunto4(xs: list[A], ys: list[A]) -> bool:
    return set(xs) <= set(ys)

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.lists(st.integers()),
       st.lists(st.integers()))
def test_filtraAplica(xs: list[int], ys: list[int]) -> None:
    r = subconjunto1(xs, ys)
    assert subconjunto2(xs, ys) == r
    assert subconjunto3(xs, ys) == r
    assert subconjunto4(xs, ys) == r

# La comprobación es
#    src> poetry run pytest -q Reconocimiento_de_subconjunto.py
#    1 passed in 0.31s

# Comparación de eficiencia
# =========================

def tiempo(e: str) -> None:
    """Tiempo (en segundos) de evaluar la expresión e."""
    t = Timer(e, "", default_timer, globals()).timeit(1)
    print(f"{t:0.2f} segundos")

# La comparación es
#    >>> xs = list(range(2*10**4))
#    >>> tiempo("subconjunto1(xs, xs)")
#    1.15 segundos
#    >>> tiempo("subconjunto2(xs, xs)")
#    2.27 segundos
#    >>> tiempo("subconjunto3(xs, xs)")
#    1.14 segundos
#    >>> tiempo("subconjunto4(xs, xs)")
#    0.00 segundos

# En lo sucesivo usaremos la cuarta definición
subconjunto = subconjunto4

from sys import setrecursionlimit

from timeit import Timer, default_timer

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

setrecursionlimit(10**6)

A = TypeVar('A')

# 1ª solución

# ===========

def subconjunto1(xs: list[A], ys: list[A]) -> bool:

return [x for x in xs if x in ys] == xs

# 2ª solución

# ===========

def subconjunto2(xs: list[A], ys: list[A]) -> bool:

if not xs:

return True

return xs[0] in ys and subconjunto2(xs[1:], ys)

# 3ª solución

# ===========

def subconjunto3(xs: list[A], ys: list[A]) -> bool:

return all(elem in ys for elem in xs)

# 4ª solución

# ===========

def subconjunto4(xs: list[A], ys: list[A]) -> bool:

return set(xs) <= set(ys)

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.lists(st.integers()),

st.lists(st.integers()))

def test_filtraAplica(xs: list[int], ys: list[int]) -> None:

r = subconjunto1(xs, ys)

assert subconjunto2(xs, ys) == r

assert subconjunto3(xs, ys) == r

assert subconjunto4(xs, ys) == r

# La comprobación es

# src> poetry run pytest -q Reconocimiento_de_subconjunto.py

# 1 passed in 0.31s

# Comparación de eficiencia

# =========================

def tiempo(e: str) -> None:

"""Tiempo (en segundos) de evaluar la expresión e."""

t = Timer(e, "", default_timer, globals()).timeit(1)

print(f"{t:0.2f} segundos")

# La comparación es

# >>> xs = list(range(2*10**4))

# >>> tiempo("subconjunto1(xs, xs)")

# 1.15 segundos

# >>> tiempo("subconjunto2(xs, xs)")

# 2.27 segundos

# >>> tiempo("subconjunto3(xs, xs)")

# 1.14 segundos

# >>> tiempo("subconjunto4(xs, xs)")

# 0.00 segundos

# En lo sucesivo usaremos la cuarta definición

subconjunto = subconjunto4

Composición de relaciones binarias

PorJosé A. Alonso 3-abril-202311-marzo-2023

Usando el tipo de las relaciones binarias, definir la función

   composicion :: Eq a => Rel a -> Rel a -> Rel a

1	composicion :: Eq a => Rel a -> Rel a -> Rel a

tal que composicion r s es la composición de las relaciones r y s. Por ejemplo,

   λ> composicion (R ([1,2],[(1,2),(2,2)])) (R ([1,2],[(2,1)]))
   R ([1,2],[(1,1),(2,1)])

1 2	λ> composicion (R ([1,2],[(1,2),(2,2)])) (R ([1,2],[(2,1)])) R ([1,2],[(1,1),(2,1)])

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Relaciones_binarias (Rel(R))
import Test.QuickCheck

-- 1ª solución
-- ===========

composicion :: Eq a => Rel a -> Rel a -> Rel a
composicion (R (u1,g1)) (R (_,g2)) =
  R (u1,[(x,z) | (x,y) <- g1, (y',z) <- g2, y == y'])

-- 2ª solución
-- ===========

composicion2 :: Eq a => Rel a -> Rel a -> Rel a
composicion2 (R (u1,g1)) (R (_,g2)) =
  R (u1, aux g1)
  where aux [] = []
        aux ((x,y):g1') = [(x,z) | (y',z) <- g2, y == y'] ++ aux g1'

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_composicion :: Rel Int -> Rel Int -> Bool
prop_composicion r1 r2 =
  composicion r1 r2 == composicion2 r1 r2

-- La comprobación es
--    λ> quickCheck prop_composicion
--    +++ OK, passed 100 tests.

import Relaciones_binarias (Rel(R))

import Test.QuickCheck

-- 1ª solución

-- ===========

composicion :: Eq a => Rel a -> Rel a -> Rel a

composicion (R (u1,g1)) (R (_,g2)) =

R (u1,[(x,z) | (x,y) <- g1, (y',z) <- g2, y == y'])

-- 2ª solución

-- ===========

composicion2 :: Eq a => Rel a -> Rel a -> Rel a

composicion2 (R (u1,g1)) (R (_,g2)) =

R (u1, aux g1)

where aux [] = []

aux ((x,y):g1') = [(x,z) | (y',z) <- g2, y == y'] ++ aux g1'

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_composicion :: Rel Int -> Rel Int -> Bool

prop_composicion r1 r2 =

composicion r1 r2 == composicion2 r1 r2

-- La comprobación es

-- λ> quickCheck prop_composicion

-- +++ OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución
# ===========

def composicion(r1: Rel[A], r2: Rel[A]) -> Rel[A]:
    (u1, g1) = r1
    (_,  g2) = r2
    return (u1, [(x, z) for (x, y) in g1 for (u, z) in g2 if y == u])

# 2ª solución
# ===========

def composicion2(r1: Rel[A], r2: Rel[A]) -> Rel[A]:
    (u1, g1) = r1
    (_,  g2) = r2
    def aux(g: list[tuple[A, A]]) -> list[tuple[A, A]]:
        if not g:
            return []
        (x, y) = g[0]
        return [(x, z) for (u, z) in g2 if y == u] + aux(g[1:])

    return (u1, aux(g1))

# 2ª solución
# ===========

def composicion3(r1: Rel[A], r2: Rel[A]) -> Rel[A]:
    (u1, g1) = r1
    (_,  g2) = r2
    r: list[tuple[A, A]] = []
    for (x, y) in g1:
        r = r + [(x, z) for (u, z) in g2 if y == u]
    return (u1, r)

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.integers(min_value=0, max_value=10),
       st.integers(min_value=0, max_value=10))
def test_simetrica(n: int, m: int) -> None:
    r1 = relacionArbitraria(n)
    r2 = relacionArbitraria(m)
    res = composicion(r1, r2)
    assert composicion2(r1, r2) == res
    assert composicion2(r1, r2) == res

# La comprobación es
#    > poetry run pytest -q Composicion_de_relaciones_binarias_v2.py
#    1 passed in 0.19s

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución

# ===========

def composicion(r1: Rel[A], r2: Rel[A]) -> Rel[A]:

(u1, g1) = r1

(_, g2) = r2

return (u1, [(x, z) for (x, y) in g1 for (u, z) in g2 if y == u])

# 2ª solución

# ===========

def composicion2(r1: Rel[A], r2: Rel[A]) -> Rel[A]:

(u1, g1) = r1

(_, g2) = r2

def aux(g: list[tuple[A, A]]) -> list[tuple[A, A]]:

if not g:

return []

(x, y) = g[0]

return [(x, z) for (u, z) in g2 if y == u] + aux(g[1:])

return (u1, aux(g1))

# 2ª solución

# ===========

def composicion3(r1: Rel[A], r2: Rel[A]) -> Rel[A]:

(u1, g1) = r1

(_, g2) = r2

r: list[tuple[A, A]] = []

for (x, y) in g1:

r = r + [(x, z) for (u, z) in g2 if y == u]

return (u1, r)

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.integers(min_value=0, max_value=10),

st.integers(min_value=0, max_value=10))

def test_simetrica(n: int, m: int) -> None:

r1 = relacionArbitraria(n)

r2 = relacionArbitraria(m)

res = composicion(r1, r2)

assert composicion2(r1, r2) == res

# La comprobación es

# > poetry run pytest -q Composicion_de_relaciones_binarias_v2.py

# 1 passed in 0.19s

Relaciones simétricas

PorJosé A. Alonso 31-marzo-202310-marzo-2023

Usando el tipo de las relaciones binarias, definir la función

   simetrica :: Eq a => Rel a -> Bool

1	simetrica :: Eq a => Rel a -> Bool

tal que simetrica r se verifica si la relación r es simétrica. Por ejemplo,

   simetrica (R ([1,3],[(1,1),(1,3),(3,1)]))  ==  True
   simetrica (R ([1,3],[(1,1),(1,3),(3,2)]))  ==  False
   simetrica (R ([1,3],[]))                   ==  True

simetrica (R ([1,3],[(1,1),(1,3),(3,1)])) == True

simetrica (R ([1,3],[(1,1),(1,3),(3,2)])) == False

simetrica (R ([1,3],[])) == True

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Relaciones_binarias (Rel(R))
import Test.QuickCheck

-- 1ª solución
-- ===========

simetrica :: Eq a => Rel a -> Bool
simetrica (R (_,g)) = and [(y,x) `elem` g | (x,y) <- g]

-- 2ª solución
-- ===========

simetrica2 :: Eq a => Rel a -> Bool
simetrica2 (R (_,g)) = all (\(x,y) -> (y,x) `elem` g) g

-- 3ª solución
-- ===========

simetrica3 :: Eq a => Rel a -> Bool
simetrica3 (R (_,g)) = aux g
  where aux [] = True
        aux ((x,y):ps) = (y,x) `elem` g && aux ps

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_simetrica :: Rel Int -> Bool
prop_simetrica r =
  all (== simetrica r)
      [simetrica2 r,
       simetrica3 r]

-- La comprobación es
--    λ> quickCheck prop_simetrica
--    +++ OK, passed 100 tests.

import Relaciones_binarias (Rel(R))

import Test.QuickCheck

-- 1ª solución

-- ===========

simetrica :: Eq a => Rel a -> Bool

simetrica (R (_,g)) = and [(y,x) `elem` g | (x,y) <- g]

-- 2ª solución

-- ===========

simetrica2 :: Eq a => Rel a -> Bool

simetrica2 (R (_,g)) = all (\(x,y) -> (y,x) `elem` g) g

-- 3ª solución

-- ===========

simetrica3 :: Eq a => Rel a -> Bool

simetrica3 (R (_,g)) = aux g

where aux [] = True

aux ((x,y):ps) = (y,x) `elem` g && aux ps

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_simetrica :: Rel Int -> Bool

prop_simetrica r =

all (== simetrica r)

[simetrica2 r,

simetrica3 r]

-- La comprobación es

-- λ> quickCheck prop_simetrica

-- +++ OK, passed 100 tests.

Soluciones en Python

from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución
# ===========

def simetrica(r: Rel[A]) -> bool:
    (_, g) = r
    return all(((y, x) in g for (x, y) in g))

# 2ª solución
# ===========

def simetrica2(r: Rel[A]) -> bool:
    (_, g) = r
    def aux(ps: list[tuple[A, A]]) -> bool:
        if not ps:
            return True
        (x, y) = ps[0]
        return (y, x) in g and aux(ps[1:])

    return aux(g)

# 3ª solución
# ===========

def simetrica3(r: Rel[A]) -> bool:
    (_, g) = r
    for (x, y) in g:
        if (y, x) not in g:
            return False
    return True

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.integers(min_value=0, max_value=10))
def test_simetrica(n: int) -> None:
    r = relacionArbitraria(n)
    res = simetrica(r)
    assert simetrica2(r) == res
    assert simetrica3(r) == res

# La comprobación es
#    > poetry run pytest -q Relaciones_simetricas.py
#    1 passed in 0.11s

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución

# ===========

def simetrica(r: Rel[A]) -> bool:

(_, g) = r

return all(((y, x) in g for (x, y) in g))

# 2ª solución

# ===========

def simetrica2(r: Rel[A]) -> bool:

(_, g) = r

def aux(ps: list[tuple[A, A]]) -> bool:

if not ps:

return True

(x, y) = ps[0]

return (y, x) in g and aux(ps[1:])

return aux(g)

# 3ª solución

# ===========

def simetrica3(r: Rel[A]) -> bool:

(_, g) = r

for (x, y) in g:

if (y, x) not in g:

return False

return True

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.integers(min_value=0, max_value=10))

def test_simetrica(n: int) -> None:

r = relacionArbitraria(n)

res = simetrica(r)

assert simetrica2(r) == res

assert simetrica3(r) == res

# La comprobación es

# > poetry run pytest -q Relaciones_simetricas.py

# 1 passed in 0.11s

Relaciones reflexivas

PorJosé A. Alonso 30-marzo-20239-marzo-2023

Usando el tipo de las relaciones binarias, definir la función

   reflexiva :: Eq a => Rel a -> Bool

1	reflexiva :: Eq a => Rel a -> Bool

tal que reflexiva r se verifica si la relación r es reflexiva. Por ejemplo,

   reflexiva (R ([1,3],[(1,1),(1,3),(3,3)]))    ==  True
   reflexiva (R ([1,2,3],[(1,1),(1,3),(3,3)]))  ==  False

1 2	reflexiva (R ([1,3],[(1,1),(1,3),(3,3)])) == True reflexiva (R ([1,2,3],[(1,1),(1,3),(3,3)])) == False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

module Relaciones_reflexivas where

import Relaciones_binarias (Rel(R))
import Test.QuickCheck

-- 1ª solución
-- ===========

reflexiva :: Eq a => Rel a -> Bool
reflexiva (R ([], _))   = True
reflexiva (R (x:xs, ps)) = (x, x) `elem` ps && reflexiva  (R (xs, ps))

-- 2ª solución
-- ===========

reflexiva2 :: Eq a => Rel a -> Bool
reflexiva2 (R (us,ps)) = and [(x,x) `elem` ps | x <- us]

-- 3ª solución
-- ===========

reflexiva3 :: Eq a => Rel a -> Bool
reflexiva3 (R (us,ps)) = all (`elem` ps) [(x,x) | x <- us]

-- 4ª solución
-- ===========

reflexiva4 :: Eq a => Rel a -> Bool
reflexiva4 (R (us,ps)) = all (\x -> (x,x) `elem` ps) us

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_reflexiva :: Rel Int -> Bool
prop_reflexiva r =
  all (== reflexiva r)
      [reflexiva2 r,
       reflexiva3 r,
       reflexiva4 r]

-- La comprobación es
--    λ> quickCheck prop_reflexiva
--    +++ OK, passed 100 tests.

module Relaciones_reflexivas where

import Relaciones_binarias (Rel(R))

import Test.QuickCheck

-- 1ª solución

-- ===========

reflexiva :: Eq a => Rel a -> Bool

reflexiva (R ([], _)) = True

reflexiva (R (x:xs, ps)) = (x, x) `elem` ps && reflexiva (R (xs, ps))

-- 2ª solución

-- ===========

reflexiva2 :: Eq a => Rel a -> Bool

reflexiva2 (R (us,ps)) = and [(x,x) `elem` ps | x <- us]

-- 3ª solución

-- ===========

reflexiva3 :: Eq a => Rel a -> Bool

reflexiva3 (R (us,ps)) = all (`elem` ps) [(x,x) | x <- us]

-- 4ª solución

-- ===========

reflexiva4 :: Eq a => Rel a -> Bool

reflexiva4 (R (us,ps)) = all (\x -> (x,x) `elem` ps) us

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_reflexiva :: Rel Int -> Bool

prop_reflexiva r =

all (== reflexiva r)

[reflexiva2 r,

reflexiva3 r,

reflexiva4 r]

-- La comprobación es

-- λ> quickCheck prop_reflexiva

-- +++ OK, passed 100 tests.

Soluciones en Python

from random import choice, randint, sample
from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución
# ===========

def reflexiva(r: Rel[A]) -> bool:
    (us, ps) = r
    if not us:
        return True
    return (us[0], us[0]) in ps and reflexiva((us[1:], ps))

# 2ª solución
# ===========

def reflexiva2(r: Rel[A]) -> bool:
    (us, ps) = r
    return all(((x,x) in ps for x in us))

# 3ª solución
# ===========

def reflexiva3(r: Rel[A]) -> bool:
    (us, ps) = r
    for x in us:
        if (x, x) not in ps:
            return False
    return True

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.integers(min_value=0, max_value=10))
def test_reflexiva(n: int) -> None:
    r = relacionArbitraria(n)
    res = reflexiva(r)
    assert reflexiva2(r) == res
    assert reflexiva3(r) == res

# La comprobación es
#    > poetry run pytest -q Relaciones_reflexivas.py
#    1 passed in 0.41s

from random import choice, randint, sample

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.Relaciones_binarias import Rel, relacionArbitraria

A = TypeVar('A')

# 1ª solución

# ===========

def reflexiva(r: Rel[A]) -> bool:

(us, ps) = r

if not us:

return True

return (us[0], us[0]) in ps and reflexiva((us[1:], ps))

# 2ª solución

# ===========

def reflexiva2(r: Rel[A]) -> bool:

(us, ps) = r

return all(((x,x) in ps for x in us))

# 3ª solución

# ===========

def reflexiva3(r: Rel[A]) -> bool:

(us, ps) = r

for x in us:

if (x, x) not in ps:

return False

return True

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.integers(min_value=0, max_value=10))

def test_reflexiva(n: int) -> None:

r = relacionArbitraria(n)

res = reflexiva(r)

assert reflexiva2(r) == res

assert reflexiva3(r) == res

# La comprobación es

# > poetry run pytest -q Relaciones_reflexivas.py

# 1 passed in 0.41s

Universo y grafo de una relación binaria

PorJosé A. Alonso 29-marzo-20236-marzo-2023

Usando el tipo de las relaciones binarias, definir las funciones

   universo :: Eq a => Rel a -> [a]
   grafo    :: Eq a => ([a],[(a,a)]) -> [(a,a)]

1 2	universo :: Eq a => Rel a -> [a] grafo :: Eq a => ([a],[(a,a)]) -> [(a,a)]

tales que

universo r es el universo de la relación r. Por ejemplo,

     λ> r = R ([1, 3],[(3, 1), (3, 3)])
     λ> universo r
     [1,3]

λ> r = R ([1, 3],[(3, 1), (3, 3)])

λ> universo r

[1,3]

grafo r es el grafo de la relación r. Por ejemplo,

     λ> grafo r
     [(3,1),(3,3)]

1 2	λ> grafo r [(3,1),(3,3)]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Relaciones_binarias

universo :: Eq a => Rel a -> [a]
universo (R (u,_)) = u

grafo :: Eq a => Rel a -> [(a,a)]
grafo (R (_,g)) = g

import Relaciones_binarias

universo :: Eq a => Rel a -> [a]

universo (R (u,_)) = u

grafo :: Eq a => Rel a -> [(a,a)]

grafo (R (_,g)) = g

Soluciones en Python

from typing import TypeVar

A = TypeVar('A')

Rel = tuple[list[A], list[tuple[A, A]]]

def universo(r: Rel[A]) -> list[A]:
    return r[0]

def grafo(r: Rel[A]) -> list[tuple[A, A]]:
    return r[1]

from typing import TypeVar

A = TypeVar('A')

Rel = tuple[list[A], list[tuple[A, A]]]

def universo(r: Rel[A]) -> list[A]:

return r[0]

def grafo(r: Rel[A]) -> list[tuple[A, A]]:

return r[1]

Relaciones binarias

PorJosé A. Alonso 28-marzo-202311-marzo-2023

Una relación 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).

Definir el tipo de dato (Rel a), para representar las relaciones binarias sobre a, y la función

   esRelacionBinaria :: Eq a => Rel a -> Bool

1	esRelacionBinaria :: Eq a => Rel a -> Bool

tal que esRelacionBinaria r se verifica si r es una relación binaria. Por ejemplo,

   λ> esRelacionBinaria (R ([1, 3], [(3, 1), (3, 3)]))
   True
   λ> esRelacionBinaria (R ([1, 3], [(3, 1), (3, 2)]))
   False

λ> esRelacionBinaria (R ([1, 3], [(3, 1), (3, 3)]))

True

λ> esRelacionBinaria (R ([1, 3], [(3, 1), (3, 2)]))

False

Además, definir un generador de relaciones binarias y comprobar que las relaciones que genera son relaciones binarias.

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Data.List (nub)
import Test.QuickCheck

newtype Rel a = R ([a], [(a,a)])
  deriving (Eq, Show)

-- 1ª solución
-- ===========

esRelacionBinaria :: Eq a => Rel a -> Bool
esRelacionBinaria (R (u, g)) =
  and [x `elem` u && y `elem` u | (x,y) <- g]

-- 2ª solución
-- ===========

esRelacionBinaria2 :: Eq a => Rel a -> Bool
esRelacionBinaria2 (R (u, g)) =
  all (\(x,y) -> x `elem` u && y `elem` u) g

-- 3ª solución
-- ===========

esRelacionBinaria3 :: Eq a => Rel a -> Bool
esRelacionBinaria3 (R (_, []))         = True
esRelacionBinaria3 (R (u, (x,y):g)) =
  x `elem` u &&
  y `elem` u &&
  esRelacionBinaria3 (R (u, g))

-- Comprobación de equivalencia
-- ============================

-- Generador de relaciones binarias. Por ejemplo,
--    λ> sample (relacionArbitraria :: Gen (Rel Int))
--    R ([0],[])
--    R ([0,-1,1],[(0,-1),(0,1),(-1,1),(1,0)])
--    R ([1],[])
--    R ([-5,3],[(-5,-5),(-5,3),(3,-5),(3,3)])
--    R ([-2,-7],[(-7,-7)])
--    R ([11,-7],[])
--    R ([0],[])
--    R ([-13,-11],[(-13,-13)])
relacionArbitraria :: (Arbitrary a, Eq a) => Gen (Rel a)
relacionArbitraria = do
  n <- choose (0, 10)
  u1 <- vectorOf n arbitrary
  let u = nub u1
  g <- sublistOf [(x,y) | x <- u, y <- u]
  return (R (u, g))

-- Relaciones es una subclase de Arbitrary.
instance (Arbitrary a, Eq a) => Arbitrary (Rel a) where
  arbitrary = relacionArbitraria

-- La propiedad es
prop_esRelacionBinaria :: Rel Int -> Bool
prop_esRelacionBinaria r =
  esRelacionBinaria r  &&
  esRelacionBinaria2 r &&
  esRelacionBinaria3 r

-- La comprobación es
--    λ> quickCheck prop_esRelacionBinaria
--    +++ OK, passed 100 tests.

import Data.List (nub)

import Test.QuickCheck

newtype Rel a = R ([a], [(a,a)])

deriving (Eq, Show)

-- 1ª solución

-- ===========

esRelacionBinaria :: Eq a => Rel a -> Bool

esRelacionBinaria (R (u, g)) =

and [x `elem` u && y `elem` u | (x,y) <- g]

-- 2ª solución

-- ===========

esRelacionBinaria2 :: Eq a => Rel a -> Bool

esRelacionBinaria2 (R (u, g)) =

all (\(x,y) -> x `elem` u && y `elem` u) g

-- 3ª solución

-- ===========

esRelacionBinaria3 :: Eq a => Rel a -> Bool

esRelacionBinaria3 (R (_, [])) = True

esRelacionBinaria3 (R (u, (x,y):g)) =

x `elem` u &&

y `elem` u &&

esRelacionBinaria3 (R (u, g))

-- Comprobación de equivalencia

-- ============================

-- Generador de relaciones binarias. Por ejemplo,

-- λ> sample (relacionArbitraria :: Gen (Rel Int))

-- R ([0],[])

-- R ([0,-1,1],[(0,-1),(0,1),(-1,1),(1,0)])

-- R ([1],[])

-- R ([-5,3],[(-5,-5),(-5,3),(3,-5),(3,3)])

-- R ([-2,-7],[(-7,-7)])

-- R ([11,-7],[])

-- R ([0],[])

-- R ([-13,-11],[(-13,-13)])

relacionArbitraria :: (Arbitrary a, Eq a) => Gen (Rel a)

relacionArbitraria = do

n <- choose (0, 10)

u1 <- vectorOf n arbitrary

let u = nub u1

g <- sublistOf [(x,y) | x <- u, y <- u]

return (R (u, g))

-- Relaciones es una subclase de Arbitrary.

instance (Arbitrary a, Eq a) => Arbitrary (Rel a) where

arbitrary = relacionArbitraria

-- La propiedad es

prop_esRelacionBinaria :: Rel Int -> Bool

prop_esRelacionBinaria r =

esRelacionBinaria r &&

esRelacionBinaria2 r &&

esRelacionBinaria3 r

-- La comprobación es

-- λ> quickCheck prop_esRelacionBinaria

-- +++ OK, passed 100 tests.

Soluciones en Python

from random import choice, randint, sample
from typing import TypeVar

from hypothesis import given
from hypothesis import strategies as st

A = TypeVar('A')

Rel = tuple[list[A], list[tuple[A, A]]]

# 1ª solución
# ===========

def esRelacionBinaria(r: Rel[A]) -> bool:
    (u, g) = r
    return all((x in u and y in u for (x, y) in g))

# 2ª solución
# ===========

def esRelacionBinaria2(r: Rel[A]) -> bool:
    (u, g) = r
    if not g:
        return True
    (x, y) = g[0]
    return x in u and y in u and esRelacionBinaria2((u, g[1:]))

# 3ª solución
# ===========

def esRelacionBinaria3(r: Rel[A]) -> bool:
    (u, g) = r
    for (x, y) in g:
        if x not in u or y not in u:
            return False
    return True

# Generador de relaciones binarias
# ================================

# conjuntoArbitrario(n) es un conjunto arbitrario cuyos elementos están
# entre 0 y n-1. Por ejemplo,
#    >>> conjuntoArbitrario(10)
#    [8, 9, 4, 5]
#    >>> conjuntoArbitrario(10)
#    [1, 2, 3, 4, 5, 6, 7, 8, 9]
#    >>> conjuntoArbitrario(10)
#    [0, 1, 2, 3, 6, 7, 9]
#    >>> conjuntoArbitrario(10)
#    [8, 2, 3, 7]
def conjuntoArbitrario(n: int) -> list[int]:
    xs = sample(range(n), randint(0, n))
    return list(set(xs))

# productoCartesiano(xs, ys) es el producto cartesiano de xs e ys. Por
# ejemplo,
#    >>> productoCartesiano([2, 3], [1, 7, 5])
#    [(2, 1), (2, 7), (2, 5), (3, 1), (3, 7), (3, 5)]
def productoCartesiano(xs: list[int], ys: list[int]) -> list[tuple[int, int]]:
    return [(x, y) for x in xs for y in ys]

# sublistaArbitraria(xs) es una sublista arbitraria de xs. Por ejemplo,
#    >>> sublistaArbitraria(range(10))
#    [3, 7]
#    >>> sublistaArbitraria(range(10))
#    []
#    >>> sublistaArbitraria(range(10))
#    [4, 1, 0, 9, 8, 7, 5, 6, 2, 3]
def sublistaArbitraria(xs: list[A]) -> list[A]:
    n = len(xs)
    k = randint(0, n)
    return sample(xs, k)

# relacionArbitraria(n) es una relación arbitraria tal que los elementos
# de su universo están entre 0 y n-1. Por ejemplo,
#    >>> relacionArbitraria(3)
#    ([0, 1], [(1, 0), (1, 1)])
#    >>> relacionArbitraria(3)
#    ([], [])
#    >>> relacionArbitraria(5)
#    ([0, 2, 3, 4], [(2, 0), (3, 3), (2, 3), (4, 0), (3, 4), (4, 2)])
def relacionArbitraria(n: int) -> Rel[int]:
    u = conjuntoArbitrario(n)
    g = sublistaArbitraria(productoCartesiano(u, u))
    return (u, g)

# Comprobación de la propiedad
# ============================

# La propiedad es
@given(st.integers(min_value=0, max_value=10))
def test_esRelacionBinaria(n: int) -> None:
    r = relacionArbitraria(n)
    assert esRelacionBinaria(r)
    assert esRelacionBinaria2(r)
    assert esRelacionBinaria3(r)

# La comprobación es
#    > poetry run pytest -q Relaciones_binarias.py
#    1 passed in 0.14s

100

from random import choice, randint, sample

from typing import TypeVar

from hypothesis import given

from hypothesis import strategies as st

A = TypeVar('A')

Rel = tuple[list[A], list[tuple[A, A]]]

# 1ª solución

# ===========

def esRelacionBinaria(r: Rel[A]) -> bool:

(u, g) = r

return all((x in u and y in u for (x, y) in g))

# 2ª solución

# ===========

def esRelacionBinaria2(r: Rel[A]) -> bool:

(u, g) = r

if not g:

return True

(x, y) = g[0]

return x in u and y in u and esRelacionBinaria2((u, g[1:]))

# 3ª solución

# ===========

def esRelacionBinaria3(r: Rel[A]) -> bool:

(u, g) = r

for (x, y) in g:

if x not in u or y not in u:

return False

return True

# Generador de relaciones binarias

# ================================

# conjuntoArbitrario(n) es un conjunto arbitrario cuyos elementos están

# entre 0 y n-1. Por ejemplo,

# >>> conjuntoArbitrario(10)

# [8, 9, 4, 5]

# >>> conjuntoArbitrario(10)

# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# >>> conjuntoArbitrario(10)

# [0, 1, 2, 3, 6, 7, 9]

# >>> conjuntoArbitrario(10)

# [8, 2, 3, 7]

def conjuntoArbitrario(n: int) -> list[int]:

xs = sample(range(n), randint(0, n))

return list(set(xs))

# productoCartesiano(xs, ys) es el producto cartesiano de xs e ys. Por

# ejemplo,

# >>> productoCartesiano([2, 3], [1, 7, 5])

# [(2, 1), (2, 7), (2, 5), (3, 1), (3, 7), (3, 5)]

def productoCartesiano(xs: list[int], ys: list[int]) -> list[tuple[int, int]]:

return [(x, y) for x in xs for y in ys]

# sublistaArbitraria(xs) es una sublista arbitraria de xs. Por ejemplo,

# >>> sublistaArbitraria(range(10))

# [3, 7]

# >>> sublistaArbitraria(range(10))

# []

# >>> sublistaArbitraria(range(10))

# [4, 1, 0, 9, 8, 7, 5, 6, 2, 3]

def sublistaArbitraria(xs: list[A]) -> list[A]:

n = len(xs)

k = randint(0, n)

return sample(xs, k)

# relacionArbitraria(n) es una relación arbitraria tal que los elementos

# de su universo están entre 0 y n-1. Por ejemplo,

# >>> relacionArbitraria(3)

# ([0, 1], [(1, 0), (1, 1)])

# >>> relacionArbitraria(3)

# ([], [])

# >>> relacionArbitraria(5)

# ([0, 2, 3, 4], [(2, 0), (3, 3), (2, 3), (4, 0), (3, 4), (4, 2)])

def relacionArbitraria(n: int) -> Rel[int]:

u = conjuntoArbitrario(n)

g = sublistaArbitraria(productoCartesiano(u, u))

return (u, g)

# Comprobación de la propiedad

# ============================

# La propiedad es

@given(st.integers(min_value=0, max_value=10))

def test_esRelacionBinaria(n: int) -> None:

r = relacionArbitraria(n)

assert esRelacionBinaria(r)

assert esRelacionBinaria2(r)

assert esRelacionBinaria3(r)

# La comprobación es

# > poetry run pytest -q Relaciones_binarias.py

# 1 passed in 0.14s

TAD de los conjuntos: Producto cartesiano de dos conjuntos

PorJosé A. Alonso 27-marzo-20233-marzo-2023

Utilizando el tipo abstracto de datos de los conjuntos (https://bit.ly/3HbB7fo) definir la función

   productoC :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)

1	productoC :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)

tal que productoC c1 c2 es el producto cartesiano de los conjuntos c1 y c2. Por ejemplo,

   λ> ej1 = inserta 2 (inserta 5 vacio)
   λ> ej2 = inserta 9 (inserta 4 (inserta 3 vacio))
   λ> productoC ej1 ej2
   {(2,3), (2,4), (2,9), (5,3), (5,4), (5,9)}

λ> ej1 = inserta 2 (inserta 5 vacio)

λ> ej2 = inserta 9 (inserta 4 (inserta 3 vacio))

λ> productoC ej1 ej2

{(2,3), (2,4), (2,9), (5,3), (5,4), (5,9)}

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)
import TAD_Union_de_dos_conjuntos (union)
import Test.QuickCheck

-- 1ª solución
-- ===========

productoC :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)
productoC c1 c2
  | esVacio c1 = vacio
  | otherwise  = agrega mc1 c2 `union` productoC rc1 c2
  where mc1 = menor c1
        rc1 = elimina mc1 c1

-- (agrega x c) es el conjunto de los pares de x con los elementos de
-- c. Por ejemplo,
--    λ> agrega 2 (inserta 9 (inserta 4 (inserta 3 vacio)))
--    {(2,3), (2,4), (2,9)}
agrega :: (Ord a, Ord b) => a -> Conj b -> Conj (a,b)
agrega x c
  | esVacio c = vacio
  | otherwise = inserta (x, mc) (agrega x rc)
  where mc = menor c
        rc = elimina mc c

-- La función union está definida en el ejercicio
-- "Unión de dos conjuntos" que se encuentra en
-- https://bit.ly/3Y1jBl8

-- 2ª solución
-- ===========

productoC2 :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)
productoC2 c1 c2 =
  foldr inserta vacio [(x,y) | x <- xs, y <- ys]
  where xs = conjuntoAlista c1
        ys = conjuntoAlista c2

-- 3ª solución
-- ===========

productoC3 :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)
productoC3 c1 c2 =
  listaAconjunto [(x,y) | x <- xs, y <- ys]
  where xs = conjuntoAlista c1
        ys = conjuntoAlista c2

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_productoC :: Conj Int -> Conj Int -> Bool
prop_productoC c1 c2 =
  all (== productoC c1 c2)
      [productoC2 c1 c2,
       productoC3 c1 c2]

-- La comprobación es
--    λ> quickCheck prop_productoC
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)

import TAD_Union_de_dos_conjuntos (union)

import Test.QuickCheck

-- 1ª solución

-- ===========

productoC :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)

productoC c1 c2

| esVacio c1 = vacio

| otherwise = agrega mc1 c2 `union` productoC rc1 c2

where mc1 = menor c1

rc1 = elimina mc1 c1

-- (agrega x c) es el conjunto de los pares de x con los elementos de

-- c. Por ejemplo,

-- λ> agrega 2 (inserta 9 (inserta 4 (inserta 3 vacio)))

-- {(2,3), (2,4), (2,9)}

agrega :: (Ord a, Ord b) => a -> Conj b -> Conj (a,b)

agrega x c

| esVacio c = vacio

| otherwise = inserta (x, mc) (agrega x rc)

where mc = menor c

rc = elimina mc c

-- La función union está definida en el ejercicio

-- "Unión de dos conjuntos" que se encuentra en

-- https://bit.ly/3Y1jBl8

-- 2ª solución

-- ===========

productoC2 :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)

productoC2 c1 c2 =

foldr inserta vacio [(x,y) | x <- xs, y <- ys]

where xs = conjuntoAlista c1

ys = conjuntoAlista c2

-- 3ª solución

-- ===========

productoC3 :: (Ord a, Ord b) => Conj a -> Conj b -> Conj (a,b)

productoC3 c1 c2 =

listaAconjunto [(x,y) | x <- xs, y <- ys]

where xs = conjuntoAlista c1

ys = conjuntoAlista c2

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_productoC :: Conj Int -> Conj Int -> Bool

prop_productoC c1 c2 =

all (== productoC c1 c2)

[productoC2 c1 c2,

productoC3 c1 c2]

-- La comprobación es

-- λ> quickCheck prop_productoC

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from functools import reduce
from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, vacio)
from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,
                                                       listaAconjunto)
from src.TAD_Union_de_dos_conjuntos import union


class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)
B = TypeVar('B', bound=Comparable)

# 1ª solución
# ===========

# (agrega x c) es el conjunto de los pares de x con los elementos de
# c. Por ejemplo,
#    >>> agrega(2, inserta(9, inserta(4, inserta(3, vacio()))))
#    {(2, 3), (2, 4), (2, 9)}
def agrega(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:
    if esVacio(c):
        return vacio()
    mc = menor(c)
    rc = elimina(mc, c)
    return inserta((x, mc), agrega(x, rc))

def productoC(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:
    if esVacio(c1):
        return vacio()
    mc1 = menor(c1)
    rc1 = elimina(mc1, c1)
    return union(agrega(mc1, c2), productoC(rc1, c2))

# La función union está definida en el ejercicio
# "Unión de dos conjuntos" que se encuentra en
# https://bit.ly/3Y1jBl8

# 2ª solución
# ===========

def productoC2(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:
    xs = conjuntoAlista(c1)
    ys = conjuntoAlista(c2)
    return reduce(lambda bs, a: inserta(a, bs), [(x,y) for x in xs for y in ys], vacio())

# 3ª solución
# ===========

def productoC3(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:
    xs = conjuntoAlista(c1)
    ys = conjuntoAlista(c2)
    return listaAconjunto([(x,y) for x in xs for y in ys])

# 4ª solución
# ===========

def agrega4Aux(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:
    r: Conj[tuple[A, B]] = vacio()
    while not esVacio(c):
        mc = menor(c)
        c = elimina(mc, c)
        r = inserta((x, mc), r)
    return r

def agrega4(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:
    _c = deepcopy(c)
    return agrega4Aux(x, _c)

def productoC4(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:
    r: Conj[tuple[A, B]] = vacio()
    while not esVacio(c1):
        mc1 = menor(c1)
        c1 = elimina(mc1, c1)
        r = union(agrega4(mc1, c2), r)
    return r

# 5ª solución
# ===========

def agrega5Aux(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:
    r: Conj[tuple[A, B]] = Conj()
    while not c.esVacio():
        mc = c.menor()
        c.elimina(mc)
        r.inserta((x, mc))
    return r

def agrega5(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:
    _c = deepcopy(c)
    return agrega5Aux(x, _c)

def productoC5(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:
    r: Conj[tuple[A, B]] = Conj()
    while not c1.esVacio():
        mc1 = c1.menor()
        c1.elimina(mc1)
        r = union(agrega5(mc1, c2), r)
    return r

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())
def test_productoC(c1: Conj[int], c2: Conj[int]) -> None:
    r = productoC(c1, c2)
    assert productoC2(c1, c2) == r
    assert productoC3(c1, c2) == r
    assert productoC4(c1, c2) == r

# La comprobación de las propiedades es
#    > poetry run pytest -q TAD_Producto_cartesiano.py
#    1 passed in 0.35s

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from functools import reduce

from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, vacio)

from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,

listaAconjunto)

from src.TAD_Union_de_dos_conjuntos import union

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

B = TypeVar('B', bound=Comparable)

# 1ª solución

# ===========

# (agrega x c) es el conjunto de los pares de x con los elementos de

# c. Por ejemplo,

# >>> agrega(2, inserta(9, inserta(4, inserta(3, vacio()))))

# {(2, 3), (2, 4), (2, 9)}

def agrega(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:

if esVacio(c):

return vacio()

mc = menor(c)

rc = elimina(mc, c)

return inserta((x, mc), agrega(x, rc))

def productoC(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:

if esVacio(c1):

return vacio()

mc1 = menor(c1)

rc1 = elimina(mc1, c1)

return union(agrega(mc1, c2), productoC(rc1, c2))

# La función union está definida en el ejercicio

# "Unión de dos conjuntos" que se encuentra en

# https://bit.ly/3Y1jBl8

# 2ª solución

# ===========

def productoC2(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:

xs = conjuntoAlista(c1)

ys = conjuntoAlista(c2)

return reduce(lambda bs, a: inserta(a, bs), [(x,y) for x in xs for y in ys], vacio())

# 3ª solución

# ===========

def productoC3(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:

xs = conjuntoAlista(c1)

ys = conjuntoAlista(c2)

return listaAconjunto([(x,y) for x in xs for y in ys])

# 4ª solución

# ===========

def agrega4Aux(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:

r: Conj[tuple[A, B]] = vacio()

while not esVacio(c):

mc = menor(c)

c = elimina(mc, c)

r = inserta((x, mc), r)

return r

def agrega4(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:

_c = deepcopy(c)

return agrega4Aux(x, _c)

def productoC4(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:

r: Conj[tuple[A, B]] = vacio()

while not esVacio(c1):

mc1 = menor(c1)

c1 = elimina(mc1, c1)

r = union(agrega4(mc1, c2), r)

return r

# 5ª solución

# ===========

def agrega5Aux(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:

r: Conj[tuple[A, B]] = Conj()

while not c.esVacio():

mc = c.menor()

c.elimina(mc)

r.inserta((x, mc))

return r

def agrega5(x: A, c: Conj[B]) -> Conj[tuple[A, B]]:

_c = deepcopy(c)

return agrega5Aux(x, _c)

def productoC5(c1: Conj[A], c2: Conj[B]) -> Conj[tuple[A, B]]:

r: Conj[tuple[A, B]] = Conj()

while not c1.esVacio():

mc1 = c1.menor()

c1.elimina(mc1)

r = union(agrega5(mc1, c2), r)

return r

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())

def test_productoC(c1: Conj[int], c2: Conj[int]) -> None:

r = productoC(c1, c2)

assert productoC2(c1, c2) == r

assert productoC3(c1, c2) == r

assert productoC4(c1, c2) == r

# La comprobación de las propiedades es

# > poetry run pytest -q TAD_Producto_cartesiano.py

# 1 passed in 0.35s

TAD de los conjuntos: Algunos elementos verifican una propiedad

PorJosé A. Alonso 24-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   algunos :: Ord a => (a -> Bool) -> Conj a -> Bool

1	algunos :: Ord a => (a -> Bool) -> Conj a -> Bool

tal que algunos p c se verifica si algún elemento de c verifica el predicado p. Por ejemplo,

   algunos even (inserta 4 (inserta 7 vacio))  ==  True
   algunos even (inserta 3 (inserta 7 vacio))  ==  False

1 2	algunos even (inserta 4 (inserta 7 vacio)) == True algunos even (inserta 3 (inserta 7 vacio)) == False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)
import Test.QuickCheck.HigherOrder

-- 1ª solución
-- ===========

algunos :: Ord a => (a -> Bool) -> Conj a -> Bool
algunos p c
  | esVacio c = False
  | otherwise = p mc || algunos p rc
  where mc = menor c
        rc = elimina mc c

-- 2ª solución
-- ===========

algunos2 :: Ord a => (a -> Bool) -> Conj a -> Bool
algunos2 p c = any p (conjuntoAlista c)

-- La función conjuntoAlista está definida en el ejercicio
-- "Transformaciones entre conjuntos y listas" que se encuentra
-- en https://bit.ly/3RexzxH

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_algunos :: (Int -> Bool) -> [Int] -> Bool
prop_algunos p xs =
  algunos p c == algunos2 p c
  where c = listaAconjunto xs

-- La comprobación es
--    λ> quickCheck' prop_algunos
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)

import Test.QuickCheck.HigherOrder

-- 1ª solución

-- ===========

algunos :: Ord a => (a -> Bool) -> Conj a -> Bool

algunos p c

| esVacio c = False

| otherwise = p mc || algunos p rc

where mc = menor c

rc = elimina mc c

-- 2ª solución

-- ===========

algunos2 :: Ord a => (a -> Bool) -> Conj a -> Bool

algunos2 p c = any p (conjuntoAlista c)

-- La función conjuntoAlista está definida en el ejercicio

-- "Transformaciones entre conjuntos y listas" que se encuentra

-- en https://bit.ly/3RexzxH

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_algunos :: (Int -> Bool) -> [Int] -> Bool

prop_algunos p xs =

algunos p c == algunos2 p c

where c = listaAconjunto xs

-- La comprobación es

-- λ> quickCheck' prop_algunos

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Callable, Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, vacio)
from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def algunos(p: Callable[[A], bool], c: Conj[A]) -> bool:
    if esVacio(c):
        return False
    mc = menor(c)
    rc = elimina(mc, c)
    return p(mc) or algunos(p, rc)

# 2ª solución
# ===========

def algunos2(p: Callable[[A], bool], c: Conj[A]) -> bool:
    return any(p(x) for x in conjuntoAlista(c))

# La función conjuntoAlista está definida en el ejercicio
# "Transformaciones entre conjuntos y listas" que se encuentra
# en https://bit.ly/3RexzxH

# 3ª solución
# ===========

def algunos3Aux(p: Callable[[A], bool], c: Conj[A]) -> bool:
    while not esVacio(c):
        mc = menor(c)
        c = elimina(mc, c)
        if p(mc):
            return True
    return False

def algunos3(p: Callable[[A], bool], c: Conj[A]) -> bool:
    _c = deepcopy(c)
    return algunos3Aux(p, _c)

# 4ª solución
# ===========

def algunos4Aux(p: Callable[[A], bool], c: Conj[A]) -> bool:
    while not c.esVacio():
        mc = c.menor()
        c.elimina(mc)
        if p(mc):
            return True
    return False

def algunos4(p: Callable[[A], bool], c: Conj[A]) -> bool:
    _c = deepcopy(c)
    return algunos4Aux(p, _c)

# Comprobación de equivalencia de las definiciones
# ================================================

# La propiedad es
@given(c=conjuntoAleatorio())
def test_algunos(c: Conj[int]) -> None:
    r = algunos(lambda x: x % 2 == 0, c)
    assert algunos2(lambda x: x % 2 == 0, c) == r
    assert algunos3(lambda x: x % 2 == 0, c) == r
    assert algunos4(lambda x: x % 2 == 0, c) == r

# La comprobación es
#    src> poetry run pytest -q TAD_AlgunosVerificanConj.py
#    1 passed in 0.28s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Callable, Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, vacio)

from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def algunos(p: Callable[[A], bool], c: Conj[A]) -> bool:

if esVacio(c):

return False

mc = menor(c)

rc = elimina(mc, c)

return p(mc) or algunos(p, rc)

# 2ª solución

# ===========

def algunos2(p: Callable[[A], bool], c: Conj[A]) -> bool:

return any(p(x) for x in conjuntoAlista(c))

# La función conjuntoAlista está definida en el ejercicio

# "Transformaciones entre conjuntos y listas" que se encuentra

# en https://bit.ly/3RexzxH

# 3ª solución

# ===========

def algunos3Aux(p: Callable[[A], bool], c: Conj[A]) -> bool:

while not esVacio(c):

mc = menor(c)

c = elimina(mc, c)

if p(mc):

return True

return False

def algunos3(p: Callable[[A], bool], c: Conj[A]) -> bool:

_c = deepcopy(c)

return algunos3Aux(p, _c)

# 4ª solución

# ===========

def algunos4Aux(p: Callable[[A], bool], c: Conj[A]) -> bool:

while not c.esVacio():

mc = c.menor()

c.elimina(mc)

if p(mc):

return True

return False

def algunos4(p: Callable[[A], bool], c: Conj[A]) -> bool:

_c = deepcopy(c)

return algunos4Aux(p, _c)

# Comprobación de equivalencia de las definiciones

# ================================================

# La propiedad es

@given(c=conjuntoAleatorio())

def test_algunos(c: Conj[int]) -> None:

r = algunos(lambda x: x % 2 == 0, c)

assert algunos2(lambda x: x % 2 == 0, c) == r

assert algunos3(lambda x: x % 2 == 0, c) == r

assert algunos4(lambda x: x % 2 == 0, c) == r

# La comprobación es

# src> poetry run pytest -q TAD_AlgunosVerificanConj.py

# 1 passed in 0.28s

TAD de los conjuntos: Todos los elementos verifican una propiedad

PorJosé A. Alonso 23-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   todos :: Ord a => (a -> Bool) -> Conj a -> Bool

1	todos :: Ord a => (a -> Bool) -> Conj a -> Bool

tal que todos p c se verifica si todos los elemsntos de c verifican el predicado p. Por ejemplo,

   todos even (inserta 4 (inserta 6 vacio))  ==  True
   todos even (inserta 4 (inserta 7 vacio))  ==  False

1 2	todos even (inserta 4 (inserta 6 vacio)) == True todos even (inserta 4 (inserta 7 vacio)) == False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)
import Test.QuickCheck.HigherOrder

-- 1ª solución
-- ===========

todos :: Ord a => (a -> Bool) -> Conj a -> Bool
todos p c
  | esVacio c = True
  | otherwise = p mc && todos p rc
  where mc = menor c
        rc = elimina mc c

-- 2ª solución
-- ===========

todos2 :: Ord a => (a -> Bool) -> Conj a -> Bool
todos2 p c = all p (conjuntoAlista c)

-- La función conjuntoAlista está definida en el ejercicio
-- "Transformaciones entre conjuntos y listas" que se encuentra
-- en https://bit.ly/3RexzxH

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_todos :: (Int -> Bool) -> [Int] -> Bool
prop_todos p xs =
  todos p c == todos2 p c
  where c = listaAconjunto xs

-- La comprobación es
--    λ> quickCheck' prop_todos
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)

import Test.QuickCheck.HigherOrder

-- 1ª solución

-- ===========

todos :: Ord a => (a -> Bool) -> Conj a -> Bool

todos p c

| esVacio c = True

| otherwise = p mc && todos p rc

where mc = menor c

rc = elimina mc c

-- 2ª solución

-- ===========

todos2 :: Ord a => (a -> Bool) -> Conj a -> Bool

todos2 p c = all p (conjuntoAlista c)

-- La función conjuntoAlista está definida en el ejercicio

-- "Transformaciones entre conjuntos y listas" que se encuentra

-- en https://bit.ly/3RexzxH

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_todos :: (Int -> Bool) -> [Int] -> Bool

prop_todos p xs =

todos p c == todos2 p c

where c = listaAconjunto xs

-- La comprobación es

-- λ> quickCheck' prop_todos

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Callable, Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, vacio)
from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def todos(p: Callable[[A], bool], c: Conj[A]) -> bool:
    if esVacio(c):
        return True
    mc = menor(c)
    rc = elimina(mc, c)
    return p(mc) and todos(p, rc)

# 2ª solución
# ===========

def todos2(p: Callable[[A], bool], c: Conj[A]) -> bool:
    return all(p(x) for x in conjuntoAlista(c))

# La función conjuntoAlista está definida en el ejercicio
# "Transformaciones entre conjuntos y listas" que se encuentra
# en https://bit.ly/3RexzxH

# 3ª solución
# ===========

def todos3Aux(p: Callable[[A], bool], c: Conj[A]) -> bool:
    while not esVacio(c):
        mc = menor(c)
        c = elimina(mc, c)
        if not p(mc):
            return False
    return True

def todos3(p: Callable[[A], bool], c: Conj[A]) -> bool:
    _c = deepcopy(c)
    return todos3Aux(p, _c)

# 4ª solución
# ===========

def todos4Aux(p: Callable[[A], bool], c: Conj[A]) -> bool:
    while not c.esVacio():
        mc = c.menor()
        c.elimina(mc)
        if not p(mc):
            return False
    return True

def todos4(p: Callable[[A], bool], c: Conj[A]) -> bool:
    _c = deepcopy(c)
    return todos4Aux(p, _c)

# Comprobación de equivalencia de las definiciones
# ================================================

# La propiedad es
@given(c=conjuntoAleatorio())
def test_todos(c: Conj[int]) -> None:
    r = todos(lambda x: x % 2 == 0, c)
    assert todos2(lambda x: x % 2 == 0, c) == r
    assert todos3(lambda x: x % 2 == 0, c) == r
    assert todos4(lambda x: x % 2 == 0, c) == r

# La comprobación es
#    src> poetry run pytest -q TAD_TodosVerificanConj.py
#    1 passed in 0.28s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Callable, Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, vacio)

from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def todos(p: Callable[[A], bool], c: Conj[A]) -> bool:

if esVacio(c):

return True

mc = menor(c)

rc = elimina(mc, c)

return p(mc) and todos(p, rc)

# 2ª solución

# ===========

def todos2(p: Callable[[A], bool], c: Conj[A]) -> bool:

return all(p(x) for x in conjuntoAlista(c))

# La función conjuntoAlista está definida en el ejercicio

# "Transformaciones entre conjuntos y listas" que se encuentra

# en https://bit.ly/3RexzxH

# 3ª solución

# ===========

def todos3Aux(p: Callable[[A], bool], c: Conj[A]) -> bool:

while not esVacio(c):

mc = menor(c)

c = elimina(mc, c)

if not p(mc):

return False

return True

def todos3(p: Callable[[A], bool], c: Conj[A]) -> bool:

_c = deepcopy(c)

return todos3Aux(p, _c)

# 4ª solución

# ===========

def todos4Aux(p: Callable[[A], bool], c: Conj[A]) -> bool:

while not c.esVacio():

mc = c.menor()

c.elimina(mc)

if not p(mc):

return False

return True

def todos4(p: Callable[[A], bool], c: Conj[A]) -> bool:

_c = deepcopy(c)

return todos4Aux(p, _c)

# Comprobación de equivalencia de las definiciones

# ================================================

# La propiedad es

@given(c=conjuntoAleatorio())

def test_todos(c: Conj[int]) -> None:

r = todos(lambda x: x % 2 == 0, c)

assert todos2(lambda x: x % 2 == 0, c) == r

assert todos3(lambda x: x % 2 == 0, c) == r

assert todos4(lambda x: x % 2 == 0, c) == r

# La comprobación es

# src> poetry run pytest -q TAD_TodosVerificanConj.py

# 1 passed in 0.28s

TAD de los conjuntos: Aplicación de una función a los elementos de un conjunto

PorJosé A. Alonso 22-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   mapC :: (Ord a, Ord b) => (a -> b) -> Conj a -> Conj b

1	mapC :: (Ord a, Ord b) => (a -> b) -> Conj a -> Conj b

tal que map f c es el conjunto formado por las imágenes de los elementos del conjunto c, mediante la aplicación f. Por ejemplo,

   λ> mapC (*2) (inserta 3 (inserta 1 vacio))
   {2, 6}

1 2	λ> mapC (*2) (inserta 3 (inserta 1 vacio)) {2, 6}

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)
import Test.QuickCheck.HigherOrder

-- 1ª solución
-- ===========

mapC :: (Ord a, Ord b) => (a -> b) -> Conj a -> Conj b
mapC f c
  | esVacio c = vacio
  | otherwise = inserta (f mc) (mapC f rc)
  where mc = menor c
        rc = elimina mc c

-- 2ª solución
-- ===========

mapC2 :: (Ord a, Ord b) => (a -> b) -> Conj a -> Conj b
mapC2 f c = listaAconjunto (map f (conjuntoAlista c))

-- Las funciones conjuntoAlista y listaAconjunto está definida en el
-- ejercicio Transformaciones entre conjuntos y listas" que se encuentra
-- en https://bit.ly/3RexzxH

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_mapC :: (Int -> Int) -> [Int] -> Bool
prop_mapC f xs =
  mapC f c == mapC2 f c
  where c = listaAconjunto xs

-- La comprobación es
--    λ> quickCheck' prop_mapC
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)

import Test.QuickCheck.HigherOrder

-- 1ª solución

-- ===========

mapC :: (Ord a, Ord b) => (a -> b) -> Conj a -> Conj b

mapC f c

| esVacio c = vacio

| otherwise = inserta (f mc) (mapC f rc)

where mc = menor c

rc = elimina mc c

-- 2ª solución

-- ===========

mapC2 :: (Ord a, Ord b) => (a -> b) -> Conj a -> Conj b

mapC2 f c = listaAconjunto (map f (conjuntoAlista c))

-- Las funciones conjuntoAlista y listaAconjunto está definida en el

-- ejercicio Transformaciones entre conjuntos y listas" que se encuentra

-- en https://bit.ly/3RexzxH

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_mapC :: (Int -> Int) -> [Int] -> Bool

prop_mapC f xs =

mapC f c == mapC2 f c

where c = listaAconjunto xs

-- La comprobación es

-- λ> quickCheck' prop_mapC

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Callable, Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, vacio)
from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,
                                                       listaAconjunto)

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)
B = TypeVar('B', bound=Comparable)

# 1ª solución
# ===========

def mapC(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:
    if esVacio(c):
        return vacio()
    mc = menor(c)
    rc = elimina(mc, c)
    return inserta(f(mc), mapC(f, rc))

# 2ª solución
# ===========

def mapC2(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:
    return listaAconjunto(list(map(f, conjuntoAlista(c))))

# Las funciones conjuntoAlista y listaAconjunto está definida en el
# ejercicio Transformaciones entre conjuntos y listas" que se encuentra
# en https://bit.ly/3RexzxH

# 3ª solución
# ===========

def mapC3Aux(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:
    r: Conj[B] = vacio()
    while not esVacio(c):
        mc = menor(c)
        c = elimina(mc, c)
        r = inserta(f(mc), r)
    return r

def mapC3(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:
    _c = deepcopy(c)
    return mapC3Aux(f, _c)

# 4ª solución
# ===========

def mapC4Aux(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:
    r: Conj[B] = Conj()
    while not c.esVacio():
        mc = c.menor()
        c.elimina(mc)
        r.inserta(f(mc))
    return r

def mapC4(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:
    _c = deepcopy(c)
    return mapC4Aux(f, _c)

# Comprobación de equivalencia de las definiciones
# ================================================

# La propiedad es
@given(c=conjuntoAleatorio())
def test_mapPila(c: Conj[int]) -> None:
    r = mapC(lambda x: 2 * x, c)
    assert mapC2(lambda x: 2 * x, c) == r
    assert mapC3(lambda x: 2 * x, c) == r
    assert mapC4(lambda x: 2 * x, c) == r

# La comprobación es
#    src> poetry run pytest -q TAD_mapC.py
#    1 passed in 0.29s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Callable, Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, vacio)

from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,

listaAconjunto)

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

B = TypeVar('B', bound=Comparable)

# 1ª solución

# ===========

def mapC(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:

if esVacio(c):

return vacio()

mc = menor(c)

rc = elimina(mc, c)

return inserta(f(mc), mapC(f, rc))

# 2ª solución

# ===========

def mapC2(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:

return listaAconjunto(list(map(f, conjuntoAlista(c))))

# Las funciones conjuntoAlista y listaAconjunto está definida en el

# ejercicio Transformaciones entre conjuntos y listas" que se encuentra

# en https://bit.ly/3RexzxH

# 3ª solución

# ===========

def mapC3Aux(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:

r: Conj[B] = vacio()

while not esVacio(c):

mc = menor(c)

c = elimina(mc, c)

r = inserta(f(mc), r)

return r

def mapC3(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:

_c = deepcopy(c)

return mapC3Aux(f, _c)

# 4ª solución

# ===========

def mapC4Aux(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:

r: Conj[B] = Conj()

while not c.esVacio():

mc = c.menor()

c.elimina(mc)

r.inserta(f(mc))

return r

def mapC4(f: Callable[[A], B], c: Conj[A]) -> Conj[B]:

_c = deepcopy(c)

return mapC4Aux(f, _c)

# Comprobación de equivalencia de las definiciones

# ================================================

# La propiedad es

@given(c=conjuntoAleatorio())

def test_mapPila(c: Conj[int]) -> None:

r = mapC(lambda x: 2 * x, c)

assert mapC2(lambda x: 2 * x, c) == r

assert mapC3(lambda x: 2 * x, c) == r

assert mapC4(lambda x: 2 * x, c) == r

# La comprobación es

# src> poetry run pytest -q TAD_mapC.py

# 1 passed in 0.29s

TAD de los conjuntos: Partición según un número

PorJosé A. Alonso 21-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   divide :: (Ord a) => a-> Conj a -> (Conj a, Conj a)

1	divide :: (Ord a) => a-> Conj a -> (Conj a, Conj a)

tal que divide x c es el par formado por dos subconjuntos de c: el de los elementos menores o iguales que x y el de los mayores que x. Por ejemplo,

   λ> divide 5 (inserta 7 (inserta 2 (inserta 8 vacio)))
   ({2},{7, 8})

1 2	λ> divide 5 (inserta 7 (inserta 2 (inserta 8 vacio))) ({2},{7, 8})

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)
import TAD_Particion_por_una_propiedad (particion)
import Test.QuickCheck

-- 1ª solución
-- ===========

divide :: Ord a => a-> Conj a -> (Conj a, Conj a)
divide x c
  | esVacio c = (vacio, vacio)
  | mc <= x   = (inserta mc c1, c2)
  | otherwise = (c1, inserta mc c2)
  where
    mc       = menor c
    rc       = elimina mc c
    (c1, c2) = divide x rc

-- 2ª solución
-- ===========

divide2 :: Ord a => a-> Conj a -> (Conj a, Conj a)
divide2 x = particion (<= x)

-- La función particion está definida en el ejercicio
-- "Partición de un conjunto según una propiedad" que se encuentra en
-- https://bit.ly/3YCOah5

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_divide :: Int -> Conj Int -> Bool
prop_divide x c =
  divide x c == divide2 x c

-- La comprobación es
--    λ> quickCheck prop_divide
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)

import TAD_Particion_por_una_propiedad (particion)

import Test.QuickCheck

-- 1ª solución

-- ===========

divide :: Ord a => a-> Conj a -> (Conj a, Conj a)

divide x c

| esVacio c = (vacio, vacio)

| mc <= x = (inserta mc c1, c2)

| otherwise = (c1, inserta mc c2)

where

mc = menor c

rc = elimina mc c

(c1, c2) = divide x rc

-- 2ª solución

-- ===========

divide2 :: Ord a => a-> Conj a -> (Conj a, Conj a)

divide2 x = particion (<= x)

-- La función particion está definida en el ejercicio

-- "Partición de un conjunto según una propiedad" que se encuentra en

-- https://bit.ly/3YCOah5

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_divide :: Int -> Conj Int -> Bool

prop_divide x c =

divide x c == divide2 x c

-- La comprobación es

-- λ> quickCheck prop_divide

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Protocol, TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, vacio)
from src.TAD_Particion_por_una_propiedad import particion

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def divide(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:
    if esVacio(c):
        return (vacio(), vacio())
    mc = menor(c)
    rc = elimina(mc, c)
    (c1, c2) = divide(x, rc)
    if mc <= x:
        return (inserta(mc, c1), c2)
    return (c1, inserta(mc, c2))

# 2ª solución
# ===========

def divide2(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:
    return particion(lambda y: y <= x, c)

# La función particion está definida en el ejercicio
# "Partición de un conjunto según una propiedad" que se encuentra en
# https://bit.ly/3YCOah5

# 3ª solución
# ===========

def divide3Aux(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:
    r: Conj[A] = vacio()
    s: Conj[A] = vacio()
    while not esVacio(c):
        mc = menor(c)
        c = elimina(mc, c)
        if mc <= x:
            r = inserta(mc, r)
        else:
            s = inserta(mc, s)
    return (r, s)

def divide3(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:
    _c = deepcopy(c)
    return divide3Aux(x, _c)

# 4ª solución
# ===========

def divide4Aux(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:
    r: Conj[A] = Conj()
    s: Conj[A] = Conj()
    while not c.esVacio():
        mc = c.menor()
        c.elimina(mc)
        if mc <= x:
            r.inserta(mc)
        else:
            s.inserta(mc)
    return (r, s)

def divide4(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:
    _c = deepcopy(c)
    return divide4Aux(x, _c)

# Comprobación de equivalencia de las definiciones
# ================================================

# La propiedad es
@given(x=st.integers(), c=conjuntoAleatorio())
def test_particion(x: int, c: Conj[int]) -> None:
    r = divide(x, c)
    assert divide2(x, c) == r
    assert divide3(x, c) == r
    assert divide4(x, c) == r

# La comprobación es
#    src> poetry run pytest -q TAD_Particion_segun_un_numero.py
#    1 passed in 0.30s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Protocol, TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, vacio)

from src.TAD_Particion_por_una_propiedad import particion

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def divide(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:

if esVacio(c):

return (vacio(), vacio())

mc = menor(c)

rc = elimina(mc, c)

(c1, c2) = divide(x, rc)

if mc <= x:

return (inserta(mc, c1), c2)

return (c1, inserta(mc, c2))

# 2ª solución

# ===========

def divide2(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:

return particion(lambda y: y <= x, c)

# La función particion está definida en el ejercicio

# "Partición de un conjunto según una propiedad" que se encuentra en

# https://bit.ly/3YCOah5

# 3ª solución

# ===========

def divide3Aux(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:

r: Conj[A] = vacio()

s: Conj[A] = vacio()

while not esVacio(c):

mc = menor(c)

c = elimina(mc, c)

if mc <= x:

r = inserta(mc, r)

else:

s = inserta(mc, s)

return (r, s)

def divide3(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:

_c = deepcopy(c)

return divide3Aux(x, _c)

# 4ª solución

# ===========

def divide4Aux(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:

r: Conj[A] = Conj()

s: Conj[A] = Conj()

while not c.esVacio():

mc = c.menor()

c.elimina(mc)

if mc <= x:

r.inserta(mc)

else:

s.inserta(mc)

return (r, s)

def divide4(x: A, c: Conj[A]) -> tuple[Conj[A], Conj[A]]:

_c = deepcopy(c)

return divide4Aux(x, _c)

# Comprobación de equivalencia de las definiciones

# ================================================

# La propiedad es

@given(x=st.integers(), c=conjuntoAleatorio())

def test_particion(x: int, c: Conj[int]) -> None:

r = divide(x, c)

assert divide2(x, c) == r

assert divide3(x, c) == r

assert divide4(x, c) == r

# La comprobación es

# src> poetry run pytest -q TAD_Particion_segun_un_numero.py

# 1 passed in 0.30s

TAD de los conjuntos: Partición de un conjunto según una propiedad

PorJosé A. Alonso 20-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   particion :: Ord a => (a -> Bool) -> Conj a -> (Conj a, Conj a)

1	particion :: Ord a => (a -> Bool) -> Conj a -> (Conj a, Conj a)

tal que particion c es el par formado por dos conjuntos: el de los elementos de c que verifican p y el de los elementos que no lo verifican. Por ejemplo,

   λ> ej = inserta 5 (inserta 4 (inserta 7 (inserta 2 vacio)))
   λ> particion even ej
   ({2, 4},{5, 7})

λ> ej = inserta 5 (inserta 4 (inserta 7 (inserta 2 vacio)))

λ> particion even ej

({2, 4},{5, 7})

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)
import TAD_Subconjunto_por_propiedad (filtra)
import Data.List (partition)
import Test.QuickCheck.HigherOrder

-- 1ª solución
-- ===========

particion :: Ord a => (a -> Bool) -> Conj a -> (Conj a, Conj a)
particion p c = (filtra p c, filtra (not . p) c)

-- La función filtra está definida en el ejercicio
-- "Subconjunto determinado por una propiedad" que se encuentra en
-- https://bit.ly/3lplFoV

-- 2ª solución
-- ===========

particion2 :: Ord a => (a -> Bool) -> Conj a -> (Conj a, Conj a)
particion2 p c = (listaAconjunto xs, listaAconjunto ys)
  where
    (xs, ys) = partition p (conjuntoAlista c)

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_particion :: (Int -> Bool) -> [Int] -> Bool
prop_particion p xs =
  particion p c == particion2 p c
  where c = listaAconjunto xs

-- La comprobación es
--    λ> quickCheck' prop_particion
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)

import TAD_Subconjunto_por_propiedad (filtra)

import Data.List (partition)

import Test.QuickCheck.HigherOrder

-- 1ª solución

-- ===========

particion :: Ord a => (a -> Bool) -> Conj a -> (Conj a, Conj a)

particion p c = (filtra p c, filtra (not . p) c)

-- La función filtra está definida en el ejercicio

-- "Subconjunto determinado por una propiedad" que se encuentra en

-- https://bit.ly/3lplFoV

-- 2ª solución

-- ===========

particion2 :: Ord a => (a -> Bool) -> Conj a -> (Conj a, Conj a)

particion2 p c = (listaAconjunto xs, listaAconjunto ys)

where

(xs, ys) = partition p (conjuntoAlista c)

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_particion :: (Int -> Bool) -> [Int] -> Bool

prop_particion p xs =

particion p c == particion2 p c

where c = listaAconjunto xs

-- La comprobación es

-- λ> quickCheck' prop_particion

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Callable, Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, vacio)
from src.TAD_Subconjunto_por_propiedad import filtra

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def particion(p: Callable[[A], bool],
              c: Conj[A]) -> tuple[Conj[A], Conj[A]]:
    return (filtra(p, c), filtra(lambda x: not p(x), c))

# La función filtra está definida en el ejercicio
# "Subconjunto determinado por una propiedad" que se encuentra en
# https://bit.ly/3lplFoV

# 2ª solución
# ===========

def particion2Aux(p: Callable[[A], bool],
                  c: Conj[A]) -> tuple[Conj[A], Conj[A]]:
    r: Conj[A] = vacio()
    s: Conj[A] = vacio()
    while not esVacio(c):
        mc = menor(c)
        c = elimina(mc, c)
        if p(mc):
            r = inserta(mc, r)
        else:
            s = inserta(mc, s)
    return (r, s)

def particion2(p: Callable[[A], bool],
               c: Conj[A]) -> tuple[Conj[A], Conj[A]]:
    _c = deepcopy(c)
    return particion2Aux(p, _c)

# 3ª solución
# ===========

def particion3Aux(p: Callable[[A], bool],
                  c: Conj[A]) -> tuple[Conj[A], Conj[A]]:
    r: Conj[A] = Conj()
    s: Conj[A] = Conj()
    while not c.esVacio():
        mc = c.menor()
        c.elimina(mc)
        if p(mc):
            r.inserta(mc)
        else:
            s.inserta(mc)
    return (r, s)

def particion3(p: Callable[[A], bool],
               c: Conj[A]) -> tuple[Conj[A], Conj[A]]:
    _c = deepcopy(c)
    return particion3Aux(p, _c)

# Comprobación de equivalencia de las definiciones
# ================================================

# La propiedad es
@given(c=conjuntoAleatorio())
def test_particion(c: Conj[int]) -> None:
    r = particion(lambda x: x % 2 == 0, c)
    assert particion2(lambda x: x % 2 == 0, c) == r
    assert particion3(lambda x: x % 2 == 0, c) == r

# La comprobación es
#    src> poetry run pytest -q TAD_Particion_por_una_propiedad.py
#    1 passed in 0.28s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Callable, Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, vacio)

from src.TAD_Subconjunto_por_propiedad import filtra

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def particion(p: Callable[[A], bool],

c: Conj[A]) -> tuple[Conj[A], Conj[A]]:

return (filtra(p, c), filtra(lambda x: not p(x), c))

# La función filtra está definida en el ejercicio

# "Subconjunto determinado por una propiedad" que se encuentra en

# https://bit.ly/3lplFoV

# 2ª solución

# ===========

def particion2Aux(p: Callable[[A], bool],

c: Conj[A]) -> tuple[Conj[A], Conj[A]]:

r: Conj[A] = vacio()

s: Conj[A] = vacio()

while not esVacio(c):

mc = menor(c)

c = elimina(mc, c)

if p(mc):

r = inserta(mc, r)

else:

s = inserta(mc, s)

return (r, s)

def particion2(p: Callable[[A], bool],

c: Conj[A]) -> tuple[Conj[A], Conj[A]]:

_c = deepcopy(c)

return particion2Aux(p, _c)

# 3ª solución

# ===========

def particion3Aux(p: Callable[[A], bool],

c: Conj[A]) -> tuple[Conj[A], Conj[A]]:

r: Conj[A] = Conj()

s: Conj[A] = Conj()

while not c.esVacio():

mc = c.menor()

c.elimina(mc)

if p(mc):

r.inserta(mc)

else:

s.inserta(mc)

return (r, s)

def particion3(p: Callable[[A], bool],

c: Conj[A]) -> tuple[Conj[A], Conj[A]]:

_c = deepcopy(c)

return particion3Aux(p, _c)

# Comprobación de equivalencia de las definiciones

# ================================================

# La propiedad es

@given(c=conjuntoAleatorio())

def test_particion(c: Conj[int]) -> None:

r = particion(lambda x: x % 2 == 0, c)

assert particion2(lambda x: x % 2 == 0, c) == r

assert particion3(lambda x: x % 2 == 0, c) == r

# La comprobación es

# src> poetry run pytest -q TAD_Particion_por_una_propiedad.py

# 1 passed in 0.28s

TAD de los conjuntos: Subconjunto determinado por una propiedad

PorJosé A. Alonso 17-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   filtra :: Ord a => (a -> Bool) -> Conj a -> Conj a

1	filtra :: Ord a => (a -> Bool) -> Conj a -> Conj a

tal filtra p c es el conjunto de elementos de c que verifican el predicado p. Por ejemplo,

   λ> filtra even (inserta 5 (inserta 4 (inserta 7 (inserta 2 vacio))))
   {2, 4}
   λ> filtra odd (inserta 5 (inserta 4 (inserta 7 (inserta 2 vacio))))
   {5, 7}

λ> filtra even (inserta 5 (inserta 4 (inserta 7 (inserta 2 vacio))))

{2, 4}

λ> filtra odd (inserta 5 (inserta 4 (inserta 7 (inserta 2 vacio))))

{5, 7}

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)
import Test.QuickCheck.HigherOrder

-- 1ª solución
-- ===========

filtra :: Ord a => (a -> Bool) -> Conj a -> Conj a
filtra p c
  | esVacio c = vacio
  | p mc      = inserta mc (filtra p rc)
  | otherwise = filtra p rc
  where mc = menor c
        rc = elimina mc c

-- 2ª solución
-- ===========

filtra2 :: Ord a => (a -> Bool) -> Conj a -> Conj a
filtra2 p c =
  listaAconjunto (filter p (conjuntoAlista c))

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_filtra :: (Int -> Bool) -> [Int] -> Bool
prop_filtra p xs =
  filtra p c == filtra2 p c
  where c = listaAconjunto xs

-- La comprobación es
--    λ> quickCheck' prop_filtra
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)

import Test.QuickCheck.HigherOrder

-- 1ª solución

-- ===========

filtra :: Ord a => (a -> Bool) -> Conj a -> Conj a

filtra p c

| esVacio c = vacio

| p mc = inserta mc (filtra p rc)

| otherwise = filtra p rc

where mc = menor c

rc = elimina mc c

-- 2ª solución

-- ===========

filtra2 :: Ord a => (a -> Bool) -> Conj a -> Conj a

filtra2 p c =

listaAconjunto (filter p (conjuntoAlista c))

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_filtra :: (Int -> Bool) -> [Int] -> Bool

prop_filtra p xs =

filtra p c == filtra2 p c

where c = listaAconjunto xs

-- La comprobación es

-- λ> quickCheck' prop_filtra

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Callable, Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, pertenece, vacio)
from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,
                                                       listaAconjunto)

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def filtra(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:
    if esVacio(c):
        return vacio()
    mc = menor(c)
    rc = elimina(mc, c)
    if p(mc):
        return inserta(mc, filtra(p, rc))
    return filtra(p, rc)

# 2ª solución
# ===========

def filtra2(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:
    return listaAconjunto(list(filter(p, conjuntoAlista(c))))

# 3ª solución
# ===========

def filtra3Aux(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:
    r: Conj[A] = vacio()
    while not esVacio(c):
        mc = menor(c)
        c = elimina(mc, c)
        if p(mc):
            r = inserta(mc, r)
    return r

def filtra3(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:
    _c = deepcopy(c)
    return filtra3Aux(p, _c)

# 4ª solución
# ===========

def filtra4Aux(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:
    r: Conj[A] = Conj()
    while not c.esVacio():
        mc = c.menor()
        c.elimina(mc)
        if p(mc):
            r.inserta(mc)
    return r

def filtra4(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:
    _c = deepcopy(c)
    return filtra4Aux(p, _c)

# Comprobación de equivalencia de las definiciones
# ================================================

# La propiedad es
@given(c=conjuntoAleatorio())
def test_filtra(c: Conj[int]) -> None:
    r = filtra(lambda x: x % 2 == 0, c)
    assert filtra2(lambda x: x % 2 == 0, c) == r
    assert filtra3(lambda x: x % 2 == 0, c) == r
    assert filtra4(lambda x: x % 2 == 0, c) == r

# La comprobación es
#    src> poetry run pytest -q TAD_Subconjunto_por_propiedad.py
#    1 passed in 0.28s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Callable, Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, pertenece, vacio)

from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,

listaAconjunto)

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def filtra(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:

if esVacio(c):

return vacio()

mc = menor(c)

rc = elimina(mc, c)

if p(mc):

return inserta(mc, filtra(p, rc))

return filtra(p, rc)

# 2ª solución

# ===========

def filtra2(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:

return listaAconjunto(list(filter(p, conjuntoAlista(c))))

# 3ª solución

# ===========

def filtra3Aux(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:

r: Conj[A] = vacio()

while not esVacio(c):

mc = menor(c)

c = elimina(mc, c)

if p(mc):

r = inserta(mc, r)

return r

def filtra3(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:

_c = deepcopy(c)

return filtra3Aux(p, _c)

# 4ª solución

# ===========

def filtra4Aux(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:

r: Conj[A] = Conj()

while not c.esVacio():

mc = c.menor()

c.elimina(mc)

if p(mc):

r.inserta(mc)

return r

def filtra4(p: Callable[[A], bool], c: Conj[A]) -> Conj[A]:

_c = deepcopy(c)

return filtra4Aux(p, _c)

# Comprobación de equivalencia de las definiciones

# ================================================

# La propiedad es

@given(c=conjuntoAleatorio())

def test_filtra(c: Conj[int]) -> None:

r = filtra(lambda x: x % 2 == 0, c)

assert filtra2(lambda x: x % 2 == 0, c) == r

assert filtra3(lambda x: x % 2 == 0, c) == r

assert filtra4(lambda x: x % 2 == 0, c) == r

# La comprobación es

# src> poetry run pytest -q TAD_Subconjunto_por_propiedad.py

# 1 passed in 0.28s

TAD de los conjuntos: Diferencia simétrica

PorJosé A. Alonso 16-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   diferenciaSimetrica :: Ord a => Conj a -> Conj a -> Conj a

1	diferenciaSimetrica :: Ord a => Conj a -> Conj a -> Conj a

tal que diferenciaSimetrica c1 c2 es la diferencia simétrica de los conjuntos c1 y c2. Por ejemplo,

   λ> ej1 = inserta 5 (inserta 3 (inserta 2 (inserta 7 vacio)))
   λ> ej2 = inserta 7 (inserta 4 (inserta 3 vacio))
   λ> diferenciaSimetrica ej1 ej2
   {2, 4, 5}

λ> ej1 = inserta 5 (inserta 3 (inserta 2 (inserta 7 vacio)))

λ> ej2 = inserta 7 (inserta 4 (inserta 3 vacio))

λ> diferenciaSimetrica ej1 ej2

{2, 4, 5}

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta)
import TAD_Diferencia_de_conjuntos (diferencia)
import TAD_Interseccion_de_dos_conjuntos (interseccion)
import TAD_Union_de_dos_conjuntos (union)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)

import Test.QuickCheck

-- 1ª solución
-- ===========

diferenciaSimetrica :: Ord a => Conj a -> Conj a -> Conj a
diferenciaSimetrica c1 c2 =
  diferencia (union c1 c2) (interseccion c1 c2)

-- 2ª solución
-- ===========

diferenciaSimetrica2 :: Ord a => Conj a -> Conj a -> Conj a
diferenciaSimetrica2 c1 c2 =
  listaAconjunto ([x | x <- xs, x `notElem` ys] ++
                  [y | y <- ys, y `notElem` xs])
  where xs = conjuntoAlista c1
        ys = conjuntoAlista c2

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_diferenciaSimetrica :: Conj Int -> Conj Int -> Bool
prop_diferenciaSimetrica c1 c2 =
  diferenciaSimetrica c1 c2 == diferenciaSimetrica2 c2 c1

-- La comprobación es
--    λ> quickCheck prop_diferenciaSimetrica
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta)

import TAD_Diferencia_de_conjuntos (diferencia)

import TAD_Interseccion_de_dos_conjuntos (interseccion)

import TAD_Union_de_dos_conjuntos (union)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)

import Test.QuickCheck

-- 1ª solución

-- ===========

diferenciaSimetrica :: Ord a => Conj a -> Conj a -> Conj a

diferenciaSimetrica c1 c2 =

diferencia (union c1 c2) (interseccion c1 c2)

-- 2ª solución

-- ===========

diferenciaSimetrica2 :: Ord a => Conj a -> Conj a -> Conj a

diferenciaSimetrica2 c1 c2 =

listaAconjunto ([x | x <- xs, x `notElem` ys] ++

[y | y <- ys, y `notElem` xs])

where xs = conjuntoAlista c1

ys = conjuntoAlista c2

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_diferenciaSimetrica :: Conj Int -> Conj Int -> Bool

prop_diferenciaSimetrica c1 c2 =

diferenciaSimetrica c1 c2 == diferenciaSimetrica2 c2 c1

-- La comprobación es

-- λ> quickCheck prop_diferenciaSimetrica

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, pertenece, vacio)
from src.TAD_Diferencia_de_conjuntos import diferencia
from src.TAD_Interseccion_de_dos_conjuntos import interseccion
from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,
                                                       listaAconjunto)
from src.TAD_Union_de_dos_conjuntos import union

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def diferenciaSimetrica(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    return diferencia(union(c1, c2), interseccion(c1, c2))

# 2ª solución
# ===========

def diferenciaSimetrica2(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    xs = conjuntoAlista(c1)
    ys = conjuntoAlista(c2)
    return listaAconjunto([x for x in xs if x not in ys] +
                          [y for y in ys if y not in xs])

# 3ª solución
# ===========

def diferenciaSimetrica3(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    r: Conj[A] = vacio()
    _c1 = deepcopy(c1)
    _c2 = deepcopy(c2)
    while not esVacio(_c1):
        mc1 = menor(_c1)
        if not pertenece(mc1, c2):
            r = inserta(mc1, r)
        _c1 = elimina(mc1, _c1)
    while not esVacio(_c2):
        mc2 = menor(_c2)
        if not pertenece(mc2, c1):
            r = inserta(mc2, r)
        _c2 = elimina(mc2, _c2)
    return r

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())
def test_diferenciaSimetrica(c1: Conj[int], c2: Conj[int]) -> None:
    r = diferenciaSimetrica(c1, c2)
    assert diferenciaSimetrica2(c1, c2) == r
    assert diferenciaSimetrica3(c1, c2) == r

# La comprobación de las propiedades es
#    > poetry run pytest -q TAD_Diferencia_simetrica.py
#    1 passed in 0.30s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, pertenece, vacio)

from src.TAD_Diferencia_de_conjuntos import diferencia

from src.TAD_Interseccion_de_dos_conjuntos import interseccion

from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,

listaAconjunto)

from src.TAD_Union_de_dos_conjuntos import union

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def diferenciaSimetrica(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

return diferencia(union(c1, c2), interseccion(c1, c2))

# 2ª solución

# ===========

def diferenciaSimetrica2(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

xs = conjuntoAlista(c1)

ys = conjuntoAlista(c2)

return listaAconjunto([x for x in xs if x not in ys] +

[y for y in ys if y not in xs])

# 3ª solución

# ===========

def diferenciaSimetrica3(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

r: Conj[A] = vacio()

_c1 = deepcopy(c1)

_c2 = deepcopy(c2)

while not esVacio(_c1):

mc1 = menor(_c1)

if not pertenece(mc1, c2):

r = inserta(mc1, r)

_c1 = elimina(mc1, _c1)

while not esVacio(_c2):

mc2 = menor(_c2)

if not pertenece(mc2, c1):

r = inserta(mc2, r)

_c2 = elimina(mc2, _c2)

return r

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())

def test_diferenciaSimetrica(c1: Conj[int], c2: Conj[int]) -> None:

r = diferenciaSimetrica(c1, c2)

assert diferenciaSimetrica2(c1, c2) == r

assert diferenciaSimetrica3(c1, c2) == r

# La comprobación de las propiedades es

# > poetry run pytest -q TAD_Diferencia_simetrica.py

# 1 passed in 0.30s

TAD de los conjuntos: Diferencia de conjuntos

PorJosé A. Alonso 15-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   diferencia :: Ord a => Conj a -> Conj a -> Conj a

1	diferencia :: Ord a => Conj a -> Conj a -> Conj a

tal que diferencia c1 c2 es el conjunto de los elementos de c1 que no son elementos de c2. Por ejemplo,

   λ> ej1 = inserta 5 (inserta 3 (inserta 2 (inserta 7 vacio)))
   λ> ej2 = inserta 7 (inserta 4 (inserta 3 vacio))
   λ> diferencia ej1 ej2
   {2, 5}
   λ> diferencia ej2 ej1
   {4}
   λ> diferencia ej1 ej1
   {}

λ> ej1 = inserta 5 (inserta 3 (inserta 2 (inserta 7 vacio)))

λ> ej2 = inserta 7 (inserta 4 (inserta 3 vacio))

λ> diferencia ej1 ej2

{2, 5}

λ> diferencia ej2 ej1

{4}

λ> diferencia ej1 ej1

{}

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, menor, elimina, pertenece, esVacio)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)
import Test.QuickCheck

-- 1ª solución
-- ===========

diferencia :: Ord a => Conj a -> Conj a -> Conj a
diferencia c1 c2
  | esVacio c1       = vacio
  | pertenece mc1 c2 = diferencia rc1 c2
  | otherwise        = inserta mc1 (diferencia rc1 c2)
  where mc1 = menor c1
        rc1 = elimina mc1 c1

-- 2ª solución
-- ===========

diferencia2 :: Ord a => Conj a -> Conj a -> Conj a
diferencia2 c1 c2 =
  listaAconjunto [x | x <- conjuntoAlista c1, not (pertenece x c2)]

-- Las funciones conjuntoAlista y listaAconjunto está definida en el
-- ejercicio Transformaciones entre conjuntos y listas" que se encuentra
-- en https://bit.ly/3RexzxH

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_diferencia :: Conj Int -> Conj Int -> Bool
prop_diferencia c1 c2 =
  diferencia c1 c2 == diferencia2 c1 c2

-- La comprobación es
--    λ> quickCheck prop_diferencia
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, menor, elimina, pertenece, esVacio)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)

import Test.QuickCheck

-- 1ª solución

-- ===========

diferencia :: Ord a => Conj a -> Conj a -> Conj a

diferencia c1 c2

| esVacio c1 = vacio

| pertenece mc1 c2 = diferencia rc1 c2

| otherwise = inserta mc1 (diferencia rc1 c2)

where mc1 = menor c1

rc1 = elimina mc1 c1

-- 2ª solución

-- ===========

diferencia2 :: Ord a => Conj a -> Conj a -> Conj a

diferencia2 c1 c2 =

listaAconjunto [x | x <- conjuntoAlista c1, not (pertenece x c2)]

-- Las funciones conjuntoAlista y listaAconjunto está definida en el

-- ejercicio Transformaciones entre conjuntos y listas" que se encuentra

-- en https://bit.ly/3RexzxH

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_diferencia :: Conj Int -> Conj Int -> Bool

prop_diferencia c1 c2 =

diferencia c1 c2 == diferencia2 c1 c2

-- La comprobación es

-- λ> quickCheck prop_diferencia

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, pertenece, vacio)
from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,
                                                       listaAconjunto)

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def diferencia(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    if esVacio(c1):
        return vacio()
    mc1 = menor(c1)
    rc1 = elimina(mc1, c1)
    if pertenece(mc1, c2):
        return diferencia(rc1, c2)
    return inserta(mc1, diferencia(rc1, c2))

# 2ª solución
# ===========

def diferencia2(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    return listaAconjunto([x for x in conjuntoAlista(c1)
                           if not pertenece(x, c2)])

# Las funciones conjuntoAlista y listaAconjunto está definida en el
# ejercicio Transformaciones entre conjuntos y listas" que se encuentra
# en https://bit.ly/3RexzxH

# 3ª solución
# ===========

def diferencia3Aux(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    r: Conj[A] = vacio()
    while not esVacio(c1):
        mc1 = menor(c1)
        if not pertenece(mc1, c2):
            r = inserta(mc1, r)
        c1 = elimina(mc1, c1)
    return r

def diferencia3(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    _c1 = deepcopy(c1)
    return diferencia3Aux(_c1, c2)

# 4ª solución
# ===========

def diferencia4Aux(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    r: Conj[A] = Conj()
    while not c1.esVacio():
        mc1 = c1.menor()
        if not c2.pertenece(mc1):
            r.inserta(mc1)
        c1.elimina(mc1)
    return r

def diferencia4(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    _c1 = deepcopy(c1)
    return diferencia4Aux(_c1, c2)

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())
def test_diferencia(c1: Conj[int], c2: Conj[int]) -> None:
    r = diferencia(c1, c2)
    assert diferencia2(c1, c2) == r
    assert diferencia3(c1, c2) == r
    assert diferencia4(c1, c2) == r

# La comprobación de las propiedades es
#    > poetry run pytest -q TAD_Diferencia_de_conjuntos.py
#    1 passed in 0.31s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, pertenece, vacio)

from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,

listaAconjunto)

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def diferencia(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

if esVacio(c1):

return vacio()

mc1 = menor(c1)

rc1 = elimina(mc1, c1)

if pertenece(mc1, c2):

return diferencia(rc1, c2)

return inserta(mc1, diferencia(rc1, c2))

# 2ª solución

# ===========

def diferencia2(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

return listaAconjunto([x for x in conjuntoAlista(c1)

if not pertenece(x, c2)])

# Las funciones conjuntoAlista y listaAconjunto está definida en el

# ejercicio Transformaciones entre conjuntos y listas" que se encuentra

# en https://bit.ly/3RexzxH

# 3ª solución

# ===========

def diferencia3Aux(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

r: Conj[A] = vacio()

while not esVacio(c1):

mc1 = menor(c1)

if not pertenece(mc1, c2):

r = inserta(mc1, r)

c1 = elimina(mc1, c1)

return r

def diferencia3(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

_c1 = deepcopy(c1)

return diferencia3Aux(_c1, c2)

# 4ª solución

# ===========

def diferencia4Aux(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

r: Conj[A] = Conj()

while not c1.esVacio():

mc1 = c1.menor()

if not c2.pertenece(mc1):

r.inserta(mc1)

c1.elimina(mc1)

return r

def diferencia4(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

_c1 = deepcopy(c1)

return diferencia4Aux(_c1, c2)

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())

def test_diferencia(c1: Conj[int], c2: Conj[int]) -> None:

r = diferencia(c1, c2)

assert diferencia2(c1, c2) == r

assert diferencia3(c1, c2) == r

assert diferencia4(c1, c2) == r

# La comprobación de las propiedades es

# > poetry run pytest -q TAD_Diferencia_de_conjuntos.py

# 1 passed in 0.31s

TAD de los conjuntos: Conjuntos disjuntos

PorJosé A. Alonso 14-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   disjuntos :: Ord a => Conj a -> Conj a -> Bool

1	disjuntos :: Ord a => Conj a -> Conj a -> Bool

tal que disjuntos c1 c2 se verifica si los conjuntos c1 y c2 son disjuntos. Por ejemplo,

   λ> ej1 = inserta 2 (inserta 5 vacio)
   λ> ej2 = inserta 4 (inserta 3 vacio)
   λ> ej3 = inserta 5 (inserta 3 vacio)
   λ> disjuntos ej1 ej2
   True
   λ> disjuntos ej1 ej3
   False

λ> ej1 = inserta 2 (inserta 5 vacio)

λ> ej2 = inserta 4 (inserta 3 vacio)

λ> ej3 = inserta 5 (inserta 3 vacio)

λ> disjuntos ej1 ej2

True

λ> disjuntos ej1 ej3

False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina, pertenece)
import TAD_Interseccion_de_dos_conjuntos (interseccion)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista)
import Test.QuickCheck

-- 1ª solución
-- ===========

disjuntos :: Ord a => Conj a -> Conj a -> Bool
disjuntos c1 c2 = esVacio (interseccion c1 c2)

-- La función interseccion está definida en el ejercicio
-- "Intersección de dos conjuntos" que se encuentra en
-- https://bit.ly/3jDL9xZ

-- 2ª solución
-- ===========

disjuntos2 :: Ord a => Conj a -> Conj a -> Bool
disjuntos2 c1 c2
  | esVacio c1 = True
  | pertenece mc1 c2 = False
  | otherwise        = disjuntos2 rc1 c2
  where mc1 = menor c1
        rc1 = elimina mc1 c1

-- 3ª solución
-- ===========

disjuntos3 :: Ord a => Conj a -> Conj a -> Bool
disjuntos3 c1 c2 =
  all (`notElem` ys) xs
  where xs = conjuntoAlista c1
        ys = conjuntoAlista c2

-- La función conjuntoAlista está definida en el ejercicio
-- "Transformaciones entre conjuntos y listas" que se encuentra en
-- https://bit.ly/3RexzxH

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_disjuntos :: Conj Int -> Conj Int -> Bool
prop_disjuntos c1 c2 =
  all (== disjuntos c1 c2)
      [disjuntos2 c1 c2,
       disjuntos3 c1 c2]

-- La comprobación es
--    λ> quickCheck prop_disjuntos
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, esVacio, menor, elimina, pertenece)

import TAD_Interseccion_de_dos_conjuntos (interseccion)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista)

import Test.QuickCheck

-- 1ª solución

-- ===========

disjuntos :: Ord a => Conj a -> Conj a -> Bool

disjuntos c1 c2 = esVacio (interseccion c1 c2)

-- La función interseccion está definida en el ejercicio

-- "Intersección de dos conjuntos" que se encuentra en

-- https://bit.ly/3jDL9xZ

-- 2ª solución

-- ===========

disjuntos2 :: Ord a => Conj a -> Conj a -> Bool

disjuntos2 c1 c2

| esVacio c1 = True

| pertenece mc1 c2 = False

| otherwise = disjuntos2 rc1 c2

where mc1 = menor c1

rc1 = elimina mc1 c1

-- 3ª solución

-- ===========

disjuntos3 :: Ord a => Conj a -> Conj a -> Bool

disjuntos3 c1 c2 =

all (`notElem` ys) xs

where xs = conjuntoAlista c1

ys = conjuntoAlista c2

-- La función conjuntoAlista está definida en el ejercicio

-- "Transformaciones entre conjuntos y listas" que se encuentra en

-- https://bit.ly/3RexzxH

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_disjuntos :: Conj Int -> Conj Int -> Bool

prop_disjuntos c1 c2 =

all (== disjuntos c1 c2)

[disjuntos2 c1 c2,

disjuntos3 c1 c2]

-- La comprobación es

-- λ> quickCheck prop_disjuntos

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, pertenece, vacio)
from src.TAD_Interseccion_de_dos_conjuntos import interseccion
from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def disjuntos(c1: Conj[A], c2: Conj[A]) -> bool:
    return esVacio(interseccion(c1, c2))

# 2ª solución
# ===========

def disjuntos2(c1: Conj[A], c2: Conj[A]) -> bool:
    if esVacio(c1):
        return True
    mc1 = menor(c1)
    rc1 = elimina(mc1, c1)
    if pertenece(mc1, c2):
        return False
    return disjuntos2(rc1, c2)

# 3ª solución
# ===========

def disjuntos3(c1: Conj[A], c2: Conj[A]) -> bool:
    xs = conjuntoAlista(c1)
    ys = conjuntoAlista(c2)
    return all((x not in ys for x in xs))

# La función conjuntoAlista está definida en el ejercicio
# "Transformaciones entre conjuntos y listas" que se encuentra en
# https://bit.ly/3RexzxH

# 4ª solución
# ===========

def disjuntos4Aux(c1: Conj[A], c2: Conj[A]) -> bool:
    while not esVacio(c1):
        mc1 = menor(c1)
        if pertenece(mc1, c2):
            return False
        c1 = elimina(mc1, c1)
    return True

def disjuntos4(c1: Conj[A], c2: Conj[A]) -> bool:
    _c1 = deepcopy(c1)
    return disjuntos4Aux(_c1, c2)

# 5ª solución
# ===========

def disjuntos5Aux(c1: Conj[A], c2: Conj[A]) -> bool:
    while not c1.esVacio():
        mc1 = c1.menor()
        if c2.pertenece(mc1):
            return False
        c1.elimina(mc1)
    return True

def disjuntos5(c1: Conj[A], c2: Conj[A]) -> bool:
    _c1 = deepcopy(c1)
    return disjuntos5Aux(_c1, c2)

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())
def test_disjuntos(c1: Conj[int], c2: Conj[int]) -> None:
    r = disjuntos(c1, c2)
    assert disjuntos2(c1, c2) == r
    assert disjuntos3(c1, c2) == r
    assert disjuntos4(c1, c2) == r
    assert disjuntos5(c1, c2) == r

# La comprobación de las propiedades es
#    > poetry run pytest -q TAD_Conjuntos_disjuntos.py
#    1 passed in 0.34s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, pertenece, vacio)

from src.TAD_Interseccion_de_dos_conjuntos import interseccion

from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def disjuntos(c1: Conj[A], c2: Conj[A]) -> bool:

return esVacio(interseccion(c1, c2))

# 2ª solución

# ===========

def disjuntos2(c1: Conj[A], c2: Conj[A]) -> bool:

if esVacio(c1):

return True

mc1 = menor(c1)

rc1 = elimina(mc1, c1)

if pertenece(mc1, c2):

return False

return disjuntos2(rc1, c2)

# 3ª solución

# ===========

def disjuntos3(c1: Conj[A], c2: Conj[A]) -> bool:

xs = conjuntoAlista(c1)

ys = conjuntoAlista(c2)

return all((x not in ys for x in xs))

# La función conjuntoAlista está definida en el ejercicio

# "Transformaciones entre conjuntos y listas" que se encuentra en

# https://bit.ly/3RexzxH

# 4ª solución

# ===========

def disjuntos4Aux(c1: Conj[A], c2: Conj[A]) -> bool:

while not esVacio(c1):

mc1 = menor(c1)

if pertenece(mc1, c2):

return False

c1 = elimina(mc1, c1)

return True

def disjuntos4(c1: Conj[A], c2: Conj[A]) -> bool:

_c1 = deepcopy(c1)

return disjuntos4Aux(_c1, c2)

# 5ª solución

# ===========

def disjuntos5Aux(c1: Conj[A], c2: Conj[A]) -> bool:

while not c1.esVacio():

mc1 = c1.menor()

if c2.pertenece(mc1):

return False

c1.elimina(mc1)

return True

def disjuntos5(c1: Conj[A], c2: Conj[A]) -> bool:

_c1 = deepcopy(c1)

return disjuntos5Aux(_c1, c2)

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())

def test_disjuntos(c1: Conj[int], c2: Conj[int]) -> None:

r = disjuntos(c1, c2)

assert disjuntos2(c1, c2) == r

assert disjuntos3(c1, c2) == r

assert disjuntos4(c1, c2) == r

assert disjuntos5(c1, c2) == r

# La comprobación de las propiedades es

# > poetry run pytest -q TAD_Conjuntos_disjuntos.py

# 1 passed in 0.34s

TAD de los conjuntos: Intersección de varios conjuntos

PorJosé A. Alonso 13-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   interseccionG :: Ord a => [Conj a] -> Conj a

1	interseccionG :: Ord a => [Conj a] -> Conj a

tal que interseccionG cs es la intersección de la lista de conjuntos cs. Por ejemplo,

   λ> ej1 = inserta 2 (inserta 3 (inserta 5 vacio))
   λ> ej2 = inserta 5 (inserta 2 (inserta 7 vacio))
   λ> ej3 = inserta 3 (inserta 2 (inserta 5 vacio))
   λ> interseccionG [ej1, ej2, ej3]
   {2, 5}

λ> ej1 = inserta 2 (inserta 3 (inserta 5 vacio))

λ> ej2 = inserta 5 (inserta 2 (inserta 7 vacio))

λ> ej3 = inserta 3 (inserta 2 (inserta 5 vacio))

λ> interseccionG [ej1, ej2, ej3]

{2, 5}

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta)
import TAD_Interseccion_de_dos_conjuntos (interseccion)
import Test.QuickCheck

-- 1ª solución
-- ===========

interseccionG :: Ord a => [Conj a] -> Conj a
interseccionG [c]      = c
interseccionG (cs:css) = interseccion cs (interseccionG css)

-- 2ª solución
-- ===========

interseccionG2 :: Ord a => [Conj a] -> Conj a
interseccionG2 = foldr1 interseccion

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_interseccionG :: NonEmptyList (Conj Int) -> Bool
prop_interseccionG (NonEmpty cs) =
  interseccionG cs == interseccionG2 cs

-- La comprobación es
--    λ> quickCheck prop_interseccionG1
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta)

import TAD_Interseccion_de_dos_conjuntos (interseccion)

import Test.QuickCheck

-- 1ª solución

-- ===========

interseccionG :: Ord a => [Conj a] -> Conj a

interseccionG [c] = c

interseccionG (cs:css) = interseccion cs (interseccionG css)

-- 2ª solución

-- ===========

interseccionG2 :: Ord a => [Conj a] -> Conj a

interseccionG2 = foldr1 interseccion

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_interseccionG :: NonEmptyList (Conj Int) -> Bool

prop_interseccionG (NonEmpty cs) =

interseccionG cs == interseccionG2 cs

-- La comprobación es

-- λ> quickCheck prop_interseccionG1

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from functools import reduce
from typing import Protocol, TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.TAD.conjunto import Conj, conjuntoAleatorio, inserta, vacio
from src.TAD_Interseccion_de_dos_conjuntos import interseccion

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def interseccionG(cs: list[Conj[A]]) -> Conj[A]:
    if len(cs) == 1:
        return cs[0]
    return interseccion(cs[0], interseccionG(cs[1:]))

# 2ª solución
# ===========

def interseccionG2(cs: list[Conj[A]]) -> Conj[A]:
    return reduce(interseccion, cs[1:], cs[0])

# 3ª solución
# ===========

def interseccionG3(cs: list[Conj[A]]) -> Conj[A]:
    r = cs[0]
    for c in cs[1:]:
        r = interseccion(c, r)
    return r

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.lists(conjuntoAleatorio(), min_size=1, max_size=10))
def test_interseccionG(cs: list[Conj[int]]) -> None:
    r = interseccionG(cs)
    assert interseccionG2(cs) == r
    assert interseccionG3(cs) == r

# La comprobación de las propiedades es
#    > poetry run pytest -q TAD_Interseccion_de_varios_conjuntos.py
#    1 passed in 0.60s

from __future__ import annotations

from abc import abstractmethod

from functools import reduce

from typing import Protocol, TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.TAD.conjunto import Conj, conjuntoAleatorio, inserta, vacio

from src.TAD_Interseccion_de_dos_conjuntos import interseccion

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def interseccionG(cs: list[Conj[A]]) -> Conj[A]:

if len(cs) == 1:

return cs[0]

return interseccion(cs[0], interseccionG(cs[1:]))

# 2ª solución

# ===========

def interseccionG2(cs: list[Conj[A]]) -> Conj[A]:

return reduce(interseccion, cs[1:], cs[0])

# 3ª solución

# ===========

def interseccionG3(cs: list[Conj[A]]) -> Conj[A]:

r = cs[0]

for c in cs[1:]:

r = interseccion(c, r)

return r

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.lists(conjuntoAleatorio(), min_size=1, max_size=10))

def test_interseccionG(cs: list[Conj[int]]) -> None:

r = interseccionG(cs)

assert interseccionG2(cs) == r

assert interseccionG3(cs) == r

# La comprobación de las propiedades es

# > poetry run pytest -q TAD_Interseccion_de_varios_conjuntos.py

# 1 passed in 0.60s

TAD de los conjuntos: Intersección de dos conjuntos

PorJosé A. Alonso 10-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   interseccion :: Ord a => Conj a -> Conj a -> Conj a

1	interseccion :: Ord a => Conj a -> Conj a -> Conj a

tal que interseccion c1 c2 es la intersección de los conjuntos c1 y c2. Por ejemplo,

   λ> ej1 = inserta 3 (inserta 5 (inserta 2 vacio))
   λ> ej2 = inserta 2 (inserta 4 (inserta 3 vacio))
   λ> interseccion ej1 ej2
   {2, 3}

λ> ej1 = inserta 3 (inserta 5 (inserta 2 vacio))

λ> ej2 = inserta 2 (inserta 4 (inserta 3 vacio))

λ> interseccion ej1 ej2

{2, 3}

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, menor, elimina, pertenece, esVacio)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)
import Data.List (intersect)
import Test.QuickCheck

-- 1ª solución
-- ===========

interseccion :: Ord a => Conj a -> Conj a -> Conj a
interseccion c1 c2
  | esVacio c1       = vacio
  | pertenece mc1 c2 = inserta mc1 (interseccion rc1 c2)
  | otherwise        = interseccion rc1 c2
  where mc1 = menor c1
        rc1 = elimina mc1 c1

-- 2ª solución
-- ===========

interseccion2 :: Ord a => Conj a -> Conj a -> Conj a
interseccion2 c1 c2 =
  listaAconjunto [x | x <- conjuntoAlista c1, x `pertenece` c2]

-- Las funciones conjuntoAlista y listaAconjunto está definida en el
-- ejercicio Transformaciones entre conjuntos y listas" que se encuentra
-- en https://bit.ly/3RexzxH

-- 3ª solución
-- ===========

interseccion3 :: Ord a => Conj a -> Conj a -> Conj a
interseccion3 c1 c2 =
  listaAconjunto (conjuntoAlista c1 `intersect` conjuntoAlista c2)

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_interseccion :: Conj Int -> Conj Int -> Bool
prop_interseccion c1 c2 =
  all (== interseccion c1 c2)
      [interseccion2 c1 c2,
       interseccion3 c1 c2]

-- La comprobación es
--    λ> quickCheck prop_interseccion
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, menor, elimina, pertenece, esVacio)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)

import Data.List (intersect)

import Test.QuickCheck

-- 1ª solución

-- ===========

interseccion :: Ord a => Conj a -> Conj a -> Conj a

interseccion c1 c2

| esVacio c1 = vacio

| pertenece mc1 c2 = inserta mc1 (interseccion rc1 c2)

| otherwise = interseccion rc1 c2

where mc1 = menor c1

rc1 = elimina mc1 c1

-- 2ª solución

-- ===========

interseccion2 :: Ord a => Conj a -> Conj a -> Conj a

interseccion2 c1 c2 =

listaAconjunto [x | x <- conjuntoAlista c1, x `pertenece` c2]

-- Las funciones conjuntoAlista y listaAconjunto está definida en el

-- ejercicio Transformaciones entre conjuntos y listas" que se encuentra

-- en https://bit.ly/3RexzxH

-- 3ª solución

-- ===========

interseccion3 :: Ord a => Conj a -> Conj a -> Conj a

interseccion3 c1 c2 =

listaAconjunto (conjuntoAlista c1 `intersect` conjuntoAlista c2)

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_interseccion :: Conj Int -> Conj Int -> Bool

prop_interseccion c1 c2 =

all (== interseccion c1 c2)

[interseccion2 c1 c2,

interseccion3 c1 c2]

-- La comprobación es

-- λ> quickCheck prop_interseccion

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, pertenece, vacio)
from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,
                                                       listaAconjunto)

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def interseccion(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    if esVacio(c1):
        return vacio()
    mc1 = menor(c1)
    rc1 = elimina(mc1, c1)
    if pertenece(mc1, c2):
        return inserta(mc1, interseccion(rc1, c2))
    return interseccion(rc1, c2)

# 2ª solución
# ===========

def interseccion2(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    return listaAconjunto([x for x in conjuntoAlista(c1)
                           if pertenece(x, c2)])
#
# Las funciones conjuntoAlista y listaAconjunto está definida en el
# ejercicio Transformaciones entre conjuntos y listas" que se encuentra
# en https://bit.ly/3RexzxH

# 3ª solución
# ===========

def interseccion3(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    r: Conj[A] = vacio()
    while not esVacio(c1):
        mc1 = menor(c1)
        c1 = elimina(mc1, c1)
        if pertenece(mc1, c2):
            r = inserta(mc1, r)
    return r

# 4ª solución
# ===========

def interseccion4Aux(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    r: Conj[A] = vacio()
    while not c1.esVacio():
        mc1 = c1.menor()
        c1.elimina(mc1)
        if c2.pertenece(mc1):
            r.inserta(mc1)
    return r

def interseccion4(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    _c1 = deepcopy(c1)
    return interseccion4Aux(_c1, c2)

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())
def test_interseccion(c1: Conj[int], c2: Conj[int]) -> None:
    r = interseccion(c1, c2)
    assert interseccion2(c1, c2) == r
    assert interseccion3(c1, c2) == r
    assert interseccion4(c1, c2) == r

# La comprobación de las propiedades es
#    > poetry run pytest -q TAD_Interseccion_de_dos_conjuntos.py
#    1 passed in 0.30s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, pertenece, vacio)

from src.TAD_Transformaciones_conjuntos_listas import (conjuntoAlista,

listaAconjunto)

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def interseccion(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

if esVacio(c1):

return vacio()

mc1 = menor(c1)

rc1 = elimina(mc1, c1)

if pertenece(mc1, c2):

return inserta(mc1, interseccion(rc1, c2))

return interseccion(rc1, c2)

# 2ª solución

# ===========

def interseccion2(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

return listaAconjunto([x for x in conjuntoAlista(c1)

if pertenece(x, c2)])

# Las funciones conjuntoAlista y listaAconjunto está definida en el

# ejercicio Transformaciones entre conjuntos y listas" que se encuentra

# en https://bit.ly/3RexzxH

# 3ª solución

# ===========

def interseccion3(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

r: Conj[A] = vacio()

while not esVacio(c1):

mc1 = menor(c1)

c1 = elimina(mc1, c1)

if pertenece(mc1, c2):

r = inserta(mc1, r)

return r

# 4ª solución

# ===========

def interseccion4Aux(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

r: Conj[A] = vacio()

while not c1.esVacio():

mc1 = c1.menor()

c1.elimina(mc1)

if c2.pertenece(mc1):

r.inserta(mc1)

return r

def interseccion4(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

_c1 = deepcopy(c1)

return interseccion4Aux(_c1, c2)

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())

def test_interseccion(c1: Conj[int], c2: Conj[int]) -> None:

r = interseccion(c1, c2)

assert interseccion2(c1, c2) == r

assert interseccion3(c1, c2) == r

assert interseccion4(c1, c2) == r

# La comprobación de las propiedades es

# > poetry run pytest -q TAD_Interseccion_de_dos_conjuntos.py

# 1 passed in 0.30s

TAD de los conjuntos: Unión de varios conjuntos

PorJosé A. Alonso 9-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   unionG:: Ord a => [Conj a] -> Conj a

1	unionG:: Ord a => [Conj a] -> Conj a

tal unionG cs calcule la unión de la lista de conjuntos cs. Por ejemplo,

   λ> ej1 = inserta 3 (inserta 5 vacio)
   λ> ej2 = inserta 5 (inserta 6 vacio)
   λ> ej3 = inserta 3 (inserta 6 vacio)
   λ> unionG [ej1, ej2, ej3]
   {3, 5, 6}

λ> ej1 = inserta 3 (inserta 5 vacio)

λ> ej2 = inserta 5 (inserta 6 vacio)

λ> ej3 = inserta 3 (inserta 6 vacio)

λ> unionG [ej1, ej2, ej3]

{3, 5, 6}

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta)
import TAD_Union_de_dos_conjuntos (union)
import Test.QuickCheck

-- 1ª solución
-- ===========

unionG :: Ord a => [Conj a] -> Conj a
unionG []          = vacio
unionG (c:cs) = c `union` unionG cs

-- La función union está definida en el ejercicio
-- "Unión de dos conjuntos" que se encuentra en
-- https://bit.ly/3Y1jBl8

-- 2ª solución
-- ===========

unionG2 :: Ord a => [Conj a] -> Conj a
unionG2 = foldr union vacio

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_unionG :: [Conj Int] -> Bool
prop_unionG cs =
  unionG cs == unionG2 cs

-- La comprobación es
--    λ> quickCheck prop_unionG
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta)

import TAD_Union_de_dos_conjuntos (union)

import Test.QuickCheck

-- 1ª solución

-- ===========

unionG :: Ord a => [Conj a] -> Conj a

unionG [] = vacio

unionG (c:cs) = c `union` unionG cs

-- La función union está definida en el ejercicio

-- "Unión de dos conjuntos" que se encuentra en

-- https://bit.ly/3Y1jBl8

-- 2ª solución

-- ===========

unionG2 :: Ord a => [Conj a] -> Conj a

unionG2 = foldr union vacio

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_unionG :: [Conj Int] -> Bool

prop_unionG cs =

unionG cs == unionG2 cs

-- La comprobación es

-- λ> quickCheck prop_unionG

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from functools import reduce
from typing import Protocol, TypeVar

from hypothesis import given
from hypothesis import strategies as st

from src.TAD.conjunto import Conj, conjuntoAleatorio, inserta, vacio
from src.TAD_Union_de_dos_conjuntos import union

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def unionG(cs: list[Conj[A]]) -> Conj[A]:
    if not cs:
        return vacio()
    return union(cs[0], unionG(cs[1:]))

# La función union está definida en el ejercicio
# "Unión de dos conjuntos" que se encuentra en
# https://bit.ly/3Y1jBl8

# 2ª solución
# ===========

def unionG2(cs: list[Conj[A]]) -> Conj[A]:
    return reduce(union, cs, vacio())

# 3ª solución
# ===========

def unionG3(cs: list[Conj[A]]) -> Conj[A]:
    r: Conj[A] = vacio()
    for c in cs:
        r = union(c, r)
    return r

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(st.lists(conjuntoAleatorio(), max_size=10))
def test_union(cs: list[Conj[int]]) -> None:
    r = unionG(cs)
    assert unionG2(cs) == r
    assert unionG3(cs) == r

# La comprobación de las propiedades es
#    > poetry run pytest -q TAD_Union_de_varios_conjuntos.py
#    1 passed in 0.75s

from __future__ import annotations

from abc import abstractmethod

from functools import reduce

from typing import Protocol, TypeVar

from hypothesis import given

from hypothesis import strategies as st

from src.TAD.conjunto import Conj, conjuntoAleatorio, inserta, vacio

from src.TAD_Union_de_dos_conjuntos import union

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def unionG(cs: list[Conj[A]]) -> Conj[A]:

if not cs:

return vacio()

return union(cs[0], unionG(cs[1:]))

# La función union está definida en el ejercicio

# "Unión de dos conjuntos" que se encuentra en

# https://bit.ly/3Y1jBl8

# 2ª solución

# ===========

def unionG2(cs: list[Conj[A]]) -> Conj[A]:

return reduce(union, cs, vacio())

# 3ª solución

# ===========

def unionG3(cs: list[Conj[A]]) -> Conj[A]:

r: Conj[A] = vacio()

for c in cs:

r = union(c, r)

return r

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(st.lists(conjuntoAleatorio(), max_size=10))

def test_union(cs: list[Conj[int]]) -> None:

r = unionG(cs)

assert unionG2(cs) == r

assert unionG3(cs) == r

# La comprobación de las propiedades es

# > poetry run pytest -q TAD_Union_de_varios_conjuntos.py

# 1 passed in 0.75s

TAD de los conjuntos: Unión de dos conjuntos

PorJosé A. Alonso 8-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   union :: Ord a => Conj a -> Conj a -> Conj a

1	union :: Ord a => Conj a -> Conj a -> Conj a

tal union c1 c2 es la unión de ambos conjuntos. Por ejemplo,

   λ> ej1 = inserta 3 (inserta 5 vacio)
   λ> ej2 = inserta 4 (inserta 3 vacio)
   λ> union ej1 ej2
   {3, 4, 5}

λ> ej1 = inserta 3 (inserta 5 vacio)

λ> ej2 = inserta 4 (inserta 3 vacio)

λ> union ej1 ej2

{3, 4, 5}

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, menor, elimina, esVacio)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)
import qualified Data.List as L (union)
import Test.QuickCheck

-- 1ª solución
-- ===========

union :: Ord a => Conj a -> Conj a -> Conj a
union c1 c2
  | esVacio c1 = c2
  | otherwise  = inserta mc1 (rc1 `union` c2)
  where mc1 = menor c1
        rc1 = elimina mc1 c1

-- 2ª solución
-- ===========

union2 :: Ord a => Conj a -> Conj a -> Conj a
union2 c1 c2 =
  foldr inserta c2 (conjuntoAlista c1)

-- La función conjuntoAlista está definida en el ejercicio
-- "Transformaciones entre conjuntos y listas" que se encuentra en
-- https://bit.ly/3RexzxH

-- 3ª solución
-- ===========

union3 :: Ord a => Conj a -> Conj a -> Conj a
union3 c1 c2 =
  listaAconjunto (conjuntoAlista c1 `L.union` conjuntoAlista c2)

-- La función listaAconjunto está definida en el ejercicio
-- "Transformaciones entre conjuntos y listas" que se encuentra en
-- https://bit.ly/3RexzxH

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_union :: Conj Int -> Conj Int -> Bool
prop_union c1 c2 =
  all (== union c1 c2)
      [union2 c1 c2,
       union3 c1 c2]

-- La comprobación es
--    λ> quickCheck prop_union
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, menor, elimina, esVacio)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista, listaAconjunto)

import qualified Data.List as L (union)

import Test.QuickCheck

-- 1ª solución

-- ===========

union :: Ord a => Conj a -> Conj a -> Conj a

union c1 c2

| esVacio c1 = c2

| otherwise = inserta mc1 (rc1 `union` c2)

where mc1 = menor c1

rc1 = elimina mc1 c1

-- 2ª solución

-- ===========

union2 :: Ord a => Conj a -> Conj a -> Conj a

union2 c1 c2 =

foldr inserta c2 (conjuntoAlista c1)

-- La función conjuntoAlista está definida en el ejercicio

-- "Transformaciones entre conjuntos y listas" que se encuentra en

-- https://bit.ly/3RexzxH

-- 3ª solución

-- ===========

union3 :: Ord a => Conj a -> Conj a -> Conj a

union3 c1 c2 =

listaAconjunto (conjuntoAlista c1 `L.union` conjuntoAlista c2)

-- La función listaAconjunto está definida en el ejercicio

-- "Transformaciones entre conjuntos y listas" que se encuentra en

-- https://bit.ly/3RexzxH

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_union :: Conj Int -> Conj Int -> Bool

prop_union c1 c2 =

all (== union c1 c2)

[union2 c1 c2,

union3 c1 c2]

-- La comprobación es

-- λ> quickCheck prop_union

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from functools import reduce
from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, vacio)
from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def union(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    if esVacio(c1):
        return c2
    mc1 = menor(c1)
    rc1 = elimina(mc1, c1)
    return inserta(mc1, union(rc1, c2))

# 2ª solución
# ===========

def union2(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    return reduce(lambda c, x: inserta(x, c), conjuntoAlista(c1), c2)

# La función conjuntoAlista está definida en el ejercicio
# "Transformaciones entre conjuntos y listas" que se encuentra en
# https://bit.ly/3RexzxH

# 3ª solución
# ===========

def union3(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    r = c2
    while not esVacio(c1):
        mc1 = menor(c1)
        r = inserta(mc1, r)
        c1 = elimina(mc1, c1)
    return r

# 4ª solución
# ===========

def union4Aux(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    while not c1.esVacio():
        mc1 = menor(c1)
        c2.inserta(mc1)
        c1.elimina(mc1)
    return c2

def union4(c1: Conj[A], c2: Conj[A]) -> Conj[A]:
    _c1 = deepcopy(c1)
    _c2 = deepcopy(c2)
    return union4Aux(_c1, _c2)

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())
def test_union(c1: Conj[int], c2: Conj[int]) -> None:
    r = union(c1, c2)
    assert union2(c1, c2) == r
    assert union3(c1, c2) == r
    assert union4(c1, c2) == r

# La comprobación de las propiedades es
#    > poetry run pytest -q TAD_Union_de_dos_conjuntos.py
#    1 passed in 0.35s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from functools import reduce

from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, vacio)

from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def union(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

if esVacio(c1):

return c2

mc1 = menor(c1)

rc1 = elimina(mc1, c1)

return inserta(mc1, union(rc1, c2))

# 2ª solución

# ===========

def union2(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

return reduce(lambda c, x: inserta(x, c), conjuntoAlista(c1), c2)

# La función conjuntoAlista está definida en el ejercicio

# "Transformaciones entre conjuntos y listas" que se encuentra en

# https://bit.ly/3RexzxH

# 3ª solución

# ===========

def union3(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

r = c2

while not esVacio(c1):

mc1 = menor(c1)

r = inserta(mc1, r)

c1 = elimina(mc1, c1)

return r

# 4ª solución

# ===========

def union4Aux(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

while not c1.esVacio():

mc1 = menor(c1)

c2.inserta(mc1)

c1.elimina(mc1)

return c2

def union4(c1: Conj[A], c2: Conj[A]) -> Conj[A]:

_c1 = deepcopy(c1)

_c2 = deepcopy(c2)

return union4Aux(_c1, _c2)

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())

def test_union(c1: Conj[int], c2: Conj[int]) -> None:

r = union(c1, c2)

assert union2(c1, c2) == r

assert union3(c1, c2) == r

assert union4(c1, c2) == r

# La comprobación de las propiedades es

# > poetry run pytest -q TAD_Union_de_dos_conjuntos.py

# 1 passed in 0.35s

TAD de los conjuntos: Número de elementos de un conjunto

PorJosé A. Alonso 7-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   cardinal :: Conj a -> Int

1	cardinal :: Conj a -> Int

tal que cardinal c es el número de elementos del conjunto c. Por ejemplo,

   cardinal (inserta 4 (inserta 5 vacio))             == 2
   cardinal (inserta 4 (inserta 5 (inserta 4 vacio))) == 2

1 2	cardinal (inserta 4 (inserta 5 vacio)) == 2 cardinal (inserta 4 (inserta 5 (inserta 4 vacio))) == 2

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, menor, elimina, esVacio)
import TAD_Transformaciones_conjuntos_listas (conjuntoAlista)
import Test.QuickCheck

-- 1ª solución
-- ===========

cardinal :: Ord a => Conj a -> Int
cardinal c
  | esVacio c = 0
  | otherwise = 1 + cardinal (elimina (menor c) c)

-- 2ª solución
-- ===========

cardinal2 :: Ord a => Conj a -> Int
cardinal2 = length . conjuntoAlista

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_cardinal :: Conj Int -> Bool
prop_cardinal c =
  cardinal c == cardinal2 c

-- La comprobación es
--    λ> quickCheck prop_cardinal
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, menor, elimina, esVacio)

import TAD_Transformaciones_conjuntos_listas (conjuntoAlista)

import Test.QuickCheck

-- 1ª solución

-- ===========

cardinal :: Ord a => Conj a -> Int

cardinal c

| esVacio c = 0

| otherwise = 1 + cardinal (elimina (menor c) c)

-- 2ª solución

-- ===========

cardinal2 :: Ord a => Conj a -> Int

cardinal2 = length . conjuntoAlista

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_cardinal :: Conj Int -> Bool

prop_cardinal c =

cardinal c == cardinal2 c

-- La comprobación es

-- λ> quickCheck prop_cardinal

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, vacio)
from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def cardinal(c: Conj[A]) -> int:
    if esVacio(c):
        return 0
    return 1 + cardinal(elimina(menor(c), c))

# 2ª solución
# ===========

def cardinal2(c: Conj[A]) -> int:
    return len(conjuntoAlista(c))

# 3ª solución
# ===========

def cardinal3(c: Conj[A]) -> int:
    r = 0
    while not esVacio(c):
        r = r + 1
        c = elimina(menor(c), c)
    return r

# 4ª solución
# ===========

def cardinal4Aux(c: Conj[A]) -> int:
    r = 0
    while not c.esVacio():
        r = r + 1
        c.elimina(menor(c))
    return r

def cardinal4(c: Conj[A]) -> int:
    _c = deepcopy(c)
    return cardinal4Aux(_c)

# Comprobación de equivalencia
# ============================

@given(c=conjuntoAleatorio())
def test_cardinal(c: Conj[int]) -> None:
    r = cardinal(c)
    assert cardinal2(c) == r
    assert cardinal3(c) == r
    assert cardinal3(c) == r

# La comprobación es
#    src> poetry run pytest -q TAD_Numero_de_elementos_de_un_conjunto.py
#    1 passed in 0.33s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, vacio)

from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def cardinal(c: Conj[A]) -> int:

if esVacio(c):

return 0

return 1 + cardinal(elimina(menor(c), c))

# 2ª solución

# ===========

def cardinal2(c: Conj[A]) -> int:

return len(conjuntoAlista(c))

# 3ª solución

# ===========

def cardinal3(c: Conj[A]) -> int:

r = 0

while not esVacio(c):

r = r + 1

c = elimina(menor(c), c)

return r

# 4ª solución

# ===========

def cardinal4Aux(c: Conj[A]) -> int:

r = 0

while not c.esVacio():

r = r + 1

c.elimina(menor(c))

return r

def cardinal4(c: Conj[A]) -> int:

_c = deepcopy(c)

return cardinal4Aux(_c)

# Comprobación de equivalencia

# ============================

@given(c=conjuntoAleatorio())

def test_cardinal(c: Conj[int]) -> None:

r = cardinal(c)

assert cardinal2(c) == r

assert cardinal3(c) == r

# La comprobación es

# src> poetry run pytest -q TAD_Numero_de_elementos_de_un_conjunto.py

# 1 passed in 0.33s

TAD de los conjuntos: Conjunto unitario

PorJosé A. Alonso 6-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   unitario :: Ord a => a -> Conj a

1	unitario :: Ord a => a -> Conj a

tal que unitario x es el conjunto {x}. Por ejemplo,

   unitario 5 == {5}

1	unitario 5 == {5}

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta)

unitario :: Ord a => a -> Conj a
unitario x = inserta x vacio

import TAD.Conjunto (Conj, vacio, inserta)

unitario :: Ord a => a -> Conj a

unitario x = inserta x vacio

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from typing import Protocol, TypeVar

from src.TAD.conjunto import Conj, inserta, vacio

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

def unitario(x: A) -> Conj[A]:
    return inserta(x, vacio())

from __future__ import annotations

from abc import abstractmethod

from typing import Protocol, TypeVar

from src.TAD.conjunto import Conj, inserta, vacio

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

def unitario(x: A) -> Conj[A]:

return inserta(x, vacio())

TAD de los conjuntos: Reconocimiento de subconjunto propio

PorJosé A. Alonso 3-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   subconjuntoPropio :: Ord a => Conj a -> Conj a -> Bool

1	subconjuntoPropio :: Ord a => Conj a -> Conj a -> Bool

tal subconjuntoPropio c1 c2 se verifica si c1 es un subconjunto propio de c2. Por ejemplo,

   λ> ej1 = inserta 5 (inserta 2 vacio)
   λ> ej2 = inserta 3 (inserta 2 (inserta 5 vacio))
   λ> ej3 = inserta 3 (inserta 4 (inserta 5 vacio))
   λ> ej4 = inserta 2 (inserta 5 vacio)
   λ> subconjuntoPropio ej1 ej2
   True
   λ> subconjuntoPropio ej1 ej3
   False
   λ> subconjuntoPropio ej1 ej4
   False

λ> ej1 = inserta 5 (inserta 2 vacio)

λ> ej2 = inserta 3 (inserta 2 (inserta 5 vacio))

λ> ej3 = inserta 3 (inserta 4 (inserta 5 vacio))

λ> ej4 = inserta 2 (inserta 5 vacio)

λ> subconjuntoPropio ej1 ej2

True

λ> subconjuntoPropio ej1 ej3

False

λ> subconjuntoPropio ej1 ej4

False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta)
import TAD_subconjunto (subconjunto)

subconjuntoPropio :: Ord a => Conj a -> Conj a -> Bool
subconjuntoPropio c1 c2 =
  subconjunto c1 c2 && c1 /= c2

-- La función subconjunto está definida en el ejercicio
-- "Reconocimiento de subconjuntos" que se encuentra en
-- https://bit.ly/3wPBtU5

import TAD.Conjunto (Conj, vacio, inserta)

import TAD_subconjunto (subconjunto)

subconjuntoPropio :: Ord a => Conj a -> Conj a -> Bool

subconjuntoPropio c1 c2 =

subconjunto c1 c2 && c1 /= c2

-- La función subconjunto está definida en el ejercicio

-- "Reconocimiento de subconjuntos" que se encuentra en

-- https://bit.ly/3wPBtU5

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from typing import Protocol, TypeVar

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, pertenece, vacio)
from src.TAD_subconjunto import subconjunto

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

def subconjuntoPropio(c1: Conj[A], c2: Conj[A]) -> bool:
    return subconjunto(c1, c2) and c1 != c2

# La función subconjunto está definida en el ejercicio
# "Reconocimiento de subconjuntos" que se encuentra en
# https://bit.ly/3wPBtU5

from __future__ import annotations

from abc import abstractmethod

from typing import Protocol, TypeVar

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, pertenece, vacio)

from src.TAD_subconjunto import subconjunto

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

def subconjuntoPropio(c1: Conj[A], c2: Conj[A]) -> bool:

return subconjunto(c1, c2) and c1 != c2

# La función subconjunto está definida en el ejercicio

# "Reconocimiento de subconjuntos" que se encuentra en

# https://bit.ly/3wPBtU5

TAD de los conjuntos: Reconocimiento de subconjuntos

PorJosé A. Alonso 2-marzo-202322-febrero-2023

Utilizando el tipo abstracto de datos de los conjuntos definir la función

   subconjunto :: Ord a => Conj a -> Conj a -> Bool

1	subconjunto :: Ord a => Conj a -> Conj a -> Bool

tal que subconjunto c1 c2 se verifica si todos los elementos de c1 pertenecen a c2. Por ejemplo,

   λ> ej1 = inserta 5 (inserta 2 vacio)
   λ> ej2 = inserta 3 (inserta 2 (inserta 5 vacio))
   λ> ej3 = inserta 3 (inserta 4 (inserta 5 vacio))
   λ> subconjunto ej1 ej2
   True
   λ> subconjunto ej1 ej3
   False

λ> ej1 = inserta 5 (inserta 2 vacio)

λ> ej2 = inserta 3 (inserta 2 (inserta 5 vacio))

λ> ej3 = inserta 3 (inserta 4 (inserta 5 vacio))

λ> subconjunto ej1 ej2

True

λ> subconjunto ej1 ej3

False

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import TAD.Conjunto (Conj, vacio, inserta, menor, elimina, pertenece, esVacio)
import Transformaciones_conjuntos_listas (conjuntoAlista)
import Test.QuickCheck

-- 1ª solución
-- ===========

subconjunto :: Ord a => Conj a -> Conj a -> Bool
subconjunto c1 c2
  | esVacio c1 = True
  | otherwise  =  pertenece mc1 c2 && subconjunto rc1 c2
  where mc1 = menor c1
        rc1 = elimina mc1 c1

-- 2ª solución
-- ===========

subconjunto2 :: Ord a => Conj a -> Conj a -> Bool
subconjunto2 c1 c2 =
  and [pertenece x c2 | x <- conjuntoAlista c1]

-- La función conjuntoAlista está definida en el ejercicio
-- "Transformaciones entre conjuntos y listas" que se encuentra en
-- https://bit.ly/3RexzxH

-- 3ª solución
-- ===========

subconjunto3 :: Ord a => Conj a -> Conj a -> Bool
subconjunto3 c1 c2 =
  all (`pertenece` c2) (conjuntoAlista c1)

-- 4ª solución
-- ===========

subconjunto4 :: Ord a => Conj a -> Conj a -> Bool
subconjunto4 c1 c2 =
  sublista (conjuntoAlista c1) (conjuntoAlista c2)

-- (sublista xs ys) se verifica si xs es una sublista de ys. Por
-- ejemplo,
--    sublista [5, 2] [3, 2, 5]  ==  True
--    sublista [5, 2] [3, 4, 5]  ==  False
sublista :: Ord a => [a] -> [a] -> Bool
sublista [] _      = True
sublista (x:xs) ys = elem x ys && sublista xs ys

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_subconjunto :: Conj Int -> Conj Int -> Bool
prop_subconjunto c1 c2 =
  all (== subconjunto c1 c2)
      [subconjunto2 c1 c2,
       subconjunto3 c1 c2,
       subconjunto4 c1 c2]

-- La comprobación es
--    λ> quickCheck prop_subconjunto
--    +++ OK, passed 100 tests.

import TAD.Conjunto (Conj, vacio, inserta, menor, elimina, pertenece, esVacio)

import Transformaciones_conjuntos_listas (conjuntoAlista)

import Test.QuickCheck

-- 1ª solución

-- ===========

subconjunto :: Ord a => Conj a -> Conj a -> Bool

subconjunto c1 c2

| esVacio c1 = True

| otherwise = pertenece mc1 c2 && subconjunto rc1 c2

where mc1 = menor c1

rc1 = elimina mc1 c1

-- 2ª solución

-- ===========

subconjunto2 :: Ord a => Conj a -> Conj a -> Bool

subconjunto2 c1 c2 =

and [pertenece x c2 | x <- conjuntoAlista c1]

-- La función conjuntoAlista está definida en el ejercicio

-- "Transformaciones entre conjuntos y listas" que se encuentra en

-- https://bit.ly/3RexzxH

-- 3ª solución

-- ===========

subconjunto3 :: Ord a => Conj a -> Conj a -> Bool

subconjunto3 c1 c2 =

all (`pertenece` c2) (conjuntoAlista c1)

-- 4ª solución

-- ===========

subconjunto4 :: Ord a => Conj a -> Conj a -> Bool

subconjunto4 c1 c2 =

sublista (conjuntoAlista c1) (conjuntoAlista c2)

-- (sublista xs ys) se verifica si xs es una sublista de ys. Por

-- ejemplo,

-- sublista [5, 2] [3, 2, 5] == True

-- sublista [5, 2] [3, 4, 5] == False

sublista :: Ord a => [a] -> [a] -> Bool

sublista [] _ = True

sublista (x:xs) ys = elem x ys && sublista xs ys

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_subconjunto :: Conj Int -> Conj Int -> Bool

prop_subconjunto c1 c2 =

all (== subconjunto c1 c2)

[subconjunto2 c1 c2,

subconjunto3 c1 c2,

subconjunto4 c1 c2]

-- La comprobación es

-- λ> quickCheck prop_subconjunto

-- +++ OK, passed 100 tests.

Soluciones en Python

from __future__ import annotations

from abc import abstractmethod
from copy import deepcopy
from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,
                              inserta, menor, pertenece, vacio)
from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):
    @abstractmethod
    def __lt__(self: A, otro: A) -> bool:
        pass

A = TypeVar('A', bound=Comparable)

# 1ª solución
# ===========

def subconjunto(c1: Conj[A], c2: Conj[A]) -> bool:
    if esVacio(c1):
        return True
    mc1 = menor(c1)
    rc1 = elimina(mc1, c1)
    return pertenece(mc1, c2) and subconjunto(rc1, c2)

# 2ª solución
# ===========

def subconjunto2(c1: Conj[A], c2: Conj[A]) -> bool:
    return all((pertenece(x, c2) for x in conjuntoAlista(c1)))

# La función conjuntoAlista está definida en el ejercicio
# "Transformaciones entre conjuntos y listas" que se encuentra en
# https://bit.ly/3RexzxH

# 3ª solución
# ===========

# (sublista xs ys) se verifica si xs es una sublista de ys. Por
# ejemplo,
#    sublista [5, 2] [3, 2, 5]  ==  True
#    sublista [5, 2] [3, 4, 5]  ==  False
def sublista(xs: list[A], ys: list[A]) -> bool:
    if not xs:
        return True
    return xs[0] in ys and sublista(xs[1:], ys)

def subconjunto3(c1: Conj[A], c2: Conj[A]) -> bool:
    return sublista(conjuntoAlista(c1), conjuntoAlista(c2))

# 4ª solución
# ===========

def subconjunto4(c1: Conj[A], c2: Conj[A]) -> bool:
    while not esVacio(c1):
        mc1 = menor(c1)
        if not pertenece(mc1, c2):
            return False
        c1 = elimina(mc1, c1)
    return True

# 5ª solución
# ===========

def subconjunto5Aux(c1: Conj[A], c2: Conj[A]) -> bool:
    while not c1.esVacio():
        mc1 = c1.menor()
        if not c2.pertenece(mc1):
            return False
        c1.elimina(mc1)
    return True

def subconjunto5(c1: Conj[A], c2: Conj[A]) -> bool:
    _c1 = deepcopy(c1)
    return subconjunto5Aux(_c1, c2)

# Comprobación de equivalencia
# ============================

# La propiedad es
@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())
def test_subconjunto(c1: Conj[int], c2: Conj[int]) -> None:
    r = subconjunto(c1, c2)
    assert subconjunto2(c1, c2) == r
    assert subconjunto3(c1, c2) == r
    assert subconjunto4(c1, c2) == r
    assert subconjunto5(c1, c2) == r

# La comprobación de las propiedades es
#    > poetry run pytest -q TAD_subconjunto.py
#    1 passed in 0.37s

from __future__ import annotations

from abc import abstractmethod

from copy import deepcopy

from typing import Protocol, TypeVar

from hypothesis import given

from src.TAD.conjunto import (Conj, conjuntoAleatorio, elimina, esVacio,

inserta, menor, pertenece, vacio)

from src.TAD_Transformaciones_conjuntos_listas import conjuntoAlista

class Comparable(Protocol):

@abstractmethod

def __lt__(self: A, otro: A) -> bool:

pass

A = TypeVar('A', bound=Comparable)

# 1ª solución

# ===========

def subconjunto(c1: Conj[A], c2: Conj[A]) -> bool:

if esVacio(c1):

return True

mc1 = menor(c1)

rc1 = elimina(mc1, c1)

return pertenece(mc1, c2) and subconjunto(rc1, c2)

# 2ª solución

# ===========

def subconjunto2(c1: Conj[A], c2: Conj[A]) -> bool:

return all((pertenece(x, c2) for x in conjuntoAlista(c1)))

# La función conjuntoAlista está definida en el ejercicio

# "Transformaciones entre conjuntos y listas" que se encuentra en

# https://bit.ly/3RexzxH

# 3ª solución

# ===========

# (sublista xs ys) se verifica si xs es una sublista de ys. Por

# ejemplo,

# sublista [5, 2] [3, 2, 5] == True

# sublista [5, 2] [3, 4, 5] == False

def sublista(xs: list[A], ys: list[A]) -> bool:

if not xs:

return True

return xs[0] in ys and sublista(xs[1:], ys)

def subconjunto3(c1: Conj[A], c2: Conj[A]) -> bool:

return sublista(conjuntoAlista(c1), conjuntoAlista(c2))

# 4ª solución

# ===========

def subconjunto4(c1: Conj[A], c2: Conj[A]) -> bool:

while not esVacio(c1):

mc1 = menor(c1)

if not pertenece(mc1, c2):

return False

c1 = elimina(mc1, c1)

return True

# 5ª solución

# ===========

def subconjunto5Aux(c1: Conj[A], c2: Conj[A]) -> bool:

while not c1.esVacio():

mc1 = c1.menor()

if not c2.pertenece(mc1):

return False

c1.elimina(mc1)

return True

def subconjunto5(c1: Conj[A], c2: Conj[A]) -> bool:

_c1 = deepcopy(c1)

return subconjunto5Aux(_c1, c2)

# Comprobación de equivalencia

# ============================

# La propiedad es

@given(c1=conjuntoAleatorio(), c2=conjuntoAleatorio())

def test_subconjunto(c1: Conj[int], c2: Conj[int]) -> None:

r = subconjunto(c1, c2)

assert subconjunto2(c1, c2) == r

assert subconjunto3(c1, c2) == r

assert subconjunto4(c1, c2) == r

assert subconjunto5(c1, c2) == r

# La comprobación de las propiedades es

# > poetry run pytest -q TAD_subconjunto.py

# 1 passed in 0.37s

Clausura reflexiva

Relaciones totales

Relaciones antisimétricas

Relaciones irreflexivas

Relaciones de equivalencia

Relaciones transitivas

Reconocimiento de subconjunto

Composición de relaciones binarias

Relaciones simétricas

Relaciones reflexivas

Universo y grafo de una relación binaria

Relaciones binarias

TAD de los conjuntos: Producto cartesiano de dos conjuntos

TAD de los conjuntos: Algunos elementos verifican una propiedad

TAD de los conjuntos: Todos los elementos verifican una propiedad

TAD de los conjuntos: Aplicación de una función a los elementos de un conjunto

TAD de los conjuntos: Partición según un número

TAD de los conjuntos: Partición de un conjunto según una propiedad

TAD de los conjuntos: Subconjunto determinado por una propiedad

TAD de los conjuntos: Diferencia simétrica

TAD de los conjuntos: Diferencia de conjuntos

TAD de los conjuntos: Conjuntos disjuntos

TAD de los conjuntos: Intersección de varios conjuntos

TAD de los conjuntos: Intersección de dos conjuntos

TAD de los conjuntos: Unión de varios conjuntos

TAD de los conjuntos: Unión de dos conjuntos

TAD de los conjuntos: Número de elementos de un conjunto

TAD de los conjuntos: Conjunto unitario

TAD de los conjuntos: Reconocimiento de subconjunto propio

TAD de los conjuntos: Reconocimiento de subconjuntos

Entradas recientes

Buscar

Correo electrónico