Menu Close

Mes: agosto 2022

Segmento de una lista

Definir la función

   segmento :: Int -> Int -> [a] -> [a]

tal que (segmento m n xs) es la lista de los elementos de xs comprendidos entre las posiciones m y n. Por ejemplo,

   segmento 3 4 [3,4,1,2,7,9,0]  ==  [1,2]
   segmento 3 5 [3,4,1,2,7,9,0]  ==  [1,2,7]
   segmento 5 3 [3,4,1,2,7,9,0]  ==  []

Soluciones

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


Soluciones en Haskell

segmento :: Int -> Int -> [a] -> [a]
segmento m n xs = drop (m-1) (take n xs)

El código se encuentra en GitHub.


Soluciones en Python

from typing import TypeVar
 
from hypothesis import given
from hypothesis import strategies as st
 
A = TypeVar('A')
 
# 1ª definición
def segmento1(m: int, n: int, xs: list[A]) -> list[A]:
    ys = xs[:n]
    if m == 0:
        return ys
    return ys[m - 1:]
 
# 2ª definición
def segmento2(m: int, n: int, xs: list[A]) -> list[A]:
    if m == 0:
        return xs[:n]
    return xs[m-1:n]
 
# La propiedad de equivalencia es
@given(st.integers(min_value=0),
       st.integers(min_value=0),
       st.lists(st.integers()))
def test_equiv_segmento(m: int, n: int, xs: list[int]) -> None:
    assert segmento1(m, n, xs) == segmento2(m, n, xs)
 
# La comprobación es
#    src> poetry run pytest -q segmento_de_una_lista.py
#    1 passed in 0.19s

El código se encuentra en GitHub.

Elementos finales

Definir la función

   finales :: Int -> [a] -> [a]

tal que (finales n xs) es la lista formada por los n finales elementos de xs. Por ejemplo,

   finales 3 [2,5,4,7,9,6]  ==  [7,9,6]

Soluciones

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


Soluciones en Haskell

import Test.QuickCheck
 
-- 1ª definición
finales1 :: Int -> [a] -> [a]
finales1 n xs = drop (length xs - n) xs
 
-- 2ª definición
finales2 :: Int -> [a] -> [a]
finales2 n xs = reverse (take n (reverse xs))
 
-- Comprobación de equivalencia
-- ============================
 
-- La propiedad es
prop_finales :: Int -> [Int] -> Bool
prop_finales n xs =
  finales1 n xs == finales2 n xs
 
-- La comprobación es
--    λ> quickCheck prop_finales
--    +++ OK, passed 100 tests.

El código se encuentra en GitHub


Soluciones en Python

from typing import TypeVar
from hypothesis import given, strategies as st
 
A = TypeVar('A')
 
# 1ª definición
def finales1(n: int, xs: list[A]) -> list[A]:
    if len(xs) <= n:
        return xs
    return xs[len(xs) - n:]
 
# 2ª definición
def finales2(n: int, xs: list[A]) -> list[A]:
    if n == 0:
        return []
    return xs[-n:]
 
# 3ª definición
def finales3(n: int, xs: list[A]) -> list[A]:
    ys = list(reversed(xs))
    return list(reversed(ys[:n]))
 
# La propiedad de equivalencia es
@given(st.integers(min_value=0), st.lists(st.integers()))
def test_equiv_finales(n, xs):
    assert finales1(n, xs) == finales2(n, xs) == finales3(n, xs)
 
# La comprobación es
#    src> poetry run pytest -q elementos_finales.py
#    1 passed in 0.18s

El código se encuentra en GitHub

Comentarios

  • La longitud de la lista xs se calcula
    • en Haskell, con length xs y
    • en Python, con len(xs).

Interior de una lista

Definir la función

   interior :: [a] -> [a]

tal que (interior xs) es la lista obtenida eliminando los extremos de la lista xs. Por ejemplo,

   interior [2,5,3,7,3]  ==  [5,3,7]
   interior [2..7]       ==  [3,4,5,6]

Soluciones

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


Soluciones en Haskell

interior :: [a] -> [a]
interior xs = tail (init xs)

El código se encuentra en GitHub.


Soluciones en Python

from typing import TypeVar
from hypothesis import given, strategies as st
 
A = TypeVar('A')
 
# 1ª solución
def interior1(xs: list[A]) -> list[A]:
    return xs[1:][:-1]
 
# 2ª solución
def interior2(xs: list[A]) -> list[A]:
    return xs[1:-1]
 
# La propiedad de equivalencia es
@given(st.lists(st.integers()))
def test_triangular(xs):
    assert interior1(xs) == interior2(xs)
 
# La comprobación es
#    src> poetry run pytest -q interior_de_una_lista.py
#    1 passed in 0.21s

El código se encuentra en GitHub.

Comentarios

  • Los elementos iniciales de una lista xs se calcula
    • en Haskell, con init xs y
    • en Python, con xs[:-1].

Reconocimiento de palíndromos

Definir la función

   palindromo :: Eq a => [a] -> Bool

tal que (palindromo xs) se verifica si xs es un palíndromo; es decir, es lo mismo leer xs de izquierda a derecha que de derecha a izquierda. Por ejemplo,

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

Soluciones

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


Soluciones en Haskell

palindromo :: Eq a => [a] -> Bool
palindromo xs =
  xs == reverse xs

El código se encuentra en GitHub.


Soluciones en Python

from typing import TypeVar
 
A = TypeVar('A')
 
def palindromo(xs: list[A]) -> bool:
    return xs == list(reversed(xs))

El código se encuentra en GitHub.

Comentarios

  • La inversa de la lista xs se calcula
    • en Haskell, con reverse xs y
    • en Python, con list(reversed(xs)).
  • Para comparar la igualdad de dos listas xs e ys se escribe igual qh Haskell y en Python: xs == ys.

Rango de una lista

Definir la función

   rango :: [Int] -> [Int]

tal que (rango xs) es la lista formada por el menor y mayor elemento de xs. Por ejemplo,

   rango [3,2,7,5]  ==  [2,7]

Soluciones

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


Soluciones en Haskell

rango :: [Int] -> [Int]
rango xs = [minimum xs, maximum xs]

El código se encuentra en GitHub.


Soluciones en Python

def rango(xs: list[int]) -> list[int]:
    return [min(xs), max(xs)]

El código se encuentra en GitHub.

Comentarios

  • El menor elemento de la lista xs se calcula
    • en Haskell, con minimum xs y
    • en Python, con min(xs).
  • El mayor elemento de la lista xs se calcula
    • en Haskell, con maximum xs y
    • en Python, con max(xs).