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

Relación 6

2021-11-09T10:36:34Z

188.78.90.137:

<source lang="haskell">

-- I1M 2021-22: Rel_6.hs (5 de noviembre de 2021)
-- Definiciones por recursió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
-- recursión correspondientes al tema 6 cuyas transparencias se
-- encuentran en
-- http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-6.html

-- ---------------------------------------------------------------------
-- Importación de librerías auxiliares --
-- ---------------------------------------------------------------------

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1.1. Definir por recursión la función
-- potencia :: Integer -> Integer -> Integer
-- tal que (potencia x n) es x elevado al número natural n. Por ejemplo,
-- potencia 2 3 == 8
-- ---------------------------------------------------------------------
-- Lucía Hernández, Irene Ortega, Ana Sánchez Martín
potencia :: Integer -> Integer -> Integer
potencia _ 0 = 1
potencia x n = x* potencia x (n-1)

-- Nicolás Rodríguez Ruiz, Elsa Domínguez, Adolfo Sagrera Vivancos
potencia :: Integer -> Integer -> Integer
potencia _ 0 = 1
potencia x n | n > 0 = x * potencia x (n-1)
| n < 0 = error "n tiene que ser un natural (>=0)"

-- ---------------------------------------------------------------------
-- Ejercicio 1.2. Comprobar con QuickCheck que la función potencia es
-- equivalente a la predefinida (^).
-- ---------------------------------------------------------------------
-- Lucía Hernández, Irene Ortega, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
-- La propiedad es
prop_potencia :: Integer -> Integer -> Property
prop_potencia x n = n>=0 ==> x^n == potencia x n

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

-- ---------------------------------------------------------------------
-- Ejercicio 2.1. Dados dos números naturales, a y b, es posible
-- calcular su máximo común divisor mediante el Algoritmo de
-- Euclides. Este algoritmo se puede resumir en la siguiente fórmula:
-- mcd(a,b) = a, si b = 0
-- = mcd (b, a módulo b), si b > 0
--
-- Definir la función
-- mcd :: Integer -> Integer -> Integer
-- tal que (mcd a b) es el máximo común divisor de a y b calculado
-- mediante el algoritmo de Euclides. Por ejemplo,
-- mcd 30 45 == 15
-- ---------------------------------------------------------------------
-- Lucía Hernández, Nicolás Rodríguez Ruiz, Irene Ortega, Elsa Domínguez
mcd :: Integer -> Integer -> Integer
mcd a 0 = a
mcd a b = mcd b (mod a b)
-- Adolfo Sagrera Vivancos, Ana Sánchez Martín
mcd1 :: Integer -> Integer -> Integer
mcd1 a b | b==0 = a
| b > 0 = mcd b (mod a b)

-- ---------------------------------------------------------------------
-- Ejercicio 2.2. Definir y comprobar la propiedad prop_mcd según la
-- cual el máximo común divisor de dos números a y b (ambos mayores que
-- 0) es siempre mayor o igual que 1 y además es menor o igual que el
-- menor de los números a y b.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Irene Ortega, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
-- La propiedad es
prop_mcd :: Integer -> Integer -> Property
prop_mcd a b = a>0 && b>0 ==> mcd a b >=1 && mcd a b <= min a b

-- Su comprobación es quickCheck prop_mcd
+++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 2.3. Teniendo en cuenta que buscamos el máximo común
-- divisor de a y b, sería razonable pensar que el máximo común divisor
-- siempre sería igual o menor que la mitad del máximo de a y b. Definir
-- esta propiedad y comprobarla.
-- ---------------------------------------------------------------------
--- Lucía Hernández
-- La propiedad es
prop_mcd_div :: Integer -> Integer -> Property
prop_mcd_div a b = a>0 && b>0 ==> (mcd a b) <= div (max a b)2

-- La comprobación es quickCheck prop_mcd_div
*** Failed! Falsifiable (after 1 test):
1
1
-- Nicolás Rodríguez Ruiz, Irene Ortega, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
prop_mcd_div :: Integer -> Integer -> Property
prop_mcd_div a b = a>0 && b>0 && a/=b==> mcd a b <= (max a b) `div` 2

-- La comprobación es
-- +++ OK, passed 100 tests; 407 discarded.
-- ---------------------------------------------------------------------
-- Ejercicio 3.1, Definir por recursión la función
-- pertenece :: Eq a => a -> [a] -> Bool
-- tal que (pertenece x xs) se verifica si x pertenece a la lista xs. Por
-- ejemplo,
-- pertenece 3 [2,3,5] == True
-- pertenece 4 [2,3,5] == False
-- ---------------------------------------------------------------------
-- Lucía Hernández, Irene Ortega, Ana Sánchez Martín
pertenece :: Eq a => a -> [a] -> Bool
pertenece _ [] = False
pertenece n (x:xs) | n == x = True
|otherwise = pertenece n xs
-- Nicolás Rodríguez Ruiz, Elsa Domínguez, Adolfo Sagrera Vivancos
pertenece :: Eq a => a -> [a] -> Bool
pertenece _ [] = False
pertenece y (x:xs) = y==x || pertenece y xs
-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Comprobar con quickCheck que pertenece es equivalente
-- a elem.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Irene Ortega, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
-- La propiedad es
prop_pertenece :: Int -> [Int] -> Bool
prop_pertenece x xs = pertenece x xs == elem x xs

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

-- ---------------------------------------------------------------------
-- Ejercicio 4.1. Definir por recursión la función
-- concatenaListas :: [[a]] -> [a]
-- tal que (concatenaListas xss) es la lista obtenida concatenando las listas de
-- xss. Por ejemplo,
-- concatenaListas [[1..3],[5..7],[8..10]] == [1,2,3,5,6,7,8,9,10]
-- ---------------------------------------------------------------------

-- Lucía Hernández , Nicolás Rodríguez Ruiz, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
concatenaListas :: [[a]] -> [a]
concatenaListas [] = []
concatenaListas (xs:xss) = xs ++ concatenaListas xss

-- ---------------------------------------------------------------------
-- Ejercicio 4.2. Comprobar con QuickCheck que concatenaListas es
-- equivalente a concat.
-- ---------------------------------------------------------------------

-- Nicolás Rodrígez Ruiz, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
-- La propiedad es
prop_concat :: [[Int]] -> Bool
prop_concat xss = concat xss == concatenaListas xss

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

-- ---------------------------------------------------------------------
-- Ejercicio 5.1. Definir por recursión la función
-- coge :: Int -> [a] -> [a]
-- tal que (coge n xs) es la lista de los n primeros elementos de
-- xs. Por ejemplo,
-- coge 3 [4..12] == [4,5,6]
-- coge (-3) [4..12] == []
-- ---------------------------------------------------------------------
-- Lucía Hernández, Nicolás Rodríguez Ruiz, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
coge :: Int -> [a] -> [a]
coge _ [] = []
coge n (x:xs) | n<=0 = []
| otherwise = x : coge (n-1) xs

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Comprobar con QuickCheck que coge es equivalente a
-- take.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Nicolás Rodríguez Ruiz, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
-- La propiedad es
prop_coge :: Int -> [Int] -> Bool
prop_coge n xs = coge n xs == take n xs

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

-- ---------------------------------------------------------------------
-- Ejercicio 6.1. Definir, por recursión, la función
-- sumaCuadradosR :: Integer -> Integer
-- tal que (sumaCuadradosR n) es la suma de los cuadrados de los números
-- de 1 a n. Por ejemplo,
-- sumaCuadradosR 4 == 30
-- ---------------------------------------------------------------------
-- Lucía Hernández, Nicolás Rodríguez Ruiz, Ana Sánchez Martín
sumaCuadradosR :: Integer -> Integer
sumaCuadradosR 0 = 0
sumaCuadradosR n = n^2 + sumaCuadradosR (n-1)
-- Elsa Domínguez, Adolfo Sagrera Vivancos
sumaCuadradosR :: Integer -> Integer
sumaCuadradosR 1 = 1
sumaCuadradosR n | n < 0 = error "n debe ser mayor que cero"
| otherwise = n^2 + sumaCuadradosR (n-1)

-- ---------------------------------------------------------------------
-- Ejercicio 6.2. Comprobar con QuickCheck si sumaCuadradosR n es igual a
-- n(n+1)(2n+1)/6.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
-- La propiedad es
prop_SumaCuadrados :: Integer -> Property
prop_SumaCuadrados n = n>=1 ==> sumaCuadradosR n == div (n*(n+1)*(2*n+1)) 6

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

-- ---------------------------------------------------------------------
-- Ejercicio 6.3. Definir, por comprensión, la función
-- sumaCuadradosC :: Integer --> Integer
-- tal que (sumaCuadradosC n) es la suma de los cuadrados de los números
-- de 1 a n. Por ejemplo,
-- sumaCuadradosC 4 == 30
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
sumaCuadradosC :: Integer -> Integer
sumaCuadradosC n = sum [x^2 | x <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 6.4. Comprobar con QuickCheck que las funciones
-- sumaCuadradosR y sumaCuadradosC son equivalentes sobre los números
-- naturales.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
-- La propiedad es
prop_sumaCuadradosR :: Integer -> Property
prop_sumaCuadradosR n = n>=1 ==> sumaCuadradosR n == sumaCuadradosC n

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

-- ---------------------------------------------------------------------
-- Ejercicio 7.1. Definir, por recursión, la función
-- digitosR :: Integer -> [Integer]
-- tal que (digitosR n) es la lista de los dígitos del número n. Por
-- ejemplo,
-- digitosR 320274 == [3,2,0,2,7,4]
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
digitosR :: Integer -> [Integer]
digitosR n = if n<10 then [n]
else digitosR (div n 10) ++ [rem n 10]
-- ---------------------------------------------------------------------
-- Ejercicio 7.2. Definir, por comprensión, la función
-- digitosC :: Integer -> [Integer]
-- tal que (digitosC n) es la lista de los dígitos del número n. Por
-- ejemplo,
-- digitosC 320274 == [3,2,0,2,7,4]
-- Indicación: Usar las funciones show y read.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
digitosC :: Integer -> [Integer]
digitosC n = [read [x] | x <- show n]
-- ---------------------------------------------------------------------
-- Ejercicio 7.3. Comprobar con QuickCheck que las funciones digitosR y
-- digitosC son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
-- La propiedad es
prop_digitos :: Integer -> Property
prop_digitos n = n>=0 ==> digitosR n == digitosC n

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

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir, por recursión, la función
-- sumaDigitosR :: Integer -> Integer
-- tal que (sumaDigitosR n) es la suma de los dígitos de n. Por ejemplo,
-- sumaDigitosR 3 == 3
-- sumaDigitosR 2454 == 15
-- sumaDigitosR 20045 == 11
-- ---------------------------------------------------------------------
-- Lucía Hernández, Adolfo Sagrera Vivancos, Ana Sánchez Martín
sumaDigitosR :: Integer -> Integer
sumaDigitosR n = if n<10 then n
else rem n 10 + sumaDigitosR (div n 10)
-- Elsa Domínguez
sumaDigitosR' :: Integer -> Integer
sumaDigitosR' 0 = 0
sumaDigitosR' n | n < 0 = error "no es posible"
| otherwise = rem n 10 + sumaDigitosR (div n 10)

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir, sin usar recursión, la función
-- sumaDigitosNR :: Integer -> Integer
-- tal que (sumaDigitosNR n) es la suma de los dígitos de n. Por ejemplo,
-- sumaDigitosNR 3 == 3
-- sumaDigitosNR 2454 == 15
-- sumaDigitosNR 20045 == 11
-- ---------------------------------------------------------------------
-- Lucía Hernández
sumaDigitosNR :: Integer -> Integer
sumaDigitosNR n = sum (digitosR n)
-- Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
sumaDigitosNR :: Integer -> Integer
sumaDigitosNR n = sum (digitosC n)

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Comprobar con QuickCheck que las funciones sumaDigitosR
-- y sumaDigitosNR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
-- La propiedad es
prop_sumaDigitos :: Integer -> Property
prop_sumaDigitos n = n>= 0 ==> sumaDigitosR n == sumaDigitosNR n

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

-- ---------------------------------------------------------------------
-- Ejercicio 9.1. Definir, por recursión, la función
-- listaNumeroR :: [Integer] -> Integer
-- tal que (listaNumeroR xs) es el número formado por los dígitos xs. Por
-- ejemplo,
-- listaNumeroR [5] == 5
-- listaNumeroR [1,3,4,7] == 1347
-- listaNumeroR [0,0,1] == 1
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sánchez Martín
listaNumeroR :: [Integer] -> Integer
listaNumeroR [] = 0
listaNumeroR [x] = x
listaNumeroR (x:xs) = x*10^(length (xs)) + listaNumeroR xs
-- Elsa Domínguez, Adolfo Sagrera Vivancos
listaNumeroR' :: [Integer] -> Integer
listaNumeroR' [] = 0
listaNumeroR' [x] = x
listaNumeroR' xs = last xs + (listaNumeroR (init xs))*10

-- ---------------------------------------------------------------------
-- Ejercicio 9.2. Definir, por comprensión, la función
-- listaNumeroC :: [Integer] -> Integer
-- tal que (listaNumeroC xs) es el número formado por los dígitos xs. Por
-- ejemplo,
-- listaNumeroC [5] == 5
-- listaNumeroC [1,3,4,7] == 1347
-- listaNumeroC [0,0,1] == 1
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sánchez Martín
listaNumeroC :: [Integer] -> Integer
listaNumeroC xs = sum [x*10^s | (x,s) <- zip(reverse xs) [0..length xs -1]]
-- Adolfo Sagrera Vivancos
listaNumeroC' :: [Integer] -> Integer
listaNumeroC' xs = sum [ x*(10^y) | (x,y) <- agrupa1 xs]
agrupa1 xs = zip (reverse xs) [0..]

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Comprobar con QuickCheck que las funciones
-- listaNumeroR y listaNumeroC son equivalentes.
-- ---------------------------------------------------------------------
--Lucía Hernández, Elsa Domínguez, Ana Sánchez Martín
-- La propiedad es
prop_listaNumero :: [Integer] -> Bool
prop_listaNumero xs = listaNumeroR xs == listaNumeroC xs

-- La comprobación es quickCheck prop_listaNumero
+++ OK, passed 100 tests.
-- Adolfo Sagrera Vivancos
prop_listaNumero' xs = not(null xs) ==> listaNumeroR xs == listaNumeroC xs

-- ---------------------------------------------------------------------
-- Ejercicio 10.1. Definir, por recursión, la función
-- mayorExponenteR :: Integer -> Integer -> Integer
-- tal que (mayorExponenteR a b) es el exponente de la mayor potencia de
-- a que divide b. Por ejemplo,
-- mayorExponenteR 2 8 == 3
-- mayorExponenteR 2 9 == 0
-- mayorExponenteR 5 100 == 2
-- mayorExponenteR 2 60 == 2
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
mayorExponenteR :: Integer -> Integer -> Integer
mayorExponenteR _ 0 = 0
mayorExponenteR a b | mod b a == 0 = 1 + mayorExponenteR a( div b a)
| otherwise = 0

-- ---------------------------------------------------------------------
-- Ejercicio 10.2. Definir, por comprensión, la función
-- mayorExponenteC :: Integer -> Integer -> Integer
-- tal que (mayorExponenteC a b) es el exponente de la mayor potencia de
-- a que divide a b. Por ejemplo,
-- mayorExponenteC 2 8 == 3
-- mayorExponenteC 5 100 == 2
-- mayorExponenteC 5 101 == 0
-- ---------------------------------------------------------------------
-- Lucía Hernández, Adolfo Sagrera Vivancos, Ana Sánchez Martín
mayorExponenteC :: Integer -> Integer -> Integer
mayorExponenteC a b = last [s | s<- [0..b], mod b (a^s) == 0]
-- Elsa Domínguez
mayorExponenteC' :: Integer -> Integer -> Integer
mayorExponenteC' a b | rem b a /= 0 = 0 -- mejora la eficiencia
| otherwise = last [x | x <- [0..32], rem b (a^x) == 0]

</source>

Relación 4

2021-11-03T12:43:47Z

188.78.90.137:

<source lang='haskell'>

-- I1M 2021-22: Rel_4.hs (27 de Octubre de 2021)
-- Definiciones por comprensión (II)
-- 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.
--
-- ---------------------------------------------------------------------
-- § Librerías auxiliares --
-- ---------------------------------------------------------------------

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
-- divisoresPrimos :: Int -> [Int]
-- tal que (divisoresPrimos x) es la lista de los divisores primos de x.
-- Por ejemplo,
-- divisoresPrimos 40 == [2,5]
-- divisoresPrimos 70 == [2,5,7]
-- ------------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sánchez Martín
divisores :: Int -> [Int]
divisores n = [x | x<-[1..n], mod n x == 0]
primo :: Int -> Bool
primo n = divisores n == [1,n]

divisoresPrimos :: Int -> [Int]
divisoresPrimos n = [ x | x <- divisores n, primo x]

-- Adolfo Sagrera Vivancos
divisores' n = [x | x <- [1..n], rem n x == 0]
divisoresPrimos' :: Int -> [Int]
divisoresPrimos' y = [ m | m <- [2..y], divisores' m == [1,m], rem y m == 0] -- Prof: debería usar divisores'?
-- Nicolás Rodríguez Ruiz
divisoresPrimos x = [a | a <- (primos x), x `mod`a == 0]
where primos n = [a | a <- [1..n], divisores a == [1,a]]
divisores n = [ a | a <- [1..n], n `mod` a == 0]

-- ---------------------------------------------------------------------
-- Ejercicio 2. Un número es libre de cuadrados si no es divisible por el
-- cuadrado de ningún entero mayor que 1. Por ejemplo, 70 es libre de
-- cuadrado porque sólo es divisible por 1, 2, 5, 7 y 70; en cambio, 40
-- no es libre de cuadrados porque es divisible por 2^2.
--
-- Definir la función
-- libreDeCuadrados :: Int -> Bool
-- tal que (libreDeCuadrados x) se verifica si x es libre de cuadrados.
-- Por ejemplo,
-- libreDeCuadrados 70 == True
-- libreDeCuadrados 40 == False
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos
libreDeCuadrados :: Int -> Bool
libreDeCuadrados n = null [x | x<- cuadrados n, mod n x == 0]
where cuadrados n = [x^2 | x <- [2..n]]
-- Nicolás Rodríguez Ruiz
libreDeCuadrados n = [ a | a <- divisores n, (sq a) == (ndsq a) ] == [] -- Si el conjunto esta vacio => n no es producto de cuadrados
where divisores n = [ a | a <- [2..n-1], n `mod` a == 0]
sq a = sqrt (fromIntegral a) -- Raiz con decimales
ndsq a = fromIntegral(truncate (sq a)) -- Raiz sin decimales
-- Ana Sánchez Martín
libreDeCuadrados :: Int -> Bool
libreDeCuadrados n = n == product([x |x <- divisores n, primo x])

-- ---------------------------------------------------------------------
-- Ejercicio 3. [Del problema 21 del Proyecto Euler]. Sea d(n) la suma
-- de los divisores propios de n. Si d(a) = b y d(b) = a, siendo a
-- distinto de b,
-- decimos que a y b son un par de números amigos. Por ejemplo, los
-- divisores propios de 220 son 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 y
-- 110; por tanto, d(220) = 284. Los divisores propios de 284 son 1, 2,
-- 4, 71 y 142; por tanto, d(284) = 220. Luego, 220 y 284 son dos
-- números amigos.
--
-- Definir la función
-- amigos :: Int -> Int -> Bool
-- tal que (amigos a b) se verifica si a y b son números amigos. Por
-- ejemplo,
-- amigos 6 6 == False
-- amigos 220 248 == False
-- amigos 220 284 == True
-- amigos 100 200 == False
-- amigos 1184 1210 == True
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos
divisores :: Int -> [Int]
divisores n = [x | x<-[1..n], mod n x == 0]

amigos1 :: Int -> Int -> Bool
amigos1 a b = and [sumaDivisores a == b && sumaDivisores b == a, a/=b]
where sumaDivisores n = sum(divisores n) - n

-- Prof: En clase hemos visto
divisoresP :: Int -> [Int]
divisoresP n = [x | x<-[1..n-1], rem n x == 0]

amigos2 :: Int -> Int -> Bool
amigos2 a b = sumaDivisores a == b && sumaDivisores b == a && a/=b
where sumaDivisores n = sum(divisoresP n)

-- Prof: he movido aquí esta solución que estaba en el primer ejercicio
-- José Manuel García
d x = [n | n <- [1..x], rem x n == 0]
sumad x = sum (d x)

amigos3 :: Int -> Int -> Bool
amigos3 a b = if a == b then False else sumad a == sumad b
-- Ana Sánchez Martín
amigos4 :: Int -> Int -> Bool
amigos4 a b = a /= b && sum (init(divisores a)) == b && sum (init(divisores b)) == a

-- ---------------------------------------------------------------------
-- Ejercicio 4. (Problema 211 del proyecto Euler) Dado un entero
-- positivo n, consideremos la suma de los cuadrados de sus divisores,
-- Por ejemplo,
-- f(10) = 1 + 4 + 25 + 100 = 130
-- f(42) = 1 + 4 + 9 + 36 + 49 + 196 + 441 + 1764 = 2500
-- Decimos que n es especial si f(n) es un cuadrado perfecto. En los
-- ejemplos anteriores, 42 es especial y 10 no lo es.
--
-- Definir la función
-- especial:: Int -> Bool
-- tal que (especial x) se verifica si x es un número es especial. Por
-- ejemplo,
-- especial 42 == True
-- especial 10 == False
--
-- Calcular todos los números especiales de tres cifras.
-- El resultado es:
-- λ> calculo
-- [246,287,728]
-- ---------------------------------------------------------------------
-- Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez
sumaDivisoresCuadrados n = sum [ x^2 | x<- divisores n]
especial :: Int -> Bool
especial n = x^2 == sumaDivisoresCuadrados n
where s = fromIntegral (sumaDivisoresCuadrados n)
x = floor (sqrt s)

-- Prof: Otra solución sin usar floor ni sqrt (aunque más lenta)
especial2 :: Int -> Bool
especial2 n = elem s [ x^2 | x <-[1 .. s]]
where s = sumaDivisoresCuadrados n

-- Lucía Hernández
especial3 = [ x | x<-[100..999], especial x]
-- Ana Sánchez Martín
esCuadrado x = or [x == n^2 | n <- [1..x]]
especial :: Int -> Bool
especial x = esCuadrado (sum (map (^2) (divisores x)))
especiales3 = [x | x <- [100..999], especial x]

-- ---------------------------------------------------------------------
-- Ejercicio 5. La multiplicidad de x en y es la mayor potencia de x
-- que divide a y. Por ejemplo, la multiplicidad de 2 en 40 es 3 porque
-- 40 es divisible por 2^3 y no lo es por 2^4. Además, la multiplicidad
-- de 1 en cualquier número se supone igual a 1.
--
-- Definir la función
-- multiplicidad :: Integer -> Integer -> Integer
-- tal que (multiplicidad x y) es la
-- multiplicidad de x en y. Por ejemplo,
-- multiplicidad 2 40 == 3
-- multiplicidad 5 40 == 1
-- multiplicidad 3 40 == 0
-- multiplicidad 1 40 == 1
-- ---------------------------------------------------------------------
-- Lucía Hernández
multiplicidad :: Integer -> Integer -> Integer
multiplicidad 1 _ = 1
multiplicidad x y = last [ s | s<-[0..y], elem (x^s) (potencias x), elem (x^s)(divisores y)]
where potencias n = [n^s | s<-[0..y]]
-- Prof: en esta solución se puede simplificar lo siguiente:
-- - elem (x^s) (potencias x) no hace falta, ya que siempre se va a cumplir
-- - elem (x^s)(divisores y) se puede simplificar a simplemente comprobar si x^s divide a y

-- Elsa Domínguez, Ana Sánchez Martín
multiplicidad1 :: Integer -> Integer -> Integer
multiplicidad1 x y = if x == 1 then 1 else sum [1 | n <- [1..y], rem y (x^n) == 0]

-- Nicolás Rodríguez Ruiz
multiplicidad a b = sum [1 | x <- [1..length(divisores b)], a^x `elem` (divisores b)]
where divisores n = [ a | a <- [1..n], n `mod` a == 0]
-- Prof: en esta solución se puede simplificar lo siguiente:
-- - a^x `elem` (divisores b) se puede simplificar a simplemente comprobar si a^x divide a b
-- Adolfo Sagrera Vivancos
multiplicidad2 :: Integer -> Integer -> Integer
multiplicidad2 1 _ = 1
multiplicidad2 x y = last [s | s <- [0..y], rem y (x^s) == 0]

-- -------------------------------------------------------------
-- Ejercicio 6.1. Sea t una lista de pares de la forma
-- (nombre, [(asig_1, nota_1),...,(asig_k, nota.k)])
-- Por ejemplo,
-- t1 = [("Ana",[("Alg",1),("Cal",3),("Inf",8),("Fis",2)]),
-- ("Juan",[("Alg",5),("Cal",1),("Inf",2),("Fis",9)]),
-- ("Alba",[("Alg",5),("Cal",6),("Inf",6),("Fis",5)]),
-- ("Pedro",[("Alg",9),("Cal",5),("Inf",3),("Fis",1)])]
-- Definir la función
-- calificaciones :: [(String,[(String,Int)])] -> String -> [(String,Int)]
-- tal que (calificaciones t p) es la lista de las calificaciones de la
-- persona p en la lista t. Por ejemplo,
-- ghci> calificaciones t1 "Pedro"
-- [("Alg",9),("Cal",5),("Inf",3),("Fis",1)]
-- ---------------------------------------------------------------------

t1 :: [(String,[(String,Int)])]
t1 = [("Ana",[("Alg",1),("Cal",3),("Inf",8),("Fis",2)]),
("Juan",[("Alg",5),("Cal",1),("Inf",2),("Fis",9)]),
("Alba",[("Alg",5),("Cal",6),("Inf",6),("Fis",5)]),
("Pedro",[("Alg",9),("Cal",5),("Inf",3),("Fis",1)])]

--Nicolás Rodríguez Ruiz, Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
calificaciones :: [(String,[(String,Int)])] -> String -> [(String,Int)]
calificaciones t p = head[ ns | (nom, ns) <- t, nom == p ]

-- ---------------------------------------------------------------------
-- Ejercicio 6.2. Definir la función
-- todasAprobadas :: [(String,[(String,Int)])] -> String -> Bool
-- tal que (todasAprobadas t p) se cumple si en la lista t, p tiene
-- todas las asignaturas aprobadas. Por ejemplo,
-- todasAprobadas t1 "Alba" == True
-- todasAprobadas t1 "Pedro" == False
-- ---------------------------------------------------------------------

-- Nicolás Rodríguez Ruiz, Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
todasAprobadas :: [(String,[(String,Int)])] -> String -> Bool
todasAprobadas t p = and[n>=5 | (_, n) <- (calificaciones t p)]

-- ---------------------------------------------------------------------
-- Ejercicio 6.3. Definir la función
-- aprobados :: [(String,[(String,Int)])] -> [String]
-- tal que (aprobados t) es la lista de los alumnos de la lista de notas
-- t que han aprobado todas las asignaturas.Por ejemplo,
-- ghci> aprobados t1 == ["Alba"]
-- ---------------------------------------------------------------------

-- Nicolás Rodríguez Ruiz, Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
aprobados :: [(String,[(String,Int)])] -> [String]
aprobados t = [nom | (nom, _) <- t, todasAprobadas t nom]

-- ---------------------------------------------------------------------
-- Ejercicio 7. Un número n es de Angelini si n y 2n tienen algún
-- dígito común. Por ejemplo, 2014 es un número de Angelini ya que 2014
-- y su doble (4028) comparten los dígitos 4 y 0.
--
-- Definir la función
-- angelini :: Integer -> Bool
-- tal que (angelini n) se verifica si n es un número de Angelini. Por
-- ejemplo,
-- angelini 2014 == True
-- angelini 2067 == False
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Adolfo Sagrera Vivancos
angelini :: Integer -> Bool
angelini n = not (null (cifrasIguales n))
where cifrasIguales n = [a | (a,b) <- ns, a == b] -- Prof: se puede simplificar con la función elem
ns = [(a,b) | a <- cifras n, b <- cifras (2*n)]

cifras :: Integer -> [Int]
cifras n = [read [x] | x <- show n]

-- Nicolás Rodríguez Ruiz, Ana Sánchez Martín
angelini1 :: Integer -> Bool
angelini1 n = or[c `elem` (show (2*n)) | c <- (show n)]

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir la función
-- unitarios :: Int -> [Int]
-- tal (unitarios n) es la lista de números [n,nn, nnn, ....]. Por
-- ejemplo.
-- take 7 (unitarios 3) == [3,33,333,3333,33333,333333,3333333]
-- take 3 (unitarios 1) == [1,11,111]
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
repetir x n = sum [x*10^i | i<-[0..n-1]]
unitarios :: Int -> [Int]
unitarios x = [ (repetir x n) | n<- [1..]]

--Nicolás Rodríguez Ruiz
unitarios x = [ sum[ x*(10^a) | a <- [0..n] ] | n <- [1..]]

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir la función
-- multiplosUnitarios :: Int -> Int -> Int -> [Int]
-- tal que (multiplosUnitarios x y n) es la lista de los n primeros
-- múltiplos de x cuyo único dígito es y. Por ejemplo,
-- multiplosUnitarios 7 1 2 == [111111,111111111111]
-- multiplosUnitarios 11 3 5 == [33,3333,333333,33333333,3333333333]
-- ---------------------------------------------------------------------

-- Lucía Hernández, Elsa Domínguez, Ana Sánchez Martín
multiplosUnitarios :: Int -> Int -> Int -> [Int]
multiplosUnitarios x y n = take n ([a | a<- unitarios y, mod a x == 0])

-- ---------------------------------------------------------------------
-- Ejercicio 9. Definir la función
-- masOcurrentes :: Eq a => [a] -> [a]
-- tal que (masOcurrentes xs) es la lista de los elementos de xs que
-- ocurren el máximo número de veces. Por ejemplo,
-- masOcurrentes [1,2,3,4,3,2,3,1,4] == [3,3,3]
-- masOcurrentes [1,2,3,4,5,2,3,1,4] == [1,2,3,4,2,3,1,4]
-- masOcurrentes "Salamanca" == "aaaa"
-- ---------------------------------------------------------------------

--Nicolás Rodríguez Ruiz y Elsa Domínguez
masOcurrentes :: Eq a => [a] -> [a]
masOcurrentes xs = [ b | (a,b) <- (paresOrd xs), a ==( maximum (numVeces xs))]
where paresOrd xs = zip (numVeces xs) xs
numVeces xs = [veces x xs | x <- xs]
veces n xs = sum[ 1 | x <- xs, x ==n]

-- Fernando Ruiz, Ana Sánchez Martín
masOcurrentes' xs = [ a | a <- xs , ocurrencia a xs == maximum (ocurrencias xs) ]

ocurrencias xs = [ ocurrencia a xs | a <- xs]
ocurrencia a xs = sum [ 1 | b <- xs, b == a]

--Manuel ALcaide
agrup xs = group (sort xs)

vecesqueaparecen xs = nub [(n,length v)|n<-xs,v<- agrup xs, elem n v]

listapoyo xs = [(g,h)|g<-(xs),(l,h)<-(vecesqueaparecen xs),g==l]

masOcurrentes'' :: Ord a => [a] -> [a]
masOcurrentes'' xs
|length (nub [m|(_,m)<-(vecesqueaparecen xs)]) == 1 = xs
|otherwise = [p|(p,q)<-(listapoyo xs) , q == maximum ([m|(_,m)<-(vecesqueaparecen xs)])]
-- Adolfo Sagrera Vivancos
masOcurrentes :: Ord a => [a] -> [a]
masOcurrentes xs = [x | x <- xs, longitud xs == veces x xs]
ordenados xs = group (sort xs)
longitud xs = maximum [length n | n <- ordenados xs]
veces n xs = sum[1 | a <- xs, n == a]

-- ---------------------------------------------------------------------
-- Ejercicio 10. La suma de la serie
-- 1/1^2 + 1/2^2 + 1/3^2 + 1/4^2 + ...
-- es pi^2/6. Por tanto, pi se puede aproximar mediante la raíz cuadrada
-- de 6 por la suma de la serie.
--
-- Definir la función aproximaPi tal que (aproximaPi n) es la aproximación
-- de pi obtenida mediante n términos de la serie. Por ejemplo,
-- aproximaPi 4 == 2.9226129861250305
-- aproximaPi 1000 == 3.1406380562059946
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Adolfo Sagrera Vivancos, Ana Sánchez Martín
aproximaPi n = sqrt (6*sum [1/x^2 | x <- [1..n]])

-- ---------------------------------------------------------------------
-- Ejercicio 11. Una representación de 20 en base 2 es [0,0,1,0,1] pues
-- 20 = 1*2^2 + 1*2^4. Y una representación de 46 en base 3 es [1,0,2,1]
-- pues 46 = 1*3^0 + 0*3^1 + 2*3^2 + 1*3^3.
--
-- Definir la función
-- deBaseABase10 :: Int -> [Int] -> Int
-- tal que (deBaseABase10 b xs) es el número n tal que su representación
-- en base b es xs. Por ejemplo,
-- deBaseABase10 2 [0,0,1,0,1] == 20
-- deBaseABase10 2 [1,1,0,1] == 11
-- deBaseABase10 3 [1,0,2,1] == 46
-- deBaseABase10 5 [0,2,1,3,1,4,1] == 2916
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sánchez Martín
deBaseABase10 :: Int -> [Int] -> Int
deBaseABase10 b xs = sum [i*( b^n) | (i,n)<- zip xs [0..length xs -1] ]
-- Adolfo Sagrera Vivancos
deBaseABase10' :: Int -> [Int] -> Int
deBaseABase10' b xs = sum[ n*(b^c) | (n,c) <- posicion xs]
posicion xs = zip xs [0..]

-- ---------------------------------------------------------------------
-- Ejercicio 12.1. Definir la función
-- conPos :: [a] -> [(a,Int)]
-- tal que (conPos xs) es la lista obtenida a partir de xs especificando
-- las posiciones de sus elementos. Por ejemplo,
-- conPos [1,5,0,7] == [(1,0),(5,1),(0,2),(7,3)]
-- ---------------------------------------------------------------------
-- Lucía Hernández
conPos :: [a] -> [(a,Int)]
conPos xs = [ (x,y) | (x,y)<- zip xs ys]
where ys = [0..length xs - 1]
-- Elsa Domínguez, Ana Sánchez Martín
conPos1 :: [a] -> [(a,Int)]
conPos1 xs = zip xs [0..length xs-1]
-- Adolfo Sagrera Vivancos
conPos' :: [a] -> [(a,Int)]
conPos' xs = zip xs [0..]

-- ---------------------------------------------------------------------
-- Ejercicio 12.2. Definir la función
-- pares :: [a] -> [a]
-- tal que (pares cs) es la cadena formada por los caracteres en
-- posición par de cs. Por ejemplo,
-- pares "el cielo sobre berlin" == "e il or eln"
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sánchez Martín
pares :: [a] -> [a]
pares cs = [a | (a,b) <- conPos cs, even b]

-- ---------------------------------------------------------------------
-- Ejercicio 13. Dos listas xs, ys de la misma longitud son
-- perpendiculares si el producto escalar de ambas es 0, donde el
-- producto escalar de dos listas de enteros xs e ys viene
-- dado por la suma de los productos de los elementos correspondientes.
--
-- Definir la función
-- perpendiculares :: (Num a, Eq a) => [a] -> [[a]] -> [[a]]
-- tal que (perpendiculares xs yss) es la lista de los elementos de yss
-- que son perpendiculares a xs. Por ejemplo,
-- ghci> perpendiculares [1,0,1] [[0,1,0], [2,3,1], [-1,7,1],[3,1,0]]
-- [[0,1,0],[-1,7,1]]
-- ---------------------------------------------------------------------

--Nicolás Rodríguez Ruiz y Elsa Domínguez
perpendiculares :: (Num a, Eq a) => [a] -> [[a]] -> [[a]]
perpendiculares xs yss = [ ys | ys <- yss, xs `productoEscalar` ys==0]
where productoEscalar xs ys = sum [a*x | (a,x) <- zip xs ys]

-- Ana Sánchez Martín
productoEscalar xs ys = sum [a*x | (a,x) <- zip xs ys]
-- Una vez tengamos la función productoEscalar hacemos perpendiculares
perpendiculares :: (Num a, Eq a) => [a] -> [[a]] -> [[a]]
perpendiculares xs yss = [ys | ys <- yss, productoEscalar xs ys == 0]

-- ---------------------------------------------------------------------
-- Ejercicio 14. Dada una lista de números enteros, definiremos el
-- mayor salto como el mayor valor de las diferencias (en valor
-- absoluto) entre números consecutivos de la lista. Por ejemplo, dada
-- la lista [2,5,-3] las distancias son
-- 3 (valor absoluto de la resta 2 - 5) y
-- 8 (valor absoluto de la resta de 5 y (-3))
-- Por tanto, su mayor salto es 8. No está definido el mayor salto para
-- listas con menos de 2 elementos
--
-- Definir la función
-- mayorSalto :: [Integer] -> Integer
-- tal que (mayorSalto xs) es el mayor salto de la lista xs. Por
-- ejemplo,
-- mayorSalto [1,5] == 4
-- mayorSalto [10,-10,1,4,20,-2] == 22
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sánchez Martín
mayorSalto :: [Integer] -> Integer
mayorSalto xs = maximum [abs (a-b) | (a,b) <- zip xs (tail xs)]

-- ---------------------------------------------------------------------
-- Ejercicio 15. Definir la función
-- longCamino :: [(Float,Float)] -> Float
-- tal que (longCamino xs) es la longitud del camino determinado por los
-- puntos del plano listados en xs. Por ejemplo,
-- longCamino [(0,0),(1,0),(2,1),(2,0)] == 3.4142137
-- ---------------------------------------------------------------------

--Elsa Domínguez y Nicolás Rodríguez Ruiz, Ana Sánchez Martín
longCamino :: [(Float,Float)] -> Float
longCamino xs = sum [distancia a b | (a,b) <- zip xs (tail xs)]
where distancia (a,b) (x,y) = sqrt((x-a)^2 + (y-b)^2)
-- Adolfo Sagrera Vivancos
longCamino1 :: [(Float,Float)] -> Float
longCamino1 xs = sum [ sqrt ((c-a)^2 + ((d-b)^2)) | ((a,b),(c,d)) <- agrupa xs]
agrupa xs = zip (init xs) (tail xs)

-- ---------------------------------------------------------------------
-- Ejercicio 16. Definir la función
-- numeroConsecutivos :: (Num a, Eq a) => [a] -> Int
-- tal que (numeroConsecutivosC xs) es la cantidad de números
-- consecutivos que aparecen al comienzo de la lista xs. Por ejemplo,
-- numeroConsecutivosC [1,3,5,7,9] == 1
-- numeroConsecutivosC [1,2,3,4,5,7,9] == 5
-- numeroConsecutivosC [] == 0
-- ---------------------------------------------------------------------

-- Prof; posibles soluciones
-- 1ª solución (con índices)
numeroConsecutivosC :: (Num a, Eq a) => [a] -> Int
numeroConsecutivosC xs
| null ys = length xs
| otherwise = head ys
where ys = [n | n <- [1..length xs -1], xs !! n /= 1 + xs !! (n-1)]

-- 2ª solución (con zip3)
numeroConsecutivosC2 :: (Num a, Eq a) => [a] -> Int
numeroConsecutivosC2 [] = 0
numeroConsecutivosC2 [x] = 1
numeroConsecutivosC2 [x,y] | x+1 == y = 2
| otherwise = 1
numeroConsecutivosC2 xs =
head [k | (x,y,k) <- zip3 xs (tail xs) [1..], y /= x+1]

-- ---------------------------------------------------------------------
-- Ejercicio 17. Definir la función
-- sumaEquidistantes :: Num a => [a] -> [a]
-- tal que (sumaEquidistantes xs) es la lista sumando el primer elemento
-- de xs con el último, el segundo con el penúltimo y así
-- sucesivamente. Por ejemplo,
-- sumaEquidistantes [6,5,3,1] == [7,8]
-- sumaEquidistantes [6,5,3] == [9,10]
-- sumaEquidistantes [3,2,3,2] == [5,5]
-- sumaEquidistantes [6,5,3,1,2,0,4,7,8,9] == [15,13,10,5,2]
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sánchez Martín
sumaEquidistantes :: Num a => [a] -> [a]
sumaEquidistantes xs = reverse (drop (div (length xs) 2) [a+b | (a,b) <- zip xs (reverse xs)])

-- ---------------------------------------------------------------------
-- Ejercicio 18. La distancia entre dos números es el valor absoluto de
-- su diferencia. Por ejemplo, la distancia entre 2 y 5 es 3.
--
-- Definir la función
-- cercanos :: [Int] -> [Int] -> [(Int,Int)]
-- tal que (cercanos xs ys) es la lista de pares de elementos de xs e ys
-- cuya distancia es mínima. Por ejemplo,
-- cercanos [3,7,2,1] [5,11,9] == [(3,5),(7,5),(7,9)]
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sánchez Martín
distancia x y = abs(x-y)
cercanos :: [Int] -> [Int] -> [(Int,Int)]
cercanos xs ys = [(x,y) | x<- xs, y<-ys, distancia x y == minimum [distancia x' y' | x'<- xs, y'<-ys]]

-- Elsa Domínguez
cercanos1 :: [Int] -> [Int] -> [(Int,Int)]
cercanos1 xs ys = [(a,b) | a <- xs, b <- ys, abs (a-b) == minimum (distanciaPares xs ys)]

distanciaPares xs ys = [abs (a-b) | a <- xs, b <- ys]

-- ---------------------------------------------------------------------
-- Ejercicio 19. [De la IMO 1996]. Una sucesión [a(0),a(1),...,a(n)]
-- se denomina cuadrática si para cada i {1, 2,..., n} se cumple que
-- |a(i)- a(i-1)| = i^2 .
--
-- Definir la función
-- esCuadratica :: [Int] -> Bool
-- tal que (esCuadratica xs) se verifica si xs cuadrática. Por ejemplo,
-- esCuadratica [2,1,-3,6] == True
-- esCuadratica [2,1,3,5] == False
-- esCuadratica [3,4,8,17,33,58,94,45,-19,-100] == True
-- ---------------------------------------------------------------------

-- Elsa Domínguez
esCuadratica :: [Int] -> Bool
esCuadratica xs = [abs (a-b) | (a,b) <- ys] == [x^2 | x <- [1..length (ys)]]
where ys = zip (tail xs) xs

-- Prof: otra opción
esCuadratica :: [Int] -> Bool
esCuadratica xs = and [abs (a-b) == x^2 | (a,b,x) <- zip3 (tail xs) xs [1..]]

-- ---------------------------------------------------------------------
-- Ejercicio 20.1. Definir las funciones
-- ultima, primera :: Int -> Int
-- tales que
-- * (ultima n) es la última cifra del número natural n y
-- * (primera n) es la primera cifra del número natural n.
-- Por ejemplo,
-- ultima 711 = 1
-- primera 711 = 7
-- ---------------------------------------------------------------------

--Nicolás Rodríguez Ruiz y Elsa Domínguez, Ana Sánchez Martín
ultima, primera :: Int -> Int
ultima n = rem n 10
primera n = read [head (show n)]
-- prof: también con digitToInt de Data.Char

-- ---------------------------------------------------------------------
-- Ejercicio 20.2. Definir la función
-- encadenadoC :: [Int] -> Bool
-- tal que (encadenadoC xs) se verifica si xs es una lista de enteros
-- positivos encadenados (es decir, la última cifra de cada número
-- coincide con la primera del siguiente en la lista). Por ejemplo,
-- encadenadoC [711,1024,413,367] == True
-- encadenadoC [711,1024,213,367] == False
-- ---------------------------------------------------------------------

-- Elsa Domínguez y Nicolás Rodríguez Ruiz, Ana Sánchez Martín
encadenadoC :: [Int] -> Bool
encadenadoC xs = and [ ultima a == primera b | (a,b) <- zip xs (tail xs)]

</source>

Relación 3

2021-11-03T12:34:10Z

188.78.90.137:

<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, Ana Sánchez Martín, Irene Ortega Moncayo
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, Ana Sánchez Martín
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]
-- Ana Sánchez Martín
suma n = [x | x <- [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, Ana Sánchez Martín
linea :: Integer -> [Integer]
linea n = [x | x<-[suma(n-1) +1..suma n]]
-- Adolfo Sagrera Vivancos, Carmen Blanco, 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, Lucía González, Elsa Domínguez, Cristina Torres, Carmen Blanco, Ana Sánchez Martín
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, Ana Sánchez Martín
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, Carmen Blanco, Lucía González
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, Lucía González
numeroAbundante :: Int -> Bool
numeroAbundante n = n < (sum (factores n) - n)
-- Lucía Hernández, Cristina Torres, Ana Sánchez Martín
numeroAbundante :: Int -> Bool
numeroAbundante n = n < sum(factores n)
-- Elsa Domínguez, Carmen Blanco
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, Carmen Blanco, Lucía González, Ana Sánchez Martín
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, Lucía González
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]
-- Ana Sánchez Martín
todosPares :: Int -> Bool
todosPares n = all even (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, Lucía González, Ana Sánchez Martín
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, Irene Ortega Moncayo
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, Lucía González, Ana Sánchez Martín
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, Lucía González, Irene Ortega Moncayo, Ana Sánchez Martín
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, Lucía González, Irene Ortega Moncayo, Ana Sánchez Martín
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, Lucía González, Ana Sánchez Martín
-- 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, Ana Sánchez Martín
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, Lucía González, Irene Ortega Moncayo
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, Lucía González, Ana Sánchez Martín
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, Lucía González, Ana Sánchez Martín
-- 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, Lucía González, Ana Sánchez Martín
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, Ana Sánchez Martín
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, Lucía González, Ana Sánchez Martín
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, Lucía González, Irene Ortega Moncayo, Ana Sánchez Martín
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, Lucía González, Adolfo Sagrera Vivancos, Irene Ortega Moncayo, Ana Sánchez Martín
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, Lucía González, Adolfo Sagrera Vivancos, Irene Ortega Moncayo, Ana Sánchez Martín
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, Lucía González
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]
-- Adolfo Sagrera Vivancos, Irene Ortega Moncayo, Ana Sánchez Martín
ternasPitagoricas1 :: Integer -> [(Integer,Integer,Integer)]
ternasPitagoricas1 x = [(a,b,c) | a <- [1..x], b <- [a+1..x], c <- [x-a-b],
a^2+b^2 == c^2]

-- ---------------------------------------------------------------------
-- 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.
-- ---------------------------------------------------------------------
--Lucía González, Ana Sánchez Martín
euler9 :: Integer
euler9 = a*b*c
where (a,b,c)= head (ternasPitagoricas 1000)
-- Adolfo Sagrera Vivancos
euler9' :: Integer
euler9' = head[ a*b*c | (a,b,c) <- (ternasPitagoricas 1000)]
-- 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, Lucía González, Adolfo Sagrera Vivancos, Ana Sánchez Martín
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, Lucía González, Adolfo Sagrera Vivancos, Irene Ortega Moncayo, Ana Sánchez Martín
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, Adolfo Sagrera Vivancos, Ana Sánchez Martín
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]

--Lucía González
densa2 :: [Int] -> [(Int,Int)]
densa2 xs = [(x,y)| (x,y) <- zip [n-1,n-2..0] xs, y/=0]
where n= length xs
-- ---------------------------------------------------------------------
-- 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, Lucía González, Adolfo Sagrera Vivancos, Irene Ortega Moncayo
nombres :: [(String,String,Int,Int)] -> [String]
nombres bd = [(a) | (a,_,_,_) <- bd]
-- Ana Sánchez Martín
nombres :: [(String,String,Int,Int)] -> [String]
nombres bd = [nombre | (nombre, actividad, nacimiento, fallecimiento) <- 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, Lucía González, Adolfo Sagrera Vivancos, Irene Ortega Moncayo
musicos :: [(String,String,Int,Int)] -> [String]
musicos bd = [(a) | (a,b,_,_) <- bd, b == "Musica"]
-- Ana Sánchez Martín
musicos :: [(String,String,Int,Int)] -> [String]
musicos bd = [nombre | (nombre, actividad, nacimiento, fallecimiento) <- bd,
actividad == "Música"

-- ---------------------------------------------------------------------
-- 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, Lucía González, Adolfo Sagrera Vivancos, Irene Ortega Moncayo
seleccion :: [(String,String,Int,Int)] -> String -> [String]
seleccion bd m = [(a) | (a,b,_,_) <- bd, b == m]
-- Ana Sánchez Martín
seleccion :: [(String,String,Int,Int)] -> String -> [String]
seleccion bd m = [nombre |(nombre, actividad, nacimiento, fallecimiento) <- bd,
actividad == 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, Lucía González, Adolfo Sagrera Vivancos, Irene Ortega Moncayo, Ana Sánchez Martín
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, Lucía González, Adolfo Sagrera Vivancos, Irene Ortega Moncayo
vivas :: [(String,String,Int,Int)] -> Int -> [String]
vivas ps a = [(p) | (p,_,c,d) <- ps, c <= a && a <= d]
-- Ana Sánchez Martín
vivas :: [(String,String,Int,Int)] -> Int -> [String]
vivas ps a = [nombre | (nombre, actividad, nacimiento, fallecimiento) <- bd,
nacimiento <= a, fallecimiento >= a]

</source>