septiembre 2022 – Página 5

Intercambio de componentes de un par

PorJosé A. Alonso 5-septiembre-202214-diciembre-2022

Definir la función

   intercambia :: (a,b) -> (b,a)

1	intercambia :: (a,b) -> (b,a)

tal que (intercambia p) es el punto obtenido intercambiando las coordenadas del punto p. Por ejemplo,

   intercambia (2,5)  ==  (5,2)
   intercambia (5,2)  ==  (2,5)

1 2	intercambia (2,5) == (5,2) intercambia (5,2) == (2,5)

Soluciones

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

Soluciones en Haskell

intercambia :: (a,b) -> (b,a)
intercambia (x,y) = (y,x)

1 2	intercambia :: (a,b) -> (b,a) intercambia (x,y) = (y,x)

El código se encuentra en GitHub.

Soluciones en Python

from typing import TypeVar
from hypothesis import given, strategies as st

A = TypeVar('A')
B = TypeVar('B')

def intercambia(p: tuple[A, B]) -> tuple[B, A]:
    (x, y) = p
    return (y, x)

# La propiedad de es
@given(st.tuples(st.integers(), st.integers()))
def test_equiv_intercambia(p):
    assert intercambia(intercambia(p)) == p

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

from typing import TypeVar

from hypothesis import given, strategies as st

A = TypeVar('A')

B = TypeVar('B')

def intercambia(p: tuple[A, B]) -> tuple[B, A]:

(x, y) = p

return (y, x)

# La propiedad de es

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

def test_equiv_intercambia(p):

assert intercambia(intercambia(p)) == p

# La comprobación es

# src> poetry run pytest -q intercambio_de_componentes_de_un_par.py

# 1 passed in 0.15s

El código se encuentra en GitHub.

Comentarios

En Haskell se pone el patrón en los argumentos y en Python hay que extraerlos mediante un asignación.

Mayor rectángulo

PorJosé A. Alonso 2-septiembre-202214-diciembre-2022

Las dimensiones de los rectángulos puede representarse por pares; por ejemplo, (5,3) representa a un rectángulo de base 5 y altura 3.

Definir la función

   mayorRectangulo :: (Num a, Ord a) => (a,a) -> (a,a) -> (a,a)

1	mayorRectangulo :: (Num a, Ord a) => (a,a) -> (a,a) -> (a,a)

tal que (mayorRectangulo r1 r2) es el rectángulo de mayor área entre r1 y r2. Por ejemplo,

   mayorRectangulo (4,6) (3,7)  ==  (4,6)
   mayorRectangulo (4,6) (3,8)  ==  (4,6)
   mayorRectangulo (4,6) (3,9)  ==  (3,9)

mayorRectangulo (4,6) (3,7) == (4,6)

mayorRectangulo (4,6) (3,8) == (4,6)

mayorRectangulo (4,6) (3,9) == (3,9)

Soluciones

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

Soluciones en Haskell

mayorRectangulo :: (Num a, Ord a) => (a,a) -> (a,a) -> (a,a)
mayorRectangulo (a,b) (c,d)
  | a*b >= c*d = (a,b)
  | otherwise  = (c,d)

mayorRectangulo :: (Num a, Ord a) => (a,a) -> (a,a) -> (a,a)

mayorRectangulo (a,b) (c,d)

| a*b >= c*d = (a,b)

| otherwise = (c,d)

El código se encuentra en GitHub.

Soluciones en Python

def mayorRectangulo(r1: tuple[float, float],
                    r2: tuple[float, float]) -> tuple[float, float]:
    (a, b) = r1
    (c, d) = r2
    if a*b >= c*d:
        return (a, b)
    return (c, d)

def mayorRectangulo(r1: tuple[float, float],

r2: tuple[float, float]) -> tuple[float, float]:

(a, b) = r1

(c, d) = r2

if a*b >= c*d:

return (a, b)

return (c, d)

El código se encuentra en GitHub.

Disyunción excluyente

PorJosé A. Alonso 1-septiembre-202214-diciembre-2022

La disyunción excluyente de dos fórmulas se verifica si una es verdadera y la otra es falsa. Su tabla de verdad es

   x     | y     | xor x y
   ------+-------+---------
   True  | True  | False
   True  | False | True
   False | True  | True
   False | False | False

x | y | xor x y

------+-------+---------

True | True | False

True | False | True

False | True | True

False | False | False

Definir la función

   xor :: Bool -> Bool -> Bool

1	xor :: Bool -> Bool -> Bool

tal que (xor x y) es la disyunción excluyente de x e y. Por ejemplo,

   xor True  True  == False
   xor True  False == True
   xor False True  == True
   xor False False == False

xor True True == False

xor True False == True

xor False True == True

xor False False == False

Soluciones

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

Soluciones en Haskell

import Test.QuickCheck

-- 1ª solución
xor1 :: Bool -> Bool -> Bool
xor1 True  True  = False
xor1 True  False = True
xor1 False True  = True
xor1 False False = False

-- 2ª solución
xor2 :: Bool -> Bool -> Bool
xor2 True  y = not y
xor2 False y = y

-- 3ª solución:
xor3 :: Bool -> Bool -> Bool
xor3 x y = (x || y) && not (x && y)

-- 4ª solución:
xor4 :: Bool -> Bool -> Bool
xor4 x y = (x && not y) || (y && not x)

-- 5ª solución:
xor5 :: Bool -> Bool -> Bool
xor5 x y = x /= y

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

-- La propiedad es
prop_xor :: Bool -> Bool -> Bool
prop_xor x y =
  all (== xor1 x y)
      [xor2 x y,
       xor3 x y,
       xor4 x y,
       xor5 x y]

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

import Test.QuickCheck

-- 1ª solución

xor1 :: Bool -> Bool -> Bool

xor1 True True = False

xor1 True False = True

xor1 False True = True

xor1 False False = False

-- 2ª solución

xor2 :: Bool -> Bool -> Bool

xor2 True y = not y

xor2 False y = y

-- 3ª solución:

xor3 :: Bool -> Bool -> Bool

xor3 x y = (x || y) && not (x && y)

-- 4ª solución:

xor4 :: Bool -> Bool -> Bool

xor4 x y = (x && not y) || (y && not x)

-- 5ª solución:

xor5 :: Bool -> Bool -> Bool

xor5 x y = x /= y

-- Comprobación de equivalencia

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

-- La propiedad es

prop_xor :: Bool -> Bool -> Bool

prop_xor x y =

all (== xor1 x y)

[xor2 x y,

xor3 x y,

xor4 x y,

xor5 x y]

-- La comprobación es

-- λ> quickCheck prop_xor

-- +++ OK, passed 100 tests.

El código se encuentra en GitHub.

Soluciones en Python

from hypothesis import given, strategies as st

# 1ª solución
def xor1(x, y):
    match x, y:
        case True,  True: return False
        case True,  False: return True
        case False, True: return True
        case False, False: return False

# 2ª solución
def xor2(x: bool, y: bool) -> bool:
    if x:
        return not y
    return y

# 3ª solución
def xor3(x: bool, y: bool) -> bool:
    return (x or y) and not(x and y)

# 4ª solución
def xor4(x: bool, y: bool) -> bool:
    return (x and not y) or (y and not x)

# 5ª solución
def xor5(x: bool, y: bool) -> bool:
    return x != y

# La propiedad de equivalencia es
@given(st.booleans(), st.booleans())
def test_equiv_xor(x, y):
    assert xor1(x, y) == xor2(x, y) == xor3(x, y) == xor4(x, y) == xor5(x, y)

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

from hypothesis import given, strategies as st

# 1ª solución

def xor1(x, y):

match x, y:

case True, True: return False

case True, False: return True

case False, True: return True

case False, False: return False

# 2ª solución

def xor2(x: bool, y: bool) -> bool:

if x:

return not y

return y

# 3ª solución

def xor3(x: bool, y: bool) -> bool:

return (x or y) and not(x and y)

# 4ª solución

def xor4(x: bool, y: bool) -> bool:

return (x and not y) or (y and not x)

# 5ª solución

def xor5(x: bool, y: bool) -> bool:

return x != y

# La propiedad de equivalencia es

@given(st.booleans(), st.booleans())

def test_equiv_xor(x, y):

assert xor1(x, y) == xor2(x, y) == xor3(x, y) == xor4(x, y) == xor5(x, y)

# La comprobación es

# src> poetry run pytest -q disyuncion_excluyente.py

# 1 passed in 0.11s

El código se encuentra en GitHub.

Comentarios

La negación de x se escribe igual en Haskell y Python; not x
La disyunción de x e y se escribe
- en Haskell, como x || y y
- en Python, como x or y.

Meses: septiembre 2022

Intercambio de componentes de un par

Mayor rectángulo

Disyunción excluyente

Entradas recientes

Buscar

Correo electrónico