Ir al contenido principal

El primero al final

Definir la función

   rota1 :: [a] -> [a]

tal que (rota1 xs) es la lista obtenida poniendo el primer elemento de xs al final de la lista. Por ejemplo,

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

Soluciones

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

Soluciones en Haskell

import Test.QuickCheck

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

rota1a :: [a] -> [a]
rota1a [] = []
rota1a xs = tail xs ++ [head xs]

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

rota1b :: [a] -> [a]
rota1b []     = []
rota1b (x:xs) = xs ++ [x]

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

-- La propiedad es
prop_rota1 :: [Int] -> Bool
prop_rota1 xs =
  rota1a xs == rota1b xs

-- La comprobación es
--    λ> quickCheck prop_rota1
--    +++ 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ª solución
def rota1a(xs: list[A]) -> list[A]:
    if xs == []:
        return []
    return xs[1:] + [xs[0]]

# 2ª solución
def rota1b(xs: list[A]) -> list[A]:
    if xs == []:
        return []
    ys = xs[1:]
    ys.append(xs[0])
    return ys

# 3ª solución
def rota1c(xs: list[A]) -> list[A]:
    if xs == []:
        return []
    y, *ys = xs
    return ys + [y]

# La equivalencia de las definiciones es
@given(st.lists(st.integers()))
def test_rota1(xs: list[int]) -> None:
    assert rota1a(xs) == rota1b(xs) == rota1c(xs)

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

El código se encuentra en GitHub.

Comentarios

  • El primer elemento de la lista xs se calcula
  • en Haskell, con head xs
  • en Python, con xs[0]
  • El resto de la lista xs se calcula
  • en Haskell, con tail xs
  • en Python, con xs[1:]
  • La concatenación de las listas xse ysse calcula
  • en Haskell, con xs ++ ys
  • en Python, con xs + ys
  • En Python. xs.append(x) modifica la lista xs añadiéndole x al final. Por ejemplo,
>>> xs = [3, 2, 5]
>>> xs.append(1)
>>> xs
[3, 2, 5, 1]