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

Relación 8

2021-11-30T14:24:50Z

Anasoscab:

<source lang='haskell'>

-- I1M 2021-22: Rel_8.hs (24 de noviembre de 2021)
-- Funciones de orden superior y definiciones por plegados.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

-- Esta relación tiene contiene ejercicios con funciones de orden
-- superior y definiciones por plegado correspondientes al tema 7
-- http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-7.html

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

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
-- segmentos :: (a -> Bool) -> [a] -> [a]
-- tal que (segmentos p xs) es la lista de los segmentos de xs cuyos
-- elementos verifican la propiedad p. Por ejemplo,
-- segmentos even [1,2,0,4,9,6,4,5,7,2] == [[2,0,4],[6,4],[2]]
-- segmentos odd [1,2,0,4,9,6,4,5,7,2] == [[1],[9],[5,7]]
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
segmentos1 :: (a -> Bool) -> [a] -> [[a]]
segmentos1 p [] = []
segmentos1 p (x:xs) | p x = [a] ++ segmentos1 p (dropWhile p (x:xs))
| otherwise = segmentos1 p xs
where a = takeWhile p (x:xs)
segmentos :: (a -> Bool) -> [a] -> [[a]]
segmentos p [] = []
segmentos p (x:xs)
| p x = (takeWhile p (x:xs)) : segmentos p (dropWhile p (x:xs))
| otherwise = segmentos p (dropWhile (not.p) xs)

-- ---------------------------------------------------------------------
-- Ejercicio 2.1. Definir, por comprensión, la función
-- relacionadosC :: (a -> a -> Bool) -> [a] -> Bool
-- tal que (relacionadosC r xs) se verifica si para todo par (x,y) de
-- elementos consecutivos de xs se cumple la relación r. Por ejemplo,
-- relacionadosC (<) [2,3,7,9] == True
-- relacionadosC (<) [2,3,1,9] == False
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Ana Sosa Caballero
relacionadosC :: (a -> a -> Bool) -> [a] -> Bool
relacionadosC r xs = and [r a b | (a,b) <- zip xs (tail xs)]
--José Manuel García
relacionadosC1 :: (a -> a -> Bool) -> [a] -> Bool
relacionadosC1 r xs = (length [1 | (a,b) <- (zip xs (tail xs)), a `r` b]) ==
(length (zip xs (tail xs)))
-- ---------------------------------------------------------------------
-- Ejercicio 2.2. Definir, por recursión, la función
-- relacionadosR :: (a -> a -> Bool) -> [a] -> Bool
-- tal que (relacionadosR r xs) se verifica si para todo par (x,y) de
-- elementos consecutivos de xs se cumple la relación r. Por ejemplo,
-- relacionadosR (<) [2,3,7,9] == True
-- relacionadosR (<) [2,3,1,9] == False
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández
relacionadosR :: (a -> a -> Bool) -> [a] -> Bool
relacionadosR r [] = True
relacionadosR r [x] = True
relacionadosR r (x:y:zs) = (r x y) && relacionadosR r (y:zs)
--José Manuel García
relacionadosR :: (a -> a -> Bool) -> [a] -> Bool
relacionadosR r [x1,x2] = x1 `r` x2
relacionadosR r (x1:x2:xs) = (x1 `r`x2) && (relacionadosR r (x2:xs))
-- Ana Sosa Caballero
relacionadosR :: (a -> a -> Bool) -> [a] -> Bool
relacionadosR _ [] = False
relacionadosR r [x,y] = r x y
relacionadosR r (x:y:xs) | r x y = relacionadosR r (y:xs)
| otherwise = False
-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Definir la función
-- agrupa :: Eq a => [[a]] -> [[a]]
-- tal que (agrupa xss) es la lista de las listas obtenidas agrupando
-- los primeros elementos, los segundos, ... Por ejemplo,
-- agrupa [[1..6],[7..9],[10..20]] == [[1,7,10],[2,8,11],[3,9,12]]
-- agrupa [] == []
-- ---------------------------------------------------------------------

-- Lucía Hernández, Ana Sosa Caballero
agrupa :: Eq a => [[a]] -> [[a]]
agrupa [] = []
agrupa xss | any null xss = []
| otherwise =[map head xss] ++ agrupa (map tail xss)

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Comprobar con QuickChek que la longitud de todos los
-- elementos de (agrupa xs) es igual a la longitud de xs.
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sosa Caballero
-- La propiedad es
prop_agrupa :: [[Int]] -> Bool
prop_agrupa xss = and [length xs == length xss | xs <- agrupa xss]

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

-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir, por recursión, la función
-- concatR :: [[a]] -> [a]
-- tal que (concatR xss) es la concatenación de las listas de xss. Por
-- ejemplo,
-- concatR [[1,3],[2,4,6],[1,9]] == [1,3,2,4,6,1,9]
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Ana Sosa Caballero
concatR :: [[a]] -> [a]
concatR [] = []
concatR (x:xs) = x ++ concatR xs

-- ---------------------------------------------------------------------
-- Ejercicio 5.1. Definir, por comprensión, la función
-- filtraAplicaC :: (a -> b) -> (a -> Bool) -> [a] -> [b]
-- tal que (filtraAplicaC f p xs) es la lista obtenida aplicándole a los
-- elementos de xs que cumplen el predicado p la función f. Por ejemplo,
-- filtraAplicaC (4+) (<3) [1..7] => [5,6]
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Ana Sosa Caballero
filtraAplicaC :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaC f p xs = [f x | x <- xs, p x]

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Definir, usando map y filter, la función
-- filtraAplicaMF :: (a -> b) -> (a -> Bool) -> [a] -> [b]
-- tal que (filtraAplicaMF f p xs) es la lista obtenida aplicándole a los
-- elementos de xs que cumplen el predicado p la función f. Por ejemplo,
-- filtraAplicaMF (4+) (<3) [1..7] => [5,6]
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Lucía Hernández, Ana Sosa Caballero
filtraAplicaMF :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaMF f p xs = map f (filter p xs)

-- ---------------------------------------------------------------------
-- Ejercicio 5.3. Definir, por recursión, la función
-- filtraAplicaR :: (a -> b) -> (a -> Bool) -> [a] -> [b]
-- tal que (filtraAplicaR f p xs) es la lista obtenida aplicándole a los
-- elementos de xs que cumplen el predicado p la función f. Por ejemplo,
-- filtraAplicaR (4+) (<3) [1..7] => [5,6]
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sosa Caballero
filtraAplicaR :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaR f p [] = []
filtraAplicaR f p (x:xs) | p x = [f x] ++ filtraAplicaR f p xs
| (not.p) x = filtraAplicaR f p xs

-- ---------------------------------------------------------------------
-- Ejercicio 6.1. Definir, mediante recursión, la función
-- maximumR :: Ord a => [a] -> a
-- tal que (maximumR xs) es el máximo de la lista xs. Por ejemplo,
-- maximumR [3,7,2,5] == 7
-- maximumR ["todo","es","falso"] == "todo"
-- maximumR ["menos","alguna","cosa"] == "menos"
--
-- Nota: La función maximumR es equivalente a la predefinida maximum.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
maximumR :: Ord a => [a] -> a
maximumR [x] = x
maximumR (x:xs) = max x (maximumR XS)

-- Ana Sosa Caballero
maximumR :: Ord a => [a] -> a
maximumR [x] = x
maximumR (x:xs) | x > (head xs) = maximumR (x:(tail xs))
| otherwise = maximumR (xs)

-- ---------------------------------------------------------------------
-- Ejercicio 6.2. La función de plegado foldr1 está definida por
-- foldr1 :: (a -> a -> a) -> [a] -> a
-- foldr1 _ [x] = x
-- foldr1 f (x:xs) = f x (foldr1 f xs)
--
-- Definir, mediante plegado con foldr1, la función
-- maximumP :: Ord a => [a] -> a
-- tal que (maximumR xs) es el máximo de la lista xs. Por ejemplo,
-- maximumP [3,7,2,5] == 7
-- maximumP ["todo","es","falso"] == "todo"
-- maximumP ["menos","alguna","cosa"] == "menos"
--
-- Nota: La función maximumP es equivalente a la predefinida maximum.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
maximumP :: Ord a => [a] -> a
maximumP xs = foldr1 max xs

-- ---------------------------------------------------------------------
-- Ejercicio 7.1. Definir, usando foldr, la función
-- concatP :: [[a]] -> [a]
-- tal que (concatP xss) es la concatenación de las listas de xss. Por
-- ejemplo,
-- concatP [[1,3],[2,4,6],[1,9]] == [1,3,2,4,6,1,9]
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sosa Caballero
concatP :: [[a]] -> [a]
concatP xs = foldr (++) [] xs

-- ---------------------------------------------------------------------
-- Ejercicio 7.2. Comprobar con QuickCheck que la funciones concatR,
-- concatP y concat son equivalentes.
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sosa Caballero
-- La propiedad es
prop_concat :: [[Int]] -> Bool
prop_concat xss = concatR xss == concat xss && concatP xss == concat xss

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

-- ---------------------------------------------------------------------
-- Ejercicio 7.3. Comprobar con QuickCheck que la longitud de
-- (concatP xss) es la suma de las longitudes de los elementos de xss.
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sosa Caballero
-- La propiedad es
prop_longConcat :: [[Int]] -> Bool
prop_longConcat xss = length (concatP xss) == sum [length xs | xs <- xss]

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

-- ---------------------------------------------------------------------
-- Ejercicio 8. Definir, por plegado, la función
-- filtraAplicaP :: (a -> b) -> (a -> Bool) -> [a] -> [b]
-- tal que (filtraAplicaP f p xs) es la lista obtenida aplicándole a los
-- elementos de xs que cumplen el predicado p la función f. Por ejemplo,
-- filtraAplicaP (4+) (<3) [1..7] => [5,6]
-- ---------------------------------------------------------------------

-- Elsa Domínguez, Ana Sosa Caballero
filtraAplicaP :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaP f p xs = foldr g [] xs
where g x recu | p x = [f x] ++ recu
| (not.p) x = recu

-- ---------------------------------------------------------------------
-- Ejercicio 9.1. Definir, con la función all, la función
-- relacionadosA :: (a -> a -> Bool) -> [a] -> Bool
-- tal que (relacionadosA r xs) se verifica si para todo par (x,y) de
-- elementos consecutivos de xs se cumple la relación r. Por ejemplo,
-- relacionadosA (<) [2,3,7,9] == True
-- relacionadosA (<) [2,3,1,9] == False
-- ---------------------------------------------------------------------

relacionadosA :: (a -> a -> Bool) -> [a] -> Bool
relacionadosA = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 9.2. Definir, con la función foldr, la función
-- relacionadosP :: (a -> a -> Bool) -> [a] -> Bool
-- tal que (relacionadosP r xs) se verifica si para todo par (x,y) de
-- elementos consecutivos de xs se cumple la relación r. Por ejemplo,
-- relacionadosP (<) [2,3,7,9] == True
-- relacionadosP (<) [2,3,1,9] == False
-- ---------------------------------------------------------------------

relacionadosP :: (a -> a -> Bool) -> [a] -> Bool
relacionadosP = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. (Basado en el ejercicio 4 del primer parcial del
-- grupo E de 2017)
-- Una lista se dirá muy creciente si cada elemento es mayor estricto
-- que el triple del siguiente.
-- Empleando tan solo (relacionadosA p xs), define el predicado
-- muyCreciente :: [Integer] -> Bool
-- tal que (muyCreciente xs) se verifica si xs es muy creciente. Por
-- ejemplo:
-- muyCreciente [1,5,23,115] == True
-- muyCreciente [1,2,7,14] == False
-- muyCreciente [7] == True
-- muyCreciente [] == True
-- ---------------------------------------------------------------------

muyCreciente :: [Integer] -> Bool
muyCreciente xs = undefined

</source>

Relación 7

2021-11-29T18:42:00Z

Anasoscab:

<source lang='haskell'>

-- I1M 2021-22: Rel_7.hs
-- Definiciones por recursión y por comprensión
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

-- Esta relación es de repaso y servirá para seguir practicando los
-- conceptos de recursión y comprensión
-- En esta relación se presentan ejercicios con dos definiciones (una
-- por recursión y otra por comprensión) y la comprobación de la
-- equivalencia de las dos definiciones con QuickCheck. Los ejercicios
-- corresponden a los temas 5 y 6
-- ---------------------------------------------------------------------
-- Importación de librerías auxiliares --
-- ---------------------------------------------------------------------

import Test.QuickCheck
import Data.List

-- ---------------------------------------------------------------------
-- Operaciones conjuntistas sobre listas.
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 1.1. Definir, por comprensión, la función
-- subconjunto :: Eq a => [a] -> [a] -> Bool
-- tal que (subconjunto xs ys) se verifica si xs es un subconjunto de
-- ys; es decir, si todos los elementos de xs pertenecen a ys. Por
-- ejemplo,
-- subconjunto [3,2,3] [2,5,3,5] == True
-- subconjunto [3,2,3] [2,5,6,5] == False
-- ---------------------------------------------------------------------
-- Lucía Hernández, Lucía González , Adolfo Sagrera, Elsa Domínguez, Ana Sosa Caballero
subconjunto :: Eq a => [a] -> [a] -> Bool
subconjunto xs ys = and [elem x ys | x<- xs]

-- Sara Cerro
subconjunto :: Eq a => [a] -> [a] -> Bool
subconjunto xs ys = length [ x | x <- xs, elem x ys] == length xs

-- ---------------------------------------------------------------------
-- Ejercicio 1.2. Definir, por recursión, la función
-- subconjuntoR :: Eq a => [a] -> [a] -> Bool
-- tal que (subconjuntoR xs ys) se verifica si xs es un subconjunto de
-- ys; es decir, si todos los elementos de xs pertenecen a ys. Por
-- ejemplo,
-- subconjuntoR [3,2,3] [2,5,3,5] == True
-- subconjuntoR [3,2,3] [2,5,6,5] == False
-- ---------------------------------------------------------------------
-- Lucía Hernández, Adolfo Sagrera Vivancos, Lucía González Guillén
subconjuntoR :: Eq a => [a] -> [a] -> Bool
subconjuntoR [] _ = True
subconjuntoR (x:xs) ys | elem x ys = subconjuntoR xs ys
| otherwise = False
-- Elsa Domínguez
subconjuntoR' :: Eq a => [a] -> [a] -> Bool
subconjuntoR' [] _ = True
subconjuntoR' (x:xs) ys = x `elem` ys && (subconjuntoR xs ys)

-- Ana Sosa Caballero
subconjuntoR :: Eq a => [a] -> [a] -> Bool
subconjuntoR _ [] = False
subconjuntoR [] _ = True
subconjuntoR (x:xs) ys = and [elem x ys && subconjuntoR xs ys]

-- ---------------------------------------------------------------------
-- Ejercicio 1.3. Comprobar con QuickCheck que las definiciones
-- subconjunto y subconjuntoR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero
-- La propiedad es
prop_subconjuntoR :: [Int] -> [Int] -> Bool
prop_subconjuntoR xs ys = (subconjunto xs ys) == (subconjuntoR xs ys)

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

-- ---------------------------------------------------------------------
-- Ejercicio 1.4. Definir, mediante all, la función
-- subconjuntoA :: Eq a => [a] -> [a] -> Bool
-- tal que (subconjuntoA xs ys) se verifica si xs es un subconjunto de
-- ys. Por ejemplo,
-- subconjuntoA [1,3,2,3] [1,2,3] == True
-- subconjuntoA [1,3,4,3] [1,2,3] == False
-- ---------------------------------------------------------------------

subconjuntoA :: Eq a => [a] -> [a] -> Bool
subconjuntoA = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 1.5. Comprobar con QuickCheck que las funciones subconjunto
-- y subconjuntoA son equivalentes.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_subconjuntoA :: [Int] -> [Int] -> Bool
prop_subconjuntoA = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir la función
-- iguales :: Eq a => [a] -> [a] -> Bool
-- tal que (iguales xs ys) se verifica si xs e ys son iguales; es decir,
-- tienen los mismos elementos. Por ejemplo,
-- iguales [3,2,3] [2,3] == True
-- iguales [3,2,3] [2,3,2] == True
-- iguales [3,2,3] [2,3,4] == False
-- iguales [2,3] [4,5] == False
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
iguales :: Eq a => [a] -> [a] -> Bool
iguales xs ys = subconjuntoR xs ys && subconjuntoR ys xs
-- Adolfo Sagrera Vivancos, Lucía González, Ana Sosa Caballero
iguales1 :: Eq a => [a] -> [a] -> Bool
iguales1 xs ys = and [ elem x ys && elem y xs | x <- xs, y <- ys]

-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Definir, por comprensión, la función
-- union :: Eq a => [a] -> [a] -> [a]
-- tal que (union xs ys) es la unión de los conjuntos xs e ys. Por
-- ejemplo,
-- union [3,2,5] [5,7,3,4] == [3,2,5,7,4]
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
union1 :: Eq a => [a] -> [a] -> [a]
union1 xs ys = [x | x<- nub(xs++ys)]
-- Elsa Domínguez
union' :: Eq a => [a] -> [a] -> [a]
union' xs ys = [x | x <- xs, x `notElem` ys] ++ ys

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Definir, por recursión, la función
-- unionR :: Eq a => [a] -> [a] -> [a]
-- tal que (unionR xs ys) es la unión de los conjuntos xs e ys. Por
-- ejemplo,
-- unionR [3,2,5] [5,7,3,4] == [2,5,7,3,4]
-- ---------------------------------------------------------------------
-- Lucía Hernández
unionR :: Eq a => [a] -> [a] -> [a]
unionR [] xs = nub xs
unionR xs [] = nub xs
unionR (x:xs) ys | not(elem x ys) = x: unionR xs ys
| otherwise = unionR xs ys
-- Elsa Domínguez
unionR1 :: Eq a => [a] -> [a] -> [a]
unionR1 xs ys = nub (unionR' xs ys)
unionR' [] ys = ys
unionR' (x:xs) (ys) = unionR xs (x:ys)

-- Ana Sosa Caballero
unionR :: Eq a => [a] -> [a] -> [a]
unionR xs [] = xs
unionR [] ys = ys
unionR xs (y:ys) = nub( xs ++ [y] ++ unionR [] ys)

-- ---------------------------------------------------------------------
-- Ejercicio 3.3. Comprobar con QuickCheck que union y unionR son
-- equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández
-- La propiedad es
prop_union :: [Int] -> [Int] -> Bool
prop_union xs ys = (union1 xs ys == unionR xs ys) ||
(iguales (union1 xs ys) (unionR xs ys))
-- Elsa Domínguez
-- La propiedad es
prop_union :: [Int] -> [Int] -> Bool
prop_union xs ys = iguales (union' xs ys) (unionR xs ys)
-- La comprobación es quickCheck prop_union
-- +++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 4. Comprobar con QuickCheck que la unión es conmutativa.
-- ---------------------------------------------------------------------
-- Lucía Hernández
-- La propiedad es
prop_union_conmutativa :: [Int] -> [Int] -> Bool
prop_union_conmutativa xs ys =(union1 xs ys == union1 ys xs) ||
(iguales (union1 xs ys) (union1 ys xs))

-- Elsa Domínguez, Ana Sosa Caballero
-- La propiedad es
prop_union_conmutativa :: [Int] -> [Int] -> Bool
prop_union_conmutativa xs ys = iguales (union' xs ys) (union' ys xs)
-- La comprobación es quickCheck prop_union_conmutativa
-- +++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 5.1. Definir, por comprensión, la función
-- interseccion :: Eq a => [a] -> [a] -> [a]
-- tal que (interseccion xs ys) es la intersección de xs e ys. Por
-- ejemplo,
-- interseccion [3,2,5] [5,7,3,4] == [3,5]
-- interseccion [3,2,5] [9,7,6,4] == []
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero
interseccion :: Eq a => [a] -> [a] -> [a]
interseccion xs ys = [ x | x<- xs, elem x ys]

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Definir, por recursión, la función
-- interseccionR :: Eq a => [a] -> [a] -> [a]
-- tal que (interseccionR xs ys) es la intersección de xs e ys. Por
-- ejemplo,
-- interseccionR [3,2,5] [5,7,3,4] == [3,5]
-- interseccionR [3,2,5] [9,7,6,4] == []
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
interseccionR :: Eq a => [a] -> [a] -> [a]
interseccionR [] _ = []
interseccionR _ [] = []
interseccionR (x:xs) ys | elem x ys = x : interseccionR xs ys
| otherwise = interseccionR xs ys
-- Elsa Domínguez
interseccionR' :: Eq a => [a] -> [a] -> [a]
interseccionR' [] _ = []
interseccionR' (x:xs) ys | x `elem` ys = x:interseccionR xs ys
| otherwise = interseccionR xs ys

-- ---------------------------------------------------------------------
-- Ejercicio 5.3. Comprobar con QuickCheck que interseccion e
-- interseccionR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero
-- La propiedad es
prop_interseccion :: [Int] -> [Int] -> Bool
prop_interseccion xs ys = interseccion xs ys == interseccionR xs ys

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

-- ---------------------------------------------------------------------
-- Ejercicio 6. Comprobar con QuickCheck si se cumple la siguiente
-- propiedad
-- A ∪ (B ∩ C) = (A ∪ B) ∩ C
-- donde se considera la igualdad como conjuntos. En el caso de que no
-- se cumpla verificar el contraejemplo calculado por QuickCheck.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
prop_union_interseccion :: [Int] -> [Int] -> [Int] -> Bool
prop_union_interseccion xs ys zs = union1 xs (interseccion ys zs) == interseccion (union xs ys) zs

-- La comprobación es

-- Elsa Domínguez
prop_union_interseccion :: [Int] -> [Int] -> [Int] -> Bool
prop_union_interseccion a b c = union' a (interseccion b c) == interseccion (union' a b) c

-- La comprobación es quickCheck prop_union_interseccion
-- *** Failed! Falsifiable (after 3 tests and 3 shrinks):
-- [0]
-- []
-- []
-- λ> union' [0] (interseccion [] [])
-- [0]
-- λ> interseccion (union' [0] []) []
-- []
-- ---------------------------------------------------------------------
-- Ejercicio 7.1. Definir, por comprensión, la función
-- diferencia :: Eq a => [a] -> [a] -> [a]
-- tal que (diferencia xs ys) es la diferencia entre los conjuntos xs e
-- ys; es decir, la lista de los elementos que sólo pertenecen a xs. Por
-- ejemplo,
-- diferencia [3,2,5,6] [5,7,3,4] == [2,6]
-- diferencia [3,2,5] [5,7,3,2] == []
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero
diferencia :: Eq a => [a] -> [a] -> [a]
diferencia xs ys = [x | x<-xs, not(elem x ys)]

-- ---------------------------------------------------------------------
-- Ejercicio 7.2. Definir, por recursión, la función
-- diferenciaR :: Eq a => [a] -> [a] -> [a]
-- tal que (diferenciaR xs ys) es la diferencia entre los conjuntos xs e
-- ys; es decir, la lista de los elementos que sólo pertenecen a xs. Por
-- ejemplo,
-- diferenciaR [3,2,5,6] [5,7,3,4] == [2,6]
-- diferenciaR [3,2,5] [5,7,3,2] == []
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero
diferenciaR :: Eq a => [a] -> [a] -> [a]
diferenciaR xs [] = xs
diferenciaR [] _ = []
diferenciaR (x:xs) ys | not(elem x ys) = x: diferenciaR xs ys
| otherwise = diferenciaR xs ys

-- ---------------------------------------------------------------------
-- Ejercicio 7.3. Comprobar con QuickCheck que diferencia y diferenciaR
-- son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero
-- La propiedad es
prop_diferencia :: [Int] -> [Int] -> Bool
prop_diferencia xs ys = diferenciaR xs ys == diferencia xs ys

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

-- ---------------------------------------------------------------------
-- Ejercicio 8. Comprobar con QuickCheck si la diferencia es
-- conmutativa.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero
prop_diferencia_conmutativa :: [Int] -> [Int] -> Bool
prop_diferencia_conmutativa xs ys = diferenciaR xs ys == diferenciaR ys xs

-- La comprobación es quickCheck prop_diferencia_conmutativa
-- *** Failed! Falsifiable (after 2 tests and 1 shrink):
-- []
-- [0]

-- ---------------------------------------------------------------------
-- Ejercicio 9. Comprobar con QuickCheck si se cumple la siguiente
-- propiedad: A \ B ⊂ A
-- ---------------------------------------------------------------------
-- Elsa Domínguez, Ana Sosa Caballero
-- La propiedad es
prop_diferencia_subconjunto :: [Int] -> [Int] -> Bool
prop_diferencia_subconjunto a b = subconjunto (diferencia a b) a

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

-- ---------------------------------------------------------------------
-- Ejercicio 10. Comprobar con QuickCheck si se cumple la siguiente
-- propiedad: (A \ B) ∩ B = ∅.
-- ---------------------------------------------------------------------
-- Elsa Domínguez, Ana Sosa Caballero
-- La propiedad es
prop_diferencia_interseccion :: [Int] -> [Int] -> Bool
prop_diferencia_interseccion a b = interseccion (diferencia a b) b == []

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

-- ---------------------------------------------------------------------
-- Ejercicio 11.1. Definir, por comprensión, la función
-- producto :: Eq a => [a] -> [a] -> [(a,a)]
-- tal que (producto xs ys) es el producto cartesiano de xs e ys. Por
-- ejemplo,
-- producto [1,3] [2,4] == [(1,2),(1,4),(3,2),(3,4)]
-- ---------------------------------------------------------------------
-- Lucía Hernández
producto :: Eq a => [a] -> [a] -> [(a,a)]
producto xs ys = [(a,b) | (a,b) <- zip xs ys ++ zip xs ys']
where ys' = reverse ys
-- Elsa Domínguez, Ana Sosa Caballero
producto' :: Eq a => [a] -> [a] -> [(a,a)]
producto' xs ys= [(x,y) | x <- xs, y <- ys]

-- ---------------------------------------------------------------------
-- Ejercicio 11.2. Definir, por recursión, la función
-- productoR :: Eq a => [a] -> [a] -> [(a,a)]
-- tal que (productoR xs ys) es el producto cartesiano de xs e ys. Por
-- ejemplo,
-- productoR [1,3] [2,4] == [(1,2),(1,4),(3,2),(3,4)]
-- ---------------------------------------------------------------------
-- Lucía Hernández
productoR :: Eq a => [a] -> [a] -> [(a,a)]
productoR [] _ = []
productoR _ [] = []
productoR (x:xs) (y:ys) = (x,y): productoR xs (y:ys)
--Adriana Gordillo
productoR :: Eq a => [a] -> [a] -> [(a,a)]
productoR _ [] = []
productoR [] _ = []
productoR (x:xs) ys = zip (take (length ys) (repeat x) ) ys ++ productoR xs ys
--Fernando Ruiz Mazo, Ana Sosa Caballero
productoR'' :: Eq a => [a] -> [a] -> [(a,a)]
productoR'' [] ys = []
productoR'' xs [] = []
productoR'' (x:xs) ys = [ (x,b) | b <- ys ] ++ productoR xs ys
--José Manuel García
productoR :: Eq a => [a] -> [a] -> [(a,a)]
productoR1 _ [] = []
productoR1 (x:xs) (y:ys) = [(x,y)] ++ productoR1 (x:xs) ys
productoR [] _ = []
productoR (x:xs) (y:ys) = (productoR1 (x:xs) (y:ys) ) ++ (productoR xs (y:ys))
-- Elsa Domínguez
productoR2 :: Eq a => [a] -> [a] -> [(a,a)]
productoR2 xs ys = nub (productoR2' xs ys)
productoR2' _ [] = []
productoR2' [] _ = []
productoR2' (x:xs) (y:ys) = (x,y):producto (x:xs) ys ++ (producto xs (y:ys))
-- ---------------------------------------------------------------------
-- Ejercicio 11.3. Comprobar con QuickCheck que producto y productoR
-- son equivalentes.
-- ---------------------------------------------------------------------
-- Elsa Domínguez, Ana Sosa Caballero
-- La propiedad es
prop_producto :: [Int] -> [Int] -> Bool
prop_producto xs ys = iguales (producto xs ys) (productoR xs ys)

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

-- ---------------------------------------------------------------------
-- Ejercicio 12. Comprobar con QuickCheck que el número de elementos
-- de (producto xs ys) es el producto del número de elementos de xs y de
-- ys.
-- ---------------------------------------------------------------------
-- Elsa Domínguez, Ana Sosa Caballero
-- La propiedad es
prop_elementos_producto :: [Int] -> [Int] -> Bool
prop_elementos_producto xs ys = length (producto xs ys) == length xs * length ys

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

-- ---------------------------------------------------------------------
-- Ejercicio 13. Definir la función
-- subconjuntos :: [a] -> [[a]]
-- tal que (subconjuntos xs) es la lista de las subconjuntos de la lista
-- xs. Por ejemplo,
-- ghci> subconjuntos [2,3,4]
-- [[2,3,4],[2,3],[2,4],[2],[3,4],[3],[4],[]]
-- ghci> subconjuntos [1,2,3,4]
-- [[1,2,3,4],[1,2,3],[1,2,4],[1,2],[1,3,4],[1,3],[1,4],[1],
-- [2,3,4], [2,3], [2,4], [2], [3,4], [3], [4], []]
-- ---------------------------------------------------------------------
-- Adriana Gordillo
subconjuntos :: [a] -> [[a]]
subconjuntos = subconjuntos xs = [take k cs | cs<-css, k<-[1..length xs-1]]++[xs,[]]
where css= [ (drop n xs) ++ (take n xs) |n<-[0..length xs -1]]
--Fernando Ruiz Mazo, Elsa Domínguez
subconjuntosR :: [a] -> [[a]]
subconjuntosR [] = [[]]
subconjuntosR (x:xs) = [ x : ys | ys <- subconjuntos xs ] ++ subconjuntos xs

-- ---------------------------------------------------------------------
-- Ejercicio 14. Comprobar con QuickChek que el número de elementos de
-- (subconjuntos xs) es 2 elevado al número de elementos de xs.
--
-- Nota. Al hacer la comprobación limitar el tamaño de las pruebas como
-- se indica a continuación
-- quickCheckWith (stdArgs {maxSize=7}) prop_subconjuntos
-- ---------------------------------------------------------------------
-- Elsa Domínguez
-- La propiedad es
prop_subconjuntos :: [Int] -> Bool
prop_subconjuntos xs = length (subconjuntos xs) == 2^(length xs)

-- La comprobación es quickCheckWith (stdArgs {maxSize=7}) prop_subconjuntos
-- +++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicios variados
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 15.1 Se quiere formar una escalera con bloques cuadrados,
-- de forma que tenga un número determinado de escalones. Por ejemplo,
-- una escalera con tres escalones tendría la siguiente forma:
-- XX
-- XXXX
-- XXXXXX
-- Definir, por recursión, la función
-- numeroBloquesR :: Integer -> Integer
-- tal que (numeroBloquesR n) es el número de bloques necesarios para
-- construir una escalera con n escalones. Por ejemplo,
-- numeroBloquesR 1 == 2
-- numeroBloquesR 3 == 12
-- numeroBloquesR 10 == 110
-- ---------------------------------------------------------------------

--Sara Cerro, Ana Sosa Caballero
numeroBloquesR :: Integer -> Integer
numeroBloquesR 1 = 2
numeroBloquesR n = 2*n + numeroBloquesR (n-1)

-- ---------------------------------------------------------------------
-- Ejercicio 15.2. Definir, por comprensión, la función
-- numeroBloquesC :: Integer -> Integer
-- tal que (numeroBloquesC n) es el número de bloques necesarios para
-- construir una escalera con n escalones. Por ejemplo,
-- numeroBloquesC 1 == 2
-- numeroBloquesC 3 == 12
-- numeroBloquesC 10 == 110
-- ---------------------------------------------------------------------

--Sara Cerro, Ana Sosa Caballero
numeroBloquesC :: Integer -> Integer
numeroBloquesC n = sum [ 2*x | x <- xs]
where xs = [1..n]
-- ---------------------------------------------------------------------
-- Ejercicio 15.3. Comprobar con QuickCheck que (numeroBloquesC n) es
-- igual a n+n^2.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_numeroBloquesR :: Integer -> Bool
prop_numeroBloquesR n =(abs n) + n^2 == numeroBloquesC (abs n)

prop_numeroBloquesR :: Integer -> Property
prop_numeroBloquesR n =
n>=0 ==> n + n^2 == numeroBloquesC n

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 16. Definir la función
-- esDigito :: Integer -> Integer -> Bool
-- tal que (esDigito x n) se verifica si x es un dígito de n. Por
-- ejemplo,
-- esDigito 4 1041 == True
-- esDigito 3 1041 == False
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
digitos n | n<10 = [n]
| otherwise = digitos (div n 10) ++ [rem n 10]

esDigito :: Integer -> Integer -> Bool
esDigito x n = elem x (digitos n)

-- Sara Cerro
esDigito :: Integer -> Integer -> Bool
esDigito x n = elem x (convertirLista n)
convertirLista 0 = []
convertirLista n = [rem n 10] ++ convertirLista (div n 10)

esDigito1 :: Integer -> Integer -> Bool
esDigito1 x n = elem head(show x) (show n)

-- ---------------------------------------------------------------------
-- Ejercicio 17. Definir la función
-- numeroDeDigitos :: Integer -> Integer
-- tal que (numeroDeDigitos x) es el número de dígitos de x. Por ejemplo,
-- numeroDeDigitos 34047 == 5
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
numeroDeDigitos :: Integer -> Int
numeroDeDigitos x = length(digitos x)
-- NOTA: PRUEBA CON SHOW
-- Adolfo Sagrera Vivancos
numeroDeDigitos1 :: Integer -> Int
numeroDeDigitos1 x = sum [ 1 | x <- cifras x]
cifras x = [read [c] :: Int | c <- show x]

-- ---------------------------------------------------------------------
-- Ejercicio 18.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 Sosa Caballero
listaNumeroR :: [Integer] -> Integer
listaNumeroR [x] = x
listaNumeroR (x:xs) = x*10^(length xs) + listaNumeroR xs

-- ---------------------------------------------------------------------
-- Ejercicio 18.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, Ana Sosa Caballero
listaNumeroC :: [Integer] -> Integer
listaNumeroC xs = sum [x*(10^s) | (x,s)<- zip xs ys]
where ys = reverse [0..length xs-1]

-- ---------------------------------------------------------------------
-- Ejercicio 19.1. Definir, por recursión, la función
-- pegaNumerosR :: Integer -> Integer -> Integer
-- tal que (pegaNumerosR x y) es el número resultante de "pegar" los
-- números x e y. Por ejemplo,
-- pegaNumerosR 12 987 == 12987
-- pegaNumerosR 1204 7 == 12047
-- pegaNumerosR 100 100 == 100100
-- ---------------------------------------------------------------------
-- AYUDA: HAZ RECURSIÓN EN EL SEGUNDO NÚMERO
pegaNumerosR :: Integer -> Integer -> Integer
pegaNumerosR x y = undefined
-- T: DOS OPCIONES
pegaNumerosR1 :: Integer -> Integer -> Integer
pegaNumerosR1 x y = x * 10^length(digitosR y) + y
-- Sin usar dígitos recursiva, me da igual trabajar con caracteres ya que --- no voy a operar como números
pegaNumerosR2 :: Integer -> Integer -> Integer
pegaNumerosR2 x y = x * 10^(length (show y)) + y
-- Definición de pN recursiva:
pN x y | y<10 = x*10 + y
| otherwise = (pN x (div y 10) ) * 10 + rem y 10
-- ---------------------------------------------------------------------
-- Ejercicio 19.2. Definir, sin usar recursión, la función
-- pegaNumerosNR :: Integer -> Integer -> Integer
-- tal que (pegaNumerosNR x y) es el número resultante de "pegar" los
-- números x e y. Por ejemplo,
-- pegaNumerosNR 12 987 == 12987
-- pegaNumerosNR 1204 7 == 12047
-- pegaNumerosNR 100 100 == 100100
-- ---------------------------------------------------------------------
-- Lucía Hernández
pegaNumerosNR :: Integer -> Integer -> Integer
pegaNumerosNR x y = x*10^(length (digitos y)) + y
-- T:
-- ESA USA RECURSIÓN YA QUE DIGITOS ES RECURSIVA
-- PRUEBA A USAR SHOW READ o bien listanumeroR:
pegaNumerosNR1 :: Integer -> Integer -> Integer
pegaNumerosNR1 x y = read (show x ++ show y)

pegaNumerosNR :: Integer -> Integer -> Integer
pegaNumerosNR x y = listaNumeroR (digitosR x ++ digitosR y)
-- ---------------------------------------------------------------------
-- Ejercicio 19.3. Comprobar con QuickCheck que las funciones
-- pegaNumerosR y pegaNumerosNR son equivalentes.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_pegaNumeros x y = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 20.1. Definir, por recursión, la función
-- primerDigitoR :: Integer -> Integer
-- tal que (primerDigitoR n) es el primer dígito de n. Por ejemplo,
-- primerDigitoR 425 == 4
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
primerDigitoR :: Integer -> Integer
primerDigitoR n | n<10 = n
| otherwise = primerDigitoR (div n 10)

-- ---------------------------------------------------------------------
-- Ejercicio 20.2. Definir, sin usar recursión, la función
-- primerDigitoNR :: Integer -> Integer
-- tal que (primerDigitoNR n) es la primera digito de n. Por ejemplo,
-- primerDigitoNR 425 == 4
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
primerDigitoNR :: Integer -> Integer
primerDigitoNR n = head (digitos n) -- digitos era recursiva
pDNR n = read [(head (show n))] -- esta es sin recursión
-- ---------------------------------------------------------------------
-- Ejercicio 20.3. Comprobar con QuickCheck que las funciones
-- primerDigitoR y primerDigitoNR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
-- La propiedad es
prop_primerDigito x = primerDigitoR x == primerDigitoNR x

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 21.1. Definir la función
-- inverso :: Integer -> Integer
-- tal que (inverso n) es el número obtenido escribiendo los dígitos de n
-- en orden inverso. Por ejemplo,
-- inverso 42578 == 87524
-- inverso 203 == 302
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
inverso :: Integer -> Integer
inverso n = listaNumeroC (reverse (digitos n))

-- ---------------------------------------------------------------------
-- Ejercicio 22.2. Definir, usando show y read, la función
-- inverso' :: Integer -> Integer
-- tal que (inverso' n) es el número obtenido escribiendo los dígitos de n
-- en orden inverso'. Por ejemplo,
-- inverso' 42578 == 87524
-- inverso' 203 == 302
-- ---------------------------------------------------------------------

inverso' :: Integer -> Integer
inverso' n = read (reverse (show n))
-- Mejor:
inverso' = read.reverse.show

-- ---------------------------------------------------------------------
-- Ejercicio 22.3. Comprobar con QuickCheck que las funciones
-- inverso e inverso' son equivalentes.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_inverso n = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 23. Definir la función
-- capicua :: Integer -> Bool
-- tal que (capicua n) se verifica si los dígitos de n son las mismas
-- de izquierda a derecha que de derecha a izquierda. Por ejemplo,
-- capicua 1234 = False
-- capicua 1221 = True
-- capicua 4 = True
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
capicua :: Integer -> Bool
capicua n = reverse(digitos n) == digitos n
cap n = inverso' n == n
-- ---------------------------------------------------------------------
-- Ejercicio 24. (Problema 16 del proyecto Euler) El problema se
-- encuentra en http://goo.gl/4uWh y consiste en calcular la suma de los
-- dígitos de 2^1000. Lo resolveremos mediante los distintos apartados de
-- este ejercicio.
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 24.1. Definir la función
-- euler16 :: Integer -> Integer
-- tal que (euler16 n) es la suma de los dígitos de 2^n. Por ejemplo,
-- euler16 4 == 7
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
euler16 :: Integer -> Integer
euler16 n = sum(digitos (2^n))

-- ---------------------------------------------------------------------
-- Ejercicio 24.2. Calcular la suma de los dígitos de 2^1000.
-- ---------------------------------------------------------------------

-- El cálculo es
-- *Main> euler16 1000
-- 1366

-- ---------------------------------------------------------------------
-- Ejercicio 25. En el enunciado de uno de los problemas de las
-- Olimpiadas matemáticas de Brasil se define el primitivo de un número
-- como sigue:
-- Dado un número natural N, multiplicamos todos sus dígitos,
-- repetimos este procedimiento hasta que quede un solo dígito al
-- cual llamamos primitivo de N. Por ejemplo para 327: 3x2x7 = 42 y
-- 4x2 = 8. Por lo tanto, el primitivo de 327 es 8.
--
-- Definir la función
-- primitivo :: Integer -> Integer
-- tal que (primitivo n) es el primitivo de n. Por ejemplo.
-- primitivo 327 == 8
-- ---------------------------------------------------------------------
-- Lucía Hernández, Ana Sosa Caballero
primitivo :: Integer -> Integer
primitivo n | n<10 = n
| otherwise = primitivo (product(digitos n))

-- ---------------------------------------------------------------------
-- Ejercicio 26. Dos números son equivalentes si la media de sus dígitos
-- son iguales. Por ejemplo, 3205 y 41 son equivalentes ya que
-- (3+2+0+5)/4 = (4+1)/2. Definir la función
-- equivalentes :: Integer -> Integer -> Bool
-- tal que (equivalentes x y) se verifica si los números x e y son
-- equivalentes. Por ejemplo,
-- equivalentes 3205 41 == True
-- equivalentes 3205 25 == False
-- ---------------------------------------------------------------------

equivalentes :: Integer -> Integer -> Bool
equivalentes x y = media1 x == media1 y
media1 x = sum(digitos x) / fromIntegral( length (show x))
-- ---------------------------------------------------------------------
-- Ejercicio 27. Un número x es especial si el número de ocurrencias de
-- cada dígito d de x en x^2 es el doble del número de ocurrencias de d
-- en x. Por ejemplo, 72576 es especial porque tiene un 2, un 5, un 6 y
-- dos 7 y su cuadrado es 5267275776 que tiene exactamente dos 2, dos 5,
-- dos 6 y cuatro 7.
--
-- Definir la función
-- especial :: Integer -> Bool
-- tal que (especial x) se verifica si x es un número especial. Por
-- ejemplo,
-- especial 72576 == True
-- especial 12 == False
-- Calcular el menor número especial mayor que 72576.
-- ---------------------------------------------------------------------

especial :: Integer -> Bool
especial x = and [ocur d (x^2) == 2*(ocur d x)| d <-digitos x]
ocur x n = sum[1 | y <-digitos n, x==y]
-- El cálculo es

</source>

Relación 6

2021-11-17T08:39:07Z

Anasoscab:

<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, Ana Sosa Caballero
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, Ana Sosa Caballero
-- 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, Ana Sosa Caballero
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, Ana Sosa Caballero
-- 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, Ana Sosa Caballero
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, Ana Sosa Caballero
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, Ana Sosa Caballero
-- 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, Ana Sosa Caballero
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, Ana Sosa Caballero
-- 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

-- Ana Sosa Caballero
coge' :: Int -> [a] -> [a]
coge' n [] = []
coge' 0 xs = []
coge' n (x:xs) | n > 0 = x : coge (n-1) xs
| otherwise = []

-- ---------------------------------------------------------------------
-- 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, Ana Sosa Caballero
-- 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, Ana Sosa Caballero
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, Ana Sosa Caballero
-- 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, Ana Sosa Caballero
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, Ana Sosa Caballero
-- 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]

-- Ana Sosa Caballero
digitosR' :: Integer -> [Integer]
digitosR' 0 = []
digitosR' n = 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, Ana Sosa Caballero
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, Ana Sosa Caballero
-- 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, Ana Sosa Caballero
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, Ana Sosa Caballero
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, Ana Sosa Caballero
-- 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, Ana Sosa Caballero
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

--José Manuel García
listaNumeroR :: [Integer] -> Integer
listaNumeroR (x:xs) = read ( (show x) ++ listaNumeroR' xs) :: Integer
listaNumeroR' :: [Integer] -> [Char]
listaNumeroR' [] = []
listaNumeroR' (x:xs) = show x ++ listaNumeroR' xs

-- ---------------------------------------------------------------------
-- 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..]

--José Manuel García
listaNumeroC :: [Integer] -> Integer
listaNumeroC xs = read [stringToChar t | t <- [show a | a <- xs]] :: Integer
stringToChar :: String -> Char
stringToChar x = head (x)

-- Ana Sosa Caballero
listaNumeroC'' :: [Integer] -> Integer
listaNumeroC'' [x] = x
listaNumeroC'' xs = sum [ x*10^(length xs) | x <- xs]
-- ---------------------------------------------------------------------
-- 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, Ana Sosa Caballero
-- 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, Ana Sosa Caballero
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 5

2021-11-17T08:29:07Z

Anasoscab:

<source lang='haskell'>

-- I1M 2021-22: Rel_5.hs (29 de octubre de 2021)
-- Definiciones por comprensión con cadenas: El cifrado César.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

-- En el tema 5, cuyas transparencias se encuentran en
-- http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-5.pdf
-- se estudió, como aplicación de las definiciones por comprensión, el
-- cifrado César. El objetivo de esta relación es modificar el programa
-- de cifrado César para que pueda utilizar también letras
-- mayúsculas. Por ejemplo,
-- ghci> descifra "Ytit Ufwf Sfif"
-- "Todo Para Nada"
-- Para ello, se propone la modificación de las funciones correspondientes
-- del tema 5.

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

import Data.Char
import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
-- minuscula2int :: Char -> Int
-- tal que (minuscula2int c) es el entero correspondiente a la letra
-- minúscula c. Por ejemplo,
-- minuscula2int 'a' == 0
-- minuscula2int 'd' == 3
-- minuscula2int 'z' == 25
-- ---------------------------------------------------------------------

minuscula2int :: Char -> Int
minuscula2int c = ord c - ord 'a'

-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir la función
-- mayuscula2int :: Char -> Int
-- tal que (mayuscula2int c) es el entero correspondiente a la letra
-- mayúscula c. Por ejemplo,
-- mayuscula2int 'A' == 0
-- mayuscula2int 'D' == 3
-- mayuscula2int 'Z' == 25
-- ---------------------------------------------------------------------

mayuscula2int :: Char -> Int
mayuscula2int = undefined

-- Ana Sosa Caballero
mayuscula2int :: Char -> Int
mayuscula2int x = ord x - ord 'A'
-- ---------------------------------------------------------------------
-- Ejercicio 3. Definir la función
-- int2minuscula :: Int -> Char
-- tal que (int2minuscula n) es la letra minúscula correspondiente al
-- entero n. Por ejemplo,
-- int2minuscula 0 == 'a'
-- int2minuscula 3 == 'd'
-- int2minuscula 25 == 'z'
-- ---------------------------------------------------------------------

-- Ana Sosa Caballero
int2minuscula :: Int -> Char
int2minuscula n = chr (ord 'a' + n)

-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir la función
-- int2mayuscula :: Int -> Char
-- tal que (int2mayuscula n) es la letra minúscula correspondiente al
-- entero n. Por ejemplo,
-- int2mayuscula 0 == 'A'
-- int2mayuscula 3 == 'D'
-- int2mayuscula 25 == 'Z'
-- ---------------------------------------------------------------------

-- Ana Sosa Caballero
int2mayuscula :: Int -> Char
int2mayuscula x = chr (x + ord 'A')

-- ---------------------------------------------------------------------
-- Ejercicio 5. Definir la función
-- desplaza :: Int -> Char -> Char
-- tal que (desplaza n c) es el carácter obtenido desplazando n
-- caracteres el carácter c. Por ejemplo,
-- desplaza 3 'a' == 'd'
-- desplaza 3 'y' == 'b'
-- desplaza (-3) 'd' == 'a'
-- desplaza (-3) 'b' == 'y'
-- desplaza 3 'A' == 'D'
-- desplaza 3 'Y' == 'B'
-- desplaza (-3) 'D' == 'A'
-- desplaza (-3) 'B' == 'Y'
-- ---------------------------------------------------------------------

-- Extender a mayúsculas
desplaza :: Int -> Char -> Char
desplaza n c
| elem c ['a'..'z'] = int2minuscula ((minuscula2int c+n) `mod` 26)
| otherwise = c

-- ---------------------------------------------------------------------
-- Ejercicio 6.1. Definir la función
-- codifica :: Int -> String -> String
-- tal que (codifica n xs) es el resultado de codificar el texto xs con
-- un desplazamiento n. Por ejemplo,
-- ghci> codifica 3 "En Todo La Medida"
-- "Hq Wrgr Od Phglgd"
-- ghci> codifica (-3) "Hq Wrgr Od Phglgd"
-- "En Todo La Medida"
-- ---------------------------------------------------------------------

codifica :: Int -> String -> String
codifica n xs = [desplaza n x | x <- xs]

-- ---------------------------------------------------------------------
-- Ejercicio 6.2. Comprobar con QuickCheck que para cualquier entero n y
-- cualquier cadena cs se tiene que (codifica (-n) (codifica n cs)) es
-- igual a cs.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_codifica :: Int -> String -> Bool
prop_codifica = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 7 (resuelto). Definir la función
-- tabla :: [Float]
-- tal que tabla es la lista de la frecuencias de las letras en
-- castellano, Por ejemplo, la frecuencia de la 'a' es del 12.53%, la de
-- la 'b' es 1.42%.
-- ---------------------------------------------------------------------

tabla :: [Float]
tabla = [12.53, 1.42, 4.68, 5.86, 13.68, 0.69, 1.01,
0.70, 6.25, 0.44, 0.01, 4.97, 3.15, 6.71,
8.68, 2.51, 0.88, 6.87, 7.98, 4.63, 3.93,
0.90, 0.02, 0.22, 0.90, 0.52]

-- ---------------------------------------------------------------------
-- Ejercicio 8. Definir la función
-- porcentaje :: Int -> Int -> Float
-- tal que (porcentaje n m) es el porcentaje de n sobre m. Por ejemplo,
-- porcentaje 2 5 == 40.0
-- ---------------------------------------------------------------------

porcentaje :: Int -> Int -> Float
porcentaje n m = (fromIntegral n / fromIntegral m) * 100

-- ---------------------------------------------------------------------
-- Ejercicio 9. Definir la función
-- letras :: String -> String
-- tal que (letras xs) es la cadena formada por las letras de la cadena
-- xs. Por ejemplo,
-- letras "Esto Es Una Prueba" == "EstoEsUnaPrueba"
-- ---------------------------------------------------------------------

-- Extender a mayúsculas
letras :: String -> String
letras xs = [x | x <- xs, elem x ['a'..'z']]

-- ---------------------------------------------------------------------
-- Ejercicio 10.1. Definir la función
-- ocurrencias :: Eq a => a -> [a] -> Int
-- tal que (ocurrencias x xs) es el número de veces que ocurre el
-- elemento x en la lista xs. Por ejemplo,
-- ocurrencias 'a' "Salamanca" == 4
-- ---------------------------------------------------------------------

ocurrencias :: Eq a => a -> [a] -> Int
ocurrencias x xs = length [x' | x' <- xs, x == x']

-- ---------------------------------------------------------------------
-- Ejercicio 10.2. Comprobar con QuickCheck si el número de ocurrencias
-- de un elemento x en una lista xs es igual que en su inversa.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_ocurrencia_inv :: Int -> [Int] -> Bool
prop_ocurrencia_inv = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 10.3. Comprobar con QuickCheck si el número de ocurrencias
-- de un elemento x en la concatenación de las listas xs e ys es igual a
-- la suma del número de ocurrencias de x en xs y en ys.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_ocurrencia_conc :: Int -> [Int] -> [Int] -> Bool
prop_ocurrencia_conc = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 12. Definir la función
-- frecuencias :: String -> [Float]
-- tal que (frecuencias xs) es la frecuencia de cada una de las letras
-- de la cadena xs. Por ejemplo,
-- ghci> frecuencias "En Todo La Medida"
-- [14.3,0,0,21.4,14.3,0,0,0,7.1,0,0,7.1,
-- 7.1,7.1,14.3,0,0,0,0,7.1,0,0,0,0,0,0]
-- ---------------------------------------------------------------------

frecuencias :: String -> [Float]
frecuencias xs =
[porcentaje (ocurrencias x xs') n | x <- ['a'..'z']]
where xs' = [toLower x | x <- xs]
n = length (letras xs)

-- ---------------------------------------------------------------------
-- Ejercicio 13.1. Definir la función
-- chiCuad :: [Float] -> [Float] -> Float
-- tal que (chiCuad os es) es la medida chi cuadrado de las
-- distribuciones os y es. Por ejemplo,
-- chiCuad [3,5,6] [3,5,6] == 0.0
-- chiCuad [3,5,6] [5,6,3] == 3.9666667
-- ---------------------------------------------------------------------

chiCuad :: [Float] -> [Float] -> Float
chiCuad os es = sum [((o-e)^2)/e | (o,e) <- zip os es]

-- Evita que si alguna lista tiene un cero, haskell divida entre 0 (= Infinity)
chiCuad' :: [Float] -> [Float] -> Float
chiCuad' os es = if elem 0 os then sum [((o - e)^2)/e | (o,e)<-zip os es]
else if elem 0 es then sum [((e - o)^2)/o | (o,e)<-zip os es]
else sum [((o - e)^2)/e | (o,e)<-zip os es]

-- ---------------------------------------------------------------------
-- Ejercicio 13.2, Comprobar con QuickCheck que para cualquier par de
-- listas xs e ys se verifica que (chiCuad xs ys) es 0 y xs e ys son
-- iguales.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_chiCuad_1 :: [Float] -> [Float] -> Bool
prop_chiCuad_1 = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 13.3. A la vista de los contraejemplos del apartado
-- anterior, qué condición hay que añadir para que se verifique la
-- propiedad.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_chiCuad_2 :: [Float] -> [Float] -> Property
prop_chiCuad_2 = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 13.3. A la vista del apartado anterior, el número de tests
-- que ha pasado puede ser menor que 100. Reescribir la propiedad de
-- forma que se verifique en los 100 tests.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_chiCuad_3 :: [Float] -> [Float] -> Bool
prop_chiCuad_3 = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 14.1. Definir la función
-- rota :: Int -> [a] -> [a]
-- tal que (rota n xs) es la lista obtenida rotando n posiciones los
-- elementos de la lista xs. Por ejemplo,
-- rota 2 "manolo" == "noloma"
-- rota 10 "manolo" == "lomano"
-- [rota n "abc" | n <- [0..5]] == ["abc","bca","cab","abc","bca","cab"]
-- ---------------------------------------------------------------------

chiCuad :: [Float] -> [Float] -> Float
chiCuad os es = sum [((o-e)^2)/e | (o,e) <- zip os es]

-- ---------------------------------------------------------------------
-- Ejercicio 14.2. Comprobar con QuickCkeck si para cualquier lista xs
-- si se rota n veces y el resultado se rota m veces se obtiene lo mismo
-- que rotando xs (n+m) veces, donde n y m son números no nulos.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_rota :: Int -> Int -> [Int] -> Property
prop_rota = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 15.1. Definir la función
-- descifra :: String -> String
-- tal que (descifra xs) es la cadena obtenida descodificando la cadena
-- xs por el anti-desplazamiento que produce una distribución de letras
-- con la menor deviación chi cuadrado respecto de la tabla de
-- distribución de las letras en castellano. Por ejemplo,
-- ghci> codifica 5 "Todo Para Nada"
-- "Ytit Ufwf Sfif"
-- ghci> descifra "Ytit Ufwf Sfif"
-- "Todo Para Nada"
-- ---------------------------------------------------------------------

descifra :: String -> String
descifra xs = codifica (-factor) xs
where factor = head (posiciones (minimum tabChi) tabChi)
tabChi = [chiCuad (rota n tabla') tabla | n <- [0..25]]
tabla' = frecuencias xs

posiciones :: Eq a => a -> [a] -> [Int]
posiciones x xs =
[i | (x',i) <- zip xs [0..], x == x']

</source>

Relación 4

2021-11-17T08:24:50Z

Anasoscab:

<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]
-- Ana Sosa Caballero
divisoresPrimos :: Int -> [Int]
divisoresPrimos x = [ n | n <- divisores x, primo n]

divisores x = [ n | n <- [1..x] , mod x n == 0]

primo x = divisores x == [1,x]
-- ---------------------------------------------------------------------
-- 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
-- Ana Sosa Caballero
amigos :: Int -> Int -> Bool
amigos a b = and [ d(a) == b, d(b) == a, a/= b]

divisores' x = [ n | n <- [1..x-1] , mod x n == 0]

d(n) = sum (divisores' n)

-- ---------------------------------------------------------------------
-- 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, Ana Sosa Caballero
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, Ana Sosa Caballero
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)]

-- Ana Sosa Caballero
angelini :: Integer -> Bool
angelini n = or [ x == y | x <- digitos n, y <- digitos (2*n)]

digitos 0 = []
digitos n = digitos (div n 10 ) ++ [rem n 10]

-- ---------------------------------------------------------------------
-- 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, Adolfo Sagrera Vivancos
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, Ana Sosa Caballero
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, Adolfo Sagrera Vivancos
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, Adolfo Sagrera Vivancos
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, Adolfo Sagrera Vivancos
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]
--Adolfo Sagrera Vivancos
numeroConsecutivos xs = sum [ 1 | (a,b) <- posicion1 xs, a == b]
posicion1 xs = zip xs [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)])
-- Adolfo Sagrera Vivancos
sumaEquidistantes xs = nub [ a+b | (a,b) <- agrupa1 xs]
agrupa1 xs = (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, Adolfo Sagrera Vivancos
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
-- Adolfo Sagrera Vivancos
ultima1 n = last(cifras n)
primera1 n = head (cifras n)

-- ---------------------------------------------------------------------
-- 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, Adolfo Sagrera Vivancos
encadenadoC :: [Int] -> Bool
encadenadoC xs = and [ ultima a == primera b | (a,b) <- zip xs (tail xs)]

</source>

Relación 3

2021-10-23T11:03:38Z

Anasoscab:

<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
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
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
suma :: Integer -> Integer
suma n = sum [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
linea :: Integer -> [Integer]
linea n = [x | x<-[suma(n-1) +1..suma n]]
-- Adolfo Sagrera Vivancos, Ana Sosa Caballero
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
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]

-- ---------------------------------------------------------------------
-- 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
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
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
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
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

-- ---------------------------------------------------------------------
-- 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
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
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
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
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
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
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
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
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

-- ---------------------------------------------------------------------
-- 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-06T12:00:07Z

Anasoscab:

<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
divisionSegura :: Double -> Double -> Double
divisionSegura x y = if y == 0 then 9999 else x/y

-- ---------------------------------------------------------------------
-- 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
intercambia :: (a,b) -> (b,a)
intercambia (a,b) = (b,a)

-- ---------------------------------------------------------------------
-- 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
-- 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

-- ---------------------------------------------------------------------
-- 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]
-- ---------------------------------------------------------------------

ciclo :: [a] -> [a]
ciclo = undefined

-- ---------------------------------------------------------------------
-- 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
-- La propiedad es
prop_ciclo :: [Int] -> Bool
prop_ciclo xs = length (ciclo xs) == length xs

-- La comprobación es

-- ---------------------------------------------------------------------
-- 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
numeroMayor :: (Num a, Ord a) => a -> a -> a
numeroMayor x y = if x > y then (x*10 + y) else (y*10+x)

-- ---------------------------------------------------------------------
-- 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

-- ---------------------------------------------------------------------
-- 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

-- ---------------------------------------------------------------------
-- 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
(~=) :: (Fractional a, Ord a) => a -> a -> Bool
x ~= y | abs(x-y) <= 0.001 = True
| otherwise = False

-- ---------------------------------------------------------------------
-- 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 ==
-- ---------------------------------------------------------------------

-- La propiedad es
prop_raices :: Double -> Double -> Double -> Property
prop_raices a b c = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- 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
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] == []
-- ---------------------------------------------------------------------

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

-- ---------------------------------------------------------------------
-- Ejercicio 12. Comprobar con QuickCheck que la intersección de
-- intervalos es conmutativa.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_interseccion :: Int -> Int -> Int -> Int -> Bool
prop_interseccion a1 b1 a2 b2 = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- 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
formaReducida :: (Int,Int) -> (Int,Int)
formaReducida (a,b) = (div a z, div b z)
where z = gcd 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)
-- ---------------------------------------------------------------------

sumaRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
sumaRacional (a,b) (c,d) = undefined

-- ---------------------------------------------------------------------
-- 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

-- ----------------------------------------------------------------------------
-- 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)
-- ----------------------------------------------------------------------------

cocienteRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
cocienteRacional (x1,x2) (y1,y2) = undefined

-- ---------------------------------------------------------------------
-- 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
igualdadRacional :: (Int,Int) -> (Int,Int) -> Bool
igualdadRacional (a,b) (c,d) = formaReducida (a,b) == formaReducida (c,d)

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

-- La propiedad es
prop_distributiva :: (Int,Int) -> (Int,Int) -> (Int,Int) -> Property
prop_distributiva x y z = undefined

-- La comprobación es

-- ----------------------------------------------------------------------------
-- 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
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
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
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)

-- ----------------------------------------------------------------------------
-- 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
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

-- ----------------------------------------------------------------------------
-- 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

-- ----------------------------------------------------------------------------
-- 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
simetricoH :: (Int,Int) -> (Int,Int)
simetricoH (x1,x2) = (x1,-x2)
-- ----------------------------------------------------------------------------
-- 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
simetricoV :: (Int,Int) -> (Int,Int)
simetricoV (x1,x2) = (-x1,x2)

-- ----------------------------------------------------------------------------
-- 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
distancia :: (Float,Float) -> (Float,Float) -> Float
distancia (x1,x2) (y1,y2) = sqrt((x1-y1)^2 + (x2-y2)^2)
-- ----------------------------------------------------------------------------
-- 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
-- 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

-- ----------------------------------------------------------------------------
-- 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
puntoMedio :: (Float,Float) -> (Float,Float) -> (Float,Float)
puntoMedio (x1,x2) (y1,y2) = ((x1+y1)/2, (x2+y2)/2)

-- ---------------------------------------------------------------------
-- 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.
-- ---------------------------------------------------------------------

xor1 :: Bool -> Bool -> Bool
xor1 = undefined

-- ---------------------------------------------------------------------
-- 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.
-- ---------------------------------------------------------------------

xor2 :: Bool -> Bool -> Bool
xor2 = undefined

-- ---------------------------------------------------------------------
-- 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.
-- ---------------------------------------------------------------------

xor3 :: Bool -> Bool -> Bool
xor3 x y = undefined

-- ---------------------------------------------------------------------
-- 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

-- ---------------------------------------------------------------------
-- Ejercicio 22.5. Comprobar con QuickCheck que las cuatro definiciones
-- de xor son equivalentes.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_xor_equivalentes :: Bool -> Bool -> Bool
prop_xor_equivalentes x y = undefined

-- La comprobación es

-- ---------------------------------------------------------------------
-- 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
or3 :: Bool -> Bool -> Bool-> Bool
or3 a b c = a || b || c
-- ---------------------------------------------------------------------
-- 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
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
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
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
siglo20 :: Int -> Bool
siglo20 x = if 1901 <= x && x < 2000 then True else False

-- ---------------------------------------------------------------------
-- 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
-- ---------------------------------------------------------------------
-- 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
-- ---------------------------------------------------------------------

xnor :: Bool -> Bool -> Bool
xnor = undefined

-- ---------------------------------------------------------------------
-- 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

-- ---------------------------------------------------------------------
-- 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

</source>

Relación 1

2021-09-29T06:59:11Z

Anasoscab:

<source lang='haskell'>

-- I1M 2021-22: Rel_1.hs (24 de septiembre de 2021)
-- Definiciones por composición sobre números, listas y booleanos.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

import Data.List

-- ---------------------------------------------------------------------
-- Introducción --
-- ---------------------------------------------------------------------
-- En esta relación se plantean ejercicios con definiciones de funciones
-- por composición sobre números, listas y booleanos.
--
-- Para solucionar los ejercicios puede ser útil el manual de
-- funciones de Haskell que se encuentra en http://bit.ly/1uJZiqi y su
-- resumen en http://bit.ly/ZwSMHO

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función media3 tal que (media3 x y z) es
-- la media aritmética de los números x, y y z. Por ejemplo,
-- media3 1 3 8 == 4.0
-- media3 (-1) 0 7 == 2.0
-- media3 (-3) 0 3 == 0.0
-- ---------------------------------------------------------------------

media3 x y z = undefined
-- Miguel Ángel Martínez
media3 x y z = .sdfsdfadf
-- Manuel Alcaide García, Lucía Hernández, Adriana Gordillo Melero, Irene Ortega Moncayo, Laura Arango, Ana Sosa Caballero, Adolfo Sagrera Vivancos, Pelayo INfante Pérez
media3 x y z = (x+y+z)/3
-- Antonio López García
media3 x y z = (sum [x,y,z])/3
media3 x y z = (x+y+z)/3
-- Francisco José Espinosa
-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir la función sumaMonedas tal que
-- (sumaMonedas a b c d e) es la suma de los euros correspondientes a
-- a monedas de 1 euro, b de 2 euros, c de 5 euros, d 10 euros y
-- e de 20 euros. Por ejemplo,
-- sumaMonedas 0 0 0 0 1 == 20
-- sumaMonedas 0 0 8 0 3 == 100
-- sumaMonedas 1 1 1 1 1 == 38
-- ---------------------------------------------------------------------

sumaMonedas a b c d e = undefined
-- Adriana Gordillo Melero, Nicolás Rodríguez Ruiz, Lucía Hernández, Laura Arango, Ana Sosa Caballero
sumamonedas a b c d e = a+b*2+c*5+d*10+e*20
-- Antonio López García
sumaMonedas a b c d e = sum [a, b*2, c*5, d*10, e*20]
-- Adolfo Sagrera Vivancos, Lucía González, Pelayo Infante, Francisco José Espinosa
sumaMonedas a b c d e = a*1+b*2+c*5+d*10+e*20

-- ---------------------------------------------------------------------
-- Ejercicio 3. Definir la función volumenEsfera tal que
-- (volumenEsfera r) es el volumen de la esfera de radio r. Por ejemplo,
-- volumenEsfera 10 == 4188.790204786391
-- Indicación: Usar la constante pi.
-- ---------------------------------------------------------------------

volumenEsfera r = undefined
-- Adriana Gordillo Melero, Lucía Hernández, Nicolás Rodríguez Ruiz, Laura Arango, Ana Sosa Caballero, Antonio López García, Lucía González, Pelayo Infante
volumenEsfera r = (4/3)*pi*r^3
-- Adolfo Sagrera Vivancos
volumenEsfera r =(4/3)*(pi*r^3)
volumenEsfera r = pi*(r^3)*4/3
-- Francisco José Espinosa
-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir la función areaDeCoronaCircular tal que
-- (areaDeCoronaCircular r1 r2) es el área de una corona circular de
-- radio interior r1 y radio exterior r2. Por ejemplo,
-- areaDeCoronaCircular 1 2 == 9.42477796076938
-- areaDeCoronaCircular 2 5 == 65.97344572538566
-- areaDeCoronaCircular 3 5 == 50.26548245743669
-- ---------------------------------------------------------------------

--Lucía Hernández, Adriana Gordillo Melero, Antonio López García, Lucía González
areaDeCoronaCircular r1 r2 = pi*r2^2 - pi*r1^2
--Álvaro Cano, Ana Sosa Caballero
areaDeCoronaCircular r1 r2 = pi*(r2^2-r1^2)
--Laura Arango
areaDeCoronaCircular r1 r2 = areaCirculo r2 - areaCirculo r1
where areaCirculo r = pi*r^2
--Adolfo Sagrera Vivancos, Pelayo INfante , Francisco José Espinosa
areaDeCoronaCircular r1 r2 = (pi*r2^2)-(pi*r1^2)
-- ---------------------------------------------------------------------
-- Ejercicio 5. Definir la función ultimaCifra tal que (ultimaCifra x)
-- es la última cifra del nímero x. Por ejemplo,
-- ultimaCifra 325 == 5
-- Indicación: Usar la función rem
-- ---------------------------------------------------------------------

--Lucía Hernández, Adriana Gordillo Melero, Laura Arango, Ana Sosa Caballero, Antonio López García, Lucía González, Adolfo Sagrera Vivancos Francisco José Espinosa
ultimaCifra x = rem x 10

-- ---------------------------------------------------------------------
-- Ejercicio 6. Definir la función maxTres tal que (maxTres x y z) es
-- el máximo de x, y y z. Por ejemplo,
-- maxTres 6 2 4 == 6
-- maxTres 6 7 4 == 7
-- maxTres 6 7 9 == 9
-- Indicación: Usar la función max.
-- ---------------------------------------------------------------------

--Lucía Hernández, Laura Arango, Adriana Gordillo
maxTres x y z = max(max x y)(z)
-- Ana Sosa Caballero
maxTres x y z = max x t
where t = max y z

-- Antonio López García
maxTres x y z = maximum [x,y,z]
-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir la función rota1 tal que (rota1 xs) es la lista
-- obtenida poniendo el primer elemento de xs al final de la lista. Por
-- ejemplo,
-- rota1 [3,2,5,7] == [2,5,7,3]
-- ---------------------------------------------------------------------

--Lucía Hernández, Laura Arango, Adriana Gordillo, Ana Sosa Caballero
rota1 xs = tail xs ++ [head xs]
-- Antonio López García
rota1 xs = drop 1 xs ++ take 1 xs

-- ---------------------------------------------------------------------
-- Ejercicio 8. Definir la función rota tal que (rota n xs) es la lista
-- obtenida poniendo los n primeros elementos de xs al final de la
-- lista. Por ejemplo,
-- rota 1 [3,2,5,7] == [2,5,7,3]
-- rota 2 [3,2,5,7] == [5,7,3,2]
-- rota 3 [3,2,5,7] == [7,3,2,5]
-- ---------------------------------------------------------------------

-- Lucía Hernández, Laura Arango, Adriana Gordillo, Ana Sosa Caballero, Antonio López García
rota n xs = drop n xs ++ take n xs

-- Fernando Ruiz (mejora para conseguir rotar el vector un número mayor de veces que de elementos en el vector)
rota n xs = drop (mod n (length xs)) xs ++ take (mod n (length xs)) xs

-- ---------------------------------------------------------------------
-- Ejercicio 9. Definir la función rango tal que (rango xs) es la
-- lista formada por el menor y mayor elemento de xs.
-- rango [3,2,7,5] == [2,7]
-- Indicación: Se pueden usar minimum y maximum.
-- ---------------------------------------------------------------------

-- Lucía Hernández, Laura Arango
rango xs = [minimum xs] ++ [maximum XS]
-- Ana Sosa Caballero, Antonio López García
rango xs = [minimum xs, maximum xs]
-- ---------------------------------------------------------------------
-- Ejercicio 10. Definir la función palindromo tal que (palindromo xs) se
-- verifica si xs es un palíndromo; es decir, es lo mismo leer xs de
-- izquierda a derecha que de derecha a izquierda. Por ejemplo,
-- palindromo [3,2,5,2,3] == True
-- palindromo [3,2,5,6,2,3] == False
-- ---------------------------------------------------------------------
--Álvaro Cano, José Manuel Sánchez Parra, Laura Arango, Ana Sosa Caballero, Antonio López García
palindromo xs = xs == reverse xs

-- ---------------------------------------------------------------------
-- Ejercicio 11. Definir la función interior tal que (interior xs) es la
-- lista obtenida eliminando los extremos de la lista xs. Por ejemplo,
-- interior [2,5,3,7,3] == [5,3,7]
-- interior [2..7] == [3,4,5,6]
-- ---------------------------------------------------------------------
--Lucía Hernández, Ana Sosa Caballero
interior xs = tail (init xs)
--Laura Arango
interior xs = drop 1 (init xs)
--Fernando Ruiz, Antonio López García
interior xs = init (tail xs)

-- ---------------------------------------------------------------------
-- Ejercicio 12. Definir la función finales tal que (finales n xs) es la
-- lista formada por los n finales elementos de xs. Por ejemplo,
-- finales 3 [2,5,4,7,9,6] == [7,9,6]
-- ---------------------------------------------------------------------
--Álvaro Cano
finales n xs = drop n xs
-- Lucía Hernández
finales n xs = reverse (take n (reverse xs))
--Laura Arango, Ana Sosa Caballero
finales n xs = drop m xs
where m = length xs - n
-- Antonio López García
finales n xs = drop (length xs - n) xs
-- ---------------------------------------------------------------------
-- Ejercicio 13. Definir la función segmento tal que (segmento m n xs) es
-- la lista de los elementos de xs comprendidos entre las posiciones m y
-- n. Por ejemplo,
-- segmento 3 4 [3,4,1,2,7,9,0] == [1,2]
-- segmento 3 5 [3,4,1,2,7,9,0] == [1,2,7]
-- segmento 5 3 [3,4,1,2,7,9,0] == []
-- ---------------------------------------------------------------------

--Laura Arango
segmento m n xs = drop (m-1) (reverse (drop a ys))
where a = length xs - n
ys = reverse XS
-- Ana Sosa Caballero, Antonio López García
segmento m n xs = drop (m-1) (take n xs)
-- ---------------------------------------------------------------------
-- Ejercicio 14. Definir la función extremos tal que (extremos n xs) es
-- la lista formada por los n primeros elementos de xs y los n finales
-- elementos de xs. Por ejemplo,
-- extremos 3 [2,6,7,1,2,4,5,8,9,2,3] == [2,6,7,9,2,3]
-- ---------------------------------------------------------------------

--Laura Arango
extremos n xs = take n xs ++ finales n XS
-- Ana Sosa Caballero, Lucía Hernández
extremos n xs = take n xs ++ reverse (take n (reverse xs))

-- ---------------------------------------------------------------------
-- Ejercicio 15. Definir la función mediano tal que (mediano x y z) es el
-- número mediano de los tres números x, y y z. Por ejemplo,
-- mediano 3 2 5 == 3
-- mediano 2 4 5 == 4
-- mediano 2 6 5 == 5
-- mediano 2 6 6 == 6
-- Indicación: Usar maximum y minimum.
-- ---------------------------------------------------------------------

--Laura Arango
mediano x y z = max x (min y z)

-- ---------------------------------------------------------------------
-- Ejercicio 16. Definir la función tresIguales tal que
-- (tresIguales x y z) se verifica si los elementos x, y y z son
-- iguales. Por ejemplo,
-- tresIguales 4 4 4 == True
-- tresIguales 4 3 4 == False
-- ---------------------------------------------------------------------

--Laura Arango, Ana Sosa Caballero
tresIguales x y z = x==y && x==z

-- ---------------------------------------------------------------------
-- Ejercicio 17. Definir la función tresDiferentes tal que
-- (tresDiferentes x y z) se verifica si los elementos x, y y z son
-- distintos. Por ejemplo,
-- tresDiferentes 3 5 2 == True
-- tresDiferentes 3 5 3 == False
-- ---------------------------------------------------------------------

--Laura Arango
tresDiferentes x y z = x/=y && x/=z
-- Ana Sosa Caballero
tresDiferentes x y z = and [x/=y, y/=z, x/=z]

-- ---------------------------------------------------------------------
-- Ejercicio 18. Definir la función cuatroIguales tal que
-- (cuatroIguales x y z u) se verifica si los elementos x, y, z y u son
-- iguales. Por ejemplo,
-- cuatroIguales 5 5 5 5 == True
-- cuatroIguales 5 5 4 5 == False
-- Indicación: Usar la función tresIguales.
-- ---------------------------------------------------------------------

--Laura Arango, Ana Sosa Caballero
cuatroIguales x y z u = tresIguales x y z == True && x==u

-- ---------------------------------------------------------------------
-- Ejercicios para trabajar con Data.List. Ver:
-- http://www.cs.us.es/~jalonso/cursos/i1m-19/doc/Funciones_basicas.html
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 19. Definir la función unicos, tal que (unicos xs)
-- devuelva la cantidad de elementos únicos que hay en la lista xs.
-- Por ejemplo,
-- unicos [1,4,8,2,1,4,6,1] == 5
-- unicos [10,9,8,10,5,10] == 4
-- unicos [10,9,8] == 3
-- ---------------------------------------------------------------------

--Laura Arango
unicos xs = length (nub xs)
-- Ana Sosa Caballero
unicos xs = length(group(sort xs))

-- ---------------------------------------------------------------------
-- Ejercicio 20. Definir la función segundoMinimo, tal que (segundoMinimo xs)
-- devuelve el segundo elemento más pequeńo de la lista xs, obviando
-- repeticiones. Por ejemplo,
-- segundoMinimo [6,9,2,4] == 4
-- segundoMinimo [0.5,1.2,0.5,4.4,0.5] == 1.2
-- ---------------------------------------------------------------------

--Laura Arango
segundoMinimo xs = sort (nub xs) !! 1

-- ---------------------------------------------------------------------
-- Ejercicio 21. Definir la función kMaximo, tal que (kMaximo n xs)
-- devuelve el k-máximo elemento de xs (es decir, el que está en la
-- posición k de valores más altos), obviando repeticiones. Por ejemplo,
-- kMaximo 2 [6,9,2,4] == 6
-- kMaximo 3 [10,9,8,10,5] == 8
-- ---------------------------------------------------------------------

--Laura Arango, Ana Sosa Caballero
kMaximo k xs = reverse (sort (nub xs)) !! (k-1)

-- ---------------------------------------------------------------------
-- Ejercicio 22. Definir la función numPermut, tal que (numPermut xs)
-- devuelve el número de permutaciones sin repetición posibles con los
-- elementos de la lista xs. Por ejemplo,
-- numPermut [6,2,4] == 6
-- numPermut [10,8,10,5] == 24
-- ---------------------------------------------------------------------

--Laura Arango, Ana Sosa Caballero
numPermut xs = length (permutations xs)

-- ---------------------------------------------------------------------
-- Ejercicio 23 Definir la función numPares, tal que (numPares xs)
-- devuelva cuantos números pares en total (sin repeticiones) aparecen
-- en la lista xs. Por ejemplo,
-- numPares [1,4,8,2,1,4,6,1] == 4
-- numPares [10,9,8,10,5,10] == 2
-- numPares [10,9,8] == 2
-- Indicación: puede ser útil la función partitions
-- ---------------------------------------------------------------------

--Laura Arango
numPares xs = length (nub (filter even xs))
-- Ana Sosa Caballero
numPares xs = length(group (sort (filter even xs)))

</source>

Relación 1

2021-09-26T08:08:24Z

Anasoscab:

<source lang='haskell'>

-- I1M 2021-22: Rel_1.hs (24 de septiembre de 2021)
-- Definiciones por composición sobre números, listas y booleanos.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

import Data.List

-- ---------------------------------------------------------------------
-- Introducción --
-- ---------------------------------------------------------------------
-- En esta relación se plantean ejercicios con definiciones de funciones
-- por composición sobre números, listas y booleanos.
--
-- Para solucionar los ejercicios puede ser útil el manual de
-- funciones de Haskell que se encuentra en http://bit.ly/1uJZiqi y su
-- resumen en http://bit.ly/ZwSMHO

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función media3 tal que (media3 x y z) es
-- la media aritmética de los números x, y y z. Por ejemplo,
-- media3 1 3 8 == 4.0
-- media3 (-1) 0 7 == 2.0
-- media3 (-3) 0 3 == 0.0
-- ---------------------------------------------------------------------

media3 x y z = undefined
-- Miguel Ángel Martínez
media3 x y z = .sdfsdfadf
-- Manuel Alcaide García, Lucía Hernández, Adriana Gordillo Melero, Irene Ortega Moncayo, Laura Arango, Ana Sosa Caballero
media3 x y z = (x+y+z)/3
-- Antonio López García
media3 x y z = (sum [x,y,z])/3
-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir la función sumaMonedas tal que
-- (sumaMonedas a b c d e) es la suma de los euros correspondientes a
-- a monedas de 1 euro, b de 2 euros, c de 5 euros, d 10 euros y
-- e de 20 euros. Por ejemplo,
-- sumaMonedas 0 0 0 0 1 == 20
-- sumaMonedas 0 0 8 0 3 == 100
-- sumaMonedas 1 1 1 1 1 == 38
-- ---------------------------------------------------------------------

sumaMonedas a b c d e = undefined
-- Adriana Gordillo Melero, Nicolás Rodríguez Ruiz, Lucía Hernández, Laura Arango, Ana Sosa Caballero
sumamonedas a b c d e = a+b*2+c*5+d*10+e*20
-- Antonio López García
sumaMonedas a b c d e = sum [a, b*2, c*5, d*10, e*20]

-- ---------------------------------------------------------------------
-- Ejercicio 3. Definir la función volumenEsfera tal que
-- (volumenEsfera r) es el volumen de la esfera de radio r. Por ejemplo,
-- volumenEsfera 10 == 4188.790204786391
-- Indicación: Usar la constante pi.
-- ---------------------------------------------------------------------

volumenEsfera r = undefined
-- Adriana Gordillo Melero, Lucía Hernández, Nicolás Rodríguez Ruiz, Laura Arango, Ana Sosa Caballero
volumenEsfera r = (4/3)*pi*r^3
-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir la función areaDeCoronaCircular tal que
-- (areaDeCoronaCircular r1 r2) es el área de una corona circular de
-- radio interior r1 y radio exterior r2. Por ejemplo,
-- areaDeCoronaCircular 1 2 == 9.42477796076938
-- areaDeCoronaCircular 2 5 == 65.97344572538566
-- areaDeCoronaCircular 3 5 == 50.26548245743669
-- ---------------------------------------------------------------------

--Lucía Hernández, Adriana Gordillo Melero
areaDeCoronaCircular r1 r2 = pi*r2^2 - pi*r1^2
--Álvaro Cano, Ana Sosa Caballero
areaDeCoronaCircular r1 r2 = pi*(r2^2-r1^2)
--Laura Arango
areaDeCoronaCircular r1 r2 = areaCirculo r2 - areaCirculo r1
where areaCirculo r = pi*r^2
-- ---------------------------------------------------------------------
-- Ejercicio 5. Definir la función ultimaCifra tal que (ultimaCifra x)
-- es la última cifra del nímero x. Por ejemplo,
-- ultimaCifra 325 == 5
-- Indicación: Usar la función rem
-- ---------------------------------------------------------------------

--Lucía Hernández, Adriana Gordillo Melero, Laura Arango, Ana Sosa Caballero
ultimaCifra x = rem x 10

-- ---------------------------------------------------------------------
-- Ejercicio 6. Definir la función maxTres tal que (maxTres x y z) es
-- el máximo de x, y y z. Por ejemplo,
-- maxTres 6 2 4 == 6
-- maxTres 6 7 4 == 7
-- maxTres 6 7 9 == 9
-- Indicación: Usar la función max.
-- ---------------------------------------------------------------------

--Lucía Hernández, Laura Arango, Adriana Gordillo
maxTres x y z = max(max x y)(z)
-- Ana Sosa Caballero
maxTres x y z = max x t
where t = max y z
-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir la función rota1 tal que (rota1 xs) es la lista
-- obtenida poniendo el primer elemento de xs al final de la lista. Por
-- ejemplo,
-- rota1 [3,2,5,7] == [2,5,7,3]
-- ---------------------------------------------------------------------

--Lucía Hernández, Laura Arango, Adriana Gordillo, Ana Sosa Caballero
rota1 xs = tail xs ++ [head xs]
-- ---------------------------------------------------------------------
-- Ejercicio 8. Definir la función rota tal que (rota n xs) es la lista
-- obtenida poniendo los n primeros elementos de xs al final de la
-- lista. Por ejemplo,
-- rota 1 [3,2,5,7] == [2,5,7,3]
-- rota 2 [3,2,5,7] == [5,7,3,2]
-- rota 3 [3,2,5,7] == [7,3,2,5]
-- ---------------------------------------------------------------------

-- Lucía Hernández, Laura Arango, Adriana Gordillo, Ana Sosa Caballero
rota n xs = drop n xs ++ take n xs

-- Fernando Ruiz (mejora para conseguir rotar el vector un número mayor de veces que de elementos en el vector)
rota n xs = drop (mod n (length xs)) xs ++ take (mod n (length xs)) xs

-- ---------------------------------------------------------------------
-- Ejercicio 9. Definir la función rango tal que (rango xs) es la
-- lista formada por el menor y mayor elemento de xs.
-- rango [3,2,7,5] == [2,7]
-- Indicación: Se pueden usar minimum y maximum.
-- ---------------------------------------------------------------------

-- Lucía Hernández, Laura Arango
rango xs = [minimum xs] ++ [maximum XS]
-- Ana Sosa Caballero
rango xs = [minimum xs, maximum xs]
-- ---------------------------------------------------------------------
-- Ejercicio 10. Definir la función palindromo tal que (palindromo xs) se
-- verifica si xs es un palíndromo; es decir, es lo mismo leer xs de
-- izquierda a derecha que de derecha a izquierda. Por ejemplo,
-- palindromo [3,2,5,2,3] == True
-- palindromo [3,2,5,6,2,3] == False
-- ---------------------------------------------------------------------
--Álvaro Cano, José Manuel Sánchez Parra, Laura Arango, Ana Sosa Caballero
palindromo xs = xs == reverse xs

-- ---------------------------------------------------------------------
-- Ejercicio 11. Definir la función interior tal que (interior xs) es la
-- lista obtenida eliminando los extremos de la lista xs. Por ejemplo,
-- interior [2,5,3,7,3] == [5,3,7]
-- interior [2..7] == [3,4,5,6]
-- ---------------------------------------------------------------------
--Lucía Hernández, Ana Sosa Caballero
interior xs = tail (init xs)
--Laura Arango
interior xs = drop 1 (init xs)
--Fernando Ruiz
interior xs = init (tail xs))

-- ---------------------------------------------------------------------
-- Ejercicio 12. Definir la función finales tal que (finales n xs) es la
-- lista formada por los n finales elementos de xs. Por ejemplo,
-- finales 3 [2,5,4,7,9,6] == [7,9,6]
-- ---------------------------------------------------------------------
--Álvaro Cano
finales n xs = drop n xs
-- Lucía Hernández
finales n xs = reverse (take n (reverse xs))
--Laura Arango, Ana Sosa Caballero
finales n xs = drop m xs
where m = length xs - n
-- ---------------------------------------------------------------------
-- Ejercicio 13. Definir la función segmento tal que (segmento m n xs) es
-- la lista de los elementos de xs comprendidos entre las posiciones m y
-- n. Por ejemplo,
-- segmento 3 4 [3,4,1,2,7,9,0] == [1,2]
-- segmento 3 5 [3,4,1,2,7,9,0] == [1,2,7]
-- segmento 5 3 [3,4,1,2,7,9,0] == []
-- ---------------------------------------------------------------------

--Laura Arango
segmento m n xs = drop (m-1) (reverse (drop a ys))
where a = length xs - n
ys = reverse XS
-- Ana Sosa Caballero
segmento m n xs = drop (m-1) (take n xs)
-- ---------------------------------------------------------------------
-- Ejercicio 14. Definir la función extremos tal que (extremos n xs) es
-- la lista formada por los n primeros elementos de xs y los n finales
-- elementos de xs. Por ejemplo,
-- extremos 3 [2,6,7,1,2,4,5,8,9,2,3] == [2,6,7,9,2,3]
-- ---------------------------------------------------------------------

--Laura Arango
extremos n xs = take n xs ++ finales n XS
-- Ana Sosa Caballero
extremos n xs = take n xs ++ reverse (take n (reverse xs))

-- ---------------------------------------------------------------------
-- Ejercicio 15. Definir la función mediano tal que (mediano x y z) es el
-- número mediano de los tres números x, y y z. Por ejemplo,
-- mediano 3 2 5 == 3
-- mediano 2 4 5 == 4
-- mediano 2 6 5 == 5
-- mediano 2 6 6 == 6
-- Indicación: Usar maximum y minimum.
-- ---------------------------------------------------------------------

--Laura Arango
mediano x y z = max x (min y z)

-- ---------------------------------------------------------------------
-- Ejercicio 16. Definir la función tresIguales tal que
-- (tresIguales x y z) se verifica si los elementos x, y y z son
-- iguales. Por ejemplo,
-- tresIguales 4 4 4 == True
-- tresIguales 4 3 4 == False
-- ---------------------------------------------------------------------

--Laura Arango, Ana Sosa Caballero
tresIguales x y z = x==y && x==z

-- ---------------------------------------------------------------------
-- Ejercicio 17. Definir la función tresDiferentes tal que
-- (tresDiferentes x y z) se verifica si los elementos x, y y z son
-- distintos. Por ejemplo,
-- tresDiferentes 3 5 2 == True
-- tresDiferentes 3 5 3 == False
-- ---------------------------------------------------------------------

--Laura Arango
tresDiferentes x y z = x/=y && x/=z
-- Ana Sosa Caballero
tresDiferentes x y z = and [x/=y, y/=z, x/=z]

-- ---------------------------------------------------------------------
-- Ejercicio 18. Definir la función cuatroIguales tal que
-- (cuatroIguales x y z u) se verifica si los elementos x, y, z y u son
-- iguales. Por ejemplo,
-- cuatroIguales 5 5 5 5 == True
-- cuatroIguales 5 5 4 5 == False
-- Indicación: Usar la función tresIguales.
-- ---------------------------------------------------------------------

--Laura Arango
cuatroIguales x y z u = tresIguales x y z == True && x==u

-- ---------------------------------------------------------------------
-- Ejercicios para trabajar con Data.List. Ver:
-- http://www.cs.us.es/~jalonso/cursos/i1m-19/doc/Funciones_basicas.html
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 19. Definir la función unicos, tal que (unicos xs)
-- devuelva la cantidad de elementos únicos que hay en la lista xs.
-- Por ejemplo,
-- unicos [1,4,8,2,1,4,6,1] == 5
-- unicos [10,9,8,10,5,10] == 4
-- unicos [10,9,8] == 3
-- ---------------------------------------------------------------------

--Laura Arango
unicos xs = length (nub xs)
-- Ana Sosa Caballero
unicos xs = length(group(sort xs))

-- ---------------------------------------------------------------------
-- Ejercicio 20. Definir la función segundoMinimo, tal que (segundoMinimo xs)
-- devuelve el segundo elemento más pequeńo de la lista xs, obviando
-- repeticiones. Por ejemplo,
-- segundoMinimo [6,9,2,4] == 4
-- segundoMinimo [0.5,1.2,0.5,4.4,0.5] == 1.2
-- ---------------------------------------------------------------------

--Laura Arango
segundoMinimo xs = sort (nub xs) !! 1

-- ---------------------------------------------------------------------
-- Ejercicio 21. Definir la función kMaximo, tal que (kMaximo n xs)
-- devuelve el k-máximo elemento de xs (es decir, el que está en la
-- posición k de valores más altos), obviando repeticiones. Por ejemplo,
-- kMaximo 2 [6,9,2,4] == 6
-- kMaximo 3 [10,9,8,10,5] == 8
-- ---------------------------------------------------------------------

--Laura Arango, Ana Sosa Caballero
kMaximo k xs = reverse (sort (nub xs)) !! (k-1)

-- ---------------------------------------------------------------------
-- Ejercicio 22. Definir la función numPermut, tal que (numPermut xs)
-- devuelve el número de permutaciones sin repetición posibles con los
-- elementos de la lista xs. Por ejemplo,
-- numPermut [6,2,4] == 6
-- numPermut [10,8,10,5] == 24
-- ---------------------------------------------------------------------

--Laura Arango, Ana Sosa Caballero
numPermut xs = length (permutations xs)

-- ---------------------------------------------------------------------
-- Ejercicio 23 Definir la función numPares, tal que (numPares xs)
-- devuelva cuantos números pares en total (sin repeticiones) aparecen
-- en la lista xs. Por ejemplo,
-- numPares [1,4,8,2,1,4,6,1] == 4
-- numPares [10,9,8,10,5,10] == 2
-- numPares [10,9,8] == 2
-- Indicación: puede ser útil la función partitions
-- ---------------------------------------------------------------------

--Laura Arango
numPares xs = length (nub (filter even xs))
-- Ana Sosa Caballero
numPares xs = length(group (sort (filter even xs)))

</source>