Utilizando el tipo abstracto de datos de los conjuntos definir la función
union :: Ord a => Conj a -> Conj a -> Conj a
tal union c1 c2 es la unión de ambos conjuntos. Por ejemplo,
λ> ej1 = inserta 3 (inserta 5 vacio) λ> ej2 = inserta 4 (inserta 3 vacio) λ> union ej1 ej2 {3, 4, 5}
Utilizando el tipo abstracto de datos de los conjuntos definir la función
cardinal :: Conj a -> Int
tal que cardinal c es el número de elementos del conjunto c. Por ejemplo,
cardinal (inserta 4 (inserta 5 vacio)) == 2 cardinal (inserta 4 (inserta 5 (inserta 4 vacio))) == 2
Utilizando el tipo abstracto de datos de los conjuntos definir la función
unitario :: Ord a => a -> Conj a
tal que unitario x es el conjunto {x}. Por ejemplo,
unitario 5 == {5}
Utilizando el tipo abstracto de datos de los conjuntos definir la función
subconjuntoPropio :: Ord a => Conj a -> Conj a -> Bool
tal subconjuntoPropio c1 c2 se verifica si c1 es un subconjunto propio de c2. Por ejemplo,
λ> ej1 = inserta 5 (inserta 2 vacio) λ> ej2 = inserta 3 (inserta 2 (inserta 5 vacio)) λ> ej3 = inserta 3 (inserta 4 (inserta 5 vacio)) λ> ej4 = inserta 2 (inserta 5 vacio) λ> subconjuntoPropio ej1 ej2 True λ> subconjuntoPropio ej1 ej3 False λ> subconjuntoPropio ej1 ej4 False
Utilizando el tipo abstracto de datos de los conjuntos definir la función
subconjunto :: Ord a => Conj a -> Conj a -> Bool
tal que subconjunto c1 c2 se verifica si todos los elementos de c1 pertenecen a c2. Por ejemplo,
λ> ej1 = inserta 5 (inserta 2 vacio) λ> ej2 = inserta 3 (inserta 2 (inserta 5 vacio)) λ> ej3 = inserta 3 (inserta 4 (inserta 5 vacio)) λ> subconjunto ej1 ej2 True λ> subconjunto ej1 ej3 False
Utilizando el tipo abstracto de datos de los conjuntos definir las funciones
listaAconjunto :: [a] -> Conj a conjuntoAlista :: Conj a -> [a]
tales que
listaAconjunto xs es el conjunto formado por los elementos de xs. Por ejemplo,λ> listaAconjunto [3, 2, 5] {2, 3, 5}
conjuntoAlista c es la lista formada por los elementos del conjunto c. Por ejemplo,λ> conjuntoAlista (inserta 5 (inserta 2 (inserta 3 vacio))) [2,3,5]
Comprobar con QuickCheck que ambas funciones son inversa; es decir,
conjuntoAlista (listaAconjunto xs) = sort (nub xs) listaAconjunto (conjuntoAlista c) = c
Un conjunto es una estructura de datos, caracterizada por ser una colección de elementos en la que no importe ni el orden ni la repetición de elementos.
Las operaciones que definen al tipo abstracto de datos (TAD) de los conjuntos (cuyos elementos son del tipo a) son las siguientes:
vacio :: Conj a inserta :: Ord a => a -> Conj a -> Conj a menor :: Ord a => Conj a -> a elimina :: Ord a => a -> Conj a -> Conj a pertenece :: Ord a => a -> Conj a -> Bool esVacio :: Conj a -> Bool
tales que
Las operaciones tienen que verificar las siguientes propiedades:
Utilizando el tipo abstracto de datos de las colas, definir las funciones
maxCola :: Ord a => Cola a -> a
tal que maxCola c sea el mayor de los elementos de la cola c. Por ejemplo,
λ> maxCola (inserta 3 (inserta 5 (inserta 1 vacia))) 5
Utilizando el tipo abstracto de datos de las colas, definir las funciones
ordenadaCola :: Ord a => Cola a -> Bool
tal que ordenadaCola c se verifica si los elementos de la cola c están ordenados en orden creciente. Por ejemplo,
ordenadaCola (inserta 6 (inserta 5 (inserta 1 vacia))) == True ordenadaCola (inserta 1 (inserta 0 (inserta 6 vacia))) == False
Utilizando el tipo abstracto de datos de las colas, definir las funciones
subCola :: Eq a => Cola a -> Cola a -> Bool
tal que subCola c1 c2 se verifica si c1 es una subcola de c2. Por ejemplo,
λ> ej1 = inserta 2 (inserta 3 vacia) λ> ej2 = inserta 7 (inserta 2 (inserta 3 (inserta 5 vacia))) λ> ej3 = inserta 2 (inserta 7 (inserta 3 (inserta 5 vacia))) λ> subCola ej1 ej2 True λ> subCola ej1 ej3 False