Informática de 1º de Matemáticas [Curso 2021-22, Grupo 2] - Contribuciones del usuario [es]

Relación 3

2021-10-26T18:06:12Z

Critorseb:

<source lang='haskell'>

-- I1M 2021-22: Rel_3.hs (20 de Octubre de 2021)
-- Definiciones por comprensión
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

-- ---------------------------------------------------------------------
-- Introducción --
-- ---------------------------------------------------------------------

-- En esta relación se presentan ejercicios con definiciones por
-- comprensión correspondientes al tema 5 que se encuentra
-- http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-5.html

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir, por comprensión, la función
-- sumaDeCuadrados :: Integer -> Integer
-- tal que (sumaDeCuadrados n) es la suma de los cuadrados de los
-- primeros n números; es decir, 1^2 + 2^2 + ... + n^2. Por ejemplo,
-- sumaDeCuadrados 3 == 14
-- sumaDeCuadrados 100 == 338350
-- ---------------------------------------------------------------------

-- José Manuel García, Lucía Hernández, Elsa Domínguez, Lucía González, Carmen Blanco, Adolfo Sagrera Vivancos, Ana Sosa Caballero, Cristina Torres
sumaDeCuadrados :: Integer -> Integer
sumaDeCuadrados n = sum [(x^2) | x <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir por comprensión la función
-- replica :: Int -> a -> [a]
-- tal que (replica n x) es la lista formada por n copias del elemento
-- x. Por ejemplo,
-- replica 4 7 == [7,7,7,7]
-- replica 3 True == [True, True, True]
-- Nota: La función replica es equivalente a la predefinida replicate.
-- ---------------------------------------------------------------------

-- José Manuel García, Lucía Hernández, Elsa Domínguez, Lucía González, Carmen Blanco, Adolfo Sagrera Vivancos, Ana Sosa Caballero, Cristina Torres
replica :: Int -> a -> [a]
replica n x = [x | _ <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Definir la función
-- suma :: Integer -> Integer
-- tal (suma n) es la suma de los n primeros números. Por ejemplo,
-- suma 3 == 6
-- ---------------------------------------------------------------------

-- José Manuel García, Lucía Hernández, Elsa Domínguez, Lucía González, Carmen Blanco, Adolfo Sagrera Vivancos, Ana Sosa Caballero, Cristina Torres
suma :: Integer -> Integer
suma n = sum [1..n]

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Los triángulos aritméticos se forman como sigue
-- 1
-- 2 3
-- 4 5 6
-- 7 8 9 10
-- 11 12 13 14 15
-- 16 17 18 19 20 21
--
-- Definir la función
-- linea :: Integer -> [Integer]
-- tal que (linea n) es la línea n-ésima de los triángulos
-- aritméticos. Por ejemplo,
-- linea 4 == [7,8,9,10]
-- linea 5 == [11,12,13,14,15]
-- ---------------------------------------------------------------------

-- José Manuel García
linea :: Integer -> [Integer]
linea n = [(1 + sum [1..n-1])..(1 + sum [1..n-1])+(n-1)]
-- cada primer elemento de cada fila sigue la siguiente sucesión:
-- F1 : 1 = 1
-- F2 : 1 + 1 = 2
-- F3 : 1 + 1 + 2 = 4
-- F4 : 1 + 1 + 2 + 3 = 7
-- F5 : 1 + 1 + 2 + 3 + 4 = 11
-- ...
-- Además, la Fila n tiene n elementos (Ej. la fila 3 es [4,5,6], tiene 3 elementos)

-- Lucía Hernández. Lucía González
linea :: Integer -> [Integer]
linea n = [x | x<-[suma(n-1) +1..suma n]]
-- Adolfo Sagrera Vivancos, Ana Sosa Caballero, Elsa Domínguez, Cristina Torres
linea1 :: Integer -> [Integer]
linea1 n = [suma (n-1)+1..suma n]

-- ---------------------------------------------------------------------
-- Ejercicio 3.3. Definir la función
-- triangulo :: Integer -> [[Integer]]
-- tal que (triangulo n) es el triángulo aritmético de altura n. Por
-- ejemplo,
-- triangulo 3 == [[1],[2,3],[4,5,6]]
-- triangulo 4 == [[1],[2,3],[4,5,6],[7,8,9,10]]
-- ---------------------------------------------------------------------

-- José Manuel García, Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez, Cristina Torres
triangulo :: Integer -> [[Integer]]
triangulo n = [linea x | x <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 4. Un entero positivo es perfecto si es igual a la suma de
-- sus factores, excluyendo el propio número.
--
-- Definir por comprensión la función
-- perfectos :: Int -> [Int]
-- tal que (perfectos n) es la lista de todos los números perfectos
-- menores que n. Por ejemplo,
-- perfectos 500 == [6,28,496]
-- Indicación: Usar la función factores del tema 5.
-- ---------------------------------------------------------------------
--Lucía Hernández
factores :: Int -> [Int]
factores n = [x | x <- [1..n-1], mod n x == 0]
perfectos :: Int -> [Int]
perfectos n = [x | x<- [1..n], x == sum (factores x)]

-- Elsa Domínguez
factores1 :: Int -> [Int]
factores1 n = [x | x <- [1..n], n `mod` x == 0]
perfectos1 :: Int -> [Int]
perfectos1 n = [x | x <- [1..n], sum (factores x) == 2*x]
-- Adolfo Sagrera Vivancos
factores2 n = [x | x <- [1..n], rem n x ==0]
perfectos2 :: Int -> [Int]
perfectos2 n = [i | i <- [1..n], perfecto i]
perfecto2 x = x == sum (factores x)-x

-- Ana Sosa Caballero
perfectos3 :: Int -> [Int]
perfectos3 n = [x | x <- [1..n], sum(init (factores x)) == x]

factores3 n = [x | x <- [1..n], rem n x == 0]

--Cristina Torres
factores4:: Int -> [Int]
factores4 n= [ x |x <- [1..n] , rem n x == 0]

perfectos4 :: Int -> [Int]
perfectos4 n = [i | i <- [1..n], perfecto i]
where perfecto x = x == sum (factores x)- x
-- ---------------------------------------------------------------------
-- Ejercicio 5.1. Un número natural n se denomina abundante si es menor
-- que la suma de sus divisores propios. Por ejemplo, 12 y 30 son
-- abundantes pero 5 y 28 no lo son.
--
-- Definir la función
-- numeroAbundante :: Int -> Bool
-- tal que (numeroAbundante n) se verifica si n es un número
-- abundante. Por ejemplo,
-- numeroAbundante 5 == False
-- numeroAbundante 12 == True
-- numeroAbundante 28 == False
-- numeroAbundante 30 == True
-- ---------------------------------------------------------------------

--Álvaro Cano, Adolfo Sagrera Vivancos
numeroAbundante :: Int -> Bool
numeroAbundante n = n < (sum (factores n) - n)
-- Lucía Hernández, Cristina Torres
numeroAbundante :: Int -> Bool
numeroAbundante n = n < sum(factores n)
-- Elsa Domínguez
numeroAbundante2 :: Int -> Bool
numeroAbundante2 n = sum (factores n) > 2*n
-- Ana Sosa Caballero
numeroAbundante3 :: Int -> Bool
numeroAbundante3 n = sum(init (factores n)) > n

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Definir la función
-- numerosAbundantesMenores :: Int -> [Int]
-- tal que (numerosAbundantesMenores n) es la lista de números
-- abundantes menores o iguales que n. Por ejemplo,
-- numerosAbundantesMenores 50 == [12,18,20,24,30,36,40,42,48]
-- numerosAbundantesMenores 48 == [12,18,20,24,30,36,40,42,48]
-- ---------------------------------------------------------------------

--Álvaro Cano, Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sosa Caballero, Cristina Torres
numerosAbundantesMenores :: Int -> [Int]
numerosAbundantesMenores n = [x | x <- [1..n], numeroAbundante x]

-- ---------------------------------------------------------------------
-- Ejercicio 5.3. Definir la función
-- todosPares :: Int -> Bool
-- tal que (todosPares n) se verifica si todos los números abundantes
-- menores o iguales que n son pares. Por ejemplo,
-- todosPares 10 == True
-- todosPares 100 == True
-- todosPares 1000 == False
-- ---------------------------------------------------------------------

--Álvaro Cano
todosPares :: Int -> Bool
todosPares n = and [x `rem` 2 == 0 | x <- numerosAbundantesMenores n]
--Lucía Hernández
todosPares :: Int -> Bool
todosPares n = [ x| x<-numerosAbundantesMenores n, even x ] == numerosAbundantesMenores n
-- Elsa Domínguez
todosPares :: Int -> Bool
todosPares n = length (filter odd (numerosAbundantesMenores n)) == 0
-- Adolfo Sagrera Vivancos, Ana Sosa Caballero, Cristina Torres
todosPares1 :: Int -> Bool
todosPares1 n = and [even x | x <- numerosAbundantesMenores n]

-- ---------------------------------------------------------------------
-- Ejercicio 5.4. Definir la constante
-- primerAbundanteImpar :: Int
-- que calcule el primer número natural abundante impar. Determinar el
-- valor de dicho número.
-- ---------------------------------------------------------------------

--Álvaro Cano, Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero, Cristina Torres
primerAbundanteImpar :: Int
primerAbundanteImpar = head [x | x <- [1,3..], numeroAbundante x]
-- Su cálculo es
-- ghci> primerAbundanteImpar
-- 945
-- Adolfo Sagrera Vivancos
primerAbundanteImpar1 :: Int
primerAbundanteImpar1 = head [n | n <- [1..], odd n, numeroAbundante n]
-- ---------------------------------------------------------------------
-- Ejercicio 6 (Problema 1 del proyecto Euler) Definir la función
-- euler1 :: Int -> Int
-- tal que (euler1 n) es la suma de todos los múltiplos de 3 ó 5 menores
-- que n. Por ejemplo,
-- euler1 10 == 23
--
-- Calcular la suma de todos los múltiplos de 3 ó 5 menores que 1000.
-- ---------------------------------------------------------------------

--Álvaro Cano
euler1 :: Int -> Int
euler1 n = sum [3*x | x <- [1..n] , 3*x < n] + sum [5*x | x <- [1..n], 5*x < n]
-- Cálculo:
-- ghci> euler1 1000
-- 266333
-- Lucía Hernández, Adolfo Sagrera Vivancos
euler1 :: Int -> Int
euler1 n = sum [x |x<-[1..n-1], mod x 5 == 0 || mod x 3 == 0]
-- Cálculo:λ> euler1 1000
-- 233168
-- Elsa Domínguez
euler1' :: Int -> Int
euler1' n = sum [x | x <- [1..n-1], multiplo x 3 || multiplo x 5]
where multiplo x y = rem x y == 0
-- Ana Sosa Caballero
euler1 :: Int -> Int
euler1 n = sum [x | x <- [1..n-1], (rem x 3 == 0) || (rem x 5 == 0)]
-- Cálculo:
-- λ> euler1' 1000
-- 233168

-- Cristina Torres

euler1 :: Int -> Int
euler1 n = sum [ i | i<- [1..n-1], rem i 3==0 || rem i 5==0 ]
-- Cálculo: λ> euler1 1000
233168

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir la función
-- circulo :: Int -> Int
-- tal que (circulo n) es el la cantidad de pares de números naturales
-- (x,y) que se encuentran dentro del círculo de radio n. Por ejemplo,
-- circulo 3 == 9
-- circulo 4 == 15
-- circulo 5 == 22
-- circulo 100 == 7949
-- ---------------------------------------------------------------------

--Álvaro Cano, Elsa Domínguez, Lucía Hernández, Adolfo Sagrera Vivancos, Cristina Torres
circulo :: Int -> Int
circulo n = length [(x,y) | x <- [0..n], y <- [0..n], x^2 + y^2 < n^2]

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir la función
-- aproxE :: Double -> [Double]
-- tal que (aproXE n) es la lista cuyos elementos son los términos de la
-- sucesión (1+1/m)**m desde 1 hasta n. Por ejemplo,
-- aproxE 1 == [2.0]
-- aproxE 4 == [2.0,2.25,2.37037037037037,2.44140625]
-- ---------------------------------------------------------------------

--Álvaro Cano, Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero, Adolfo Sagrera Vivancos, Cristina Torres
aproxE :: Double -> [Double]
aproxE n = [(1+1/m)**m | m <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. żCuál es el límite de la sucesión (1+1/m)**m ?
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- El límite es el número e.

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Definir la función
-- errorAproxE :: Double -> Double
-- tal que (errorE x) es el menor número de términos de la sucesión
-- (1+1/m)**m necesarios para obtener su límite con un error menor que
-- x. Por ejemplo,
-- errorAproxE 0.1 == 13.0
-- errorAproxE 0.01 == 135.0
-- errorAproxE 0.001 == 1359.0
-- Indicación: En Haskell, e se calcula como (exp 1).
-- ---------------------------------------------------------------------

--Álvaro Cano
errorAproxE :: Double -> Double
errorAproxE x = head [m | m <- [1..], (exp 1 - (1+1/m)**m) < x]
-- Elsa Domínguez, Lucía Hernández, Adolfo Sagrera Vivancos, Cristina Torres
errorAproxE' :: Double -> Double
errorAproxE' x = head [m | m <- [1..], abs (exp 1 - (1+1/m)**m) < x]

-- ---------------------------------------------------------------------
-- Ejercicio 9.1. Definir la función
-- aproxLimSeno :: Double -> [Double]
-- tal que (aproxLimSeno n) es la lista cuyos elementos son los términos
-- de la sucesión
-- sen(1/m)
-- --------
-- 1/m
-- desde 1 hasta n. Por ejemplo,
-- aproxLimSeno 1 == [0.8414709848078965]
-- aproxLimSeno 2 == [0.8414709848078965,0.958851077208406]
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Ana Sosa Caballero, Adolfo Sagrera Vivancos, Cristina Torres
aproxLimSeno :: Double -> [Double]
aproxLimSeno n = [sin (1/m) / (1/m) | m <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 9.2. żCuál es el límite de la sucesión sen(1/m)/(1/m) ?
-- ---------------------------------------------------------------------
-- Elsa Domínguez
-- El límite es 1.
-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Definir la función
-- errorLimSeno :: Double -> Double
-- tal que (errorLimSeno x) es el menor número de términos de la sucesión
-- sen(1/m)/(1/m) necesarios para obtener su límite con un error menor
-- que x. Por ejemplo,
-- errorLimSeno 0.1 == 2.0
-- errorLimSeno 0.01 == 5.0
-- errorLimSeno 0.001 == 13.0
-- errorLimSeno 0.0001 == 41.0
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Adolfo Sagrera Vivancos, Cristina Torres
errorLimSeno :: Double -> Double
errorLimSeno x = head [m | m <- [1..], abs (1 - sin (1/m) / (1/m)) < x]

-- ---------------------------------------------------------------------
-- Ejercicio 10.1. Definir la función
-- calculaPi :: Double -> Double
-- tal que (calculaPi n) es la aproximación del número pi calculada
-- mediante la expresión
-- 4*(1 - 1/3 + 1/5 - 1/7 + ...+ (-1)**n/(2*n+1))
-- Por ejemplo,
-- calculaPi 3 == 2.8952380952380956
-- calculaPi 300 == 3.1449149035588526
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Adolfo Sagrera Vivancos, Cristina Torres
calculaPi :: Double -> Double
calculaPi n = 4*(sum [(-1)**x / (2*x + 1) | x <- [0..n]])

-- ---------------------------------------------------------------------
-- Ejercicio 10.2. Definir la función
-- errorPi :: Double -> Double
-- tal que (errorPi x) es el menor número de términos de la serie
-- 4*(1 - 1/3 + 1/5 - 1/7 + ...+ (-1)**n/(2*n+1))
-- necesarios para obtener pi con un error menor que x. Por ejemplo,
-- errorPi 0.1 == 9.0
-- errorPi 0.01 == 99.0
-- errorPi 0.001 == 999.0
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Adolfo Sagrera Vivancos, Cristina Torres
errorPi :: Double -> Double
errorPi x = head [n | n <- [1..], abs (pi - calculaPi n) < x]

-- ---------------------------------------------------------------------
-- Ejercicio 11.1. Una terna (x,y,z) de enteros positivos es pitagórica
-- si x^2 + y^2 = z^2.
--
-- Definir, por comprensión, la función
-- pitagoricas :: Int -> [(Int,Int,Int)]
-- tal que (pitagoricas n) es la lista de todas las ternas pitagóricas
-- cuyas componentes están entre 1 y n. Por ejemplo,
-- pitagoricas 10 == [(3,4,5),(4,3,5),(6,8,10),(8,6,10)]
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero, Adolfo Sagrera Vivancos, Cristina Torres
pitagoricas :: Int -> [(Int,Int,Int)]
pitagoricas n = [(x,y,z) | x <-[1..n], y <-[1..n], z <-[1..n], x^2+y^2 == z^2]

-- ---------------------------------------------------------------------
-- Ejercicio 11.2. Definir la función
-- numeroDePares :: (Int,Int,Int) -> Int
-- tal que (numeroDePares t) es el número de elementos pares de la terna
-- t. Por ejemplo,
-- numeroDePares (3,5,7) == 0
-- numeroDePares (3,6,7) == 1
-- numeroDePares (3,6,4) == 2
-- numeroDePares (4,6,4) == 3
-- ---------------------------------------------------------------------
-- Lucía Hernández, Cristina Torres
numeroDePares :: (Int,Int,Int) -> Int
numeroDePares (x,y,z) = length [i | i<-[x,y,z], even i]

-- Elsa Domínguez
numeroDePares1 :: (Int,Int,Int) -> Int
numeroDePares1 (x,y,z) = sum [1 | a <- [x,y,z], even a]

-- Ana Sosa Caballero
numeroDePares2 :: (Int,Int,Int) -> Int
numeroDePares2 (x,y,z) = sum [1 | _ <- filter even [x,y,z]]

-- ---------------------------------------------------------------------
-- Ejercicio 11.3. Definir la función
-- conjetura :: Int -> Bool
-- tal que (conjetura n) se verifica si todas las ternas pitagóricas
-- cuyas componentes están entre 1 y n tiene un número impar de números
-- pares. Por ejemplo,
-- conjetura 10 == True
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Cristina Torres
conjetura :: Int -> Bool
conjetura n = and [odd (numeroDePares (x,y,z)) | (x,y,z) <- pitagoricas n]

-- ---------------------------------------------------------------------
-- Ejercicio 11.4. Demostrar la conjetura para todas las ternas
-- pitagóricas.
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 12.1. (Problema 9 del Proyecto Euler). Una terna pitagórica
-- es una terna de números naturales (a,b,c) tal que a<b<c y
-- a^2+b^2=c^2. Por ejemplo (3,4,5) es una terna pitagórica.
--
-- Definir la función
-- ternasPitagoricas :: Integer -> [[Integer]]
-- tal que (ternasPitagoricas x) es la lista de las ternas pitagóricas
-- cuya suma es x. Por ejemplo,
-- ternasPitagoricas 12 == [(3,4,5)]
-- ternasPitagoricas 60 == [(10,24,26),(15,20,25)]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
ternasPitagoricas :: Integer -> [(Integer,Integer,Integer)]
ternasPitagoricas x = [(a,b,c) | a <- [1..x], b <- [a+1..x], c <- [b+1..x], a^2 + b^2 == c^2, a+b+c == x]
--Lucía Hernández,Cristina Torres
ternasPitagoricas :: Integer -> [(Integer,Integer,Integer)]
ternasPitagoricas x = [(a,b,c) | a<-[1..x],b<-[1..x],c<-[1..x], a<b && b<c,a^2+b^2 == c^2,a+b+c == x ]

-- Ana Sosa Caballero
ternasPitagoricas :: Integer -> [(Integer,Integer,Integer)]
ternasPitagoricas t = [ (x,y,z) | x <- [1..], y <- [1..], z <- [1..], x<y && y<z, x^2+y^2 == z^2, sum [x,y,z] == t]

-- ---------------------------------------------------------------------
-- Ejercicio 12.2. Definir la constante
-- euler9 :: Integer
-- tal que euler9 es producto abc donde (a,b,c) es la única terna
-- pitagórica tal que a+b+c=1000.
--
-- Calcular el valor de euler9.
-- ---------------------------------------------------------------------

euler9 :: Integer
euler9 = undefined

-- El cálculo del valor de euler9 es

-- ---------------------------------------------------------------------
-- Ejercicio 13. El producto escalar de dos listas de enteros xs y ys de
-- longitud n viene dado por la suma de los productos de los elementos
-- correspondientes.
--
-- Definir por comprensión la función
-- productoEscalar :: [Int] -> [Int] -> Int
-- tal que (productoEscalar xs ys) es el producto escalar de las listas
-- xs e ys. Por ejemplo,
-- productoEscalar [1,2,3] [4,5,6] == 32
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sosa Caballero
productoEscalar :: [Int] -> [Int] -> Int
productoEscalar xs ys = sum [a*b | (a,b) <- zip xs ys]

-- Lucía Hernández
productoEscalar :: [Int] -> [Int] -> Int
productoEscalar xs ys = sum [ fst p * snd p |p<- zip xs ys]
-- ---------------------------------------------------------------------
-- Ejercicio 14. Definir, por comprensión, la función
-- sumaConsecutivos :: [Int] -> [Int]
-- tal que (sumaConsecutivos xs) es la suma de los pares de elementos
-- consecutivos de la lista xs. Por ejemplo,
-- sumaConsecutivos [3,1,5,2] == [4,6,7]
-- sumaConsecutivos [3] == []
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sosa Caballero
sumaConsecutivos :: [Int] -> [Int]
sumaConsecutivos xs = [a+b | (a,b) <- zip xs (tail xs)]
--Lucía Hernández
sumaConsecutivos :: [Int] -> [Int]
sumaConsecutivos xs = [fst p + snd p | p<-zip xs (tail xs) ]
-- ---------------------------------------------------------------------
-- Ejercicio 15. Los polinomios pueden representarse de forma dispersa o
-- densa. Por ejemplo, el polinomio 6x^4-5x^2+4x-7 se puede representar
-- de forma dispersa por [6,0,-5,4,-7] y de forma densa por
-- [(4,6),(2,-5),(1,4),(0,-7)].
--
-- Definir la función
-- densa :: [Int] -> [(Int,Int)]
-- tal que (densa xs) es la representación densa del polinomio cuya
-- representación dispersa es xs. Por ejemplo,
-- densa [6,0,-5,4,-7] == [(4,6),(2,-5),(1,4),(0,-7)]
-- densa [6,0,0,3,0,4] == [(5,6),(2,3),(0,4)]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
densa :: [Int] -> [(Int,Int)]
densa xs = [(a,b) | (a,b) <- zip (reverse [0..(length xs-1)]) xs, b /= 0]

-- Ana Sosa Caballero (Mal)
densa :: [Int] -> [(Int,Int)]
densa xs = [(y,x) | x <- xs , y <- [ys, ys-1 .. 0] ]
where ys = length xs -1
-- Lucía Hernández
densa :: [Int] -> [(Int,Int)]
densa xs = [(x,y) | (x,y)<- zip (reverse ys) xs, y/=0]
where ys = [0.. length xs-1]
-- ---------------------------------------------------------------------
-- Ejercicio 16.0. La bases de datos sobre actividades de personas pueden
-- representarse mediante listas de elementos de la forma (a,b,c,d),
-- donde a es el nombre de la persona, b su actividad, c su fecha de
-- nacimiento y d la de su fallecimiento. Un ejemplo es la siguiente que
-- usaremos a lo largo de este ejercicio,
-- ---------------------------------------------------------------------

personas :: [(String,String,Int,Int)]
personas = [("Cervantes","Literatura",1547,1616),
("Velazquez","Pintura",1599,1660),
("Picasso","Pintura",1881,1973),
("Beethoven","Musica",1770,1823),
("Poincare","Ciencia",1854,1912),
("Quevedo","Literatura",1580,1654),
("Goya","Pintura",1746,1828),
("Einstein","Ciencia",1879,1955),
("Mozart","Musica",1756,1791),
("Botticelli","Pintura",1445,1510),
("Borromini","Arquitectura",1599,1667),
("Bach","Musica",1685,1750)]

-- ---------------------------------------------------------------------
-- Ejercicio 16.1. Definir la función
-- nombres :: [(String,String,Int,Int)] -> [String]
-- tal que (nombres bd) es la lista de los nombres de las personas de la
-- base de datos bd. Por ejemplo,
-- ghci> nombres personas
-- ["Cervantes","Velazquez","Picasso","Beethoven","Poincare",
-- "Quevedo","Goya","Einstein","Mozart","Botticelli","Borromini","Bach"]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
nombres :: [(String,String,Int,Int)] -> [String]
nombres bd = [(a) | (a,_,_,_) <- bd]

-- ---------------------------------------------------------------------
-- Ejercicio 16.2. Definir la función
-- musicos :: [(String,String,Int,Int)] -> [String]
-- tal que (musicos bd) es la lista de los nombres de los músicos de la
-- base de datos bd. Por ejemplo,
-- musicos personas == ["Beethoven","Mozart","Bach"]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
musicos :: [(String,String,Int,Int)] -> [String]
musicos bd = [(a) | (a,b,_,_) <- bd, b == "Musica"]

-- ---------------------------------------------------------------------
-- Ejercicio 16.3. Definir la función
-- seleccion :: [(String,String,Int,Int)] -> String -> [String]
-- tal que (seleccion bd m) es la lista de los nombres de las personas
-- de la base de datos bd cuya actividad es m. Por ejemplo,
-- ghci> seleccion personas "Pintura"
-- ["Velazquez","Picasso","Goya","Botticelli"]
-- ghci> seleccion personas "Musica"
-- ["Beethoven","Mozart","Bach"]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
seleccion :: [(String,String,Int,Int)] -> String -> [String]
seleccion bd m = [(a) | (a,b,_,_) <- bd, b == m]

-- ---------------------------------------------------------------------
-- Ejercicio 16.4. Definir, usando el apartado anterior, la función
-- musicos' :: [(String,String,Int,Int)] -> [String]
-- tal que (musicos' bd) es la lista de los nombres de los músicos de la
-- base de datos bd. Por ejemplo,
-- ghci> musicos' personas
-- ["Beethoven","Mozart","Bach"]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
musicos' :: [(String,String,Int,Int)] -> [String]
musicos' bd = seleccion bd "Musica"

-- ---------------------------------------------------------------------
-- Ejercicio 16.5. Definir la función
-- vivas :: [(String,String,Int,Int)] -> Int -> [String]
-- tal que (vivas bd a) es la lista de los nombres de las personas de la
-- base de datos bd que estaban vivas en el ańo a. Por ejemplo,
-- ghci> vivas personas 1600
-- ["Cervantes","Velazquez","Quevedo","Borromini"]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
vivas :: [(String,String,Int,Int)] -> Int -> [String]
vivas ps a = [(p) | (p,_,c,d) <- ps, c <= a && a <= d]

</source>

Relación 3

2021-10-26T17:09:36Z

Critorseb:

<source lang='haskell'>

-- I1M 2021-22: Rel_3.hs (20 de Octubre de 2021)
-- Definiciones por comprensión
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

-- ---------------------------------------------------------------------
-- Introducción --
-- ---------------------------------------------------------------------

-- En esta relación se presentan ejercicios con definiciones por
-- comprensión correspondientes al tema 5 que se encuentra
-- http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-5.html

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir, por comprensión, la función
-- sumaDeCuadrados :: Integer -> Integer
-- tal que (sumaDeCuadrados n) es la suma de los cuadrados de los
-- primeros n números; es decir, 1^2 + 2^2 + ... + n^2. Por ejemplo,
-- sumaDeCuadrados 3 == 14
-- sumaDeCuadrados 100 == 338350
-- ---------------------------------------------------------------------

-- José Manuel García, Lucía Hernández, Elsa Domínguez, Lucía González, Carmen Blanco, Adolfo Sagrera Vivancos, Ana Sosa Caballero, Cristina Torres
sumaDeCuadrados :: Integer -> Integer
sumaDeCuadrados n = sum [(x^2) | x <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir por comprensión la función
-- replica :: Int -> a -> [a]
-- tal que (replica n x) es la lista formada por n copias del elemento
-- x. Por ejemplo,
-- replica 4 7 == [7,7,7,7]
-- replica 3 True == [True, True, True]
-- Nota: La función replica es equivalente a la predefinida replicate.
-- ---------------------------------------------------------------------

-- José Manuel García, Lucía Hernández, Elsa Domínguez, Lucía González, Carmen Blanco, Adolfo Sagrera Vivancos, Ana Sosa Caballero, Cristina Torres
replica :: Int -> a -> [a]
replica n x = [x | _ <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Definir la función
-- suma :: Integer -> Integer
-- tal (suma n) es la suma de los n primeros números. Por ejemplo,
-- suma 3 == 6
-- ---------------------------------------------------------------------

-- José Manuel García, Lucía Hernández, Elsa Domínguez, Lucía González, Carmen Blanco, Adolfo Sagrera Vivancos, Ana Sosa Caballero, Cristina Torres
suma :: Integer -> Integer
suma n = sum [1..n]

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Los triángulos aritméticos se forman como sigue
-- 1
-- 2 3
-- 4 5 6
-- 7 8 9 10
-- 11 12 13 14 15
-- 16 17 18 19 20 21
--
-- Definir la función
-- linea :: Integer -> [Integer]
-- tal que (linea n) es la línea n-ésima de los triángulos
-- aritméticos. Por ejemplo,
-- linea 4 == [7,8,9,10]
-- linea 5 == [11,12,13,14,15]
-- ---------------------------------------------------------------------

-- José Manuel García
linea :: Integer -> [Integer]
linea n = [(1 + sum [1..n-1])..(1 + sum [1..n-1])+(n-1)]
-- cada primer elemento de cada fila sigue la siguiente sucesión:
-- F1 : 1 = 1
-- F2 : 1 + 1 = 2
-- F3 : 1 + 1 + 2 = 4
-- F4 : 1 + 1 + 2 + 3 = 7
-- F5 : 1 + 1 + 2 + 3 + 4 = 11
-- ...
-- Además, la Fila n tiene n elementos (Ej. la fila 3 es [4,5,6], tiene 3 elementos)

-- Lucía Hernández. Lucía González
linea :: Integer -> [Integer]
linea n = [x | x<-[suma(n-1) +1..suma n]]
-- Adolfo Sagrera Vivancos, Ana Sosa Caballero, Elsa Domínguez, Cristina Torres
linea1 :: Integer -> [Integer]
linea1 n = [suma (n-1)+1..suma n]

-- ---------------------------------------------------------------------
-- Ejercicio 3.3. Definir la función
-- triangulo :: Integer -> [[Integer]]
-- tal que (triangulo n) es el triángulo aritmético de altura n. Por
-- ejemplo,
-- triangulo 3 == [[1],[2,3],[4,5,6]]
-- triangulo 4 == [[1],[2,3],[4,5,6],[7,8,9,10]]
-- ---------------------------------------------------------------------

-- José Manuel García, Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez, Cristina Torres
triangulo :: Integer -> [[Integer]]
triangulo n = [linea x | x <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 4. Un entero positivo es perfecto si es igual a la suma de
-- sus factores, excluyendo el propio número.
--
-- Definir por comprensión la función
-- perfectos :: Int -> [Int]
-- tal que (perfectos n) es la lista de todos los números perfectos
-- menores que n. Por ejemplo,
-- perfectos 500 == [6,28,496]
-- Indicación: Usar la función factores del tema 5.
-- ---------------------------------------------------------------------
--Lucía Hernández
factores :: Int -> [Int]
factores n = [x | x <- [1..n-1], mod n x == 0]
perfectos :: Int -> [Int]
perfectos n = [x | x<- [1..n], x == sum (factores x)]

-- Elsa Domínguez
factores1 :: Int -> [Int]
factores1 n = [x | x <- [1..n], n `mod` x == 0]
perfectos1 :: Int -> [Int]
perfectos1 n = [x | x <- [1..n], sum (factores x) == 2*x]
-- Adolfo Sagrera Vivancos
factores2 n = [x | x <- [1..n], rem n x ==0]
perfectos2 :: Int -> [Int]
perfectos2 n = [i | i <- [1..n], perfecto i]
perfecto2 x = x == sum (factores x)-x

-- Ana Sosa Caballero
perfectos3 :: Int -> [Int]
perfectos3 n = [x | x <- [1..n], sum(init (factores x)) == x]

factores3 n = [x | x <- [1..n], rem n x == 0]

--Cristina Torres
factores4:: Int -> [Int]
factores4 n= [ x |x <- [1..n] , rem n x == 0]

perfectos4 :: Int -> [Int]
perfectos4 n = [i | i <- [1..n], perfecto i]
where perfecto x = x == sum (factores x)- x
-- ---------------------------------------------------------------------
-- Ejercicio 5.1. Un número natural n se denomina abundante si es menor
-- que la suma de sus divisores propios. Por ejemplo, 12 y 30 son
-- abundantes pero 5 y 28 no lo son.
--
-- Definir la función
-- numeroAbundante :: Int -> Bool
-- tal que (numeroAbundante n) se verifica si n es un número
-- abundante. Por ejemplo,
-- numeroAbundante 5 == False
-- numeroAbundante 12 == True
-- numeroAbundante 28 == False
-- numeroAbundante 30 == True
-- ---------------------------------------------------------------------

--Álvaro Cano, Adolfo Sagrera Vivancos
numeroAbundante :: Int -> Bool
numeroAbundante n = n < (sum (factores n) - n)
-- Lucía Hernández, Cristina Torres
numeroAbundante :: Int -> Bool
numeroAbundante n = n < sum(factores n)
-- Elsa Domínguez
numeroAbundante2 :: Int -> Bool
numeroAbundante2 n = sum (factores n) > 2*n
-- Ana Sosa Caballero
numeroAbundante3 :: Int -> Bool
numeroAbundante3 n = sum(init (factores n)) > n

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Definir la función
-- numerosAbundantesMenores :: Int -> [Int]
-- tal que (numerosAbundantesMenores n) es la lista de números
-- abundantes menores o iguales que n. Por ejemplo,
-- numerosAbundantesMenores 50 == [12,18,20,24,30,36,40,42,48]
-- numerosAbundantesMenores 48 == [12,18,20,24,30,36,40,42,48]
-- ---------------------------------------------------------------------

--Álvaro Cano, Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sosa Caballero, Cristina Torres
numerosAbundantesMenores :: Int -> [Int]
numerosAbundantesMenores n = [x | x <- [1..n], numeroAbundante x]

-- ---------------------------------------------------------------------
-- Ejercicio 5.3. Definir la función
-- todosPares :: Int -> Bool
-- tal que (todosPares n) se verifica si todos los números abundantes
-- menores o iguales que n son pares. Por ejemplo,
-- todosPares 10 == True
-- todosPares 100 == True
-- todosPares 1000 == False
-- ---------------------------------------------------------------------

--Álvaro Cano
todosPares :: Int -> Bool
todosPares n = and [x `rem` 2 == 0 | x <- numerosAbundantesMenores n]
--Lucía Hernández
todosPares :: Int -> Bool
todosPares n = [ x| x<-numerosAbundantesMenores n, even x ] == numerosAbundantesMenores n
-- Elsa Domínguez
todosPares :: Int -> Bool
todosPares n = length (filter odd (numerosAbundantesMenores n)) == 0
-- Adolfo Sagrera Vivancos, Ana Sosa Caballero, Cristina Torres
todosPares1 :: Int -> Bool
todosPares1 n = and [even x | x <- numerosAbundantesMenores n]

-- ---------------------------------------------------------------------
-- Ejercicio 5.4. Definir la constante
-- primerAbundanteImpar :: Int
-- que calcule el primer número natural abundante impar. Determinar el
-- valor de dicho número.
-- ---------------------------------------------------------------------

--Álvaro Cano, Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero, Cristina Torres
primerAbundanteImpar :: Int
primerAbundanteImpar = head [x | x <- [1,3..], numeroAbundante x]
-- Su cálculo es
-- ghci> primerAbundanteImpar
-- 945
-- Adolfo Sagrera Vivancos
primerAbundanteImpar1 :: Int
primerAbundanteImpar1 = head [n | n <- [1..], odd n, numeroAbundante n]
-- ---------------------------------------------------------------------
-- Ejercicio 6 (Problema 1 del proyecto Euler) Definir la función
-- euler1 :: Int -> Int
-- tal que (euler1 n) es la suma de todos los múltiplos de 3 ó 5 menores
-- que n. Por ejemplo,
-- euler1 10 == 23
--
-- Calcular la suma de todos los múltiplos de 3 ó 5 menores que 1000.
-- ---------------------------------------------------------------------

--Álvaro Cano
euler1 :: Int -> Int
euler1 n = sum [3*x | x <- [1..n] , 3*x < n] + sum [5*x | x <- [1..n], 5*x < n]
-- Cálculo:
-- ghci> euler1 1000
-- 266333
-- Lucía Hernández, Adolfo Sagrera Vivancos
euler1 :: Int -> Int
euler1 n = sum [x |x<-[1..n-1], mod x 5 == 0 || mod x 3 == 0]
-- Cálculo:λ> euler1 1000
-- 233168
-- Elsa Domínguez
euler1' :: Int -> Int
euler1' n = sum [x | x <- [1..n-1], multiplo x 3 || multiplo x 5]
where multiplo x y = rem x y == 0
-- Ana Sosa Caballero
euler1 :: Int -> Int
euler1 n = sum [x | x <- [1..n-1], (rem x 3 == 0) || (rem x 5 == 0)]
-- Cálculo:
-- λ> euler1' 1000
-- 233168

-- Cristina Torres

euler1 :: Int -> Int
euler1 n = sum [ i | i<- [1..n-1], rem i 3==0 || rem i 5==0 ]
-- Cálculo: λ> euler1 1000
233168

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir la función
-- circulo :: Int -> Int
-- tal que (circulo n) es el la cantidad de pares de números naturales
-- (x,y) que se encuentran dentro del círculo de radio n. Por ejemplo,
-- circulo 3 == 9
-- circulo 4 == 15
-- circulo 5 == 22
-- circulo 100 == 7949
-- ---------------------------------------------------------------------

--Álvaro Cano, Elsa Domínguez, Lucía Hernández, Adolfo Sagrera Vivancos, Cristina Torres
circulo :: Int -> Int
circulo n = length [(x,y) | x <- [0..n], y <- [0..n], x^2 + y^2 < n^2]

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir la función
-- aproxE :: Double -> [Double]
-- tal que (aproXE n) es la lista cuyos elementos son los términos de la
-- sucesión (1+1/m)**m desde 1 hasta n. Por ejemplo,
-- aproxE 1 == [2.0]
-- aproxE 4 == [2.0,2.25,2.37037037037037,2.44140625]
-- ---------------------------------------------------------------------

--Álvaro Cano, Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero, Adolfo Sagrera Vivancos, Cristina Torres
aproxE :: Double -> [Double]
aproxE n = [(1+1/m)**m | m <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. żCuál es el límite de la sucesión (1+1/m)**m ?
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- El límite es el número e.

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Definir la función
-- errorAproxE :: Double -> Double
-- tal que (errorE x) es el menor número de términos de la sucesión
-- (1+1/m)**m necesarios para obtener su límite con un error menor que
-- x. Por ejemplo,
-- errorAproxE 0.1 == 13.0
-- errorAproxE 0.01 == 135.0
-- errorAproxE 0.001 == 1359.0
-- Indicación: En Haskell, e se calcula como (exp 1).
-- ---------------------------------------------------------------------

--Álvaro Cano
errorAproxE :: Double -> Double
errorAproxE x = head [m | m <- [1..], (exp 1 - (1+1/m)**m) < x]
-- Elsa Domínguez, Lucía Hernández, Adolfo Sagrera Vivancos
errorAproxE' :: Double -> Double
errorAproxE' x = head [m | m <- [1..], abs (exp 1 - (1+1/m)**m) < x]

-- ---------------------------------------------------------------------
-- Ejercicio 9.1. Definir la función
-- aproxLimSeno :: Double -> [Double]
-- tal que (aproxLimSeno n) es la lista cuyos elementos son los términos
-- de la sucesión
-- sen(1/m)
-- --------
-- 1/m
-- desde 1 hasta n. Por ejemplo,
-- aproxLimSeno 1 == [0.8414709848078965]
-- aproxLimSeno 2 == [0.8414709848078965,0.958851077208406]
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Ana Sosa Caballero, Adolfo Sagrera Vivancos
aproxLimSeno :: Double -> [Double]
aproxLimSeno n = [sin (1/m) / (1/m) | m <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 9.2. żCuál es el límite de la sucesión sen(1/m)/(1/m) ?
-- ---------------------------------------------------------------------
-- Elsa Domínguez
-- El límite es 1.
-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Definir la función
-- errorLimSeno :: Double -> Double
-- tal que (errorLimSeno x) es el menor número de términos de la sucesión
-- sen(1/m)/(1/m) necesarios para obtener su límite con un error menor
-- que x. Por ejemplo,
-- errorLimSeno 0.1 == 2.0
-- errorLimSeno 0.01 == 5.0
-- errorLimSeno 0.001 == 13.0
-- errorLimSeno 0.0001 == 41.0
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Adolfo Sagrera Vivancos
errorLimSeno :: Double -> Double
errorLimSeno x = head [m | m <- [1..], abs (1 - sin (1/m) / (1/m)) < x]

-- ---------------------------------------------------------------------
-- Ejercicio 10.1. Definir la función
-- calculaPi :: Double -> Double
-- tal que (calculaPi n) es la aproximación del número pi calculada
-- mediante la expresión
-- 4*(1 - 1/3 + 1/5 - 1/7 + ...+ (-1)**n/(2*n+1))
-- Por ejemplo,
-- calculaPi 3 == 2.8952380952380956
-- calculaPi 300 == 3.1449149035588526
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Adolfo Sagrera Vivancos
calculaPi :: Double -> Double
calculaPi n = 4*(sum [(-1)**x / (2*x + 1) | x <- [0..n]])

-- ---------------------------------------------------------------------
-- Ejercicio 10.2. Definir la función
-- errorPi :: Double -> Double
-- tal que (errorPi x) es el menor número de términos de la serie
-- 4*(1 - 1/3 + 1/5 - 1/7 + ...+ (-1)**n/(2*n+1))
-- necesarios para obtener pi con un error menor que x. Por ejemplo,
-- errorPi 0.1 == 9.0
-- errorPi 0.01 == 99.0
-- errorPi 0.001 == 999.0
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Adolfo Sagrera Vivancos
errorPi :: Double -> Double
errorPi x = head [n | n <- [1..], abs (pi - calculaPi n) < x]

-- ---------------------------------------------------------------------
-- Ejercicio 11.1. Una terna (x,y,z) de enteros positivos es pitagórica
-- si x^2 + y^2 = z^2.
--
-- Definir, por comprensión, la función
-- pitagoricas :: Int -> [(Int,Int,Int)]
-- tal que (pitagoricas n) es la lista de todas las ternas pitagóricas
-- cuyas componentes están entre 1 y n. Por ejemplo,
-- pitagoricas 10 == [(3,4,5),(4,3,5),(6,8,10),(8,6,10)]
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero, Adolfo Sagrera Vivancos
pitagoricas :: Int -> [(Int,Int,Int)]
pitagoricas n = [(x,y,z) | x <-[1..n], y <-[1..n], z <-[1..n], x^2+y^2 == z^2]

-- ---------------------------------------------------------------------
-- Ejercicio 11.2. Definir la función
-- numeroDePares :: (Int,Int,Int) -> Int
-- tal que (numeroDePares t) es el número de elementos pares de la terna
-- t. Por ejemplo,
-- numeroDePares (3,5,7) == 0
-- numeroDePares (3,6,7) == 1
-- numeroDePares (3,6,4) == 2
-- numeroDePares (4,6,4) == 3
-- ---------------------------------------------------------------------
-- Lucía Hernández
numeroDePares :: (Int,Int,Int) -> Int
numeroDePares (x,y,z) = length [i | i<-[x,y,z], even i]

-- Elsa Domínguez
numeroDePares1 :: (Int,Int,Int) -> Int
numeroDePares1 (x,y,z) = sum [1 | a <- [x,y,z], even a]

-- Ana Sosa Caballero
numeroDePares2 :: (Int,Int,Int) -> Int
numeroDePares2 (x,y,z) = sum [1 | _ <- filter even [x,y,z]]

-- ---------------------------------------------------------------------
-- Ejercicio 11.3. Definir la función
-- conjetura :: Int -> Bool
-- tal que (conjetura n) se verifica si todas las ternas pitagóricas
-- cuyas componentes están entre 1 y n tiene un número impar de números
-- pares. Por ejemplo,
-- conjetura 10 == True
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández
conjetura :: Int -> Bool
conjetura n = and [odd (numeroDePares (x,y,z)) | (x,y,z) <- pitagoricas n]

-- ---------------------------------------------------------------------
-- Ejercicio 11.4. Demostrar la conjetura para todas las ternas
-- pitagóricas.
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 12.1. (Problema 9 del Proyecto Euler). Una terna pitagórica
-- es una terna de números naturales (a,b,c) tal que a<b<c y
-- a^2+b^2=c^2. Por ejemplo (3,4,5) es una terna pitagórica.
--
-- Definir la función
-- ternasPitagoricas :: Integer -> [[Integer]]
-- tal que (ternasPitagoricas x) es la lista de las ternas pitagóricas
-- cuya suma es x. Por ejemplo,
-- ternasPitagoricas 12 == [(3,4,5)]
-- ternasPitagoricas 60 == [(10,24,26),(15,20,25)]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
ternasPitagoricas :: Integer -> [(Integer,Integer,Integer)]
ternasPitagoricas x = [(a,b,c) | a <- [1..x], b <- [a+1..x], c <- [b+1..x], a^2 + b^2 == c^2, a+b+c == x]
--Lucía Hernández
ternasPitagoricas :: Integer -> [(Integer,Integer,Integer)]
ternasPitagoricas x = [(a,b,c) | a<-[1..x],b<-[1..x],c<-[1..x], a<b && b<c,a^2+b^2 == c^2,a+b+c == x ]

-- Ana Sosa Caballero
ternasPitagoricas :: Integer -> [(Integer,Integer,Integer)]
ternasPitagoricas t = [ (x,y,z) | x <- [1..], y <- [1..], z <- [1..], x<y && y<z, x^2+y^2 == z^2, sum [x,y,z] == t]

-- ---------------------------------------------------------------------
-- Ejercicio 12.2. Definir la constante
-- euler9 :: Integer
-- tal que euler9 es producto abc donde (a,b,c) es la única terna
-- pitagórica tal que a+b+c=1000.
--
-- Calcular el valor de euler9.
-- ---------------------------------------------------------------------

euler9 :: Integer
euler9 = undefined

-- El cálculo del valor de euler9 es

-- ---------------------------------------------------------------------
-- Ejercicio 13. El producto escalar de dos listas de enteros xs y ys de
-- longitud n viene dado por la suma de los productos de los elementos
-- correspondientes.
--
-- Definir por comprensión la función
-- productoEscalar :: [Int] -> [Int] -> Int
-- tal que (productoEscalar xs ys) es el producto escalar de las listas
-- xs e ys. Por ejemplo,
-- productoEscalar [1,2,3] [4,5,6] == 32
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sosa Caballero
productoEscalar :: [Int] -> [Int] -> Int
productoEscalar xs ys = sum [a*b | (a,b) <- zip xs ys]

-- Lucía Hernández
productoEscalar :: [Int] -> [Int] -> Int
productoEscalar xs ys = sum [ fst p * snd p |p<- zip xs ys]
-- ---------------------------------------------------------------------
-- Ejercicio 14. Definir, por comprensión, la función
-- sumaConsecutivos :: [Int] -> [Int]
-- tal que (sumaConsecutivos xs) es la suma de los pares de elementos
-- consecutivos de la lista xs. Por ejemplo,
-- sumaConsecutivos [3,1,5,2] == [4,6,7]
-- sumaConsecutivos [3] == []
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sosa Caballero
sumaConsecutivos :: [Int] -> [Int]
sumaConsecutivos xs = [a+b | (a,b) <- zip xs (tail xs)]
--Lucía Hernández
sumaConsecutivos :: [Int] -> [Int]
sumaConsecutivos xs = [fst p + snd p | p<-zip xs (tail xs) ]
-- ---------------------------------------------------------------------
-- Ejercicio 15. Los polinomios pueden representarse de forma dispersa o
-- densa. Por ejemplo, el polinomio 6x^4-5x^2+4x-7 se puede representar
-- de forma dispersa por [6,0,-5,4,-7] y de forma densa por
-- [(4,6),(2,-5),(1,4),(0,-7)].
--
-- Definir la función
-- densa :: [Int] -> [(Int,Int)]
-- tal que (densa xs) es la representación densa del polinomio cuya
-- representación dispersa es xs. Por ejemplo,
-- densa [6,0,-5,4,-7] == [(4,6),(2,-5),(1,4),(0,-7)]
-- densa [6,0,0,3,0,4] == [(5,6),(2,3),(0,4)]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
densa :: [Int] -> [(Int,Int)]
densa xs = [(a,b) | (a,b) <- zip (reverse [0..(length xs-1)]) xs, b /= 0]

-- Ana Sosa Caballero (Mal)
densa :: [Int] -> [(Int,Int)]
densa xs = [(y,x) | x <- xs , y <- [ys, ys-1 .. 0] ]
where ys = length xs -1
-- Lucía Hernández
densa :: [Int] -> [(Int,Int)]
densa xs = [(x,y) | (x,y)<- zip (reverse ys) xs, y/=0]
where ys = [0.. length xs-1]
-- ---------------------------------------------------------------------
-- Ejercicio 16.0. La bases de datos sobre actividades de personas pueden
-- representarse mediante listas de elementos de la forma (a,b,c,d),
-- donde a es el nombre de la persona, b su actividad, c su fecha de
-- nacimiento y d la de su fallecimiento. Un ejemplo es la siguiente que
-- usaremos a lo largo de este ejercicio,
-- ---------------------------------------------------------------------

personas :: [(String,String,Int,Int)]
personas = [("Cervantes","Literatura",1547,1616),
("Velazquez","Pintura",1599,1660),
("Picasso","Pintura",1881,1973),
("Beethoven","Musica",1770,1823),
("Poincare","Ciencia",1854,1912),
("Quevedo","Literatura",1580,1654),
("Goya","Pintura",1746,1828),
("Einstein","Ciencia",1879,1955),
("Mozart","Musica",1756,1791),
("Botticelli","Pintura",1445,1510),
("Borromini","Arquitectura",1599,1667),
("Bach","Musica",1685,1750)]

-- ---------------------------------------------------------------------
-- Ejercicio 16.1. Definir la función
-- nombres :: [(String,String,Int,Int)] -> [String]
-- tal que (nombres bd) es la lista de los nombres de las personas de la
-- base de datos bd. Por ejemplo,
-- ghci> nombres personas
-- ["Cervantes","Velazquez","Picasso","Beethoven","Poincare",
-- "Quevedo","Goya","Einstein","Mozart","Botticelli","Borromini","Bach"]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
nombres :: [(String,String,Int,Int)] -> [String]
nombres bd = [(a) | (a,_,_,_) <- bd]

-- ---------------------------------------------------------------------
-- Ejercicio 16.2. Definir la función
-- musicos :: [(String,String,Int,Int)] -> [String]
-- tal que (musicos bd) es la lista de los nombres de los músicos de la
-- base de datos bd. Por ejemplo,
-- musicos personas == ["Beethoven","Mozart","Bach"]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
musicos :: [(String,String,Int,Int)] -> [String]
musicos bd = [(a) | (a,b,_,_) <- bd, b == "Musica"]

-- ---------------------------------------------------------------------
-- Ejercicio 16.3. Definir la función
-- seleccion :: [(String,String,Int,Int)] -> String -> [String]
-- tal que (seleccion bd m) es la lista de los nombres de las personas
-- de la base de datos bd cuya actividad es m. Por ejemplo,
-- ghci> seleccion personas "Pintura"
-- ["Velazquez","Picasso","Goya","Botticelli"]
-- ghci> seleccion personas "Musica"
-- ["Beethoven","Mozart","Bach"]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
seleccion :: [(String,String,Int,Int)] -> String -> [String]
seleccion bd m = [(a) | (a,b,_,_) <- bd, b == m]

-- ---------------------------------------------------------------------
-- Ejercicio 16.4. Definir, usando el apartado anterior, la función
-- musicos' :: [(String,String,Int,Int)] -> [String]
-- tal que (musicos' bd) es la lista de los nombres de los músicos de la
-- base de datos bd. Por ejemplo,
-- ghci> musicos' personas
-- ["Beethoven","Mozart","Bach"]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
musicos' :: [(String,String,Int,Int)] -> [String]
musicos' bd = seleccion bd "Musica"

-- ---------------------------------------------------------------------
-- Ejercicio 16.5. Definir la función
-- vivas :: [(String,String,Int,Int)] -> Int -> [String]
-- tal que (vivas bd a) es la lista de los nombres de las personas de la
-- base de datos bd que estaban vivas en el ańo a. Por ejemplo,
-- ghci> vivas personas 1600
-- ["Cervantes","Velazquez","Quevedo","Borromini"]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
vivas :: [(String,String,Int,Int)] -> Int -> [String]
vivas ps a = [(p) | (p,_,c,d) <- ps, c <= a && a <= d]

</source>

Relación 2

2021-10-20T18:47:15Z

Critorseb:

<source lang='haskell'>

-- I1M 2021-22: Rel_2.hs (08 de octubre de 2021)
-- Definiciones con condicionales, guardas o patrones.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

-- ---------------------------------------------------------------------
-- Introducción --
-- ---------------------------------------------------------------------

-- En esta relación se presentan ejercicios con definiciones elementales
-- (no recursivas) de funciones que usan condicionales, guardas o
-- patrones.
--
-- De forma adicional, se adjuntan ejercicios de repaso para trabajar con
-- operaciones lógicas sobre valores de verdad (o booleanos), sobre todo
-- con &&, || y not.
--
-- Estos ejercicios se corresponden con el tema 4 cuyas transparencias
-- se encuentran en
-- http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-4.html

-- ---------------------------------------------------------------------
-- § Librerías auxiliares --
-- ---------------------------------------------------------------------

-- Esta librería se puede instalar de la siguiente forma:
-- 1. Abrir cmd (Windows) o Terminal (MacOS y Linux)
-- 2. Escribir: cabal update
-- 3. Escribir: cabal install QuickCheck

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
-- divisionSegura :: Double -> Double -> Double
-- tal que (divisionSegura x y) es x/y si y no es cero y 9999 en caso
-- contrario. Por ejemplo,
-- divisionSegura 7 2 == 3.5
-- divisionSegura 7 0 == 9999.0
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Elsa Domínguez,Lucía González, Adolfo Sagrera Vivancos, José Manuel García, Fernando Martínez Ortega, Ángela Pérez Ríos, Irene Ortega Moncayo, Cristina Torres
divisionSegura :: Double -> Double -> Double
divisionSegura x y = if y == 0 then 9999
else x/y
-- Laura Arango
divisionSegura1 :: Double -> Double -> Double
divisionSegura1 x y | y == 0 = 999
| otherwise = x/y
-- Alereyvil
divisionSegura x y | y/=0 = x/y
| y==0 = 9999.0

-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir la función
-- intercambia :: (a,b) -> (b,a)
-- tal que (intercambia p) es el punto obtenido intercambiando las
-- coordenadas del punto p. Por ejemplo,
-- intercambia (2,5) == (5,2)
-- intercambia (5,2) == (2,5)
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero,Lucía González, Adolfo Sagrera Vivancos, José Manuel García, Fernando Martínez Ortega, Ángela Pérez Ríos, Irene Ortega Moncayo, Cristina Torres
intercambia :: (a,b) -> (b,a)
intercambia (a,b) = (b,a)
-- Lucía Hernández, Laura Arango, Elsa Domínguez
intercambia1 :: (a,b) -> (b,a)
intercambia1 p = (snd p, fst p)
-- ---------------------------------------------------------------------
-- Ejercicio 3. Comprobar con QuickCheck que la función intercambia es
-- idempotente; es decir, si se aplica dos veces es lo mismo que no
-- aplicarla ninguna.
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Adolfo Sagrera Vivancos, Lucía González, José Manuel García, Fernando Martínez Ortega, Ángela Pérez Ríos, Irene Ortega Moncayo, Cristina Torres
-- La propiedad es
prop_intercambia :: (Int,Int) -> Bool
prop_intercambia (a,b) = intercambia (intercambia (a,b)) == (a,b)
-- La comprobación es quickCheck prop_intercambia
+++ OK, passed 100 tests
--Lucía Hernández, Laura Arango, Elsa Domínguez
-- La propiedad es
prop_intercambia1 :: (Int,Int) -> Bool
prop_intercambia1 p = intercambia1 (intercambia1 p) == p

-- La comprobación es quickCheck prop_intercambia1
+++OK, passed 100 tests.
-- ---------------------------------------------------------------------
-- Ejercicio 4.1. Definir una función
-- ciclo :: [a] -> [a]
-- tal que (ciclo xs) es la lista obtenida permutando cíclicamente los
-- elementos de la lista xs, pasando el último elemento al principio de
-- la lista. Por ejemplo,
-- ciclo [2,5,7,9] == [9,2,5,7]
-- ciclo [] == []
-- ciclo [2] == [2]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
ciclo :: [a] -> [a]
ciclo xs | length xs == 0 = xs
| otherwise = last xs : init xs
--Lucía Hernández, Irene Ortega Moncayo, Cristina Torres
ciclo1 :: [a] -> [a]
ciclo1 xs =if length xs == 0 then []
else last xs:init xs
--Laura Arango
ciclo2 :: [a] -> [a]
ciclo2 [] = []
ciclo2 xs = last xs : init xs
-- Adolfo Sagrera Vivancos, Lucía González
ciclo3 xs |length xs == 0 = []
|otherwise = last xs:init xs
-- José Manuel García
ciclo4 :: [a] -> [a]
ciclo4 xs = take (length xs) ((drop (length xs - 1) xs) ++ xs)

-- ---------------------------------------------------------------------
-- Ejercicio 4.2. Comprobar que la longitud es un invariante de la
-- función ciclo; es decir, la longitud de (ciclo xs) es la misma que la
-- de xs.
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez, Lucía Hernández,Lucía González,Laura Arango, Adolfo Sagrera Vivancos, José Manuel García, Ángela Pérez Ríos, Irene Ortega Moncayo, Cristina Torres
-- La propiedad es
prop_ciclo :: [Int] -> Bool
prop_ciclo xs = length (ciclo xs) == length xs

-- La comprobación es quickCheck prop_ciclo
+++OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 5. Definir la función
-- numeroMayor :: (Num a, Ord a) => a -> a -> a
-- tal que (numeroMayor x y) es el mayor número de dos cifras que puede
-- construirse con los dígitos x e y. Por ejemplo,
-- numeroMayor 2 5 == 52
-- numeroMayor 5 2 == 52
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez, Lucía Hernández, Laura Arango, Irene Ortega Moncayo
numeroMayor :: (Num a, Ord a) => a -> a -> a
numeroMayor x y = if x > y then (x*10 + y) else (y*10+x)
-- Adolfo Sagrera Vivancos, José Manuel García, Lucía González, Cristina Torres
numeroMayor1 x y | x<y = (y*10+x)
| x>y = (x*10+y)

-- ---------------------------------------------------------------------
-- Ejercicio 6. Definir la función
-- numeroDeRaices :: (Num t, Ord t) => t -> t -> t -> Int
-- tal que (numeroDeRaices a b c) es el número de raíces reales de la
-- ecuación a*x^2 + b*x + c = 0. Por ejemplo,
-- numeroDeRaices 2 0 3 == 0
-- numeroDeRaices 4 4 1 == 1
-- numeroDeRaices 5 23 12 == 2
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
numeroDeRaices :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices a b c | t < 0 = 0
| t == 0 = 1
| otherwise = 2
where t = b^2 - 4*a*c
-- Elsa Domínguez, Lucía González, Irene Ortega Moncayo, Cristina Torres
numeroDeRaices1 :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices1 a b c | b^2-4*a*c < 0 = 0
| b^2-4*a*c == 0 = 1
| otherwise = 2
--Lucía Hernández, Laura Arango, Adolfo Sagrera Vivancos, José Manuel García
numeroDeRaices2 :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices2 a b c |(b^2-4*a*c) >0 = 2
|(b^2-4*a*c) == 0 = 1
|otherwise = 0

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir la función
-- raices :: Double -> Double -> Double -> [Double]
-- tal que (raices a b c) es la lista de las raíces reales de la
-- ecuación ax^2 + bx + c = 0. Por ejemplo,
-- raices 1 3 2 == [-1.0,-2.0]
-- raices 1 (-2) 1 == [1.0,1.0]
-- raices 1 0 1 == []
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
raices :: Double -> Double -> Double -> [Double]
raices a b c | b == 0 = []
| otherwise = [(-b+t)/2*a, (-b-t)/2*a]
where t = b^2 - 4*a*c
-- Elsa Domínguez, Laura Arango, Irene Ortega Moncayo, Cristina Torres
raices1 :: Double -> Double -> Double -> [Double]
raices1 a b c | b^2-4*a*c == 0 = [-b/2*a, -b/2*a]
| b^2-4*a*c < 0 = []
| b^2-4*a*c > 0 = [(-b+t)/(2*a), (-b-t)/(2*a)]
where t = sqrt (b^2-4*a*c)
--Lucía Hernández, José Manuel García
raices2 :: Double -> Double -> Double -> [Double]
raices2 a b c |(b^2-4*a*c) >0 = [(-b+sqrt(b^2-4*a*c))/2*a,(-b-sqrt(b^2-4*a*c))/2*a]
|(b^2-4*a*c) == 0 = [-b/2*a, -b/2*a]
|otherwise = []
-- Adolfo Sagrera Vivancos, Lucía González
raices3 a b c | numeroDeRaices a b c == 0 = []
| numeroDeRaices a b c == 1 = [-b/(2*a), -b/(2*a)]
| otherwise = [(-b+sqrt(b^2-4*a*c))/(2*a), (-b-sqrt(b^2-4*a*c))/(2*a)]
-- ---------------------------------------------------------------------
-- Ejercicio 8. Definir el operador
-- (~=) :: (Fractional a, Ord a) => a -> a -> Bool
-- tal que (x ~= y) se verifica si x e y son casi iguales; es decir si
-- el valor absoluto de su diferencia es menor que una milésima. Por
-- ejemplo,
-- 12.3457 ~= 12.3459 == True
-- 12.3457 ~= 12.3479 == False
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Adolfo Sagrera Vivancos, Cristina Torres
(~=) :: (Fractional a, Ord a) => a -> a -> Bool
x ~= y | abs(x-y) <= 0.001 = True
| otherwise = False
--Lucía Hernández, Laura Arango, Lucía González, Irene Ortega Moncayo
(~=) :: (Fractional a, Ord a) => a -> a -> Bool
x ~= y = if abs(x - y)<0.001 then True
else False
-- Elsa Domínguez, José Manuel García
(~=) :: (Fractional a, Ord a) => a -> a -> Bool
x ~= y = abs (x-y) < 0.001
-- ---------------------------------------------------------------------
-- Ejercicio 9. Comprobar con QuickCheck que la suma de las raíces
-- de la ecuación ax^2 + bx + c = 0 (con a no nulo) es -b/a y su
-- producto es c/a.
--
-- Nota. En la comparación usar ~= en lugar de ==
-- ---------------------------------------------------------------------
-- Adolfo Sagrera Vivancos, Elsa Domínguez, Lucía González, Irene Ortega Moncayo, Cristina Torres
-- La propiedad es
prop_raices :: Double -> Double -> Double -> Property
prop_raices a b c = (a /= 0) && not (null (raices a b c)) ==> (sum (raices a b c)) ~= (-b/a) && (product (raices a b c)) ~= (c/a)
-- La comprobación es quickCheck prop_raices
-- +++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 10. En geometría, la fórmula de Herón, descubierta por
-- Herón de Alejandría, dice que el área de un triángulo cuyo lados
-- miden a, b y c es la raíz cuadrada de s(s-a)(s-b)(s-c) donde s es el
-- semiperímetro
-- s = (a+b+c)/2
--
-- Definir la función
-- area :: Double -> Double -> Double -> Double
-- tal que (area a b c) es el área del triángulo de lados a, b y c. Por
-- ejemplo,
-- area 3 4 5 == 6.0
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, Lucía González, Elsa Domínguez, Adolfo Sagrera Vivancos, José Manuel García,César Fornis, Irene Ortega Moncayo, Cristina Torres
area :: Double -> Double -> Double -> Double
area a b c = sqrt(s*(s-a)*(s-b)*(s-c))
where s = (a+b+c)/2

-- ---------------------------------------------------------------------
-- Ejercicio 11. Los intervalos cerrados se pueden representar mediante
-- una lista de dos números (el primero es el extremo inferior del
-- intervalo y el segundo el superior).
--
-- Definir la función
-- interseccion :: Ord a => [a] -> [a] -> [a]
-- tal que (interseccion i1 i2) es la intersección de los intervalos i1 e
-- i2. Por ejemplo,
-- interseccion [] [3,5] == []
-- interseccion [3,5] [] == []
-- interseccion [2,4] [6,9] == []
-- interseccion [2,6] [6,9] == [6,6]
-- interseccion [2,6] [0,9] == [2,6]
-- interseccion [2,6] [0,4] == [2,4]
-- interseccion [4,6] [0,4] == [4,4]
-- interseccion [5,6] [0,4] == []
-- ---------------------------------------------------------------------
--Lucía Hernández
interseccion :: Ord a => [a] -> [a] -> [a]
interseccion [] _ = []
interseccion _ []= []
interseccion i1 i2 | last i1<head i2 = []
|head i1>last i2 = []
|otherwise = [maximum [head i1,head i2], minimum [last i1,last i2]]
--Laura Arango, Elsa Domínguez, César Fornis, Lucía González
interseccion1 :: Ord a => [a] -> [a] -> [a]
interseccion1 i1 i2 | i1==[] || i2==[] || head i1>last i2 || last i1<head i2 = []
| otherwise = [max (head i1)(head i2), min (last i1)(last i2)]
--José Manuel García, Fernando Martínez Ortega, Irene Ortega Moncayo
interseccion2 :: Ord a => [a] -> [a] -> [a]
interseccion2 i1 i2 | null i1 || null i2 || a > d || b < c = []
| a <= c && b <= d = [c,b]
| a >= c && b <= d = [a,b]
| a >= c && b >= d = [a,d]
| a <= c && b >= d = [c,d]
where a = head i1
b = last i1
c = head i2
d = last i2
-- Adolfo Sagrera Vivancos, Cristina Torres
interseccion3 :: Ord a => [a] -> [a] -> [a]
interseccion3 i1 i2 | null i1 || null i2 || a > d || b < c = []
| otherwise = [max a c, min b d]
where a = head i1
b = last i1
c = head i2
d = last i2
-- ---------------------------------------------------------------------
-- Ejercicio 12. Comprobar con QuickCheck que la intersección de
-- intervalos es conmutativa.
-- ---------------------------------------------------------------------
--Lucía Hernández, Laura Arango, Elsa Domínguez, José Manuel García, Lucía González, Adolfo Sagrera Vivancos, Irene Ortega Moncayo, Cristina Torres
-- La propiedad es
prop_interseccion :: Int -> Int -> Int -> Int -> Bool
prop_interseccion a1 a2 b1 b2 = interseccion [a1,a2] [b1,b2] == interseccion [b1,b2] [a1,a2]

-- La comprobación es quickCheck prop_interseccion
+++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 13.1. Los números racionales pueden representarse mediante
-- pares de números enteros. Por ejemplo, el número 2/5 puede
-- representarse mediante el par (2,5).
--
-- Definir la función
-- formaReducida :: (Int,Int) -> (Int,Int)
-- tal que (formaReducida x) es la forma reducida del número racional
-- x. Por ejemplo,
-- formaReducida (4,10) == (2,5)
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, José Manuel García, Lucía González, Irene Ortega Moncayo, Cristina Torres
formaReducida :: (Int,Int) -> (Int,Int)
formaReducida (a,b) = (div a z, div b z)
where z = gcd a b
-- Adolfo Sagrera Vivancos
formaReducida1 :: (Int,Int) -> (Int,Int)
formaReducida1 (a,b) = (s*abs(div a z), abs(div b z)) where z = gcd a b
s = signum (a*b)
-- Elsa Domínguez
formaReducida2 :: (Int,Int) -> (Int,Int)
formaReducida2 (a,b) | a == 0 && b == 0 = (0,0)
| otherwise = (s*abs(div a z), abs(div b z))
where z = gcd a b
s = signum (a*b)

-- ---------------------------------------------------------------------
-- Ejercicio 13.2. Definir la función
-- sumaRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
-- tal que (sumaRacional x y) es la suma de los números racionales x e
-- y, expresada en forma reducida. Por ejemplo,
-- sumaRacional (2,3) (5,6) == (3,2)
-- ---------------------------------------------------------------------

--Lucía Hernández
sumaRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
sumaRacional (a,b) (c,d) = if b<d then formaReducida((div s b)*a + c, s)
else formaReducida(a+ (div s d)*c, s)
where s = lcm b d
-- Elsa Domínguez, José Manuel García, Lucía González, Irene Ortega Moncayo, Cristina Torres
sumaRacional1 :: (Int,Int) -> (Int,Int) -> (Int,Int)
sumaRacional1 (a,b) (c,d) = formaReducida (a*d + c*b, b*d)
--Pelayo Infante
sumaRacional2 :: (Int,Int) -> (Int,Int) -> (Int,Int)
sumaRacional2 (a,b) (c,d) = formaReducida ((x), (lcm b d))
where x= y+ ((div (lcm b d) d)*c)
where y= (div(lcm b d) b)*a
--Adolfo Sagrera Vivancos
sumaRacional3 :: (Int,Int) -> (Int,Int) -> (Int,Int)
sumaRacional3 (a,b) (c,d) = formaReducida(((div t b)*a + (div t d)*c), t) where t = lcm b d

-- ---------------------------------------------------------------------
-- Ejercicio 13.3. Definir la función
-- productoRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
-- tal que (productoRacional x y) es el producto de los números
-- racionales x e y. Por ejemplo,
-- productoRacional (2,3) (5,6) == (5,9)
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
productoRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
productoRacional (a,b) (c,d) = formaReducida (x,t)
where x = a*c
t = b*d
-- Lucía Hernández, Laura Arango, Elsa Domínguez, José Manuel García, Adolfo Sagrera Vivancos, Lucía González, Irene Ortega Moncayo
productoRacional1 :: (Int,Int) -> (Int,Int) -> (Int,Int)
productoRacional1 (a,b) (c,d) = formaReducida (a*c, b*d)
-- ----------------------------------------------------------------------------
-- Ejercicio 13.4. Definir la función
-- cocienteRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
-- tal que '(cocienteRacional x y)' es el cociente de los números racionales
-- 'x' e 'y'. Por ejemplo,
-- cocienteRacional (2,3) (5,6) == (4,5)
-- ----------------------------------------------------------------------------
-- Lucía Hernández, Laura Arango, Elsa Domínguez, José Manuel García, Adolfo Sagrera Vivancos, Lucía González, Irene Ortega Moncayo
cocienteRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
cocienteRacional (x1,x2) (y1,y2) = formaReducida (x1*y2, x2*y1)

-- ---------------------------------------------------------------------
-- Ejercicio 13.5. Definir la función
-- igualdadRacional :: (Int,Int) -> (Int,Int) -> Bool
-- tal que (igualdadRacional x y) se verifica si los números racionales
-- x e y son iguales. Por ejemplo,
-- igualdadRacional (6,9) (10,15) == True
-- igualdadRacional (6,9) (11,15) == False
-- igualdadRacional (0,2) (0,-5) == True
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
igualdadRacional :: (Int,Int) -> (Int,Int) -> Bool
igualdadRacional (a,b) (c,d) = formaReducida (a,b) == formaReducida (c,d)
-- Laura Arango
igualdadRacional1 :: (Int,Int) -> (Int,Int) -> Bool
igualdadRacional1 (a,b) (c,d) = formaReducida (a,b) == formaReducida (c,d)
|| (a==0 && c==0)
|| (b==0 && d==0)
-- José Manuel García
igualdadRacional3 :: (Int,Int) -> (Int,Int) -> Bool
igualdadRacional3 (a,b) (c,d) = if (a == 0 && c == 0) || (b == 0 && d == 0)
then True
else formaReducida (a,b) == formaReducida (c,d)
-- César Fornis Catalán
igualdadRacional4 :: (Int,Int) -> (Int,Int) -> Bool
igualdadRacional4 (a,b) (c,d) = a*d == b*c

-- ---------------------------------------------------------------------
-- Ejercicio 13.6. Comprobar con QuickCheck la propiedad distributiva
-- del producto racional respecto de la suma.
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Irene Ortega Moncayo
-- La propiedad es
prop_distributiva :: (Int,Int) -> (Int,Int) -> (Int,Int) -> Property
prop_distributiva x y z = (fst x * snd x /= 0) && (fst y * snd y /= 0) && (fst z * snd z /= 0) ==>
igualdadRacional (productoRacional (sumaRacional x y) z) (sumaRacional (productoRacional x z) (productoRacional y z))

-- La comprobación es quickCheck prop_distributiva
-- +++ OK, passed 100 tests.

-- ----------------------------------------------------------------------------
-- Ejercicio 14. Los números complejos se pueden representar mediante pares de
-- números reales. Por ejemplo, el número 2+5i se puede representar mediante
-- el par (2,5).
-- ----------------------------------------------------------------------------

-- Lo siguiente significa que el tipo Complejo es lo mismo que decir (Double,Double)
type Complejo = (Double,Double)

-- ----------------------------------------------------------------------------
-- Ejercicio 14.1. Definir la función
-- sumaComplejos :: Complejo -> Complejo -> Complejo
-- tal que '(sumaComplejos x y)' es la suma de los números complejos 'x' e 'y'.
-- Por ejemplo,
-- sumaComplejos (2,3) (5,6) == (7.0,9.0)
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, Elsa Domínguez, Irene Ortega Moncayo, José Manuel García, Adolfo Sagrera Vivancos, Lucía González
sumaComplejos :: Complejo -> Complejo -> Complejo
sumaComplejos (x1,x2) (y1,y2) = (x1+y1, x2+y2)

-- ----------------------------------------------------------------------------
-- Ejercicio 14.2. Definir la función
-- productoComplejos :: Complejo -> Complejo -> Complejo
-- tal que '(productoComplejos x y)' es el producto de los números complejos
-- 'x' e 'y'. Por ejemplo,
-- productoComplejos (2,3) (5,6) == (-8.0,27.0)
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, Elsa Domínguez, José Manuel García, Adolfo Sagrera Vivancos, Irene Ortega Moncayo, Lucía González
productoComplejos :: Complejo -> Complejo -> Complejo
productoComplejos (x1,x2) (y1,y2) = ((x1*y1 - x2*y2),(x2*y1 + x1*y2))
-- ----------------------------------------------------------------------------
-- Ejercicio 14.3. Definir la función
-- cocienteComplejos :: Complejo -> Complejo -> Complejo
-- tal que '(cocienteComplejos x y)' es el cociente de los números complejos
-- 'x' e 'y'. Por ejemplo,
-- cocienteComplejos (3,2) (1,-2) == (-0.2,1.6)
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Laura Arango, Lucía González, Irene Ortega Moncayo
cocienteComplejos :: Complejo -> Complejo -> Complejo
cocienteComplejos (x1,x2) (y1,y2) = (((x1*y1 + x2*y2)/ t), ((x2*y1 - x1*y2)/t))
where t = (y1^2 + y2^2)
-- Elsa Domínguez, Adolfo Sagrera Vivancos
cocienteComplejos :: Complejo -> Complejo -> Complejo
cocienteComplejos (x1,x2) (y1,y2) = (a,b)
where a = fst (productoComplejos (x1,x2) (y1,-y2))/(y1^2 + y2^2)
b = snd (productoComplejos (x1,x2) (y1,-y2))/(y1^2 + y2^2)

-- ----------------------------------------------------------------------------
-- Ejercicio 14.4. Definir la función
-- conjugado :: Complejo -> Complejo
-- tal que '(conjugado x)' es el conjugado del número complejo 'x'. Por
-- ejemplo,
-- conjugado (2,3) == (2.0,-3.0)
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, Elsa Domínguez, Irene Ortega Moncayo, José Manuel García, Adolfo Sagrera Vivancos, Lucía González
conjugado :: Complejo -> Complejo
conjugado (x1,x2) = (x1, -x2)

-- ----------------------------------------------------------------------------
-- Ejercicio 15. Los rectángulos pueden representarse por sus dimensiones, base
-- y altura, como un par de números enteros. Por ejemplo, (5,3) representa un
-- rectángulo de base 5 y altura 3.
--
-- Definir la función
-- mayorRectangulo :: (Int,Int) -> (Int,Int) -> (Int,Int)
-- tal que '(mayorRectangulo r1 r2)' es el rectángulo de mayor área entre 'r1'
-- y 'r2'. Por ejemplo,
-- mayorRectangulo (4,6) (3,7) == (4,6)
-- mayorRectangulo (4,6) (3,8) == (4,6)
-- mayorRectangulo (4,6) (3,9) == (3,9)
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero
mayorRectangulo :: (Int,Int) -> (Int,Int) -> (Int,Int)
mayorRectangulo (x1,y1) (x2,y2) = if t >= p then (x1,y1) else (x2,y2)
where t = x1*y1
p = x2*y2
-- Lucía Hernández, Laura Arango, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
mayorRectangulo1 :: (Int,Int) -> (Int,Int) -> (Int,Int)
mayorRectangulo1 (x1,y1) (x2,y2) = if x1*y1 >= x2*y2 then (x1,y1)
else (x2,y2)
-- Adolfo Sagrera Vivancos
mayorRectangulo2 :: (Int,Int) -> (Int,Int) -> (Int,Int)
mayorRectangulo2 (x1,y1) (x2,y2) | t > s = (x1, y1)
| s > t = (x2, y2)
| otherwise = (x1, y1)
where t = x1*y1
s = x2*y2
-- ----------------------------------------------------------------------------
-- Ejercicio 16. Definir la función
-- cuadrante :: (Int,Int) -> Int
-- tal que '(cuadrante p)' es el cuadrante en el que se encuentra el punto 'p'.
-- Si el punto está sobre los ejes el resultado debe ser 0. Por ejemplo,
-- cuadrante (0,4) == 0
-- cuadrante (-3,0) == 0
-- cuadrante (0,0) == 0
-- cuadrante (3,5) == 1
-- cuadrante (-3,5) == 2
-- cuadrante (-3,-5) == 3
-- cuadrante (3,-5) == 4
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero
cuadrante :: (Int,Int) -> Int
cuadrante (x1,x2) | or [x1 == 0, x2 == 0] = 0
| and [x1 > 0, x2 > 0] = 1
| and [x1 < 0, x2 > 0] = 2
| and [x1 < 0, x2 < 0] = 3
| otherwise = 4

--Lucía Hernández
cuadrante1 :: (Int,Int) -> Int
cuadrante1 (0,_) = 0
cuadrante1 (_,0) = 0
cuadrante1 (x1,x2) | x1>0 && x2>0 = 1
| x1<0 && x2>0 = 2
| x1<0 && x2<0 = 3
| otherwise = 4
--Laura Arango, Elsa Domínguez, Irene Ortega Moncayo
cuadrante2 :: (Int,Int) -> Int
cuadrante2 (x1,x2) | x1>0 && x2>0 = 1
| x1<0 && x2>0 = 2
| x1<0 && x2<0 = 3
| x1>0 && x2<0 = 4
| otherwise = 0
-- Adolfo Sagrera Vivancos, Lucía González
cuadrante3 :: (Int,Int) -> Int
cuadrante3 (x1,x2) | x1 == 0 || x2 == 0 = 0
| x1 == 0 && x2 == 0 = 0
| x1 > 0 && x2 > 0 = 1
| x1 < 0 && x2 > 0 = 2
| x1 < 0 && x2 < 0 = 3
| otherwise = 4

-- José Manuel García
cuadrante4 :: (Int,Int) -> Int
cuadrante4 (x1,x2) | x1 * x2 == 0 = 0
| x1 > 0 && x2 > 0 = 1
| x1 < 0 && x2 > 0 = 2
| x1 < 0 && x2 < 0 = 3
| x1 > 0 && x2 < 0 = 4

-- ----------------------------------------------------------------------------
-- Ejercicio 17. Definir la función
-- simetricoH :: (Int,Int) -> (Int,Int)
-- tal que '(simetricoH p)' es el punto simétrico de 'p' respecto del eje
-- horizontal. Por ejemplo,
-- simetricoH (2,5) == (2,-5)
-- simetricoH (2,-5) == (2,5)
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, Adolfo Sagrera Vivancos, Lucía González, Irene Ortega Moncayo
simetricoH :: (Int,Int) -> (Int,Int)
simetricoH (x1,x2) = (x1,-x2)
-- Elsa Domínguez
simetricoH1 :: (Int,Int) -> (Int,Int)
simetricoH1 p = (fst p,-snd p)

-- ----------------------------------------------------------------------------
-- Ejercicio 18. Definir la función
-- simetricoV :: (Int,Int) -> (Int,Int)
-- tal que '(simetricoV p)' es el punto simétrico de 'p' respecto del eje
-- vertical. Por ejemplo,
-- simetricoV (2,5) == (-2,5)
-- simetricoV (2,-5) == (-2,-5)
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, Adolfo Sagrera Vivancos, Lucía González, Irene Ortega Moncayo
simetricoV :: (Int,Int) -> (Int,Int)
simetricoV (x1,x2) = (-x1,x2)
- Elsa Domínguez
simetricoV1 :: (Int,Int) -> (Int,Int)
simetricoV1 p = (-fst p,snd p)
-- ----------------------------------------------------------------------------
-- Ejercicio 19. Definir la función
-- distancia :: (Float,Float) -> (Float,Float) -> Float
-- tal que '(distancia p1 p2)' es la distancia entre los puntos 'p1' y 'p2'.
-- Por ejemplo,
-- distancia (1,2) (4,6) == 5.0
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Laura Arango, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
distancia :: (Float,Float) -> (Float,Float) -> Float
distancia (x1,x2) (y1,y2) = sqrt((x1-y1)^2 + (x2-y2)^2)
-- Lucía Hernández
distancia1 :: (Float,Float) -> (Float,Float) -> Float
distancia1 p1 p2 = sqrt((fst p2 - fst p1)^2 + (snd p2-snd p1)^2)
-- Adolfo Sagrera Vivancos
distancia2 :: (Float,Float) -> (Float,Float) -> Float
distancia2 (x1,x2) (y1,y2) = sqrt(t^2 + s^2)
where t = x1-y1
s = x2-y2
-- ----------------------------------------------------------------------------
-- Ejercicio 20. Comprobar con QuickCheck que se verifica la propiedad
-- triangular de la distancia; es decir, dados tres puntos p1, p2 y p3, la
-- distancia de p1 a p3 es menor o igual que la suma de las distancias de p1 a
-- p2 y de p2 a p3.
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, Elsa Domínguez, Adolfo Sagrera Vivancos, Lucía González, Irene Ortega Moncayo

-- La propiedad es
prop_triangular :: (Float,Float) -> (Float,Float) -> (Float,Float) -> Bool
prop_triangular p1 p2 p3 = distancia p1 p3 <= distancia p1 p2 + distancia p2 p3

-- La comprobación es
-- > quickCheck prop_triangular
+++ OK, passed 100 tests.
-- ----------------------------------------------------------------------------
-- Ejercicio 21. Definir la función
-- puntoMedio :: (Float,Float) -> (Float,Float) -> (Float,Float)
-- tal que '(puntoMedio p1 p2)' es el punto medio entre los puntos 'p1' y 'p2'.
-- Por ejemplo,
-- puntoMedio (0,2) (0,6) == (0.0,4.0)
-- puntoMedio (-1,2) (7,6) == (3.0,4.0)
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
puntoMedio :: (Float,Float) -> (Float,Float) -> (Float,Float)
puntoMedio (x1,x2) (y1,y2) = ((x1+y1)/2, (x2+y2)/2)
-- Adolfo Sagrera Vivancos
puntoMedio1 :: (Float,Float) -> (Float,Float) -> (Float,Float)
puntoMedio1 (x1,x2) (y1,y2) = (t/2, s/2)
where t = x1 + y1
s = x2 + y2

-- ---------------------------------------------------------------------
-- Repaso de operaciones lógicas --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 22.1. La disyunción excluyente xor de dos fórmulas se
-- verifica si una es verdadera y la otra es falsa. Su tabla de verdad
-- es
-- x | y | xor x y
-- ------+-------+---------
-- True | True | False
-- True | False | True
-- False | True | True
-- False | False | False
--
-- Definir la función
-- xor1 :: Bool -> Bool -> Bool
-- tal que (xor1 x y) es la disyunción excluyente de x e y, calculada a
-- partir de la tabla de verdad. Usar 4 ecuaciones, una por cada línea
-- de la tabla.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
xor1 :: Bool -> Bool -> Bool
xor1 True True = False
xor1 True False = True
xor1 False True = True
xor1 False False = False

-- ---------------------------------------------------------------------
-- Ejercicio 22.2. Definir la función
-- xor2 :: Bool -> Bool -> Bool
-- tal que (xor2 x y) es la disyunción excluyente de x e y, calculada a
-- partir de la tabla de verdad y patrones. Usar 2 ecuaciones, una por
-- cada valor del primer argumento.
-- ---------------------------------------------------------------------
--Lucía Hernández
xor2 :: Bool -> Bool -> Bool
xor2 x y | y/= x = True
| y == x = False
-- Adolfo Sagrera Vivancos, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
xor2' :: Bool -> Bool -> Bool
xor2' True y = not y
xor2' False y = y

-- ---------------------------------------------------------------------
-- Ejercicio 22.3. Definir la función
-- xor3 :: Bool -> Bool -> Bool
-- tal que (xor3 x y) es la disyunción excluyente de x e y, calculada
-- a partir de la disyunción (||), conjunción (&&) y negación (not).
-- Usar 1 ecuación.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
xor3 :: Bool -> Bool -> Bool
xor3 x y = (x && not y) || (y && not x)

-- ---------------------------------------------------------------------
-- Ejercicio 22.4. Definir la función
-- xor4 :: Bool -> Bool -> Bool
-- tal que (xor3 x y) es la disyunción excluyente de x e y, calculada
-- a partir de desigualdad (/=). Usar 1 ecuación.
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
xor4 :: Bool -> Bool -> Bool
xor4 x y = if x == y then False else True
-- Lucía Hernández, Adolfo Sagrera Vivancos, Lucía González, Irene Ortega Moncayo
xor4' :: Bool -> Bool -> Bool
xor4' x y = if x/=y then True else False
-- Elsa Domínguez
xor4'' :: Bool -> Bool -> Bool
xor4'' x y = x /= y

-- ---------------------------------------------------------------------
-- Ejercicio 22.5. Comprobar con QuickCheck que las cuatro definiciones
-- de xor son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
-- La propiedad es
prop_xor_equivalentes :: Bool -> Bool -> Bool
prop_xor_equivalentes x y = xor1 x y == xor2 x y && xor2 x y == xor3 x y && xor3 x y == xor4 x y

-- La comprobación es quickCheck prop_xor_equivalentes
+++ OK, passed 100 tests

-- ---------------------------------------------------------------------
-- Ejercicio 23.1 Definir la función
-- or3 :: Bool -> Bool -> Bool -> Bool
-- tal que (or3 a b c) es la disyunción entre a, b y c; es decir,
-- ocurre a o b o c. Definir la función usando '||'. Por ejemplo,
-- or3 True True False == True
-- or3 False False False == False
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
or3 :: Bool -> Bool -> Bool-> Bool
or3 a b c = a || b || c
-- Adolfo Sagrera Vivancos
or3'' :: Bool -> Bool -> Bool-> Bool
or3'' a b c | a==True || b==True || c==True = True
| otherwise = False

-- ---------------------------------------------------------------------
-- Ejercicio 23.2 Definir la función
-- or3' :: Bool -> Bool -> Bool -> Bool
-- tal que (or3' a b c) es la disyunción entre a, b y c; es decir,
-- ocurre a o b o c. Definir la función usando 'or' para listas.
-- Por ejemplo,
-- or3' True True False == True
-- or3' False False False == False
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
or3' :: Bool -> Bool -> Bool -> Bool
or3' a b c = or [a,b,c]

-- ---------------------------------------------------------------------
-- Ejercicio 24.1 Definir la función
-- and3 :: Bool -> Bool -> Bool -> Bool
-- tal que (and3 a b c) es la conjunción entre a, b y c; es decir,
-- ocurre a y b y c. Definir la función usando '&&'. Por ejemplo,
-- and3 True True True == True
-- and3 False True False == False
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
and3 :: Bool -> Bool -> Bool -> Bool
and3 a b c = a && b && c

-- ---------------------------------------------------------------------
-- Ejercicio 24.2 Definir la función
-- and3' :: Bool -> Bool -> Bool -> Bool
-- tal que (and3' a b c) es la conjunción entre a, b y c; es decir,
-- ocurre a o b o c. Definir la función usando 'and' para listas.
-- Por ejemplo,
-- and3' True True True == True
-- and3' False True False == False
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez, Lucía González
and3' :: Bool -> Bool -> Bool -> Bool
and3' a b c = and [a,b,c]

-- ---------------------------------------------------------------------
-- Ejercicio 25.1. Definir la función
-- siglo20 :: Int -> Bool
-- tal que (siglo20 x) indica si el ańo x perteneció al siglo 20; es decir,
-- si está comprendido entre el ańo 1901 y 2000.
-- Por ejemplo,
-- siglo20 1902 == True
-- siglo20 2001 == False
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Lucía González, Irene Ortega Moncayo
siglo20 :: Int -> Bool
siglo20 x = if 1901 <= x && x < 2000 then True
else False
-- Elsa Domínguez
siglo201 :: Int -> Bool
siglo201 x = 1901 <= x && x <= 2000
-- Adolfo Sagrera Vivancos
siglo20' :: Int -> Bool
siglo20' x = x > 1901 && x < 2000

-- ---------------------------------------------------------------------
-- Ejercicio 25.2. Definir la función
-- noSiglo20 :: Int -> Bool
-- tal que (noSiglo20 x) indica si el ańo x no perteneció al siglo 20; es decir,
-- si no está comprendido entre el ańo 1901 y 2000.
-- Definirla de tres formas distintas, una usando la función (siglo20 x), otra
-- usando '&&' y otra usando '||'.
--
-- Por ejemplo,
-- noSiglo20 1902 == False
-- noSiglo20 2001 == True
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
noSiglo20 :: Int -> Bool
noSiglo20 x = not (siglo20 x)
noSiglo20' = undefined
noSiglo20'' x = x < 1901 || x >= 2000
-- Lucía Hernández, Lucía González, Irene Ortega Moncayo
noSiglo20 :: Int -> Bool
noSiglo20 x = not(siglo20 x)
noSiglo20' x = if x <= 2000 && x > 1901 then False
else True
noSiglo20'' x = x=>2000 || x< 1901
-- Elsa Domínguez
noSiglo20 :: Int -> Bool
noSiglo20 x = not (siglo20 x)
noSiglo20' x = not (x >= 1901 && x <= 2000)
noSiglo20'' x = x < 1901 || x > 2000
-- Adolfo Sagrera Vivancos
noSiglo201 :: Int -> Bool
noSiglo201 x = not (siglo20 x)
noSiglo20'1 x = not(x>1901) && not(x<2000)
noSiglo20''1 x = x<1901 || x>2000
-- ---------------------------------------------------------------------
-- Ejercicio 26. Definir la función
-- xnor :: Bool -> Bool -> Bool
-- tal que (xnor a b) se calcula con su tabla de verdad, que
-- es
-- x | y | xnor x y
-- ------+-------+---------
-- False | False | True
-- False | True | False
-- True | False | False
-- True | True | True
--
-- Emplear solo operadores lógicos (&&, ||, not).
--
-- Por ejemplo,
-- xnor True True == True
-- xnor False True == False
-- xnor False False == True
-- ---------------------------------------------------------------------
-- Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez, Lucía González, Irene Ortega Moncayo

xnor :: Bool -> Bool -> Bool
xnor x y = (not x && not y) || (x && y)

-- ---------------------------------------------------------------------
-- Ejercicio 27. Definir la función
-- aprueba :: Float -> Float -> Float -> Bool
-- tal que (aprueba n1 n2 n3) indica si con las notas de los
-- exámenes parciales n1, n2 y n3 se consigue aprobar la
-- asignatura. Los criterios para aprobar la asignatura son los siguientes:
-- * La media de las notas debe ser mayor o igual que 5, y
-- * Cada una de las notas de los exámenes parciales son mayor o igual
-- que 4.0,
-- * O en el último exámen se obtuvo un 10 (entonces siempre se aprueba)
-- Por ejemplo,
-- aprueba 5.0 6.0 5.0 == True
-- aprueba 1.5 6.0 8.0 == False
-- aprueba 3.7 1.5 10.0 == True
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
aprueba :: Float -> Float -> Float -> Bool
aprueba x y z | z == 10 = True
| (x+y+z)/3 >= 5 && and [x>4, y>4, z>4] = True
| otherwise = False
--Lucía Hernández
aprueba :: Float -> Float -> Float -> Bool
aprueba n1 n2 n3 = (n1+n2+n3)/3 >= 5 &&( n1>=4 && n2>=4 && n3>=4) || n3 == 10
-- Elsa Domínguez, Lucía González
aprueba2 :: Float -> Float -> Float -> Bool
aprueba2 n1 n2 n3 | and [n1 >= 4, n2 >= 4, n3 >= 4] = (n1+n2+n3)/3 >= 5
| n3 == 10 = True
| otherwise = False
-- Adolfo Sagrera Vivancos
aprueba3 :: Float -> Float -> Float -> Bool
aprueba3 n1 n2 n3 | (n1+n2+n3)/3 >= 5 && (n1 >= 4 && n2 >= 4 && n3 >= 4) || n3 == 10 = True
| otherwise = False

-- ---------------------------------------------------------------------
-- Ejercicio 28. Comprobar las leyes de Morgan con QuickCheck. Las
-- leyes de Morgan se definen como sigue:
-- * ley 1: no (A o B) == (no A) y (no B)
-- * ley 2: no (A y B) == (no A) o (no B)
-- Consejo: definir cada ley como una función por separado para componer
-- la propiedad
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
ley1:: Bool -> Bool -> Bool
ley1 a b = not (a || b) == (not a) && (not b)

ley2:: Bool -> Bool -> Bool
ley2 a b = not (a && b) == (not a) || (not b)

-- La propiedad es
prop_leyes_morgan :: Bool -> Bool -> Bool
prop_leyes_morgan a b = ley1 a b == ley2 a b

-- Lucía Hernández, Elsa Domínguez, Lucía González, Irene Ortega Moncayo
ley1 :: Bool -> Bool -> Bool
ley1 a b = not(a || b) ==( not a && not b)

ley2 :: Bool -> Bool -> Bool
ley2 a b = not (a&&b) == ( not a || not b )

-- La propiedad es
prop_leyes_morgan :: Bool -> Bool -> Bool
prop_leyes_morgan a b= ley1 a b && ley2 a b

</source>