module Ejercicios where

import Data.Char;
--Hoja 1
--a)
ordenados::Int->Int->Int->Bool
ordenados x y z = if x<=y && y<=z then True else False
--b)
ordenar3::Int->Int->Int->(Int,Int,Int)
ordenar3 x y z
| ordenados x y z = (x,y,z)
| x<=y && y>=z && x<=z = (x,z,y)
| z<=y && y<=x = (z,y,x)
| z<=y && y>=x = (z,x,y)
| x>=y && y<=z && x>=z = (y,z,x)
| otherwise = (y,x,z)
--c)
circ::Float->(Float,Float)
circ r = let pir = r*3.14 in (2*pir,pir*r)
circ'::Float->(Float,Float)
circ' r = (2*pir,pir*r) where pir=r*3.14
--d)
concatenar::[[a]]->[a]
concatenar xs = [x| sublista<-xs, x<-sublista]
--e)
factores::Int->[Int]
factores x = [n | n<-[1..x], x `mod` n==0]
--f)
esprimo::Int->Bool
esprimo x = factores x == [1,x]
esprimo'::Int->Bool
esprimo' x = length(factores x)==2
--g)
nummayus::String->Int
nummayus css = length [x | x<-css, isUpper x]
-- isUpper tequiere importar Data.Char;
nummayus'::String->Int
nummayus' css = length [c | c<-css, c `elem` ['A'..'Z']]
-- Estas dos ultimas funciones cuentan todas las apariciones de maysculas

nummayus''::String->Int
nummayus'' css = length [x | x<-['A'..'Z'], x `elem` css]
-- Esta funcin Cuenta una sola aparicin de cada mayscula da igual que se repita
--h)
retornaprimero::((String,Int),(String,Int),(String,Int))->(String,String,String)
retornaprimero ((s1,x),(s2,y),(s3,z)) = (s1,s2,s3)
--i)
sumacuatroprimeros::[Int]->Bool
sumacuatroprimeros [] = True
sumacuatroprimeros [a] = a<10
sumacuatroprimeros [a,b] = a+b<10
sumacuatroprimeros [a,b,c] = a+b+c<10
sumacuatroprimeros (a:b:c:d:xs) = a+b+c+d<10
--j)
cardinales:: Char->String
cardinales 'N' = "Norte"
cardinales 'S' = "Sur"
cardinales 'E' = "Este"
cardinales 'O' = "Oeste"
--k)
procesaFrase::String->String
procesaFrase s@(frase) = "La primera letra de la frase ''"++ s ++ "'' es "++ (sh
ow(head s)) ++ " y la ultima letra es " ++ show(last s)
--l)
clasificarValorEntrada::Int->String
clasificarValorEntrada n | n>20 = s ++ "mayor que 20"
| n<10 = s ++ "menor que 10"
| otherwise = s ++ "mayor o igu
al a 10 y menor o igual a 20"
where s = "El valor de entrada
es "
--m)
contarApariciones::String->Char->Int
contarApariciones css c = length [x| x<-css, x==c]
--HOJA 2
--a)
cribar::[Int]->Int->[Int]
cribar xs n = [x| x<-xs, x `mod`n/=0]
--Listas de Compresin
cribar'::[Int]->Int->[Int]
cribar' [] n = []
cribar' (x:xs) n = if x `mod` n==0 then cribar' xs n else x:cribar' xs n

--Recursividad no final
cribar''::[Int]->Int->[Int]
cribar'' xs n = cribarAux xs n []
--Recursividad final o de cola
cribarAux::[Int]->Int->[Int]->[Int]
cribarAux [] n ys = ys
cribarAux (x:xs) n ys = if x `mod` n==0 then cribarAux xs n ys else cribarAux x
s n ys++[x]
-- b)
doble::Int->Int
doble = \x->x+x
-- Una forma con expresiones Lambda
doble'::Int->Int
doble' = \x->x*2
--Otra forma con expresiones Lambda
--c)
sumadobles::[Int]->Int
sumadobles [] = 0
sumadobles (x:xs) = x + x + sumadobles xs
sumadobles'::[Int]->Int
sumadobles' xs = sumadoblesAux xs 0
--Recursividad final o de cola
sumadoblesAux::[Int]->Int->Int
sumadoblesAux [] n = n
sumadoblesAux (x:xs) n = sumadoblesAux xs n+x*2
sumadobles''::[Int]->Int
sumadobles'' xs = foldl (+) 0 (map (*2) xs)
--Utilizando expresiones Lambda o de orden superior
--d)
sumacuadradospares:: [Int]->Int
sumacuadradospares xs = foldl (+) 0 (map (^2) (filter even xs))
--Con filter
sumacuadradospares'::[Int]->Int
sumacuadradospares' xs = foldl (+) 0 [x^2| x<-xs, x `mod` 2==0]
--Con listas de compresin
---e)

primeraAparicion::(Eq a)=>[a]->[(a,Int)]
primeraAparicion [] = []
primeraAparicion xs = primeraAparicionAux xs xs []
primeraAparicionAux::(Eq a)=>[a]->[a]->[a]->[(a,Int)]
primeraAparicionAux [] _ _= []
primeraAparicionAux (x:xs) ys zs = if (not (pertenece zs x)) then [(x, primeraPo
s ys x)] ++ primeraAparicionAux xs ys (zs++[x])
else primeraA
paricionAux xs ys zs
-- Forma por Recursividad no final
primeraAparicion2::(Eq a)=>[a]->[(a,Int)]
primeraAparicion2 [] = []
primeraAparicion2 xs = reverse1 (primeraAparicionAux2 xs xs [] [])
primeraAparicionAux2::(Eq a)=>[a]->[a]->[a]->[(a,Int)]->[(a,Int)]
primeraAparicionAux2 [] _ _ zs = zs
primeraAparicionAux2 (x:xs) xss ys zs = if (not (pertenece ys x)) then primeraAp
aricionAux2 xs xss (ys++[x]) ((x, primeraPos xss x):zs)
else primera
AparicionAux2 xs xss ys zs
-- Forma por Recursividad final o de cola
pertenece::(Eq a)=>[a]->a->Bool
pertenece [] _ = False
pertenece (x:xs) e = if (x==e) then True else pertenece xs e
primeraPos::(Eq a)=>[a]->a->Int
primeraPos (x:xs) e = if (x==e) then 1 else 1 + primeraPos xs e
--f)
ceros::[Int]->Int
ceros xs = cerosAux xs 0 0
cerosAux::[Int]->Int->Int->Int
cerosAux [] n m = m
cerosAux (x:xs) n m |x==0 = cerosAux xs (n+1) m
|(x/=0 && n>m) = cerosAux (desdecero xs)
0 n
|otherwise = cerosAux (desdecero xs) 0 m
ceros'::[Int]->Int
ceros' xs = maximo (cerosAux2 xs 0)
cerosAux2::[Int]->Int->[Int]
cerosAux2 [] n = [n]
cerosAux2 (x:xs) n = if (x==0) then cerosAux2 xs (n+1) else n:cerosAux2 (desdece
ro xs) 0
desdecero::[Int]->[Int]
desdecero [] = []
desdecero (0:xs) = (0:xs)
desdecero (x:xs) = desdecero xs

maximo::[Int]->Int
maximo [x] = x
maximo (x:xs) = if (x>maximo xs) then x else maximo xs
--g)
--Manera 1
repeticiones::[Int]->([Int],[Int])
repeticiones [] = ([],[])
repeticiones xs = (norepes xs, (diferenciaListas xs (repes xs) []))
numApariciones::[Int]->Int->Int
numApariciones [] e = 0
numApariciones (x:xs) e = if x==e then 1 + numApariciones xs e else numAparicion
es xs e
norepes::[Int]->[Int]
norepes [] = []
norepes xs = [x| x<-xs, (numApariciones xs x)==1]
repes::[Int]->[Int]
repes xs = quitarepes [x| x<-xs, (numApariciones xs x)>1]
quitarepes::[Int]->[Int]
quitarepes [] = []
quitarepes [x] = [x]
quitarepes (x:y:xs) = if (x==y) then quitarepes (y:xs) else x:quitarepes (y:xs)
diferenciaListas::[Int]->[Int]->[Int]->[Int]
diferenciaListas _ [] zs = zs
diferenciaListas xs (y:ys) zs = if ((pertenece xs y) && (not (pertenece zs y)))
then diferenciaListas xs ys (zs++[y]) else diferenciaListas xs ys zs
--Recibe 3 listas y mete en la tercera lista los elementos de la segunda lista c
ontenidos en la primera y pero sin repetir
--Manera 2
repeticiones'::[Int]->([Int],[Int])
repeticiones' [] = ([],[])
repeticiones' xs = (norepes xs, (diferenciaListas' xs (norepes xs) []))
diferenciaListas'::[Int]->[Int]->[Int]->[Int]
diferenciaListas' _ [] zs = zs
diferenciaListas' (x:xs) ys zs = if ((not (pertenece ys x)) && (not (pertenece z
s x))) then diferenciaListas' xs ys (zs++[x]) else diferenciaListas' xs ys zs
--Recibe 3 listas y mete en la tercera lista los elementos de la primera lista N
O CONTENIDOS en la segunda y pero sin repetir
--h)
nmayores::[Int]->Int->[Int]
nmayores [] 0 = []
nmayores [] n = []
nmayores xs 0 = []
nmayores xs n = x:nmayores(eliminarElemento xs x) (n-1) where x= maximo xs

nmayores'::[Int]->Int->[Int]
nmayores' xs n = cogeN (reverse (ordenar xs)) n
cogeN::[a]->Int->[a]
cogeN xs 0 = []
cogeN [] n = []
cogeN (x:xs) n = x:cogeN xs (n-1)
--En vez de usar la funcin cogeN se puede usar la funcin predefinida take n
--i)
incluye::(Eq a)=>[a]->[a]->Bool
incluye [] _ = True
incluye (x:xs) [] = False
incluye xs (y:ys) = if (xs==cogeN (y:ys) (length xs)) then True else incluye xs
ys
--Priemra forma cogiendo los n primeros elementos de laaa lista (siendo n la lon
gitud de la lista) y comprobar si es igual a la lista
--Si no coger los n primeros siguentes
incluye'::(Eq a)=>[a]->[a]->Bool
incluye' [] _ = True
incluye' xs ys = incluyeAux xs ys xs ys
incluyeAux::(Eq a)=>[a]->[a]->[a]->[a]->Bool
incluyeAux [] _ _ _ = True
incluyeAux _ [] _ _ = False
incluyeAux (x:xs) (y:ys) xs1 (y1:ys1) = if (x==y) then incluyeAux xs ys xs1 (y1:
ys1)
else incluyeAux xs1 ys1 xs1 ys1
-- Segunda forma con copia de la listas ya que no se puede volver atrs con la rec
ursividad
--j)
ordenar::[Int]->[Int]
ordenar [] = []
ordenar xs = x:ordenar (eliminarElemento xs x) where x= minimo xs
minimo::[Int]->Int
minimo [x] = x
minimo (x:xs) = if x<minimo xs then x else minimo xs
eliminarElemento::[Int]->Int->[Int]
eliminarElemento [] e = []
eliminarElemento (x:xs) e = if (x==e) then xs else x:eliminarElemento xs e
--k)
mezclarEnTernas::[a]->[b]->[(a,b,b)]
mezclarEnTernas [] [] = []
mezclarEnTernas [x] [] = []
mezclarEnTernas (x:xs) [y] = []
mezclarEnTernas [] (y:ys) = []

mezclarEnTernas (x:xs) (y1:y2:ys) = (x,y1,y2):mezclarEnTernas xs ys

--l)
alFinal::a->[a]->[a]
alFinal e [] = [e]
alFinal e xs = xs++[e]
--m)
zipWith'::(a->b->c)->[a]->[b]->[c]
zipWith' f [] [] = []
zipWith' f [] _ = []
zipWith' f _ [] = []
zipWith' f (x:xs) (y:ys) = (f x y):zipWith' f xs ys
--n)
reverse1::[a]->[a]
reverse1 [] = []
reverse1 [x] = [x]
reverse1 xs = last xs:reverse1' (init xs)
reverse1'::[a]->[a]
reverse1' [] = []
reverse1' [x] = [x]
reverse1' xs = reverseAux xs []
reverseAux::[a]->[a]->[a]
reverseAux [] ys = ys
reverseAux (x:xs) ys = reverseAux xs ([x]++ys)
reverse1''::[a]->[a]
reverse1'' = foldr (\x lista-> lista++[x]) []
--o)
reverse2::[[a]]->[[a]]
reverse2 [] = []
reverse2 xs = reverse1(last xs):reverse2 (init xs)
reverse2'::[[a]]->[[a]]
reverse2' [] = []
reverse2' (x:xs) = reverse2' xs ++ [reverse1 x]
--p)
flip'::(a->b->c)->b->a->c
flip' f x y = f y x
--q)
map'::(a->b)->[a]->[b]
map' f [] = []
map' f (x:xs) = (f x):map' f xs
--Hoja de Plegado de Listas

{- No no sera correcta, sera esta ya que esta funcin lo que hace es concatenar
una lista de listas en una sola lista -}
invertirLista::[[a]]->[a]
invertirLista = foldr (++) []
f::[a]->[a]
f = foldr (\a b-> a:b)[]
--Devuelve la misma lista que se le pasa
f1::[a]->[[a]]
f1 = foldr (\a b->[a]:b)[]
--Recibe una lista y devuelve una lista de listas con cada elemento de la lista
f2::[Int]->[Int]
f2 = foldl (\a b-> if b==2 then 0:a else b:a)[]
--Recibe una lista y devuelve la lista invertida con todos los 2 sustituidos por
0
f3::[a]->[a]
f3 = foldl (\a b-> b:a)[]
--Esta mal hay que cambiar a por b, as invierte la lista
incognita::[Int]->[[Int]]
incognita lista = foldl (\(y:z:xs) x -> if odd x then [y++[x],z] else [y,z++[x]]
)[[],[]] lista
{- Recibe una lista y devuelve una lista de 2 listas con losnumeros impares
en la primera lista y los pares en la 2 -}
sumadob::[Int]->Int
sumadob xs = foldl (+) 0 (map (*2) xs)
sumadob'::[Int]->Int
sumadob' xs = foldl (+) 0 (foldl (\lista x-> lista ++ [x*2]) [] xs)
--Sustituyendo map por la funcin de plegado o lo que es lo mismo plegando o recor
riendo 2 veces la funcin
sumacuad::[Int]->Int
sumacuad xs = foldl (+) 0 (map (^2) xs)
sumacuad'::[Int]->Int
sumacuad' xs = foldl (+) 0 (foldl (\lista x-> lista ++ [x*x]) [] xs)
--Sustituyendo map por la funcin de plegado o lo que es lo mismo plegando o recor
riendo 2 veces la funcin
inserta::[Int]->Int->[Int]
inserta xs e = foldr (\x lista-> [x]++lista) [e] xs
elimina::[Int]->Int->[Int]
elimina xs e = foldr (\x lista-> if x/=e then [x]++lista else lista) [] xs
--Hoja Adicional de Listas

-- a)
sacaEnteros::[Int]->[Int]
sacaEnteros [] = []
sacaEnteros (x:xs) = if x/=0 then x:sacaEnteros xs else []
--b)
parteLista::[Int]->[[Int]]
parteLista [] = []
parteLista (0:xs) = []++parteLista xs
parteLista (x:xs) = [[x]++cogepositivos xs]++parteLista (avanza xs)
cogepositivos::[Int]->[Int]
cogepositivos [] = []
cogepositivos(0:xs) = []
cogepositivos (x:xs) = x:cogepositivos xs
avanza::[Int]->[Int]
avanza [] = []
avanza (0:xs) = xs
avanza (x:xs) = avanza xs
-- c)
segmentos::[a]->[[a]]
segmentos [] = []
segmentos xs = segmentosAux xs 0
segmentosAux::[a]->Int->[[a]]
segmentosAux xs l = if (l<=length xs) then cogeN xs l:segmentosAux xs (l+1) else
[]
-- d)
dobles::[Int]->[Int]
dobles [] = []
dobles (x:xs) = x*2:dobles xs
dobles'::[Int]->[Int]
dobles' xs = doblesAux xs []
doblesAux::[Int]->[Int]->[Int]
doblesAux [] ys = ys
doblesAux (x:xs) ys = doblesAux xs ([x]++ys)
dobles''::[Int]->[Int]
dobles'' = map (*2)
dobles'''::[Int]->[Int]
dobles''' = map (\x->x*2)
-- e)
quicksort::(Ord a)=>[a]->[a]
quicksort [] = []
quicksort [x] = [x]
quicksort xs = quicksort ([x| x<-xs, x<y]) ++ ([x| x<-xs, x==y]) ++ quicksort ([
x| x<-xs, x>y]) where y = xs!!((length xs) `div` 2)

-- Algoritmo de ordenacion quicksort mediante un pivote en el medio de la lista

o sublista
quicksort'::(Ord a)=>[a]->[a]
quicksort' [] = []
quicksort' [x] = [x]
quicksort' (p:xs) = quicksort' ([x| x<-xs, x<p]) ++ [p] ++ quicksort' ([x| x<-xs
, x>=p])
-- Algoritmo de ordenacion quicksort mediante un pivote al principio de la lista
o sublista
--Hoja 3
type Numerador = Float
type Denominador = Float
equivalentes::[(Numerador,Denominador)]->(Numerador,Denominador)->[(Numerador,De
nominador)]
equivalentes ((a,b):xs) (c,d) = if (a/b)==(c/d) then (a,b):equivalentes xs (c,d)
else equivalentes xs (c,d)
data Racional = R (Numerador, Denominador) deriving Show
equivalentes'::[Racional]->Racional->[Racional]
equivalentes' [] _ = []
equivalentes' ((R (a,b)):xs) (R (c,d)) = if (a/b)==(c/d) then (R(a,b)):equivale
ntes' xs (R (c,d))
else equivalentes' xs (R (c,d))
type Punto = (Float,Float)
data PuntoCardinal = Norte | Sur | Este | Oeste
mover::PuntoCardinal->Punto->Punto
mover Este (x,y) = (x+1,y)
mover Oeste (x,y) = (x-1,y)
mover Norte (x,y) = (x,y+1)
mover Sur (x,y) = (x,y-1)
masAlSur::Punto->Punto->Punto
masAlSur (x,y) (x1,y1) = if (y<y1) then (x,y) else (x1,y1)
distancia::Punto->Punto->Float
distancia (x,y) (x1,y1) = sqrt (((x-x1)^2) + ((y-y1)^2))
camino::Punto->[PuntoCardinal]->[Punto]
camino _ [] = []
camino (x,y) (p:xs) = (punto:camino punto xs) where punto = mover p (x,y)
data Temperatura = Celsius Float | Fahrenheit Float deriving Show
convert::Temperatura->Temperatura
convert (Celsius c) = Fahrenheit (c * 9/5 + 32)
convert (Fahrenheit f) = Celsius ((f-32) * (5/9))
data Accion = On| Off deriving Show

action::Temperatura->Accion
action (Celsius c) = if (c>28) then On else Off
action (Fahrenheit f) = action (convert (Fahrenheit f))
data Moneda = Dolar Float | Euro Float deriving Show
conversion::Moneda->Moneda
conversion (Dolar d) = Euro (d*1.14)
conversion (Euro e) = Dolar (e/1.14)
data Expr = Valor Integer | Expr :+: Expr |Expr :-: Expr | Expr :*: Expr derivi
ng Show
calcula::Expr->Integer
calcula (Valor v) = v
calcula (e :+: e1) = calcula (e) + calcula (e1)
calcula (e :-: e1) = calcula (e) - calcula (e1)
calcula (e :*: e1) = calcula (e) * calcula (e1)
constantes::Expr->Int
constantes (Valor v) = 1
constantes (e :+: e1) = constantes (e) + constantes (e1)
constantes (e :-: e1) = constantes (e) + constantes (e1)
constantes (e :*: e1) = constantes (e) + constantes (e1)
data Arbol a = AV | Rama (Arbol a) a (Arbol a) deriving Show
espejo::Arbol a->Arbol a
espejo AV = AV
espejo (Rama i r d) = Rama (espejo d) r (espejo i)
-- a)
data Dia = Lunes |Martes |Miercoles |Jueves |Viernes |Sabado | Domingo deriving
Show
-- b)
laborable::Dia->Bool
laborable Sabado = False
laborable Domingo = False
laborable _ = True
-- c)
qsort::(Ord a)=>[a]->[a]
qsort (p:xs) = [x| x<-xs, x<p] ++ [p] ++ [x| x<-xs, x>=p]
-- d)
divisiones::(Integral a)=>a->[a]->[Maybe a]
divisiones n [] = []
divisiones n (0:xs) = Nothing:divisiones n xs
divisiones n (x:xs) = Just d:divisiones n xs
where d = n `div` x
-- d)

mostrarArbol::(Show a)=>Arbol a->String

mostrarArbol AV = ""
mostrarArbol (Rama AV r AV) = show r
mostrarArbol (Rama i r d) = "(" ++ mostrarArbol i ++ ")" ++ "|-" ++ show r ++ "|" ++ "(" ++ mostrarArbol d ++ ")"
-- Sera equivalente a declarar el nuevo tipo de datos Arbol como una instancia de
la clase Show?
-- No, ya que imprime el arbol tal como est en el constructor de datos
-- e)
type Nombre = String
data Titulacion = GradoII | GradoADE| GradoADE_II deriving (Eq,Show)
data Estudiante = Estu (Nombre,Titulacion)
data ListaMatriculados = ListaMatriculados [Estudiante] deriving Show
data ListaAsociaciones = ListaAsociaciones [Estudiante] deriving Show
instance Eq Estudiante where
(Estu (n,t)) == (Estu (n1,t1)) = (n==n1) && (t==t1)
(Estu (n,t)) /= (Estu (n1,t1)) = (n/=n1) || (t/=t1)
perteneceEstudiante::Estudiante->ListaAsociaciones->Bool
perteneceEstudiante e (ListaAsociaciones []) = False
perteneceEstudiante e (ListaAsociaciones (x:xs)) = (e==x) || perteneceEstudiante
e (ListaAsociaciones xs)
instance Show Estudiante where
show (Estu (n,t)) = n ++ "," ++ show t
mostrarAlumnosAsociaciones::(ListaMatriculados,ListaAsociaciones)->String
mostrarAlumnosAsociaciones ((ListaMatriculados []), _) = ""
mostrarAlumnosAsociaciones ((ListaMatriculados (x:xs)),(ListaAsociaciones ys)) =
if perteneceEstudiante x
(ListaAsociaciones ys) then "(" ++ show x ++ ")" ++ mostrarAlumnosAsociaciones
((ListaMatriculados xs), (ListaAsociaciones ys))
else mostrarAlumnosAsoci
aciones ((ListaMatriculados xs),(ListaAsociaciones ys))
listaMatriculados::ListaMatriculados
listaMatriculados = ListaMatriculados [Estu("Carlos Calle",GradoADE_II), Estu ("
Irene Plaza",GradoADE), Estu ("Juan Lopez",GradoII), Estu ("Diana Perez",GradoA
DE)]
listaAsociaciones::ListaAsociaciones
listaAsociaciones = ListaAsociaciones [Estu ("Carlos Calle",GradoADE_II), Estu (
"Irene Plaza",GradoADE)]
-- f)
data Fecha = Fech Int Int Int
instance Show Fecha where
show (Fech a b c) = show a++ "/" ++ show b ++"/" ++ show c

-- g )
mismaFecha::Fecha->Fecha->Bool
mismaFecha (Fech d m a) (Fech d1 m1 a1) = (d==d1) && (m==m1) && (a==a1)
-- h)
instance Eq Fecha where
(Fech d m a) == (Fech d1 m1 a1) = (d==d1) && (m==m1) && (a==a1)
(Fech d m a) /= (Fech d1 m1 a1) = (d/=d1) || (m/=m1) || (a/=a1)
instance Ord Fecha where
(Fech d m a) > (Fech d1 m1 a1) = if (a>a1) then True
else if (a==a1) && (m>m1) then True
else if (a==a1) && (m==m1) && (d>d1) then True
else False
(Fech d m a) < (Fech d1 m1 a1) = not ((Fech d m a) > (Fech d1 m1 a1))
(Fech d m a) >= (Fech d1 m1 a1) = if (Fech d m a) > (Fech d1 m1 a1) ||
(Fech d m a) == (Fech d1 m1 a1) then True else False
(Fech d m a) <= (Fech d1 m1 a1) = if (Fech d m a) < (Fech d1 m1 a1) ||
(Fech d m a) == (Fech d1 m1 a1) then True else False
qs::[Fecha]->[Fecha]
qs (f:fs) = qs [x| x<-fs, x<f] ++ [f] ++ qs [x| x<-fs, x>=f]
-- i)
class Coleccion c where
esVacia::c a->Bool
insertar::c a->a->c a
primero::c a->a
eliminar::c a->c a
size::c a->Int
data Pila a = Pil [a] deriving Show
data Cola a = Col [a] deriving Show
instance Coleccion Pila where
esVacia (Pil p) = (length p==0)
insertar (Pil p) e = Pil (p++[e])
primero (Pil p) = last p
eliminar (Pil p) = Pil (init p)
size (Pil p) = length p
instance Coleccion Cola where
esVacia (Col c) = (length c==0)
insertar (Col c) e = Col (c++[e])
primero (Col c) = head c
eliminar (Col c) = Col (tail c)
size (Col c) = length c
-- Hoja de Examenes

-- 1)
matriz::[[Int]]->Bool
matriz [] = True
matriz (x:xs) = horizontales (suma(x),x:xs) && verticales(suma(x),x:xs)
horizontales::(Int, [[Int]])->Bool
horizontales (_,[]) = True
horizontales (valor, x:xs) = if suma (x) == valor then horizontales(valor,xs) el
se False
verticales::(Int, [[Int]])->Bool
verticales (_,[]) = True
verticales (valor, m) | (null (dameColumna m)) = True
| (suma (dameColumna m)==valor) = vert
icales(valor,(quitaColumna m))
| otherwise = False
dameColumna::[[Int]]->[Int]
dameColumna [] = []
dameColumna ([]:xs) = dameColumna xs
dameColumna ((y:ys):xs) = y:dameColumna(xs)
quitaColumna::[[Int]] -> [[Int]]
quitaColumna [] = []
quitaColumna (x:xs) = (tail x):quitaColumna(xs)
suma::[Int]->Int
suma [] = 0
suma (x:xs) = x + suma(xs)
-- 2)
type Factor1 = Int
type Factor2 = Int
type Resultado = Int
data Tabla = Tab [(Factor1,Factor2,Resultado)]
instance Show Tabla where
show (Tab [(f1,f2,r)]) = show f1 ++ " x " ++ show f2 ++ " = " ++ show r
show (Tab ((f1,f2,r):(x:xs))) = show f1 ++ " x " ++ show f2 ++ " = " ++
show r ++ "\n" ++ show (Tab (x:xs))
errores::Tabla->String
errores (Tab ((f1,f2,r):xs)) = erroresAux (Tab ((f1,f2,r):xs)) f1 0 False []
erroresAux::Tabla->Int->Int->Bool->[String]->String
erroresAux (Tab []) _ _ False ys = "No hay errores."
erroresAux (Tab []) _ _ True ys = "Hay "++ show (length ys) ++ " errores que son
: " ++ imprimefallos ys
erroresAux (Tab ((p1,p2,r):xs)) f1 f2 b ys = if ((p1/=f1) || (p2/=f2) || (p1*p2/
=r)) then erroresAux (Tab xs) f1 (f2+1) True (ys++[s])
else erroresAux (Tab xs) f1 (f2+1) b ys
where s = show p1 ++ "x" ++ show p2 ++ "=" ++ show r

imprimefallos::[String]->String
imprimefallos [] = []
imprimefallos [s] = s
imprimefallos (sub:s) = sub ++ ", " ++ imprimefallos s
t::Tabla
t = Tab [(3,0,0),(4,1,3),(3,2,6),(3,3,10),(3,4,12),(3,5,15),(3,6,20),(3,7,21),(3
,3,24),(3,9,27),(3,10,30)]
-- 3)
matriz'::[[Int]]-> Bool
matriz' [] = True
matriz' (x:xs) = horizontales' (suma'(x),x:xs) && verticales' (suma'(x),x:xs)
horizontales'::(Int, [[Int]]) -> Bool
horizontales' (_,[]) = True
horizontales' (valor, x:xs) = if suma' (x)==valor then horizontales'(valor,xs) e
lse False
verticales'::(Int, [[Int]]) -> Bool
verticales' (_,[]) = True
verticales' (valor, m) | (null (dameColumna m)) = True
| (suma (dameColumna m)==valor) = ver
ticales'(valor,(quitaColumna m))
| otherwise = False
dameCol::[[Int]] -> [Int]
dameCol [] = []
dameCol ([]:xs) = dameCol xs
dameCol ((y:ys):xs) = y:dameCol(xs)
quitaCol::[[Int]] -> [[Int]]
quitaCol [] = []
quitaCol (x:xs) = tail(x):quitaCol(xs)
suma'::[Int] -> Int
suma' [] = 0
suma' (x:xs) = x + suma(xs)
-- 4)
type Equipo = String
type Resul = (Int,Int)
data Encuentro = Enc Equipo Resul Equipo
type Jornada = [Encuentro]
type Temporada = [Jornada]
data Partido = Ganado | Empatado | Perdido deriving Eq
estadisticas::(Equipo,Temporada)->String
estadisticas (e,[]) = ""
estadisticas (e,xs) = imprimeestadisticas(estadisticasAux e xs (0,0,0))
estadisticasAux::Equipo->Temporada->(Int,Int,Int)->(Int,Int,Int)
estadisticasAux e [] (gan,emp,per) = (gan,emp,per)
estadisticasAux e (x:xs) (gan,emp,per) | ((resultadojornada x e) == Ganado) = e
stadisticasAux e xs ((gan+1),emp,per)
| ((r

esultadojornada x e) == Empatado) = estadisticasAux e xs (gan,(emp+1),per)

| ((r
esultadojornada x e) == Perdido) = estadisticasAux e xs (gan,emp,(per+1))
imprimeestadisticas::(Int,Int,Int)->String
imprimeestadisticas (g,e,p) = "Ganados: " ++show g ++ ", Empatados: " ++ show e
++ ", Perdidos: " ++ show p
resultadojornada::Jornada->Equipo->Partido
resultadojornada ((Enc e1 (r1,r2) e2):xs) e | (e==e1) = resultadoPartido (r1-r2)
| (e==e2) = resultadoPartido (r2-r1)
| otherwise = resultadojornada xs e
resultadoPartido::Int->Partido
resultadoPartido 0 = Empatado
resultadoPartido n = if n>0 then Ganado else Perdido
jornada1::Jornada
jornada1 = [(Enc "R.Madrid" (2,1) "Betis"),(Enc "Atletico de Madrid" (6,1) "Vale
ncia")]
jornada2::Jornada
jornada2 = [(Enc "Valencia" (1,5) "R.Madrid"),(Enc "Betis" (3,3) "Atletico de Ma
drid")]
jornada3::Jornada
jornada3 = [(Enc "Betis" (0,0) "Valencia"),(Enc "R.Madrid" (3,3) "Atletico de Ma
drid")]
madrid::Equipo
madrid = "R.Madrid"
temporada2010_2011::Temporada
temporada2010_2011 = [jornada1,jornada2,jornada3]
-- 5)
recEn_PreOrden::(Eq a)=>[a]->[a]->Arbol a
recEn_PreOrden [] [] = AV
recEn_PreOrden [r] [z] = (Rama AV r AV)
recEn_PreOrden (p:ps) is = (Rama (recEn_PreOrden (take (length xs) ps) xs) p (re
cEn_PreOrden (reverse(take (length (divideDer is p)) (reverse ps))) (divideDer i
s p)))
where xs = divideIzq is p
divideIzq::(Eq a)=>[a]->a->[a]
divideIzq [] _ = []
divideIzq (x:xs) e = if (e==x) then [] else x:divideIzq xs e
divideDer::(Eq a)=>[a]->a->[a]
divideDer [] _ = []
divideDer (x:xs) e = if (e==x) then xs else divideDer xs e
restoLista::(Eq a)=>[a]->[a]->[a]
restoLista [] [] = []

restoLista (x:xs) (y:ys) = if (x==y) then restoLista xs (y:ys) else (x:xs)

-- 6)
erastotenes::Int->[Int]
erastotenes n = erastotenesAux [2..n] 16
erastotenesAux::[Int]->Int->[Int]
erastotenesAux (x:xs) n = if (x^2>n) then (x:xs) else x:(erastotenesAux [e| e<-x
s, e `mod`x /=0] n)
-- 7)
recorridoPreOrden::Arbol a->[a]
recorridoPreOrden AV = []
recorridoPreOrden (Rama AV r AV) = [r]
recorridoPreOrden (Rama i r d) = [r] ++ recorridoPreOrden i ++ recorridoPreOrden
d
-- 8)
hermanos::(Eq a)=>Arbol a->a->a->Bool
hermanos AV n1 n2 = False
hermanos (Rama AV _ _) n1 n2 = False
hermanos (Rama _ _ AV) n1 n2 = False
hermanos (Rama i r d) n1 n2 = ((raiz i==n1) && (raiz d==n2)) || ((raiz i==n2) &&
(raiz d==n1)) || (hermanos i n1 n2) || (hermanos d n1 n2)
raiz::Arbol a->a
raiz (Rama _ r _) = r
-- 9)
type Nombre_Torneo = String
type Finalista = String
type Juego = Int
type Set = (Juego,Juego)
data Torneo = Tor Nombre_Torneo Finalista Finalista [Set] deriving Show
type TemporadaTenis = [Torneo]
instance Eq Torneo where
(Tor n1 _ _ _) == (Tor n2 _ _ _) = n1==n2
(Tor n1 _ _ _) /= (Tor n2 _ _ _) = n1/=n2
instance Ord Torneo where
(Tor n1 _ _ _) > (Tor n2 _ _ _) = n1>n2
(Tor n1 _ _ _) < (Tor n2 _ _ _) = n1<n2
(Tor n1 _ _ _) >= (Tor n2 _ _ _) = n1>=n2
(Tor n1 _ _ _) <= (Tor n2 _ _ _) = n1<=n2
mostrarListadoOrdenadoTorneos::TemporadaTenis->String
mostrarListadoOrdenadoTorneos xs = mostrarListadoOrdenadoTorneosAux (ordMezcla
xs)
-- Se ha utilizado el algoritmo de ordenacin mergersort del ejercicio 11 pero pod
ra haberse utilizado cualquier otro como quicksort o bubblesort
mostrarListadoOrdenadoTorneosAux::TemporadaTenis->String
mostrarListadoOrdenadoTorneosAux [] = ""

mostrarListadoOrdenadoTorneosAux (x:xs) = mostrarTorneo x ++ mostrarListadoOrde

nadoTorneosAux xs
mostrarTorneo::Torneo->String
mostrarTorneo (Tor n f1 f2 xs) = n ++ ", " ++ (ganadorSet f1 f2 xs 0 0) ++ ", en
" ++ show (length xs) ++ " sets. "
ganadorSet::Finalista->Finalista->[Set]->Int->Int->String
ganadorSet f1 f2 [] n m = if n>m then "Ganador: " ++ f1 else "Ganador: " ++ f2
ganadorSet f1 f2 ((j1,j2):xs) n m = if (j1>j2) then ganadorSet f1 f2 xs (n+1) m
else g
anadorSet f1 f2 xs n (m+1)
openAustralia::Torneo
openAustralia = (Tor "Open de Australia" "Novak Djokovic" "Andy Murray" [(6,7),(
7,6),(6,3),(6,2)])
indianWells::Torneo
indianWells = (Tor "Indian Wells" "Juan Martin del Potro" "Rafael Nadal" [(6,4),
(3,6),(4,6)])
mutuaMadridOpen::Torneo
mutuaMadridOpen = (Tor "Mutua Madrid Open" "Rafael Nadal" "Stanislas Wawrinka" [
(6,2),(6,4)])
wimbeldon::Torneo
wimbeldon = (Tor "Wimbeldon" "Novak Djokovic" "Andy Murray" [(6,4),(7,5),(6,4)])
temporada2013::TemporadaTenis
temporada2013 = [openAustralia,indianWells,mutuaMadridOpen,wimbeldon]
-- 10)
data Student = Student {fullname:: String, age:: Integer, qualifications:: [Inte
ger]}
instance Eq Student where
(Student n a qs) == (Student nom e cal) = (n==nom)
(Student n a qs) /= (Student nom e cal) = (n/=nom)
instance Ord Student where
(Student n a qs) > (Student nom e cal)
(Student n a qs) < (Student nom e cal)
(Student n a qs) >= (Student nom e cal)
(Student n a qs) <= (Student nom e cal)

= (n>nom)
= (n<nom)
= (n>=nom)
= (n<=nom)

{- Se ha decidido ordenar los alumnos por su nombre completo pero podra haberse o
redenado por
cualquier otro criterio como su edad o sus calificaciones. Notse que no se ha aadi
do el cdigo que
da el ejercicio para probarlo ya que solo se piden las instancias y el construct
or de datos Tree no coincide con
el correspondiente al de importar la estrutuctra de datos mediante import Data.T
ree;
ya que es una funcin meramente representativa y donde GT significa Greater Than y
_ significa en caso contrario -}
-- 11)

type Adyacentes a = [a]

type Nodo a = (a,Adyacentes a)
data Grafo a = GVacio | G [Nodo a] deriving Show
nvalladolid::Nodo String
nvalladolid = ("Valladolid",["Valladolid","Madrid"])
nmadrid::Nodo String
nmadrid = ("Madrid",["Madrid","Barcelona","Valencia"])
nalbacete::Nodo String
nalbacete = ("Albacete",["Albacete","Madrid","Valencia"])
nvalencia::Nodo String
nvalencia = ("Valencia",["Valencia","Barcelona","Albacete"])
nbarcelona::Nodo String
nbarcelona = ("Barcelona",["Barcelona","Madrid","Valencia"])
ciudades::Grafo String
ciudades = G [nvalladolid,nmadrid,nalbacete,nvalencia,nbarcelona]
esAdyacente::(Eq a)=>Nodo a->Nodo a->Grafo a->Bool
esAdyacente (n,xs) (m,ys) (G grafo) = perteneceVertice (n,xs) (G grafo) && pert
eneceVertice (m,ys) (G grafo) && n `elem`ys
perteneceVertice::(Eq a)=>Nodo a->Grafo a->Bool
perteneceVertice (vertice, (a:aristas)) (G []) = False
perteneceVertice (vertice, (a:aristas)) GVacio = False
perteneceVertice (vertice, (a:aristas)) (G ((v,(a1:as)):gs)) = if (vertice==v) t
hen True else perteneceVertice (vertice, (a:aristas)) (G gs)
instance (Eq a)=>Eq (Grafo a) where
(G ((v,xs):g1)) == (G ((v1,ys):g2)) = (v==v1) && (xs==ys) && ((G g1)==(G
g2))
(G ((v,xs):g1)) /= (G ((v1,ys):g2)) = (v/=v1) || (xs/=ys) || ((G g1)/=(G
g2))
grafosIguales::(Eq a)=>Grafo a->Grafo a->Bool
grafosIguales GVacio GVacio = True
grafosIguales _ GVacio = False
grafosIguales GVacio _ = False
grafosIguales (G g1) (G g2) = (g1==g2)
-- 12)
type Capacidad = Int
type Numero = Int
data Mesa = M Capacidad Numero
type Libres = [Mesa]
type Ocupadas = [Mesa]
data Ocupacion = Ocup Libres Ocupadas

instance Show Mesa where

show (M c n) = "Mesa " ++ show n ++ " -> " ++ "Capacidad:" ++ show c
instance Show Ocupacion where
show (Ocup xs ys) = "Libres:\n" ++ show xs ++ "\n" ++ "Ocupadas:\n" ++
show ys
instance Eq Mesa where
(M c n) == (M c1 n1) = c==c1
(M c n) /= (M c1 n1) = c/=c1
instance Ord
(M c
(M c
(M c
(M c

Mesa where
n) > (M c1 n1) = c>c1
n) < (M c1 n1) = c<c1
n) >= (M c1 n1) = c>=c1
n) <= (M c1 n1) = c<=c1

addMesa::[Mesa]->Mesa->[Mesa]
addMesa [] mesa = [mesa]
addMesa (x:xs) mesa = if (mesa<x) then (mesa:(x:xs))
else (x:addMesa xs mesa)
insertarMesaLibre::Ocupacion->Mesa->Ocupacion
insertarMesaLibre (Ocup xs ys) m = (Ocup (addMesa xs m) ys)
insertarMesaOcupada::Ocupacion->Mesa->Ocupacion
insertarMesaOcupada (Ocup xs ys) m = (Ocup xs (addMesa ys m))

type Comensales = Int

ocuparMesa::Ocupacion->Comensales->Ocupacion
ocuparMesa (Ocup [] ys) comens = (Ocup [] ys)
ocuparMesa (Ocup ((M c n):xs) ys) comens = if (comens>c) then insertarMesaLibre
(ocuparMesa (Ocup xs ys) comens) (M c n)
else ins
ertarMesaOcupada (Ocup xs ys) (M c n)
lib::Libres
lib = [(M 1 1),(M 2 2),(M 3 3),(M 4 4),(M 5 5),(M 6 6)]
ocu::Ocupadas
ocu = [(M 7 7),(M 8 8),(M 9 9),(M 10 10),(M 11 11),(M 12 12)]
restaurante::Ocupacion
restaurante = (Ocup ocu lib)
-- 13)
type
type
type
type
type

Title = String
Abstract = String
Day = Int
Month = Int
Year = Int

data Date = D Day Month Year deriving Show

data Article = Art Title Date Abstract deriving Show
equal :: Date -> Date -> Bool
equal (D d1 m1 y1) (D d2 m2 y2) = d1==d2 && m1==m2 && y1==y2
lessThan :: Date -> Date -> Bool
lessThan (D d1 m1 y1) (D d2 m2 y2) = y1 < y2 || (y1==y2) && (m1 < m2) || (y1==y
2) && (m1==m2) && (d1<d2)
greaterThan :: Date -> Date -> Bool
greaterThan date1 date2 = not (equal date1 date2) && not (lessThan date1 date2)
-- Funciones de ordenacin de listas
mitades::[a]->([a],[a])
mitades xs = splitAt (length xs `div` 2) xs
mezcla
mezcla
mezcla
mezcla

:: Ord a => [a] -> [a] -> [a]

[] ys = ys
xs [] = xs
(x:xs) (y:ys) | x <= y = x:mezcla xs (y:ys)
| otherwise = y : mezcla (x:xs) ys

ordMezcla
ordMezcla
ordMezcla
ordMezcla

:: Ord a => [a] -> [a]

[] = []
[x] = [x]
xs = mezcla (ordMezcla ys) (ordMezcla zs) where (ys,zs) = mitades xs

-- Declaracin de datos concretos

date1 :: Date
date1 = D 16 06 2015
date2 :: Date
date2 = D 10 05 2015
date3 :: Date
date3 = D 09 01 2014
date4 :: Date
date4 = D 10 05 2015
article1 = Art "Pope Francis Calls for Climate Action in Draft of Encyclical" d
ate1 "Pope Francis offers a broad vision of..."
article2 = Art "Discontent in Eastern Ukraine Leads to Rare Public Protest" dat
e2 "Residents of two frequently shelled..."
article3 = Art "Hong Kong Police Arrest 9 Ahead of Contentious Vote" date3 "The
Hong Kong police said on Monday that..."
article4 = Art "DnA Deciphers Roots of Modern Europeans" date4 "For centuries,
archaeologists have..."
articlesList = [article1,article2,article3,article4]
-- Codigo a aadir

instance Eq Article where

(Art t d _) == (Art t1 d1 _) = (equal d d1) && (t==t1)
(Art t d _) /= (Art t1 d1 _) = (t/=t1) || (not (equal d d1) && (t==t1))
instance Ord
(Art
))
(Art
(Art
t1))
(Art
)

Article where
t d _) > (Art t1 d1 _) = greaterThan d d1 || ((equal d d1) && (t>t1
t d _) < (Art t1 d1 _) = lessThan d d1 || ((equal d d1) && (t<t1))
t d _) >= (Art t1 d1 _) = greaterThan d d1 || ((equal d d1) && (t>=
t d _) <= (Art t1 d1 _) = lessThan d d1 || ((equal d d1) && (t<=t1)

-- En este caso tambin compara por ttulo, en caso de tener fechas iguales
--Otros ejercicios de exmenes
--Realice la funcin pertenece con funciones de plegado
pertenece'::(Eq a)=>[a]->a->Bool
pertenece' xs e = foldl (||) False (foldl (\ l x-> if (x==e) then True:l else Fa
lse:l) [] xs)
--Realice una funcin para hallar el producto escalar de dos vectores mediante lis
tas de comprensin funciones de plegado y la funcin zip
productoescalar::[Int]->[Int]->Int
productoescalar xs ys = foldl (+) 0 (foldl (\lista (a,b)->(a*b):lista) [] (zip x
s ys))