Utilizando el tipo abstracto de datos de las colas, definir las funciones
algunoVerifica :: (a -> Bool) -> Cola a -> Bool
tal que algunoVerifica p c se verifica si alguno de los elementos de la cola c cumplen la propiedad p. Por ejemplo,
algunoVerifica (< 0) (inserta 3 (inserta (-2) vacia)) == True algunoVerifica (< 0) (inserta 3 (inserta 2 vacia)) == False
Utilizando el tipo abstracto de datos de las colas, definir las funciones
todosVerifican :: (a -> Bool) -> Cola a -> Bool
tal que todosVerifican p c se verifica si todos los elementos de la cola c cumplen la propiedad p. Por ejemplo,
todosVerifican (>0) (inserta 3 (inserta 2 vacia)) == True todosVerifican (>0) (inserta 3 (inserta (-2) vacia)) == False
Utilizando el tipo abstracto de datos de las colas, definir las funciones
longitudCola :: Cola a -> Int
tal que longitudCola c es el número de elementos de la cola c. Por ejemplo,
longitudCola (inserta 4 (inserta 2 (inserta 5 vacia))) == 3
Utilizando el tipo abstracto de datos de las colas, definir las funciones
ultimoCola :: Cola a -> a
tal que ultimoCola c es el último elemento de la cola c. Por ejemplo,
ultimoCola (inserta 3 (inserta 5 (inserta 2 vacia))) == 3 ultimoCola (inserta 2 vacia) == 2
Utilizando el tipo abstracto de datos de las colas, definir las funciones
listaAcola :: [a] -> Cola a colaAlista :: Cola a -> [a]
tales que
listaAcola xs es la cola formada por los elementos de xs. Por ejemplo,λ> listaAcola [3, 2, 5] 3 | 2 | 5
colaAlista c es la lista formada por los elementos de la cola c. Por ejemplo,λ> colaAlista (inserta 5 (inserta 2 (inserta 3 vacia))) [3, 2, 5]
Comprobar con QuickCheck que ambas funciones son inversa; es decir,
colaAlista (listaAcola xs) = xs listaAcola (colaAlista c) = c
Una cola es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción se realiza por un extremo (el posterior o final) y la operación de extracción por el otro (el anterior o frente).
Las operaciones que definen a tipo abstracto de datos (TAD) de las colas (cuyos elementos son del tipo a) son las siguientes:
vacia :: Cola a inserta :: a -> Cola a -> Cola a primero :: Cola a -> a resto :: Cola a -> Cola a esVacia :: Cola a -> Bool
tales que
Las operaciones tienen que verificar las siguientes propiedades:
Utilizando el tipo abstracto de datos de las pilas, definir la función
maxPila :: Ord a => Pila a -> a
tal que maxPila p sea el mayor de los elementos de la pila p. Por ejemplo,
λ> maxPila (apila 3 (apila 5 (apila 1 vacia))) 5
Utilizando el tipo abstracto de datos de las pilas, definir la función
nubPila :: Eq a => Pila a -> Pila a
tal que nubPila p es la pila con los elementos de p sin repeticiones. Por ejemplo,
λ> nubPila (apila 3 (apila 1 (apila 3 (apila 5 vacia)))) 1 | 3 | 5
Utilizando el tipo abstracto de datos de las pilas, definir la función
ordenaInserPila :: Ord a => Pila a -> Pila a
tal que ordenaInserPila p es la pila obtenida ordenando por inserción los los elementos de la pila p. Por ejemplo,
λ> ordenaInserPila (apila 4 (apila 1 (apila 3 vacia))) 1 | 3 | 4
Comprobar con QuickCheck que la pila (ordenaInserPila p) está ordenada.
Utilizando el tipo abstracto de datos de las pilas, definir la función
ordenadaPila :: Ord a => Pila a -> Bool
tal que ordenadaPila p se verifica si los elementos de la pila p están ordenados en orden creciente. Por ejemplo,
ordenadaPila (apila 1 (apila 5 (apila 6 vacia))) == True ordenadaPila (apila 1 (apila 0 (apila 6 vacia))) == False