diciembre 2022 – Página 5

Aplicación de una función a un árbol

PorJosé A. Alonso 7-diciembre-202214-diciembre-2022

El árbol binario

        ·
       / \
      /   \
     ·     ·
    / \   / \
   1   4 6   9

/ \

· ·

/ \ / \

1 4 6 9

se puede representar por

   ejArbol = Nodo (Nodo (Hoja 1) (Hoja 4))
                  (Nodo (Hoja 6) (Hoja 9))

1 2	ejArbol = Nodo (Nodo (Hoja 1) (Hoja 4)) (Nodo (Hoja 6) (Hoja 9))

El tipo de los árboles binarios se puede definir por

   data Arbol a = Hoja a
                | Nodo (Arbol a) (Arbol a)
     deriving (Show, Eq)

data Arbol a = Hoja a

| Nodo (Arbol a) (Arbol a)

deriving (Show, Eq)

Definir la función

   mapArbol :: (a -> b) -> Arbol a -> Arbol b

1	mapArbol :: (a -> b) -> Arbol a -> Arbol b

tal que mapArbol f t es el árbolo obtenido aplicando la función f a los elementos del árbol t. Por ejemplo,

   λ> mapArbol (+ 1) (Nodo (Hoja 2) (Hoja 4))
   Nodo (Hoja 3) (Hoja 5)

1 2	λ> mapArbol (+ 1) (Nodo (Hoja 2) (Hoja 4)) Nodo (Hoja 3) (Hoja 5)

Soluciones

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

Soluciones en Haskell

data Arbol a = Hoja a
             | Nodo (Arbol a) (Arbol a)
  deriving (Show, Eq)

mapArbol :: (a -> b) -> Arbol a -> Arbol b
mapArbol f (Hoja a)   = Hoja (f a)
mapArbol f (Nodo l r) = Nodo (mapArbol f l) (mapArbol f r)

data Arbol a = Hoja a

| Nodo (Arbol a) (Arbol a)

deriving (Show, Eq)

mapArbol :: (a -> b) -> Arbol a -> Arbol b

mapArbol f (Hoja a) = Hoja (f a)

mapArbol f (Nodo l r) = Nodo (mapArbol f l) (mapArbol f r)

Soluciones en Python

from dataclasses import dataclass
from typing import Callable, Generic, TypeVar

A = TypeVar("A")
B = TypeVar("B")

@dataclass
class Arbol(Generic[A]):
    pass

@dataclass
class Hoja(Arbol[A]):
    x: A

@dataclass
class Nodo(Arbol[A]):
    i: Arbol[A]
    d: Arbol[A]

def mapArbol(f: Callable[[A], B], a: Arbol[A]) -> Arbol[B]:
    match a:
        case Hoja(x):
            return Hoja(f(x))
        case Nodo(i, d):
            return Nodo(mapArbol(f, i), mapArbol(f, d))
    assert False

from dataclasses import dataclass

from typing import Callable, Generic, TypeVar

A = TypeVar("A")

B = TypeVar("B")

@dataclass

class Arbol(Generic[A]):

pass

@dataclass

class Hoja(Arbol[A]):

x: A

@dataclass

class Nodo(Arbol[A]):

i: Arbol[A]

d: Arbol[A]

def mapArbol(f: Callable[[A], B], a: Arbol[A]) -> Arbol[B]:

match a:

case Hoja(x):

return Hoja(f(x))

case Nodo(i, d):

return Nodo(mapArbol(f, i), mapArbol(f, d))

assert False

Altura de un árbol binario

PorJosé A. Alonso 6-diciembre-202214-diciembre-2022

El árbol binario

        ·
       / \
      /   \
     ·     ·
    / \   / \
   1   4 6   9

/ \

· ·

/ \ / \

1 4 6 9

se puede representar por

   ejArbol = Nodo (Nodo (Hoja 1) (Hoja 4))
                  (Nodo (Hoja 6) (Hoja 9))

1 2	ejArbol = Nodo (Nodo (Hoja 1) (Hoja 4)) (Nodo (Hoja 6) (Hoja 9))

El tipo de los árboles binarios se puede definir por

data Arbol a = Hoja a
| Nodo (Arbol a) (Arbol a)

Definir la función

   altura :: Arbol a -> Int

1	altura :: Arbol a -> Int

tal que altura t es la altura del árbol t. Por ejemplo,

   λ> altura (Hoja 1)
   0
   λ> altura (Nodo (Hoja 1) (Hoja 6))
   1
   λ> altura (Nodo (Nodo (Hoja 1) (Hoja 6)) (Hoja 2))
   2
   λ> altura (Nodo (Nodo (Hoja 1) (Hoja 6)) (Nodo (Hoja 2) (Hoja 7)))
   2

λ> altura (Hoja 1)

λ> altura (Nodo (Hoja 1) (Hoja 6))

λ> altura (Nodo (Nodo (Hoja 1) (Hoja 6)) (Hoja 2))

λ> altura (Nodo (Nodo (Hoja 1) (Hoja 6)) (Nodo (Hoja 2) (Hoja 7)))

Soluciones

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

Soluciones en Haskell

data Arbol a = Hoja a
             | Nodo (Arbol a) (Arbol a)

altura :: Arbol a -> Int
altura (Hoja _)   = 0
altura (Nodo i d) = 1 + max (altura i) (altura d)

data Arbol a = Hoja a

| Nodo (Arbol a) (Arbol a)

altura :: Arbol a -> Int

altura (Hoja _) = 0

altura (Nodo i d) = 1 + max (altura i) (altura d)

Soluciones en Python

from dataclasses import dataclass
from typing import Generic, TypeVar

A = TypeVar("A")

@dataclass
class Arbol(Generic[A]):
    pass

@dataclass
class Hoja(Arbol[A]):
    x: A

@dataclass
class Nodo(Arbol[A]):
    i: Arbol[A]
    d: Arbol[A]

def altura(a: Arbol[A]) -> int:
    match a:
        case Hoja(_):
            return 0
        case Nodo(i, d):
            return 1 + max(altura(i), altura(d))
    assert False

from dataclasses import dataclass

from typing import Generic, TypeVar

A = TypeVar("A")

@dataclass

class Arbol(Generic[A]):

pass

@dataclass

class Hoja(Arbol[A]):

x: A

@dataclass

class Nodo(Arbol[A]):

i: Arbol[A]

d: Arbol[A]

def altura(a: Arbol[A]) -> int:

match a:

case Hoja(_):

return 0

case Nodo(i, d):

return 1 + max(altura(i), altura(d))

assert False

El tipo de los árboles binarios con valores en las hojas

PorJosé A. Alonso 6-diciembre-202223-abril-2023

1. El tipo de los árboles binarios con valores en las hojas en Haskell

El árbol binario

        ·
       / \
      /   \
     ·     ·
    / \   / \
   1   4 6   9

/ \

· ·

/ \ / \

1 4 6 9

se puede representar por

   ejArbol = Nodo (Nodo (Hoja 1) (Hoja 4))
                  (Nodo (Hoja 6) (Hoja 9))

1 2	ejArbol = Nodo (Nodo (Hoja 1) (Hoja 4)) (Nodo (Hoja 6) (Hoja 9))

usando el tipo de los árboles binarios con valores en las hojas definido como se muestra a continuación.

data Arbol a = Hoja a
             | Nodo (Arbol a) (Arbol a)
  deriving (Eq, Show)

-- (arbolArbitrario n) es un árbol aleatorio de altura n. Por ejemplo,
--    λ> sample (arbolArbitrario 3 :: Gen (Arbol Int))
--    Nodo (Nodo (Nodo (Hoja 0) (Hoja 0)) (Hoja 0)) (Hoja 0)
--    Nodo (Nodo (Hoja 4) (Hoja 8)) (Hoja (-4))
--    Nodo (Nodo (Nodo (Hoja 4) (Hoja 10)) (Hoja (-6))) (Hoja (-1))
--    Nodo (Nodo (Hoja 3) (Hoja 6)) (Hoja (-5))
--    Nodo (Nodo (Hoja (-11)) (Hoja (-13))) (Hoja 14)
--    Nodo (Nodo (Hoja (-7)) (Hoja 15)) (Hoja (-2))
--    Nodo (Nodo (Hoja (-9)) (Hoja (-2))) (Hoja (-6))
--    Nodo (Nodo (Hoja (-15)) (Hoja (-16))) (Hoja (-20))
arbolArbitrario :: Arbitrary a => Int -> Gen (Arbol a)
arbolArbitrario n
  | n <= 1    = Hoja <$> arbitrary
  | otherwise = do
      k <- choose (2, n - 1)
      Nodo <$> arbolArbitrario k <*> arbolArbitrario (n - k)

-- Arbol es subclase de Arbitraria
instance Arbitrary a => Arbitrary (Arbol a) where
  arbitrary = sized arbolArbitrario
  shrink (Hoja x)   = Hoja <$> shrink x
  shrink (Nodo l r) = l :
                      r :
                      [Nodo l' r | l' <- shrink l] ++
                      [Nodo l r' | r' <- shrink r]

data Arbol a = Hoja a

| Nodo (Arbol a) (Arbol a)

deriving (Eq, Show)

-- (arbolArbitrario n) es un árbol aleatorio de altura n. Por ejemplo,

-- λ> sample (arbolArbitrario 3 :: Gen (Arbol Int))

-- Nodo (Nodo (Nodo (Hoja 0) (Hoja 0)) (Hoja 0)) (Hoja 0)

-- Nodo (Nodo (Hoja 4) (Hoja 8)) (Hoja (-4))

-- Nodo (Nodo (Nodo (Hoja 4) (Hoja 10)) (Hoja (-6))) (Hoja (-1))

-- Nodo (Nodo (Hoja 3) (Hoja 6)) (Hoja (-5))

-- Nodo (Nodo (Hoja (-11)) (Hoja (-13))) (Hoja 14)

-- Nodo (Nodo (Hoja (-7)) (Hoja 15)) (Hoja (-2))

-- Nodo (Nodo (Hoja (-9)) (Hoja (-2))) (Hoja (-6))

-- Nodo (Nodo (Hoja (-15)) (Hoja (-16))) (Hoja (-20))

arbolArbitrario :: Arbitrary a => Int -> Gen (Arbol a)

arbolArbitrario n

| n <= 1 = Hoja <$> arbitrary

| otherwise = do

k <- choose (2, n - 1)

Nodo <$> arbolArbitrario k <*> arbolArbitrario (n - k)

-- Arbol es subclase de Arbitraria

instance Arbitrary a => Arbitrary (Arbol a) where

arbitrary = sized arbolArbitrario

shrink (Hoja x) = Hoja <$> shrink x

shrink (Nodo l r) = l :

r :

[Nodo l' r | l' <- shrink l] ++

[Nodo l r' | r' <- shrink r]

2. El tipo de los árboles binarios con valores en las hojas en Python

El árbol binario

        ·
       / \
      /   \
     ·     ·
    / \   / \
   1   4 6   9

/ \

· ·

/ \ / \

1 4 6 9

se puede representar por

   ejArbol = Nodo(Nodo(Hoja(1), Hoja(4)),
                  Nodo(Hoja(6), Hoja(9)))

1 2	ejArbol = Nodo(Nodo(Hoja(1), Hoja(4)), Nodo(Hoja(6), Hoja(9)))

usando el tipo de los árboles binarios con valores en las hojas definido como se muestra a continuación.

from dataclasses import dataclass
from typing import Generic, TypeVar
from random import randint

A = TypeVar("A")

@dataclass
class Arbol(Generic[A]):
    pass

@dataclass
class Hoja(Arbol[A]):
    x: A

@dataclass
class Nodo(Arbol[A]):
    i: Arbol[A]
    d: Arbol[A]

# Generador
# =========

# arbolArbitrario(n) es un árbol aleatorio de orden n. Por ejemplo,
#    >>> arbolArbitrario(2)
#    Nodo(i=Nodo(i=Hoja(x=6), d=Hoja(x=3)), d=Nodo(i=Hoja(x=4), d=Hoja(x=4)))
#    >>> arbolArbitrario(2)
#    Nodo(i=Nodo(i=Hoja(x=9), d=Hoja(x=6)), d=Nodo(i=Hoja(x=9), d=Hoja(x=8)))
def arbolArbitrario(n: int) -> Arbol[int]:
    if n == 0:
        return Hoja(randint(1, 10))
    if n == 1:
        return Nodo(arbolArbitrario(0), arbolArbitrario(0))
    k = min(randint(1, n + 1), n - 1)
    return Nodo(arbolArbitrario(k), arbolArbitrario(n - k))

from dataclasses import dataclass

from typing import Generic, TypeVar

from random import randint

A = TypeVar("A")

@dataclass

class Arbol(Generic[A]):

pass

@dataclass

class Hoja(Arbol[A]):

x: A

@dataclass

class Nodo(Arbol[A]):

i: Arbol[A]

d: Arbol[A]

# Generador

# =========

# arbolArbitrario(n) es un árbol aleatorio de orden n. Por ejemplo,

# >>> arbolArbitrario(2)

# Nodo(i=Nodo(i=Hoja(x=6), d=Hoja(x=3)), d=Nodo(i=Hoja(x=4), d=Hoja(x=4)))

# >>> arbolArbitrario(2)

# Nodo(i=Nodo(i=Hoja(x=9), d=Hoja(x=6)), d=Nodo(i=Hoja(x=9), d=Hoja(x=8)))

def arbolArbitrario(n: int) -> Arbol[int]:

if n == 0:

return Hoja(randint(1, 10))

if n == 1:

return Nodo(arbolArbitrario(0), arbolArbitrario(0))

k = min(randint(1, n + 1), n - 1)

return Nodo(arbolArbitrario(k), arbolArbitrario(n - k))

El tipo de las fórmulas proposicionales: Reconocedor de tautologías

PorJosé A. Alonso 5-diciembre-202215-abril-2023

Una fórmula es una tautología si es verdadera en todas sus interpretaciones. Por ejemplo,

(A ∧ B) → A es una tautología
A → (A ∧ B) no es una tautología

Usando el tipo de las fórmulas proposicionales definido en el ejercicio anterior, definir la función

   esTautologia :: FProp -> Bool

1	esTautologia :: FProp -> Bool

tal que esTautologia p se verifica si la fórmula p es una tautología. Por ejemplo,

   λ> esTautologia (Impl (Conj (Var 'A') (Var 'B')) (Var 'A'))
   True
   λ> esTautologia (Impl (Var 'A') (Conj (Var 'A') (Var 'B')))
   False

λ> esTautologia (Impl (Conj (Var 'A') (Var 'B')) (Var 'A'))

True

λ> esTautologia (Impl (Var 'A') (Conj (Var 'A') (Var 'B')))

False

Soluciones

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

Soluciones en Haskell

import Tipo_de_formulas (FProp(..))
import Valor_de_una_formula (valor)
import Interpretaciones_de_una_formula (interpretaciones)

esTautologia :: FProp -> Bool
esTautologia p =
  and [valor i p | i <- interpretaciones p]

import Tipo_de_formulas (FProp(..))

import Valor_de_una_formula (valor)

import Interpretaciones_de_una_formula (interpretaciones)

esTautologia :: FProp -> Bool

esTautologia p =

and [valor i p | i <- interpretaciones p]

Soluciones en Python

from src.interpretaciones_de_una_formula import interpretaciones
from src.tipo_de_formulas import Conj, Const, FProp, Impl, Neg, Var
from src.valor_de_una_formula import valor

def esTautologia(p: FProp) -> bool:
    return all((valor(i, p) for i in interpretaciones(p)))

from src.interpretaciones_de_una_formula import interpretaciones

from src.tipo_de_formulas import Conj, Const, FProp, Impl, Neg, Var

from src.valor_de_una_formula import valor

def esTautologia(p: FProp) -> bool:

return all((valor(i, p) for i in interpretaciones(p)))

El tipo de las fórmulas proposicionales: Interpretaciones de una fórmula

PorJosé A. Alonso 2-diciembre-202215-abril-2023

Usando el tipo de las fórmulas proposicionales definido en el ejercicio anterior, definir la función

   interpretaciones :: FProp -> [Interpretacion]

1	interpretaciones :: FProp -> [Interpretacion]

tal que interpretaciones p es la lista de las interpretaciones de la fórmula p. Por ejemplo,

   λ> interpretaciones (Impl (Var 'A') (Conj (Var 'A') (Var 'B')))
   [[('A',False),('B',False)],
    [('A',False),('B',True)],
    [('A',True),('B',False)],
    [('A',True),('B',True)]]

λ> interpretaciones (Impl (Var 'A') (Conj (Var 'A') (Var 'B')))

[[('A',False),('B',False)],

[('A',False),('B',True)],

[('A',True),('B',False)],

[('A',True),('B',True)]]

Soluciones

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

Soluciones en Haskell

import Tipo_de_formulas (FProp(..))
import Variables_de_una_formula (variables)
import Valor_de_una_formula (Interpretacion)
import Data.List (nub)

interpretaciones :: FProp -> [Interpretacion]
interpretaciones p =
  [zip vs i | i <- interpretacionesVar (length vs)]
  where vs = nub (variables p)

-- (interpretacionesVar n) es la lista de las interpretaciones de n
-- variables. Por ejemplo,
--    λ> interpretacionesVar 2
--    [[False,False],
--     [False,True],
--     [True,False],
--     [True,True]]
interpretacionesVar :: Int -> [[Bool]]
interpretacionesVar 0 = [[]]
interpretacionesVar n = map (False:) bss ++ map (True:) bss
  where bss = interpretacionesVar (n-1)

import Tipo_de_formulas (FProp(..))

import Variables_de_una_formula (variables)

import Valor_de_una_formula (Interpretacion)

import Data.List (nub)

interpretaciones :: FProp -> [Interpretacion]

interpretaciones p =

[zip vs i | i <- interpretacionesVar (length vs)]

where vs = nub (variables p)

-- (interpretacionesVar n) es la lista de las interpretaciones de n

-- variables. Por ejemplo,

-- λ> interpretacionesVar 2

-- [[False,False],

-- [False,True],

-- [True,False],

-- [True,True]]

interpretacionesVar :: Int -> [[Bool]]

interpretacionesVar 0 = [[]]

interpretacionesVar n = map (False:) bss ++ map (True:) bss

where bss = interpretacionesVar (n-1)

Soluciones en Python

from src.tipo_de_formulas import Conj, Const, FProp, Impl, Neg, Var
from src.valor_de_una_formula import Interpretacion
from src.variables_de_una_formula import variables

# interpretacionesVar(n) es la lista de las interpretaciones de n
# variables. Por ejemplo,
#    >>> interpretacionesVar 2
#    [[False, False],
#     [False, True],
#     [True, False],
#     [True, True]]
def interpretacionesVar(n: int) -> list[list[bool]]:
    if n == 0:
        return [[]]
    bss = interpretacionesVar(n-1)
    return [[False] + x for x in bss] + [[True] + x for x in bss]

def interpretaciones(f: FProp) -> list[Interpretacion]:
    vs = list(set(variables(f)))
    return [list(zip(vs, i)) for i in interpretacionesVar(len(vs))]

from src.tipo_de_formulas import Conj, Const, FProp, Impl, Neg, Var

from src.valor_de_una_formula import Interpretacion

from src.variables_de_una_formula import variables

# interpretacionesVar(n) es la lista de las interpretaciones de n

# variables. Por ejemplo,

# >>> interpretacionesVar 2

# [[False, False],

# [False, True],

# [True, False],

# [True, True]]

def interpretacionesVar(n: int) -> list[list[bool]]:

if n == 0:

return [[]]

bss = interpretacionesVar(n-1)

return [[False] + x for x in bss] + [[True] + x for x in bss]

def interpretaciones(f: FProp) -> list[Interpretacion]:

vs = list(set(variables(f)))

return [list(zip(vs, i)) for i in interpretacionesVar(len(vs))]

Meses: diciembre 2022

Aplicación de una función a un árbol

Altura de un árbol binario

El tipo de los árboles binarios con valores en las hojas

1. El tipo de los árboles binarios con valores en las hojas en Haskell

2. El tipo de los árboles binarios con valores en las hojas en Python

El tipo de las fórmulas proposicionales: Reconocedor de tautologías

El tipo de las fórmulas proposicionales: Interpretaciones de una fórmula

Entradas recientes

Buscar

Correo electrónico