--Practico 7----------------------------------------------------------
--Ejer 1
suma::N->N->N
suma 0 0 = 0
suma 0 (S y) = (S y)
suma (S x) 0 = (S x)
suma (S x) (S y) = S(suma x (S y))

--Ejer 3
iguales :: N->N-> Bool
iguales 0 0 = True
iguales (S y) 0 = False
iguales 0 (S x) = False
iguales (S x) (S y) = iguales x y

--Ejer 8
prod :: N->N->N
prod 0 0 = 0
prod (S x) 0 = 0
prod 0 (S y) = 0
prod (S x) (S y) = suma (S x)(prod (S x)y) 

--Ejer 10
suma_hasta_n::N->N
suma_hasta_n 0 = 0
suma_hasta_n (S x) = suma (S x) (suma_hasta_n x)

--Ejer 13
espar:: N -> Bool
espar 0 = True
espar (S x) = if espar x then False else True

--Ejer 14
esimpar:: N -> Bool
esimpar 0 = False
esimpar (S x) = if esimpar x then False else True


menor::N->N->Bool
menor 0 0 = False
menor 0 (S x)=True
menor (S x) 0 = False
menor (S x) (S y) = menor x y

--menor_o_igual::N->N->Bool
--menor_o_igual 0 _=True
--menor_o_igual (S x) 0 = False
--menor_o_igual S x (S y) = if menor (S x) (S y) then True else if (S x) (S y) then True else False

--resta::N->N->N
--resta 0 _ = 0
--resta S x (S y) = if menor_o_igual (S x) (S y) then 0 else S(resta x (S y))


--Practico 7 profundización------------------------------------------------
adiv:: N->N->N
adiv _ 0 = error "el segundo argumento debe ser distinto de 0"
adiv 0 x = 0
adiv (S x) (S y) = if (S x) < (S y) then 0 else S (adiv(S x) (S y))

--Ejer 1
factorial::N->N
factorial 0 = 1
factorial (S a) = (S a) * (factorial a) 

--Ejer 2
resta:: N->N->N
resta 0 n = 0
resta n 0 = n
resta (S n)  (S m) = if (S n) <= (S m) then 0 else (resta (S n) (S m))


--Ejer 4
--amcd:: N->N->N
--amcd 0 0 = 0
--amcd n m = if n == m then n
--amcd (S n) (S m) = if (S n) < (S m) then (amcd ((S m) - (S n))) (S n)
--amcd (S n) (S m) = if (S m) < (S n) then (amcd ((S n) - (S m))) (S m) else error
 

--Ejer 5
fibonacci::N->N
fibonacci 0 = 0
fibonacci (S 0) = (S 0)
fibonacci (S (S n)) = if n > 2 then (suma (S n) n) else 0 

--Ejer 6
sumDesdeHasta :: N->N->N
sumDesdeHasta 0 0 = 0
sumDesdeHasta 0 (S m) = suma_hasta_n (S m)
sumDesdeHasta (S n) 0 = error "el primer argumento debe ser menor o igual que el segudno"
sumDesdeHasta (S n) (S m) = if iguales (S n) (S m) then (S n) else suma (S m) (sumDesdeHasta (S n) m)

--Ejer 7
prodDesdeHasta :: N->N->N
prodDesdeHasta 0 0 = 0
prodDesdeHasta 0 (S m) = 0
prodDesdeHasta (S n) 0 = error "el primer argumento debe ser menor o igual que el segundo"
prodDesdeHasta (S n) (S m) = if iguales (S n) (S m) then prod (S n) (S n) else prod (S m) (prodDesdeHasta (S n) m)

--Ejer 8
buscarDesde :: Integer->Integer->Integer
buscarDesde 0 0 = 0
buscarDesde i n = if ((i+1)^2<=n)&&((i+2)^2>n)then i+1 else buscarDesde (i+1)n

--Practico 8---------------------------------------------------------
--Ejer 4
ordenada:: [Integer]->Bool
ordenada [] = True
ordenada [a] = True
ordenada (a:b:xs) = if a<b then (ordenada (b:xs)) else False

--Ejer 5 a
sumalist:: [Integer]-> Integer
sumalist [] = 0
sumalist [a] = a
sumalist (a:xs) = a + (sumalist (xs))

--Ejer 5 b
mul:: [Integer]-> Integer
mul [] = 0
mul [a] = a
mul (a:xs) = a * (mul (xs))


--Ejer 5 g
--mapear::(Int->Int)->[Int]->[Int]

espar1::Integer->Bool
espar1 a = mod a 2 == 0

--Ejer 5 h
filtrar :: (Int->Bool)->[Int]->[Int]
filtrar funcion [] = []
filtrar funcion(a:xs)=if(funcion a)then(a:filtrar funcion(xs))else(filtrar funcion(xs))

--Ejer 5 i
existe :: [Integer]->(Integer->Bool)->Bool
existe [] funcion = False
--existe [a] funcion = True
existe (a:xs) funcion = if(funcion a) then True else (existe (xs) funcion)

--Ejer 5 j
pertenece:: Integer->[Integer]->Bool
pertenece a [] = False
pertenece b (a:xs) = if b == a then True else (pertenece b (xs))

--Ejer 5 k
borrar :: [Integer]->Integer->[Integer]
borrar [] b = []
borrar(a:xs) b = if b == a then (borrar (xs) b) else (a: borrar (xs) b)



--ordenar:: [Integer]->[Integer]
--ordenar [ ] = [ ]
--ordenar (a:b:xs) = if a<b then (ordenar (b:xs)) else (a:b: ordenar (xs))


--Ejer 5 l
--insetaOrd:: [Integer]->Integer->[Integer]
--insetaOrd [ ] b = [b]
--insetaOrd 

--- Se agradece a la estudiante Mariana Laclau por estas soluciones.