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

Relación 12

2021-12-26T16:47:20Z

Elsdomgon:

<source lang='haskell'>

-- I1M 2021-22: Relación 12 (7 de enero de 2022)
-- Tipos de datos algebraicos: Árboles binarios.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

-- En esta relación se presenta ejercicios sobre árboles binarios
-- definidos como tipos de datos algebraicos.
--
-- Los ejercicios corresponden al tema 9 que se encuentra en
-- http://www.cs.us.es/cursos/i1m/temas/tema-9.html

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

import Test.QuickCheck
import Control.Monad

-- ---------------------------------------------------------------------
-- Nota. En los siguientes ejercicios se trabajará con los árboles
-- binarios definidos como sigue
-- data Arbol a = H a
-- | N a (Arbol a) (Arbol a)
-- deriving (Show, Eq)
-- Por ejemplo, el árbol
-- 9
-- / \
-- / \
-- 3 7
-- / \
-- 2 4
-- se representa por
-- N 9 (N 3 (H 2) (H 4)) (H 7)
-- ---------------------------------------------------------------------

data Arbol a = H a
| N a (Arbol a) (Arbol a)
deriving (Show, Eq)

-- ---------------------------------------------------------------------
-- Ejercicio 1.1. Definir la función
-- nHojas :: Arbol a -> Int
-- tal que (nHojas x) es el número de hojas del árbol x. Por ejemplo,
-- nHojas (N 9 (N 3 (H 2) (H 4)) (H 7)) == 3
-- ---------------------------------------------------------------------

-- Elsa Domínguez
nHojas :: Arbol a -> Int
nHojas (H _) = 1
nHojas (N _ i d) = nHojas i + nHojas d

-- ---------------------------------------------------------------------
-- Ejercicio 1.2. Definir la función
-- nNodos :: Arbol a -> Int
-- tal que (nNodos x) es el número de nodos del árbol x. Por ejemplo,
-- nNodos (N 9 (N 3 (H 2) (H 4)) (H 7)) == 2
-- ---------------------------------------------------------------------

-- Elsa Domínguez
nNodos :: Arbol a -> Int
nNodos (H _) = 0
nNodos (N _ i d) = 1 + nNodos i + nNodos d

-- ---------------------------------------------------------------------
-- Ejercicio 1.3. Comprobar con QuickCheck que en todo árbol binario el
-- número de sus hojas es igual al número de sus nodos más uno.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_nHojas :: Arbol Int -> Bool
prop_nHojas x = nNodos x + 1 == nHojas x

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

-- ---------------------------------------------------------------------
-- Ejercicio 2.1. Definir la función
-- profundidad :: Arbol a -> Int
-- tal que (profundidad x) es la profundidad del árbol x. Por ejemplo,
-- profundidad (N 9 (N 3 (H 2) (H 4)) (H 7)) == 2
-- profundidad (N 9 (N 3 (H 2) (N 1 (H 4) (H 5))) (H 7)) == 3
-- profundidad (N 4 (N 5 (H 4) (H 2)) (N 3 (H 7) (H 4))) == 2
-- ---------------------------------------------------------------------

-- Elsa Domínguez
profundidad :: Arbol a -> Int
profundidad (H _) = 0
profundidad (N _ i d) = 1 + max (profundidad i) (profundidad d)

-- ---------------------------------------------------------------------
-- Ejercicio 2.2. Comprobar con QuickCheck que para todo árbol biario
-- x, se tiene que
-- nNodos x <= 2^(profundidad x) - 1
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_nNodosProfundidad :: Arbol Int -> Bool
prop_nNodosProfundidad x = nNodos x <= 2^(profundidad x) - 1

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

-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Definir la función
-- preorden :: Arbol a -> [a]
-- tal que (preorden x) es la lista correspondiente al recorrido
-- preorden del árbol x; es decir, primero visita la raíz del árbol, a
-- continuación recorre el subárbol izquierdo y, finalmente, recorre el
-- subárbol derecho. Por ejemplo,
-- preorden (N 9 (N 3 (H 2) (H 4)) (H 7)) == [9,3,2,4,7]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
preorden :: Arbol a -> [a]
preorden (H a) = [a]
preorden (N a i d) = [a] ++ preorden i ++ preorden d

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Comprobar con QuickCheck que la longitud de la lista
-- obtenida recorriendo un árbol en sentido preorden es igual al número
-- de nodos del árbol más el número de hojas.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_length_preorden :: Arbol Int -> Bool
prop_length_preorden x = nHojas x + nNodos x == length (preorden x)

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

-- ---------------------------------------------------------------------
-- Ejercicio 3.3. Definir la función
-- postorden :: Arbol a -> [a]
-- tal que (postorden x) es la lista correspondiente al recorrido
-- postorden del árbol x; es decir, primero recorre el subárbol
-- izquierdo, a continuación el subárbol derecho y, finalmente, la raíz
-- del árbol. Por ejemplo,
-- postorden (N 9 (N 3 (H 2) (H 4)) (H 7)) == [2,4,3,7,9]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
postorden :: Arbol a -> [a]
postorden (H a) = [a]
postorden (N a i d) = postorden i ++ postorden d ++ [a]

-- ---------------------------------------------------------------------
-- Ejercicio 3.4. Definir, usando un acumulador, la función
-- preordenIt :: Arbol a -> [a]
-- tal que (preordenIt x) es la lista correspondiente al recorrido
-- preorden del árbol x; es decir, primero visita la raíz del árbol, a
-- continuación recorre el subárbol izquierdo y, finalmente, recorre el
-- subárbol derecho. Por ejemplo,
-- preordenIt (N 9 (N 3 (H 2) (H 4)) (H 7)) == [9,3,2,4,7]
--
-- Nota: No usar (++) en la definición
-- ---------------------------------------------------------------------

-- Elsa Domínguez
preordenIt :: Arbol a -> [a]
preordenIt x = aux x []
where aux (H a) xs = a : xs
aux (N a i d) xs = a : aux i (aux d xs)

-- ---------------------------------------------------------------------
-- Ejercicio 3.5. Comprobar con QuickCheck que preordenIt es equivalente
-- a preorden.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_preordenIt :: Arbol Int -> Bool
prop_preordenIt x = preordenIt x == preorden x

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

-- ---------------------------------------------------------------------
-- Ejercicio 4.1. Definir la función
-- espejo :: Arbol a -> Arbol a
-- tal que (espejo x) es la imagen especular del árbol x. Por ejemplo,
-- espejo (N 9 (N 3 (H 2) (H 4)) (H 7)) == N 9 (H 7) (N 3 (H 4) (H 2))
-- ---------------------------------------------------------------------

-- Elsa Domínguez
espejo :: Arbol a -> Arbol a
espejo (H a) = H a
espejo (N a i d) = N a (espejo d) (espejo i)

-- ---------------------------------------------------------------------
-- Ejercicio 4.2. Comprobar con QuickCheck que para todo árbol x,
-- espejo (espejo x) = x
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_espejo :: Arbol Int -> Bool
prop_espejo x = espejo (espejo x) == x

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

-- ---------------------------------------------------------------------
-- Ejercicio 4.3. Comprobar con QuickCheck que para todo árbol binario
-- x, se tiene que
-- reverse (preorden (espejo x)) = postorden x
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_reverse_preorden_espejo :: Arbol Int -> Bool
prop_reverse_preorden_espejo x = reverse (preorden (espejo x)) == postorden x

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

-- ---------------------------------------------------------------------
-- Ejercicio 4.4. Comprobar con QuickCheck que para todo árbol x,
-- postorden (espejo x) = reverse (preorden x)
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_recorrido :: Arbol Int -> Bool
prop_recorrido x = postorden (espejo x) == reverse (preorden x)

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

-- ---------------------------------------------------------------------
-- Ejercicio 5.1. La función take está definida por
-- take :: Int -> [a] -> [a]
-- take 0 = []
-- take (n+1) [] = []
-- take (n+1) (x:xs) = x : take n xs
--
-- Definir la función
-- takeArbol :: Int -> Arbol a -> Arbol a
-- tal que (takeArbol n t) es el subárbol de t de profundidad n. Por
-- ejemplo,
-- takeArbol 0 (N 9 (N 3 (H 2) (H 4)) (H 7)) == H 9
-- takeArbol 1 (N 9 (N 3 (H 2) (H 4)) (H 7)) == N 9 (H 3) (H 7)
-- takeArbol 2 (N 9 (N 3 (H 2) (H 4)) (H 7)) == N 9 (N 3 (H 2) (H 4)) (H 7)
-- takeArbol 3 (N 9 (N 3 (H 2) (H 4)) (H 7)) == N 9 (N 3 (H 2) (H 4)) (H 7)
-- ---------------------------------------------------------------------

-- Elsa Domínguez
takeArbol :: Int -> Arbol a -> Arbol a
takeArbol _ (H a) = H a
takeArbol 0 (N a i d) = H a
takeArbol n (N a i d) = N a (takeArbol (n-1) i) (takeArbol (n-1) d)

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Comprobar con QuickCheck que la profundidad de
-- (takeArbol n x) es menor o igual que n, para todo número natural n y
-- todo árbol x.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_takeArbol:: Int -> Arbol Int -> Property
prop_takeArbol n x = n >= 0 ==> profundidad (takeArbol n x) <= n

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

-- ---------------------------------------------------------------------
-- Ejercicio 6.1. La función
-- repeat :: a -> [a]
-- está definida de forma que (repeat x) es la lista formada por
-- infinitos elementos x. Por ejemplo,
-- repeat 3 == [3,3,3,3,3,3,3,3,3,3,3,3,3,...
-- La definición de repeat es
-- repeat x = xs where xs = x:xs
--
-- Definir la función
-- repeatArbol :: a -> Arbol a
-- tal que (repeatArbol x) es es árbol con infinitos nodos x. Por
-- ejemplo,
-- takeArbol 0 (repeatArbol 3) == H 3
-- takeArbol 1 (repeatArbol 3) == N 3 (H 3) (H 3)
-- takeArbol 2 (repeatArbol 3) == N 3 (N 3 (H 3) (H 3)) (N 3 (H 3) (H 3))
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repeatArbol :: a -> Arbol a
repeatArbol x = N x id id
where id = repeatArbol x

-- ---------------------------------------------------------------------
-- Ejercicio 6.2. La función
-- replicate :: Int -> a -> [a]
-- está definida por
-- replicate n = take n . repeat
-- es tal que (replicate n x) es la lista de longitud n cuyos elementos
-- son x. Por ejemplo,
-- replicate 3 5 == [5,5,5]
--
-- Definir la función
-- replicateArbol :: Int -> a -> Arbol a
-- tal que (replicate n x) es el árbol de profundidad n cuyos nodos son
-- x. Por ejemplo,
-- replicateArbol 0 5 == H 5
-- replicateArbol 1 5 == N 5 (H 5) (H 5)
-- replicateArbol 2 5 == N 5 (N 5 (H 5) (H 5)) (N 5 (H 5) (H 5))
-- ---------------------------------------------------------------------

-- Elsa Domínguez
replicateArbol :: Int -> a -> Arbol a
replicateArbol 0 x = H x
replicateArbol n x = N x id id
where id = replicateArbol (n-1) x

-- ---------------------------------------------------------------------
-- Ejercicio 6.3. Comprobar con QuickCheck que el número de hojas de
-- (replicateArbol n x) es 2^n, para todo número natural n
--
-- Nota. Al hacer la comprobación limitar el tamańo de las pruebas como
-- se indica a continuación
-- quickCheckWith (stdArgs {maxSize=7}) prop_replicateArbol
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_replicateArbol :: Int -> Int -> Property
prop_replicateArbol n x = n >= 0 ==> nHojas (replicateArbol n x) == 2^n

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

-- ---------------------------------------------------------------------
-- Ejercicio 7.1. Definir la función
-- mapArbol :: (a -> a) -> Arbol a -> Arbol a
-- tal que (mapArbol f x) es el árbol obtenido aplicándole a cada nodo de
-- x la función f. Por ejemplo,
-- ghci> mapArbol (*2) (N 9 (N 3 (H 2) (H 4)) (H 7))
-- N 18 (N 6 (H 4) (H 8)) (H 14)
-- ---------------------------------------------------------------------

-- Elsa Domínguez
mapArbol :: (a -> a) -> Arbol a -> Arbol a
mapArbol f (H a) = H (f a)
mapArbol f (N a i d) = N (f a) (mapArbol f i) (mapArbol f d)

-- ---------------------------------------------------------------------
-- Ejercicio 7.2. Comprobar con QuickCheck que
-- (mapArbol (1+)) . espejo = espejo . (mapArbol (1+))
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_mapArbol_espejo :: Arbol Int -> Bool
prop_mapArbol_espejo x = (mapArbol (1+) . espejo) x == (espejo . mapArbol (1+)) x

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

-- ---------------------------------------------------------------------
-- Ejercicio 7.3. Comprobar con QuickCheck que
-- (map (1+)) . preorden = preorden . (mapArbol (1+))
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_map_preorden :: Arbol Int -> Bool
prop_map_preorden x = (map (1+) . preorden) x == (preorden . mapArbol (1+)) x

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

-- ---------------------------------------------------------------------
-- Nota. Para comprobar propiedades de árboles con QuickCheck se
-- utilizará el siguiente generador.
-- ---------------------------------------------------------------------

instance Arbitrary a => Arbitrary (Arbol a) where
arbitrary = sized arbol
where
arbol 0 = liftM H arbitrary
arbol n | n>0 = oneof [liftM H arbitrary,
liftM3 N arbitrary subarbol subarbol]
where subarbol = arbol (div n 2)
arbol _ = error "Imposible"

</source>

Relación 11

2021-12-16T19:34:38Z

Elsdomgon:

<source lang='haskell'>

-- I1M 2021-22: Rel_11.hs (17 de diciembre de 2021)
-- Evaluación perezosa y listas infinitas.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

-- En esta relación se presentan ejercicios con listas infinitas y
-- evaluación perezosa. Estos ejercicios corresponden al tema 10 cuyas
-- transparencias se encuentran en
-- https://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-10.html

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

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1.1. Definir, por recursión, la función
-- repite :: a -> [a]
-- tal que (repite x) es la lista infinita cuyos elementos son x. Por
-- ejemplo,
-- repite 5 == [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,...
-- take 3 (repite 5) == [5,5,5]
--
-- Nota: La función repite es equivalente a la función repeat definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repite :: a -> [a]
repite x = [x] ++ repite x

-- ---------------------------------------------------------------------
-- Ejercicio 1.2. Definir, por comprensión, la función
-- repiteC :: a -> [a]
-- tal que (repiteC x) es la lista infinita cuyos elementos son x. Por
-- ejemplo,
-- repiteC 5 == [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,...
-- take 3 (repiteC 5) == [5,5,5]
--
-- Nota: La función repiteC es equivalente a la función repeat definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteC :: a -> [a]
repiteC x = [x | _ <- [1..]]

-- ---------------------------------------------------------------------
-- Ejercicio 2.1. Definir, por recursión, la función
-- repiteFinitaR :: Int-> a -> [a]
-- tal que (repiteFinitaR n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinitaR 3 5 == [5,5,5]
--
-- Nota: La función repiteFinitaR es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinitaR :: Int -> a -> [a]
repiteFinitaR n x | n <= 0 = []
| otherwise = [x] ++ repiteFinitaR (n-1) x

-- ---------------------------------------------------------------------
-- Ejercicio 2.2. Definir, por comprensión, la función
-- repiteFinitaC :: Int-> a -> [a]
-- tal que (repiteFinitaC n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinitaC 3 5 == [5,5,5]
--
-- Nota: La función repiteFinitaC es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinitaC :: Int -> a -> [a]
repiteFinitaC n x = [x | _ <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 2.3. Definir, usando repite, la función
-- repiteFinita :: Int-> a -> [a]
-- tal que (repiteFinita n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinita 3 5 == [5,5,5]
--
-- Nota: La función repiteFinita es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinita :: Int -> a -> [a]
repiteFinita n x = take n (repite x)

-- ---------------------------------------------------------------------
-- Ejercicio 2.4. Comprobar con QuickCheck que las funciones
-- repiteFinitaR, repiteFinitaC y repiteFinita son equivalentes a
-- replicate.
--
-- Nota. Al hacer la comprobación limitar el tamańo de las pruebas como
-- se indica a continuación
-- quickCheckWith (stdArgs {maxSize=7}) prop_repiteFinitaEquiv
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaEquiv :: Int -> Int -> Bool
prop_repiteFinitaEquiv n x = repiteFinitaR n x == replicate n x && repiteFinitaC n x == replicate n x && repiteFinita n x == replicate n x

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

-- ---------------------------------------------------------------------
-- Ejercicio 2.5. Comprobar con QuickCheck que la longitud de
-- (repiteFinita n x) es n, si n es positivo y 0 si no lo es.
--
-- Nota. Al hacer la comprobación limitar el tamańo de las pruebas como
-- se indica a continuación
-- quickCheckWith (stdArgs {maxSize=30}) prop_repiteFinitaLongitud
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaLongitud :: Int -> Int -> Bool
prop_repiteFinitaLongitud n x = if n > 0 then length (repiteFinita n x) == n else length (repiteFinita n x) == 0

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

-- ---------------------------------------------------------------------
-- Ejercicio 2.6. Comprobar con QuickCheck que todos los elementos de
-- (repiteFinita n x) son iguales a x.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaIguales :: Int -> Int -> Bool
prop_repiteFinitaIguales n x = all (==x) (repiteFinita n x)

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

-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Definir, por comprensión, la función
-- ecoC :: String -> String
-- tal que (ecoC xs) es la cadena obtenida a partir de la cadena xs
-- repitiendo cada elemento tantas veces como indica su posición: el
-- primer elemento se repite 1 vez, el segundo 2 veces y así
-- sucesivamente. Por ejemplo,
-- ecoC "abcd" == "abbcccdddd"
-- ---------------------------------------------------------------------

-- Elsa Domínguez
ecoC :: String -> String
ecoC xs = concat [replicate n x| (x,n) <- zip xs [1..]]

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Definir, por recursión, la función
-- ecoR :: String -> String
-- tal que (ecoR xs) es la cadena obtenida a partir de la cadena xs
-- repitiendo cada elemento tantas veces como indica su posición: el
-- primer elemento se repite 1 vez, el segundo 2 veces y así
-- sucesivamente. Por ejemplo,
-- ecoR "abcd" == "abbcccdddd"
-- ---------------------------------------------------------------------

-- Elsa Domínguez
ecoR :: String -> String
ecoR xs = aux 1 xs
where aux n [] = []
aux n (x:xs) = replicate n x ++ aux (n+1) xs

-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir, por recursión, la función
-- itera :: (a -> a) -> a -> [a]
-- tal que (itera f x) es la lista cuyo primer elemento es x y los
-- siguientes elementos se calculan aplicando la función f al elemento
-- anterior. Por ejemplo,
-- ghci> itera (+1) 3
-- [3,4,5,6,7,8,9,10,11,12,{Interrupted!}
-- ghci> itera (*2) 1
-- [1,2,4,8,16,32,64,{Interrupted!}
-- ghci> itera (`div` 10) 1972
-- [1972,197,19,1,0,0,0,0,0,0,{Interrupted!}
--
-- Nota: La función repite es equivalente a la función iterate definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
itera :: (a -> a) -> a -> [a]
itera f x = x : itera f (f x)

-- ----------------------------------------------------------------------------
-- Ejercicio 5.1. Definir, por recursión, la función
-- agrupaR :: Int -> [a] -> [[a]]
-- tal que (agrupaR n xs) es la lista formada por listas de n elementos
-- consecutivos de la lista xs (salvo posiblemente la última que puede
-- tener menos de n elementos). Por ejemplo,
-- ghci> agrupaR 2 [3,1,5,8,2,7]
-- [[3,1],[5,8],[2,7]]
-- ghci> agrupaR 2 [3,1,5,8,2,7,9]
-- [[3,1],[5,8],[2,7],[9]]
-- ghci> agrupaR 5 "todo necio confunde valor y precio"
-- ["todo ","necio"," conf","unde ","valor"," y pr","ecio"]
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
agrupaR :: Int -> [a] -> [[a]]
agrupaR _ [] = []
agrupaR n xs = [take n xs] ++ agrupaR n (drop n xs)

-- ----------------------------------------------------------------------------
-- Ejercicio 5.2. Definir, de manera no recursiva con iterate, la función
-- agrupa :: Int -> [a] -> [[a]]
-- tal que (agrupa n xs) es la lista formada por listas de n elementos
-- consecutivos de la lista xs (salvo posiblemente la última que puede
-- tener menos de n elementos). Por ejemplo,
-- ghci> agrupa 2 [3,1,5,8,2,7]
-- [[3,1],[5,8],[2,7]]
-- ghci> agrupa 2 [3,1,5,8,2,7,9]
-- [[3,1],[5,8],[2,7],[9]]
-- ghci> agrupa 5 "todo necio confunde valor y precio"
-- ["todo ","necio"," conf","unde ","valor"," y pr","ecio"]
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
agrupa :: Int -> [a] -> [[a]]
agrupa n xs = takeWhile (not.null) (map (take n) (iterate (drop n) xs))

-- ----------------------------------------------------------------------------
-- Ejercicio 5.3. Comprobar con QuickCheck que todos los grupos de
-- (agrupa n xs) tienen longitud n (salvo el último que puede tener una
-- longitud menor).
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
--prop_AgrupaLongitud :: Int -> [Int] -> Property
prop_AgrupaLongitud n xs = n>0 && not (null xs) ==> and [length ys == n | ys <- init (agrupa n xs)] && length (last (agrupa n xs)) <= n

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

-- ----------------------------------------------------------------------------
-- Ejercicio 5.4. Comprobar con QuickCheck que combinando todos los
-- grupos de ((agrupa n xs)) se obtiene la lista xs.
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
-- La segunda propiedad es
prop_AgrupaCombina :: Int -> [Int] -> Property
prop_AgrupaCombina n xs = n>0 ==> concat (agrupa n xs) == xs

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

-- ---------------------------------------------------------------------
-- Ejercicio 6.1. Sea la siguiente operación, aplicable a cualquier
-- número entero positivo:
-- * Si el número es par, se divide entre 2.
-- * Si el número es impar, se multiplica por 3 y se suma 1.
-- Dado un número cualquiera, podemos considerar su órbita, es decir,
-- las imágenes sucesivas al iterar la función. Por ejemplo, la órbita
-- de 13 es
-- 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1,...
-- Si observamos este ejemplo, la órbita de 13 es periódica, es decir,
-- se repite indefinidamente a partir de un momento dado). La conjetura
-- de Collatz dice que siempre alcanzaremos el 1 para cualquier número
-- con el que comencemos. Ejemplos:
-- * Empezando en n = 6 se obtiene 6, 3, 10, 5, 16, 8, 4, 2, 1.
-- * Empezando en n = 11 se obtiene: 11, 34, 17, 52, 26, 13, 40, 20,
-- 10, 5, 16, 8, 4, 2, 1.
-- * Empezando en n = 27, la sucesión tiene 112 pasos, llegando hasta
-- 9232 antes de descender a 1: 27, 82, 41, 124, 62, 31, 94, 47,
-- 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274,
-- 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263,
-- 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502,
-- 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958,
-- 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644,
-- 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308,
-- 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122,
-- 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5,
-- 16, 8, 4, 2, 1.
--
-- Definir la función
-- siguiente :: Integer -> Integer
-- tal que (siguiente n) es el siguiente de n en la sucesión de
-- Collatz. Por ejemplo,
-- siguiente 13 == 40
-- siguiente 40 == 20
-- ---------------------------------------------------------------------

-- Elsa Domínguez
siguiente :: Integer -> Integer
siguiente n = if even n then div n 2 else n*3 + 1

-- ---------------------------------------------------------------------
-- Ejercicio 6.2. Definir, por recursión, la función
-- collatzR :: Integer -> [Integer]
-- tal que (collatzR n) es la órbita de CollatzR de n hasta alcanzar el
-- 1. Por ejemplo,
-- collatzR 13 == [13,40,20,10,5,16,8,4,2,1]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
collatzR :: Integer -> [Integer]
collatzR 1 = [1]
collatzR n = n : collatzR (siguiente n)

-- ---------------------------------------------------------------------
-- Ejercicio 6.3. Definir, sin recursión y con iterate, la función
-- collatz :: Integer -> [Integer]
-- tal que (collatz n) es la órbita de Collatz d n hasta alcanzar el
-- 1. Por ejemplo,
-- collatz 13 == [13,40,20,10,5,16,8,4,2,1]
-- Indicación: Usar takeWhile e iterate.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
collatz :: Integer -> [Integer]
collatz n = takeWhile (/=1) (iterate siguiente n) ++ [1]

-- ---------------------------------------------------------------------
-- Ejercicio 6.4. Definir la función
-- menorCollatzMayor :: Int -> Integer
-- tal que (menorCollatzMayor x) es el menor número cuya órbita de
-- Collatz tiene más de x elementos. Por ejemplo,
-- menorCollatzMayor 100 == 27
-- ---------------------------------------------------------------------

-- Elsa Domínguez
menorCollatzMayor :: Int -> Integer
menorCollatzMayor x = head [n | n <- [1..], length (collatz n) > x]

-- ---------------------------------------------------------------------
-- Ejercicio 6.5. Definir la función
-- menorCollatzSupera :: Integer -> Integer
-- tal que (menorCollatzSupera x) es el menor número cuya órbita de
-- Collatz tiene algún elemento mayor que x. Por ejemplo,
-- menorCollatzSupera 100 == 15
-- ---------------------------------------------------------------------

-- Elsa Domínguez
menorCollatzSupera :: Integer -> Integer
menorCollatzSupera x = head [n | n <- [1..], any (>x) (collatz n)]

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir, usando takeWhile y map, la función
-- potenciasMenores :: Int -> Int -> [Int]
-- tal que (potenciasMenores x y) es la lista de las potencias de x
-- menores que y. Por ejemplo,
-- potenciasMenores 2 1000 == [2,4,8,16,32,64,128,256,512]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
potenciasMenores :: Int -> Int -> [Int]
potenciasMenores x y = takeWhile (<y) (map (x^) [1..])

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir, usando la criba de Eratóstenes, la constante
-- primos :: Integral a => [a]
-- cuyo valor es la lista de los números primos. Por ejemplo,
-- take 10 primos == [2,3,5,7,11,13,17,19,23,29]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
primos :: Integral a => [a]
primos = criba [2..]

criba (p:xs) = p : criba [x | x <- xs, x `mod` p /= 0]

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir, usando primos, la función
-- primo :: Integral a => a -> Bool
-- tal que (primo n) se verifica si n es primo. Por ejemplo,
-- primo 7 == True
-- primo 9 == False
-- ---------------------------------------------------------------------

-- Elsa Domínguez
primo :: Int -> Bool
primo n = last (takeWhile (<=n) primos) == n

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Definir la función
-- sumaDeDosPrimos :: Int -> [(Int,Int)]
-- tal que (sumaDeDosPrimos n) es la lista de las distintas
-- descomposiciones de n como suma de dos números primos. Por ejemplo,
-- sumaDeDosPrimos 30 == [(7,23),(11,19),(13,17)]
-- sumaDeDosPrimos 10 == [(3,7),(5,5)]
-- Calcular, usando la función sumaDeDosPrimos, el menor número que
-- puede escribirse de 10 formas distintas como suma de dos primos.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
sumaDeDosPrimos :: Int -> [(Int,Int)]
sumaDeDosPrimos n = [(x,n-x) | x <- [2..div n 2], primo x, primo (n-x)]

-- El cálculo es head [n | n <- [4..], length (sumaDeDosPrimos n) == 10]
-- 114

-- ---------------------------------------------------------------------
-- § La lista infinita de factoriales --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 9.1. Definir, por comprensión, la función
-- factoriales1 :: [Integer]
-- tal que factoriales1 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales1 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales1 :: [Integer]
factoriales1 = [factorial n | n <- [0..]]

factorial n = product [1..n]

-- ---------------------------------------------------------------------
-- Ejercicio 9.2. Definir, usando zipWith, la función
-- factoriales2 :: [Integer]
-- tal que factoriales2 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales2 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales2 :: [Integer]
factoriales2 = 1 : zipWith (*) [1..] factoriales2

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Definir, por recursión, la función
-- factoriales3 :: [Integer]
-- tal que factoriales3 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales3 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales3 :: [Integer]
factoriales3 = 1 : aux 1 [1..]
where aux v (x:xs) = (v*x) : aux (v*x) xs

-- ---------------------------------------------------------------------
-- Ejercicio 9.4. Definir, usando scanl1, la función
-- factoriales4 :: [Integer]
-- tal que factoriales4 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales4 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales4 :: [Integer]
factoriales4 = 1 : scanl1 (*) [1..]

-- ---------------------------------------------------------------------
-- Ejercicio 9.5. Definir, usando iterate, la función
-- factoriales5 :: [Integer]
-- tal que factoriales5 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales5 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales5 :: [Integer]
factoriales5 = map snd (iterate f (1,1))
where f (x,y) = (x+1,x*y)

-- ---------------------------------------------------------------------
-- § La sucesión de Fibonacci --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 10.1. La sucesión de Fibonacci está definida por
-- f(0) = 0
-- f(1) = 1
-- f(n) = f(n-1)+f(n-2), si n > 1.
--
-- Definir la función
-- fib :: Integer -> Integer
-- tal que (fib n) es el n-ésimo término de la sucesión de Fibonacci.
-- Por ejemplo,
-- fib 8 == 21
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fib :: Integer -> Integer
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

-- ---------------------------------------------------------------------
-- Ejercicio 10.2. Definir, por comprensión, la función
-- fibs1 :: [Integer]
-- tal que fibs1 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs1 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fibs1 :: [Integer]
fibs1 = [fib n | n <- [0..]]

-- ---------------------------------------------------------------------
-- Ejercicio 10.3. Definir, por recursión, la función
-- fibs2 :: [Integer]
-- tal que fibs2 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs2 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

fibs2 :: [Integer]
fibs2 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 10.4. Definir, por recursión con zipWith, la función
-- fibs3 :: [Integer]
-- tal que fibs3 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs3 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fibs3 :: [Integer]
fibs3 = 0 : 1 : zipWith (+) fibs3 (tail fibs3)

-- ---------------------------------------------------------------------
-- Ejercicio 10.5. Definir, por recursión con acumuladores, la función
-- fibs4 :: [Integer]
-- tal que fibs4 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs4 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fibs4 :: [Integer]
fibs4 = aux 0 1
where aux x y = x : aux y (x+y)

-- ---------------------------------------------------------------------
-- § El triángulo de Pascal --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 11.1. El triángulo de Pascal es un triángulo de números
-- 1
-- 1 1
-- 1 2 1
-- 1 3 3 1
-- 1 4 6 4 1
-- 1 5 10 10 5 1
-- ...............
-- construido de la siguiente forma
-- * la primera fila está formada por el número 1;
-- * las filas siguientes se construyen sumando los números adyacentes
-- de la fila superior y ańadiendo un 1 al principio y al final de la
-- fila.
--
-- Definir, con iterate y zipWith, la función
-- pascal1 :: [[Integer]]
-- tal que pascal es la lista de las líneas del triángulo de Pascal. Por
-- ejemplo,
-- ghci> take 6 pascal1
-- [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1],[1,5,10,10,5,1]]
-- ---------------------------------------------------------------------

pascal1 :: [[Integer]]
pascal1 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 11.2. Definir, con map y zipWith, la función
-- pascal2 :: [[Integer]]
-- tal que pascal es la lista de las líneas del triángulo de Pascal. Por
-- ejemplo,
-- ghci> take 6 pascal2
-- [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1],[1,5,10,10,5,1]]
-- ---------------------------------------------------------------------

-- 2ª definición (con map):
pascal2 :: [[Integer]]
pascal2 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 11.3. Escribir la traza del cálculo de la expresión
-- take 4 pascal2
-- ---------------------------------------------------------------------

</source>

Relación 11

2021-12-16T19:27:36Z

Elsdomgon:

<source lang='haskell'>

-- I1M 2021-22: Rel_11.hs (17 de diciembre de 2021)
-- Evaluación perezosa y listas infinitas.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

-- En esta relación se presentan ejercicios con listas infinitas y
-- evaluación perezosa. Estos ejercicios corresponden al tema 10 cuyas
-- transparencias se encuentran en
-- https://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-10.html

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

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1.1. Definir, por recursión, la función
-- repite :: a -> [a]
-- tal que (repite x) es la lista infinita cuyos elementos son x. Por
-- ejemplo,
-- repite 5 == [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,...
-- take 3 (repite 5) == [5,5,5]
--
-- Nota: La función repite es equivalente a la función repeat definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repite :: a -> [a]
repite x = [x] ++ repite x

-- ---------------------------------------------------------------------
-- Ejercicio 1.2. Definir, por comprensión, la función
-- repiteC :: a -> [a]
-- tal que (repiteC x) es la lista infinita cuyos elementos son x. Por
-- ejemplo,
-- repiteC 5 == [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,...
-- take 3 (repiteC 5) == [5,5,5]
--
-- Nota: La función repiteC es equivalente a la función repeat definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteC :: a -> [a]
repiteC x = [x | _ <- [1..]]

-- ---------------------------------------------------------------------
-- Ejercicio 2.1. Definir, por recursión, la función
-- repiteFinitaR :: Int-> a -> [a]
-- tal que (repiteFinitaR n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinitaR 3 5 == [5,5,5]
--
-- Nota: La función repiteFinitaR es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinitaR :: Int -> a -> [a]
repiteFinitaR n x | n <= 0 = []
| otherwise = [x] ++ repiteFinitaR (n-1) x

-- ---------------------------------------------------------------------
-- Ejercicio 2.2. Definir, por comprensión, la función
-- repiteFinitaC :: Int-> a -> [a]
-- tal que (repiteFinitaC n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinitaC 3 5 == [5,5,5]
--
-- Nota: La función repiteFinitaC es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinitaC :: Int -> a -> [a]
repiteFinitaC n x = [x | _ <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 2.3. Definir, usando repite, la función
-- repiteFinita :: Int-> a -> [a]
-- tal que (repiteFinita n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinita 3 5 == [5,5,5]
--
-- Nota: La función repiteFinita es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinita :: Int -> a -> [a]
repiteFinita n x = take n (repite x)

-- ---------------------------------------------------------------------
-- Ejercicio 2.4. Comprobar con QuickCheck que las funciones
-- repiteFinitaR, repiteFinitaC y repiteFinita son equivalentes a
-- replicate.
--
-- Nota. Al hacer la comprobación limitar el tamańo de las pruebas como
-- se indica a continuación
-- quickCheckWith (stdArgs {maxSize=7}) prop_repiteFinitaEquiv
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaEquiv :: Int -> Int -> Bool
prop_repiteFinitaEquiv n x = repiteFinitaR n x == replicate n x && repiteFinitaC n x == replicate n x && repiteFinita n x == replicate n x

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

-- ---------------------------------------------------------------------
-- Ejercicio 2.5. Comprobar con QuickCheck que la longitud de
-- (repiteFinita n x) es n, si n es positivo y 0 si no lo es.
--
-- Nota. Al hacer la comprobación limitar el tamańo de las pruebas como
-- se indica a continuación
-- quickCheckWith (stdArgs {maxSize=30}) prop_repiteFinitaLongitud
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaLongitud :: Int -> Int -> Bool
prop_repiteFinitaLongitud n x = if n > 0 then length (repiteFinita n x) == n else length (repiteFinita n x) == 0

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

-- ---------------------------------------------------------------------
-- Ejercicio 2.6. Comprobar con QuickCheck que todos los elementos de
-- (repiteFinita n x) son iguales a x.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaIguales :: Int -> Int -> Bool
prop_repiteFinitaIguales n x = all (==x) (repiteFinita n x)

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

-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Definir, por comprensión, la función
-- ecoC :: String -> String
-- tal que (ecoC xs) es la cadena obtenida a partir de la cadena xs
-- repitiendo cada elemento tantas veces como indica su posición: el
-- primer elemento se repite 1 vez, el segundo 2 veces y así
-- sucesivamente. Por ejemplo,
-- ecoC "abcd" == "abbcccdddd"
-- ---------------------------------------------------------------------

-- Elsa Domínguez
ecoC :: String -> String
ecoC xs = concat [replicate n x| (x,n) <- zip xs [1..]]

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Definir, por recursión, la función
-- ecoR :: String -> String
-- tal que (ecoR xs) es la cadena obtenida a partir de la cadena xs
-- repitiendo cada elemento tantas veces como indica su posición: el
-- primer elemento se repite 1 vez, el segundo 2 veces y así
-- sucesivamente. Por ejemplo,
-- ecoR "abcd" == "abbcccdddd"
-- ---------------------------------------------------------------------

ecoR :: String -> String
ecoR xs = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir, por recursión, la función
-- itera :: (a -> a) -> a -> [a]
-- tal que (itera f x) es la lista cuyo primer elemento es x y los
-- siguientes elementos se calculan aplicando la función f al elemento
-- anterior. Por ejemplo,
-- ghci> itera (+1) 3
-- [3,4,5,6,7,8,9,10,11,12,{Interrupted!}
-- ghci> itera (*2) 1
-- [1,2,4,8,16,32,64,{Interrupted!}
-- ghci> itera (`div` 10) 1972
-- [1972,197,19,1,0,0,0,0,0,0,{Interrupted!}
--
-- Nota: La función repite es equivalente a la función iterate definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
itera :: (a -> a) -> a -> [a]
itera f x = x : itera f (f x)

-- ----------------------------------------------------------------------------
-- Ejercicio 5.1. Definir, por recursión, la función
-- agrupaR :: Int -> [a] -> [[a]]
-- tal que (agrupaR n xs) es la lista formada por listas de n elementos
-- consecutivos de la lista xs (salvo posiblemente la última que puede
-- tener menos de n elementos). Por ejemplo,
-- ghci> agrupaR 2 [3,1,5,8,2,7]
-- [[3,1],[5,8],[2,7]]
-- ghci> agrupaR 2 [3,1,5,8,2,7,9]
-- [[3,1],[5,8],[2,7],[9]]
-- ghci> agrupaR 5 "todo necio confunde valor y precio"
-- ["todo ","necio"," conf","unde ","valor"," y pr","ecio"]
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
agrupaR :: Int -> [a] -> [[a]]
agrupaR _ [] = []
agrupaR n xs = [take n xs] ++ agrupaR n (drop n xs)

-- ----------------------------------------------------------------------------
-- Ejercicio 5.2. Definir, de manera no recursiva con iterate, la función
-- agrupa :: Int -> [a] -> [[a]]
-- tal que (agrupa n xs) es la lista formada por listas de n elementos
-- consecutivos de la lista xs (salvo posiblemente la última que puede
-- tener menos de n elementos). Por ejemplo,
-- ghci> agrupa 2 [3,1,5,8,2,7]
-- [[3,1],[5,8],[2,7]]
-- ghci> agrupa 2 [3,1,5,8,2,7,9]
-- [[3,1],[5,8],[2,7],[9]]
-- ghci> agrupa 5 "todo necio confunde valor y precio"
-- ["todo ","necio"," conf","unde ","valor"," y pr","ecio"]
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
agrupa :: Int -> [a] -> [[a]]
agrupa n xs = takeWhile (not.null) (map (take n) (iterate (drop n) xs))

-- ----------------------------------------------------------------------------
-- Ejercicio 5.3. Comprobar con QuickCheck que todos los grupos de
-- (agrupa n xs) tienen longitud n (salvo el último que puede tener una
-- longitud menor).
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
--prop_AgrupaLongitud :: Int -> [Int] -> Property
prop_AgrupaLongitud n xs = n>0 && not (null xs) ==> and [length ys == n | ys <- init (agrupa n xs)] && length (last (agrupa n xs)) <= n

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

-- ----------------------------------------------------------------------------
-- Ejercicio 5.4. Comprobar con QuickCheck que combinando todos los
-- grupos de ((agrupa n xs)) se obtiene la lista xs.
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
-- La segunda propiedad es
prop_AgrupaCombina :: Int -> [Int] -> Property
prop_AgrupaCombina n xs = n>0 ==> concat (agrupa n xs) == xs

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

-- ---------------------------------------------------------------------
-- Ejercicio 6.1. Sea la siguiente operación, aplicable a cualquier
-- número entero positivo:
-- * Si el número es par, se divide entre 2.
-- * Si el número es impar, se multiplica por 3 y se suma 1.
-- Dado un número cualquiera, podemos considerar su órbita, es decir,
-- las imágenes sucesivas al iterar la función. Por ejemplo, la órbita
-- de 13 es
-- 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1,...
-- Si observamos este ejemplo, la órbita de 13 es periódica, es decir,
-- se repite indefinidamente a partir de un momento dado). La conjetura
-- de Collatz dice que siempre alcanzaremos el 1 para cualquier número
-- con el que comencemos. Ejemplos:
-- * Empezando en n = 6 se obtiene 6, 3, 10, 5, 16, 8, 4, 2, 1.
-- * Empezando en n = 11 se obtiene: 11, 34, 17, 52, 26, 13, 40, 20,
-- 10, 5, 16, 8, 4, 2, 1.
-- * Empezando en n = 27, la sucesión tiene 112 pasos, llegando hasta
-- 9232 antes de descender a 1: 27, 82, 41, 124, 62, 31, 94, 47,
-- 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274,
-- 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263,
-- 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502,
-- 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958,
-- 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644,
-- 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308,
-- 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122,
-- 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5,
-- 16, 8, 4, 2, 1.
--
-- Definir la función
-- siguiente :: Integer -> Integer
-- tal que (siguiente n) es el siguiente de n en la sucesión de
-- Collatz. Por ejemplo,
-- siguiente 13 == 40
-- siguiente 40 == 20
-- ---------------------------------------------------------------------

-- Elsa Domínguez
siguiente :: Integer -> Integer
siguiente n = if even n then div n 2 else n*3 + 1

-- ---------------------------------------------------------------------
-- Ejercicio 6.2. Definir, por recursión, la función
-- collatzR :: Integer -> [Integer]
-- tal que (collatzR n) es la órbita de CollatzR de n hasta alcanzar el
-- 1. Por ejemplo,
-- collatzR 13 == [13,40,20,10,5,16,8,4,2,1]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
collatzR :: Integer -> [Integer]
collatzR 1 = [1]
collatzR n = n : collatzR (siguiente n)

-- ---------------------------------------------------------------------
-- Ejercicio 6.3. Definir, sin recursión y con iterate, la función
-- collatz :: Integer -> [Integer]
-- tal que (collatz n) es la órbita de Collatz d n hasta alcanzar el
-- 1. Por ejemplo,
-- collatz 13 == [13,40,20,10,5,16,8,4,2,1]
-- Indicación: Usar takeWhile e iterate.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
collatz :: Integer -> [Integer]
collatz n = takeWhile (/=1) (iterate siguiente n) ++ [1]

-- ---------------------------------------------------------------------
-- Ejercicio 6.4. Definir la función
-- menorCollatzMayor :: Int -> Integer
-- tal que (menorCollatzMayor x) es el menor número cuya órbita de
-- Collatz tiene más de x elementos. Por ejemplo,
-- menorCollatzMayor 100 == 27
-- ---------------------------------------------------------------------

-- Elsa Domínguez
menorCollatzMayor :: Int -> Integer
menorCollatzMayor x = head [n | n <- [1..], length (collatz n) > x]

-- ---------------------------------------------------------------------
-- Ejercicio 6.5. Definir la función
-- menorCollatzSupera :: Integer -> Integer
-- tal que (menorCollatzSupera x) es el menor número cuya órbita de
-- Collatz tiene algún elemento mayor que x. Por ejemplo,
-- menorCollatzSupera 100 == 15
-- ---------------------------------------------------------------------

-- Elsa Domínguez
menorCollatzSupera :: Integer -> Integer
menorCollatzSupera x = head [n | n <- [1..], any (>x) (collatz n)]

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir, usando takeWhile y map, la función
-- potenciasMenores :: Int -> Int -> [Int]
-- tal que (potenciasMenores x y) es la lista de las potencias de x
-- menores que y. Por ejemplo,
-- potenciasMenores 2 1000 == [2,4,8,16,32,64,128,256,512]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
potenciasMenores :: Int -> Int -> [Int]
potenciasMenores x y = takeWhile (<y) (map (x^) [1..])

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir, usando la criba de Eratóstenes, la constante
-- primos :: Integral a => [a]
-- cuyo valor es la lista de los números primos. Por ejemplo,
-- take 10 primos == [2,3,5,7,11,13,17,19,23,29]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
primos :: Integral a => [a]
primos = criba [2..]

criba (p:xs) = p : criba [x | x <- xs, x `mod` p /= 0]

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir, usando primos, la función
-- primo :: Integral a => a -> Bool
-- tal que (primo n) se verifica si n es primo. Por ejemplo,
-- primo 7 == True
-- primo 9 == False
-- ---------------------------------------------------------------------

-- Elsa Domínguez
primo :: Int -> Bool
primo n = last (takeWhile (<=n) primos) == n

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Definir la función
-- sumaDeDosPrimos :: Int -> [(Int,Int)]
-- tal que (sumaDeDosPrimos n) es la lista de las distintas
-- descomposiciones de n como suma de dos números primos. Por ejemplo,
-- sumaDeDosPrimos 30 == [(7,23),(11,19),(13,17)]
-- sumaDeDosPrimos 10 == [(3,7),(5,5)]
-- Calcular, usando la función sumaDeDosPrimos, el menor número que
-- puede escribirse de 10 formas distintas como suma de dos primos.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
sumaDeDosPrimos :: Int -> [(Int,Int)]
sumaDeDosPrimos n = [(x,n-x) | x <- [2..div n 2], primo x, primo (n-x)]

-- El cálculo es head [n | n <- [4..], length (sumaDeDosPrimos n) == 10]
-- 114

-- ---------------------------------------------------------------------
-- § La lista infinita de factoriales --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 9.1. Definir, por comprensión, la función
-- factoriales1 :: [Integer]
-- tal que factoriales1 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales1 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales1 :: [Integer]
factoriales1 = [factorial n | n <- [0..]]

factorial n = product [1..n]

-- ---------------------------------------------------------------------
-- Ejercicio 9.2. Definir, usando zipWith, la función
-- factoriales2 :: [Integer]
-- tal que factoriales2 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales2 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales2 :: [Integer]
factoriales2 = 1 : zipWith (*) [1..] factoriales2

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Definir, por recursión, la función
-- factoriales3 :: [Integer]
-- tal que factoriales3 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales3 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales3 :: [Integer]
factoriales3 = 1 : aux 1 [1..]
where aux v (x:xs) = (v*x) : aux (v*x) xs

-- ---------------------------------------------------------------------
-- Ejercicio 9.4. Definir, usando scanl1, la función
-- factoriales4 :: [Integer]
-- tal que factoriales4 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales4 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales4 :: [Integer]
factoriales4 = 1 : scanl1 (*) [1..]

-- ---------------------------------------------------------------------
-- Ejercicio 9.5. Definir, usando iterate, la función
-- factoriales5 :: [Integer]
-- tal que factoriales5 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales5 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales5 :: [Integer]
factoriales5 = map snd (iterate f (1,1))
where f (x,y) = (x+1,x*y)

-- ---------------------------------------------------------------------
-- § La sucesión de Fibonacci --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 10.1. La sucesión de Fibonacci está definida por
-- f(0) = 0
-- f(1) = 1
-- f(n) = f(n-1)+f(n-2), si n > 1.
--
-- Definir la función
-- fib :: Integer -> Integer
-- tal que (fib n) es el n-ésimo término de la sucesión de Fibonacci.
-- Por ejemplo,
-- fib 8 == 21
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fib :: Integer -> Integer
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

-- ---------------------------------------------------------------------
-- Ejercicio 10.2. Definir, por comprensión, la función
-- fibs1 :: [Integer]
-- tal que fibs1 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs1 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fibs1 :: [Integer]
fibs1 = [fib n | n <- [0..]]

-- ---------------------------------------------------------------------
-- Ejercicio 10.3. Definir, por recursión, la función
-- fibs2 :: [Integer]
-- tal que fibs2 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs2 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

fibs2 :: [Integer]
fibs2 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 10.4. Definir, por recursión con zipWith, la función
-- fibs3 :: [Integer]
-- tal que fibs3 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs3 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fibs3 :: [Integer]
fibs3 = 0 : 1 : zipWith (+) fibs3 (tail fibs3)

-- ---------------------------------------------------------------------
-- Ejercicio 10.5. Definir, por recursión con acumuladores, la función
-- fibs4 :: [Integer]
-- tal que fibs4 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs4 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fibs4 :: [Integer]
fibs4 = aux 0 1
where aux x y = x : aux y (x+y)

-- ---------------------------------------------------------------------
-- § El triángulo de Pascal --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 11.1. El triángulo de Pascal es un triángulo de números
-- 1
-- 1 1
-- 1 2 1
-- 1 3 3 1
-- 1 4 6 4 1
-- 1 5 10 10 5 1
-- ...............
-- construido de la siguiente forma
-- * la primera fila está formada por el número 1;
-- * las filas siguientes se construyen sumando los números adyacentes
-- de la fila superior y ańadiendo un 1 al principio y al final de la
-- fila.
--
-- Definir, con iterate y zipWith, la función
-- pascal1 :: [[Integer]]
-- tal que pascal es la lista de las líneas del triángulo de Pascal. Por
-- ejemplo,
-- ghci> take 6 pascal1
-- [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1],[1,5,10,10,5,1]]
-- ---------------------------------------------------------------------

pascal1 :: [[Integer]]
pascal1 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 11.2. Definir, con map y zipWith, la función
-- pascal2 :: [[Integer]]
-- tal que pascal es la lista de las líneas del triángulo de Pascal. Por
-- ejemplo,
-- ghci> take 6 pascal2
-- [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1],[1,5,10,10,5,1]]
-- ---------------------------------------------------------------------

-- 2ª definición (con map):
pascal2 :: [[Integer]]
pascal2 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 11.3. Escribir la traza del cálculo de la expresión
-- take 4 pascal2
-- ---------------------------------------------------------------------

</source>

Relación 11

2021-12-16T19:14:57Z

Elsdomgon:

<source lang='haskell'>

-- I1M 2021-22: Rel_11.hs (17 de diciembre de 2021)
-- Evaluación perezosa y listas infinitas.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

-- En esta relación se presentan ejercicios con listas infinitas y
-- evaluación perezosa. Estos ejercicios corresponden al tema 10 cuyas
-- transparencias se encuentran en
-- https://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-10.html

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

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1.1. Definir, por recursión, la función
-- repite :: a -> [a]
-- tal que (repite x) es la lista infinita cuyos elementos son x. Por
-- ejemplo,
-- repite 5 == [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,...
-- take 3 (repite 5) == [5,5,5]
--
-- Nota: La función repite es equivalente a la función repeat definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repite :: a -> [a]
repite x = [x] ++ repite x

-- ---------------------------------------------------------------------
-- Ejercicio 1.2. Definir, por comprensión, la función
-- repiteC :: a -> [a]
-- tal que (repiteC x) es la lista infinita cuyos elementos son x. Por
-- ejemplo,
-- repiteC 5 == [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,...
-- take 3 (repiteC 5) == [5,5,5]
--
-- Nota: La función repiteC es equivalente a la función repeat definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteC :: a -> [a]
repiteC x = [x | _ <- [1..]]

-- ---------------------------------------------------------------------
-- Ejercicio 2.1. Definir, por recursión, la función
-- repiteFinitaR :: Int-> a -> [a]
-- tal que (repiteFinitaR n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinitaR 3 5 == [5,5,5]
--
-- Nota: La función repiteFinitaR es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinitaR :: Int -> a -> [a]
repiteFinitaR n x | n <= 0 = []
| otherwise = [x] ++ repiteFinitaR (n-1) x

-- ---------------------------------------------------------------------
-- Ejercicio 2.2. Definir, por comprensión, la función
-- repiteFinitaC :: Int-> a -> [a]
-- tal que (repiteFinitaC n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinitaC 3 5 == [5,5,5]
--
-- Nota: La función repiteFinitaC es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinitaC :: Int -> a -> [a]
repiteFinitaC n x = [x | _ <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 2.3. Definir, usando repite, la función
-- repiteFinita :: Int-> a -> [a]
-- tal que (repiteFinita n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinita 3 5 == [5,5,5]
--
-- Nota: La función repiteFinita es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinita :: Int -> a -> [a]
repiteFinita n x = take n (repite x)

-- ---------------------------------------------------------------------
-- Ejercicio 2.4. Comprobar con QuickCheck que las funciones
-- repiteFinitaR, repiteFinitaC y repiteFinita son equivalentes a
-- replicate.
--
-- Nota. Al hacer la comprobación limitar el tamańo de las pruebas como
-- se indica a continuación
-- quickCheckWith (stdArgs {maxSize=7}) prop_repiteFinitaEquiv
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaEquiv :: Int -> Int -> Bool
prop_repiteFinitaEquiv n x = repiteFinitaR n x == replicate n x && repiteFinitaC n x == replicate n x && repiteFinita n x == replicate n x

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

-- ---------------------------------------------------------------------
-- Ejercicio 2.5. Comprobar con QuickCheck que la longitud de
-- (repiteFinita n x) es n, si n es positivo y 0 si no lo es.
--
-- Nota. Al hacer la comprobación limitar el tamańo de las pruebas como
-- se indica a continuación
-- quickCheckWith (stdArgs {maxSize=30}) prop_repiteFinitaLongitud
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaLongitud :: Int -> Int -> Bool
prop_repiteFinitaLongitud n x = if n > 0 then length (repiteFinita n x) == n else length (repiteFinita n x) == 0

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

-- ---------------------------------------------------------------------
-- Ejercicio 2.6. Comprobar con QuickCheck que todos los elementos de
-- (repiteFinita n x) son iguales a x.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaIguales :: Int -> Int -> Bool
prop_repiteFinitaIguales n x = all (==x) (repiteFinita n x)

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

-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Definir, por comprensión, la función
-- ecoC :: String -> String
-- tal que (ecoC xs) es la cadena obtenida a partir de la cadena xs
-- repitiendo cada elemento tantas veces como indica su posición: el
-- primer elemento se repite 1 vez, el segundo 2 veces y así
-- sucesivamente. Por ejemplo,
-- ecoC "abcd" == "abbcccdddd"
-- ---------------------------------------------------------------------

-- Elsa Domínguez
ecoC :: String -> String
ecoC xs = concat [replicate n x| (x,n) <- zip xs [1..]]

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Definir, por recursión, la función
-- ecoR :: String -> String
-- tal que (ecoR xs) es la cadena obtenida a partir de la cadena xs
-- repitiendo cada elemento tantas veces como indica su posición: el
-- primer elemento se repite 1 vez, el segundo 2 veces y así
-- sucesivamente. Por ejemplo,
-- ecoR "abcd" == "abbcccdddd"
-- ---------------------------------------------------------------------

ecoR :: String -> String
ecoR xs = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir, por recursión, la función
-- itera :: (a -> a) -> a -> [a]
-- tal que (itera f x) es la lista cuyo primer elemento es x y los
-- siguientes elementos se calculan aplicando la función f al elemento
-- anterior. Por ejemplo,
-- ghci> itera (+1) 3
-- [3,4,5,6,7,8,9,10,11,12,{Interrupted!}
-- ghci> itera (*2) 1
-- [1,2,4,8,16,32,64,{Interrupted!}
-- ghci> itera (`div` 10) 1972
-- [1972,197,19,1,0,0,0,0,0,0,{Interrupted!}
--
-- Nota: La función repite es equivalente a la función iterate definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
itera :: (a -> a) -> a -> [a]
itera f x = x : itera f (f x)

-- ----------------------------------------------------------------------------
-- Ejercicio 5.1. Definir, por recursión, la función
-- agrupaR :: Int -> [a] -> [[a]]
-- tal que (agrupaR n xs) es la lista formada por listas de n elementos
-- consecutivos de la lista xs (salvo posiblemente la última que puede
-- tener menos de n elementos). Por ejemplo,
-- ghci> agrupaR 2 [3,1,5,8,2,7]
-- [[3,1],[5,8],[2,7]]
-- ghci> agrupaR 2 [3,1,5,8,2,7,9]
-- [[3,1],[5,8],[2,7],[9]]
-- ghci> agrupaR 5 "todo necio confunde valor y precio"
-- ["todo ","necio"," conf","unde ","valor"," y pr","ecio"]
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
agrupaR :: Int -> [a] -> [[a]]
agrupaR _ [] = []
agrupaR n xs = [take n xs] ++ agrupaR n (drop n xs)

-- ----------------------------------------------------------------------------
-- Ejercicio 5.2. Definir, de manera no recursiva con iterate, la función
-- agrupa :: Int -> [a] -> [[a]]
-- tal que (agrupa n xs) es la lista formada por listas de n elementos
-- consecutivos de la lista xs (salvo posiblemente la última que puede
-- tener menos de n elementos). Por ejemplo,
-- ghci> agrupa 2 [3,1,5,8,2,7]
-- [[3,1],[5,8],[2,7]]
-- ghci> agrupa 2 [3,1,5,8,2,7,9]
-- [[3,1],[5,8],[2,7],[9]]
-- ghci> agrupa 5 "todo necio confunde valor y precio"
-- ["todo ","necio"," conf","unde ","valor"," y pr","ecio"]
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
agrupa :: Int -> [a] -> [[a]]
agrupa n xs = takeWhile (not.null) (map (take n) (iterate (drop n) xs))

-- ----------------------------------------------------------------------------
-- Ejercicio 5.3. Comprobar con QuickCheck que todos los grupos de
-- (agrupa n xs) tienen longitud n (salvo el último que puede tener una
-- longitud menor).
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
--prop_AgrupaLongitud :: Int -> [Int] -> Property
prop_AgrupaLongitud n xs = n>0 && not (null xs) ==> and [length ys == n | ys <- init (agrupa n xs)] && length (last (agrupa n xs)) <= n

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

-- ----------------------------------------------------------------------------
-- Ejercicio 5.4. Comprobar con QuickCheck que combinando todos los
-- grupos de ((agrupa n xs)) se obtiene la lista xs.
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
-- La segunda propiedad es
prop_AgrupaCombina :: Int -> [Int] -> Property
prop_AgrupaCombina n xs = n>0 ==> concat (agrupa n xs) == xs

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

-- ---------------------------------------------------------------------
-- Ejercicio 6.1. Sea la siguiente operación, aplicable a cualquier
-- número entero positivo:
-- * Si el número es par, se divide entre 2.
-- * Si el número es impar, se multiplica por 3 y se suma 1.
-- Dado un número cualquiera, podemos considerar su órbita, es decir,
-- las imágenes sucesivas al iterar la función. Por ejemplo, la órbita
-- de 13 es
-- 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1,...
-- Si observamos este ejemplo, la órbita de 13 es periódica, es decir,
-- se repite indefinidamente a partir de un momento dado). La conjetura
-- de Collatz dice que siempre alcanzaremos el 1 para cualquier número
-- con el que comencemos. Ejemplos:
-- * Empezando en n = 6 se obtiene 6, 3, 10, 5, 16, 8, 4, 2, 1.
-- * Empezando en n = 11 se obtiene: 11, 34, 17, 52, 26, 13, 40, 20,
-- 10, 5, 16, 8, 4, 2, 1.
-- * Empezando en n = 27, la sucesión tiene 112 pasos, llegando hasta
-- 9232 antes de descender a 1: 27, 82, 41, 124, 62, 31, 94, 47,
-- 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274,
-- 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263,
-- 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502,
-- 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958,
-- 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644,
-- 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308,
-- 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122,
-- 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5,
-- 16, 8, 4, 2, 1.
--
-- Definir la función
-- siguiente :: Integer -> Integer
-- tal que (siguiente n) es el siguiente de n en la sucesión de
-- Collatz. Por ejemplo,
-- siguiente 13 == 40
-- siguiente 40 == 20
-- ---------------------------------------------------------------------

-- Elsa Domínguez
siguiente :: Integer -> Integer
siguiente n = if even n then div n 2 else n*3 + 1

-- ---------------------------------------------------------------------
-- Ejercicio 6.2. Definir, por recursión, la función
-- collatzR :: Integer -> [Integer]
-- tal que (collatzR n) es la órbita de CollatzR de n hasta alcanzar el
-- 1. Por ejemplo,
-- collatzR 13 == [13,40,20,10,5,16,8,4,2,1]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
collatzR :: Integer -> [Integer]
collatzR 1 = [1]
collatzR n = n : collatzR (siguiente n)

-- ---------------------------------------------------------------------
-- Ejercicio 6.3. Definir, sin recursión y con iterate, la función
-- collatz :: Integer -> [Integer]
-- tal que (collatz n) es la órbita de Collatz d n hasta alcanzar el
-- 1. Por ejemplo,
-- collatz 13 == [13,40,20,10,5,16,8,4,2,1]
-- Indicación: Usar takeWhile e iterate.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
collatz :: Integer -> [Integer]
collatz n = takeWhile (/=1) (iterate siguiente n) ++ [1]

-- ---------------------------------------------------------------------
-- Ejercicio 6.4. Definir la función
-- menorCollatzMayor :: Int -> Integer
-- tal que (menorCollatzMayor x) es el menor número cuya órbita de
-- Collatz tiene más de x elementos. Por ejemplo,
-- menorCollatzMayor 100 == 27
-- ---------------------------------------------------------------------

-- Elsa Domínguez
menorCollatzMayor :: Int -> Integer
menorCollatzMayor x = head [n | n <- [1..], length (collatz n) > x]

-- ---------------------------------------------------------------------
-- Ejercicio 6.5. Definir la función
-- menorCollatzSupera :: Integer -> Integer
-- tal que (menorCollatzSupera x) es el menor número cuya órbita de
-- Collatz tiene algún elemento mayor que x. Por ejemplo,
-- menorCollatzSupera 100 == 15
-- ---------------------------------------------------------------------

-- Elsa Domínguez
menorCollatzSupera :: Integer -> Integer
menorCollatzSupera x = head [n | n <- [1..], any (>x) (collatz n)]

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir, usando takeWhile y map, la función
-- potenciasMenores :: Int -> Int -> [Int]
-- tal que (potenciasMenores x y) es la lista de las potencias de x
-- menores que y. Por ejemplo,
-- potenciasMenores 2 1000 == [2,4,8,16,32,64,128,256,512]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
potenciasMenores :: Int -> Int -> [Int]
potenciasMenores x y = takeWhile (<y) (map (x^) [1..])

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir, usando la criba de Eratóstenes, la constante
-- primos :: Integral a => [a]
-- cuyo valor es la lista de los números primos. Por ejemplo,
-- take 10 primos == [2,3,5,7,11,13,17,19,23,29]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
primos :: Integral a => [a]
primos = criba [2..]

criba (p:xs) = p : criba [x | x <- xs, x `mod` p /= 0]

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir, usando primos, la función
-- primo :: Integral a => a -> Bool
-- tal que (primo n) se verifica si n es primo. Por ejemplo,
-- primo 7 == True
-- primo 9 == False
-- ---------------------------------------------------------------------

-- Elsa Domínguez
primo :: Int -> Bool
primo n = last (takeWhile (<=n) primos) == n

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Definir la función
-- sumaDeDosPrimos :: Int -> [(Int,Int)]
-- tal que (sumaDeDosPrimos n) es la lista de las distintas
-- descomposiciones de n como suma de dos números primos. Por ejemplo,
-- sumaDeDosPrimos 30 == [(7,23),(11,19),(13,17)]
-- sumaDeDosPrimos 10 == [(3,7),(5,5)]
-- Calcular, usando la función sumaDeDosPrimos, el menor número que
-- puede escribirse de 10 formas distintas como suma de dos primos.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
sumaDeDosPrimos :: Int -> [(Int,Int)]
sumaDeDosPrimos n = [(x,n-x) | x <- [2..div n 2], primo x, primo (n-x)]

-- El cálculo es head [n | n <- [4..], length (sumaDeDosPrimos n) == 10]
-- 114

-- ---------------------------------------------------------------------
-- § La lista infinita de factoriales --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 9.1. Definir, por comprensión, la función
-- factoriales1 :: [Integer]
-- tal que factoriales1 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales1 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales1 :: [Integer]
factoriales1 = [factorial n | n <- [0..]]

factorial n = product [1..n]

-- ---------------------------------------------------------------------
-- Ejercicio 9.2. Definir, usando zipWith, la función
-- factoriales2 :: [Integer]
-- tal que factoriales2 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales2 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales2 :: [Integer]
factoriales2 = 1 : zipWith (*) [1..] factoriales2

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Definir, por recursión, la función
-- factoriales3 :: [Integer]
-- tal que factoriales3 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales3 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

factoriales3 :: [Integer]
factoriales3 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 9.4. Definir, usando scanl1, la función
-- factoriales4 :: [Integer]
-- tal que factoriales4 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales4 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
factoriales4 :: [Integer]
factoriales4 = 1 : scanl1 (*) [1..]

-- ---------------------------------------------------------------------
-- Ejercicio 9.5. Definir, usando iterate, la función
-- factoriales5 :: [Integer]
-- tal que factoriales5 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales5 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

factoriales5 :: [Integer]
factoriales5 = undefined

-- ---------------------------------------------------------------------
-- § La sucesión de Fibonacci --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 10.1. La sucesión de Fibonacci está definida por
-- f(0) = 0
-- f(1) = 1
-- f(n) = f(n-1)+f(n-2), si n > 1.
--
-- Definir la función
-- fib :: Integer -> Integer
-- tal que (fib n) es el n-ésimo término de la sucesión de Fibonacci.
-- Por ejemplo,
-- fib 8 == 21
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fib :: Integer -> Integer
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

-- ---------------------------------------------------------------------
-- Ejercicio 10.2. Definir, por comprensión, la función
-- fibs1 :: [Integer]
-- tal que fibs1 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs1 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fibs1 :: [Integer]
fibs1 = [fib n | n <- [0..]]

-- ---------------------------------------------------------------------
-- Ejercicio 10.3. Definir, por recursión, la función
-- fibs2 :: [Integer]
-- tal que fibs2 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs2 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

fibs2 :: [Integer]
fibs2 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 10.4. Definir, por recursión con zipWith, la función
-- fibs3 :: [Integer]
-- tal que fibs3 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs3 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fibs3 :: [Integer]
fibs3 = 0 : 1 : zipWith (+) fibs3 (tail fibs3)

-- ---------------------------------------------------------------------
-- Ejercicio 10.5. Definir, por recursión con acumuladores, la función
-- fibs4 :: [Integer]
-- tal que fibs4 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs4 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
fibs4 :: [Integer]
fibs4 = aux 0 1
where aux x y = x : aux y (x+y)

-- ---------------------------------------------------------------------
-- § El triángulo de Pascal --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 11.1. El triángulo de Pascal es un triángulo de números
-- 1
-- 1 1
-- 1 2 1
-- 1 3 3 1
-- 1 4 6 4 1
-- 1 5 10 10 5 1
-- ...............
-- construido de la siguiente forma
-- * la primera fila está formada por el número 1;
-- * las filas siguientes se construyen sumando los números adyacentes
-- de la fila superior y ańadiendo un 1 al principio y al final de la
-- fila.
--
-- Definir, con iterate y zipWith, la función
-- pascal1 :: [[Integer]]
-- tal que pascal es la lista de las líneas del triángulo de Pascal. Por
-- ejemplo,
-- ghci> take 6 pascal1
-- [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1],[1,5,10,10,5,1]]
-- ---------------------------------------------------------------------

pascal1 :: [[Integer]]
pascal1 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 11.2. Definir, con map y zipWith, la función
-- pascal2 :: [[Integer]]
-- tal que pascal es la lista de las líneas del triángulo de Pascal. Por
-- ejemplo,
-- ghci> take 6 pascal2
-- [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1],[1,5,10,10,5,1]]
-- ---------------------------------------------------------------------

-- 2ª definición (con map):
pascal2 :: [[Integer]]
pascal2 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 11.3. Escribir la traza del cálculo de la expresión
-- take 4 pascal2
-- ---------------------------------------------------------------------

</source>

Relación 11

2021-12-16T19:11:37Z

Elsdomgon:

<source lang='haskell'>

-- I1M 2021-22: Rel_11.hs (17 de diciembre de 2021)
-- Evaluación perezosa y listas infinitas.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

-- En esta relación se presentan ejercicios con listas infinitas y
-- evaluación perezosa. Estos ejercicios corresponden al tema 10 cuyas
-- transparencias se encuentran en
-- https://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-10.html

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

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1.1. Definir, por recursión, la función
-- repite :: a -> [a]
-- tal que (repite x) es la lista infinita cuyos elementos son x. Por
-- ejemplo,
-- repite 5 == [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,...
-- take 3 (repite 5) == [5,5,5]
--
-- Nota: La función repite es equivalente a la función repeat definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repite :: a -> [a]
repite x = [x] ++ repite x

-- ---------------------------------------------------------------------
-- Ejercicio 1.2. Definir, por comprensión, la función
-- repiteC :: a -> [a]
-- tal que (repiteC x) es la lista infinita cuyos elementos son x. Por
-- ejemplo,
-- repiteC 5 == [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,...
-- take 3 (repiteC 5) == [5,5,5]
--
-- Nota: La función repiteC es equivalente a la función repeat definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteC :: a -> [a]
repiteC x = [x | _ <- [1..]]

-- ---------------------------------------------------------------------
-- Ejercicio 2.1. Definir, por recursión, la función
-- repiteFinitaR :: Int-> a -> [a]
-- tal que (repiteFinitaR n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinitaR 3 5 == [5,5,5]
--
-- Nota: La función repiteFinitaR es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinitaR :: Int -> a -> [a]
repiteFinitaR n x | n <= 0 = []
| otherwise = [x] ++ repiteFinitaR (n-1) x

-- ---------------------------------------------------------------------
-- Ejercicio 2.2. Definir, por comprensión, la función
-- repiteFinitaC :: Int-> a -> [a]
-- tal que (repiteFinitaC n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinitaC 3 5 == [5,5,5]
--
-- Nota: La función repiteFinitaC es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinitaC :: Int -> a -> [a]
repiteFinitaC n x = [x | _ <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 2.3. Definir, usando repite, la función
-- repiteFinita :: Int-> a -> [a]
-- tal que (repiteFinita n x) es la lista con n elementos iguales a
-- x. Por ejemplo,
-- repiteFinita 3 5 == [5,5,5]
--
-- Nota: La función repiteFinita es equivalente a la función replicate
-- definida en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
repiteFinita :: Int -> a -> [a]
repiteFinita n x = take n (repite x)

-- ---------------------------------------------------------------------
-- Ejercicio 2.4. Comprobar con QuickCheck que las funciones
-- repiteFinitaR, repiteFinitaC y repiteFinita son equivalentes a
-- replicate.
--
-- Nota. Al hacer la comprobación limitar el tamańo de las pruebas como
-- se indica a continuación
-- quickCheckWith (stdArgs {maxSize=7}) prop_repiteFinitaEquiv
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaEquiv :: Int -> Int -> Bool
prop_repiteFinitaEquiv n x = repiteFinitaR n x == replicate n x && repiteFinitaC n x == replicate n x && repiteFinita n x == replicate n x

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

-- ---------------------------------------------------------------------
-- Ejercicio 2.5. Comprobar con QuickCheck que la longitud de
-- (repiteFinita n x) es n, si n es positivo y 0 si no lo es.
--
-- Nota. Al hacer la comprobación limitar el tamańo de las pruebas como
-- se indica a continuación
-- quickCheckWith (stdArgs {maxSize=30}) prop_repiteFinitaLongitud
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaLongitud :: Int -> Int -> Bool
prop_repiteFinitaLongitud n x = if n > 0 then length (repiteFinita n x) == n else length (repiteFinita n x) == 0

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

-- ---------------------------------------------------------------------
-- Ejercicio 2.6. Comprobar con QuickCheck que todos los elementos de
-- (repiteFinita n x) son iguales a x.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
prop_repiteFinitaIguales :: Int -> Int -> Bool
prop_repiteFinitaIguales n x = all (==x) (repiteFinita n x)

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

-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Definir, por comprensión, la función
-- ecoC :: String -> String
-- tal que (ecoC xs) es la cadena obtenida a partir de la cadena xs
-- repitiendo cada elemento tantas veces como indica su posición: el
-- primer elemento se repite 1 vez, el segundo 2 veces y así
-- sucesivamente. Por ejemplo,
-- ecoC "abcd" == "abbcccdddd"
-- ---------------------------------------------------------------------

-- Elsa Domínguez
ecoC :: String -> String
ecoC xs = concat [replicate n x| (x,n) <- zip xs [1..]]

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Definir, por recursión, la función
-- ecoR :: String -> String
-- tal que (ecoR xs) es la cadena obtenida a partir de la cadena xs
-- repitiendo cada elemento tantas veces como indica su posición: el
-- primer elemento se repite 1 vez, el segundo 2 veces y así
-- sucesivamente. Por ejemplo,
-- ecoR "abcd" == "abbcccdddd"
-- ---------------------------------------------------------------------

ecoR :: String -> String
ecoR xs = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir, por recursión, la función
-- itera :: (a -> a) -> a -> [a]
-- tal que (itera f x) es la lista cuyo primer elemento es x y los
-- siguientes elementos se calculan aplicando la función f al elemento
-- anterior. Por ejemplo,
-- ghci> itera (+1) 3
-- [3,4,5,6,7,8,9,10,11,12,{Interrupted!}
-- ghci> itera (*2) 1
-- [1,2,4,8,16,32,64,{Interrupted!}
-- ghci> itera (`div` 10) 1972
-- [1972,197,19,1,0,0,0,0,0,0,{Interrupted!}
--
-- Nota: La función repite es equivalente a la función iterate definida
-- en el preludio de Haskell.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
itera :: (a -> a) -> a -> [a]
itera f x = x : itera f (f x)

-- ----------------------------------------------------------------------------
-- Ejercicio 5.1. Definir, por recursión, la función
-- agrupaR :: Int -> [a] -> [[a]]
-- tal que (agrupaR n xs) es la lista formada por listas de n elementos
-- consecutivos de la lista xs (salvo posiblemente la última que puede
-- tener menos de n elementos). Por ejemplo,
-- ghci> agrupaR 2 [3,1,5,8,2,7]
-- [[3,1],[5,8],[2,7]]
-- ghci> agrupaR 2 [3,1,5,8,2,7,9]
-- [[3,1],[5,8],[2,7],[9]]
-- ghci> agrupaR 5 "todo necio confunde valor y precio"
-- ["todo ","necio"," conf","unde ","valor"," y pr","ecio"]
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
agrupaR :: Int -> [a] -> [[a]]
agrupaR _ [] = []
agrupaR n xs = [take n xs] ++ agrupaR n (drop n xs)

-- ----------------------------------------------------------------------------
-- Ejercicio 5.2. Definir, de manera no recursiva con iterate, la función
-- agrupa :: Int -> [a] -> [[a]]
-- tal que (agrupa n xs) es la lista formada por listas de n elementos
-- consecutivos de la lista xs (salvo posiblemente la última que puede
-- tener menos de n elementos). Por ejemplo,
-- ghci> agrupa 2 [3,1,5,8,2,7]
-- [[3,1],[5,8],[2,7]]
-- ghci> agrupa 2 [3,1,5,8,2,7,9]
-- [[3,1],[5,8],[2,7],[9]]
-- ghci> agrupa 5 "todo necio confunde valor y precio"
-- ["todo ","necio"," conf","unde ","valor"," y pr","ecio"]
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
agrupa :: Int -> [a] -> [[a]]
agrupa n xs = takeWhile (not.null) (map (take n) (iterate (drop n) xs))

-- ----------------------------------------------------------------------------
-- Ejercicio 5.3. Comprobar con QuickCheck que todos los grupos de
-- (agrupa n xs) tienen longitud n (salvo el último que puede tener una
-- longitud menor).
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
-- La propiedad es
--prop_AgrupaLongitud :: Int -> [Int] -> Property
prop_AgrupaLongitud n xs = n>0 && not (null xs) ==> and [length ys == n | ys <- init (agrupa n xs)] && length (last (agrupa n xs)) <= n

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

-- ----------------------------------------------------------------------------
-- Ejercicio 5.4. Comprobar con QuickCheck que combinando todos los
-- grupos de ((agrupa n xs)) se obtiene la lista xs.
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
-- La segunda propiedad es
prop_AgrupaCombina :: Int -> [Int] -> Property
prop_AgrupaCombina n xs = n>0 ==> concat (agrupa n xs) == xs

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

-- ---------------------------------------------------------------------
-- Ejercicio 6.1. Sea la siguiente operación, aplicable a cualquier
-- número entero positivo:
-- * Si el número es par, se divide entre 2.
-- * Si el número es impar, se multiplica por 3 y se suma 1.
-- Dado un número cualquiera, podemos considerar su órbita, es decir,
-- las imágenes sucesivas al iterar la función. Por ejemplo, la órbita
-- de 13 es
-- 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1,...
-- Si observamos este ejemplo, la órbita de 13 es periódica, es decir,
-- se repite indefinidamente a partir de un momento dado). La conjetura
-- de Collatz dice que siempre alcanzaremos el 1 para cualquier número
-- con el que comencemos. Ejemplos:
-- * Empezando en n = 6 se obtiene 6, 3, 10, 5, 16, 8, 4, 2, 1.
-- * Empezando en n = 11 se obtiene: 11, 34, 17, 52, 26, 13, 40, 20,
-- 10, 5, 16, 8, 4, 2, 1.
-- * Empezando en n = 27, la sucesión tiene 112 pasos, llegando hasta
-- 9232 antes de descender a 1: 27, 82, 41, 124, 62, 31, 94, 47,
-- 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274,
-- 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263,
-- 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502,
-- 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958,
-- 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644,
-- 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308,
-- 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122,
-- 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5,
-- 16, 8, 4, 2, 1.
--
-- Definir la función
-- siguiente :: Integer -> Integer
-- tal que (siguiente n) es el siguiente de n en la sucesión de
-- Collatz. Por ejemplo,
-- siguiente 13 == 40
-- siguiente 40 == 20
-- ---------------------------------------------------------------------

-- Elsa Domínguez
siguiente :: Integer -> Integer
siguiente n = if even n then div n 2 else n*3 + 1

-- ---------------------------------------------------------------------
-- Ejercicio 6.2. Definir, por recursión, la función
-- collatzR :: Integer -> [Integer]
-- tal que (collatzR n) es la órbita de CollatzR de n hasta alcanzar el
-- 1. Por ejemplo,
-- collatzR 13 == [13,40,20,10,5,16,8,4,2,1]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
collatzR :: Integer -> [Integer]
collatzR 1 = [1]
collatzR n = n : collatzR (siguiente n)

-- ---------------------------------------------------------------------
-- Ejercicio 6.3. Definir, sin recursión y con iterate, la función
-- collatz :: Integer -> [Integer]
-- tal que (collatz n) es la órbita de Collatz d n hasta alcanzar el
-- 1. Por ejemplo,
-- collatz 13 == [13,40,20,10,5,16,8,4,2,1]
-- Indicación: Usar takeWhile e iterate.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
collatz :: Integer -> [Integer]
collatz n = takeWhile (/=1) (iterate siguiente n) ++ [1]

-- ---------------------------------------------------------------------
-- Ejercicio 6.4. Definir la función
-- menorCollatzMayor :: Int -> Integer
-- tal que (menorCollatzMayor x) es el menor número cuya órbita de
-- Collatz tiene más de x elementos. Por ejemplo,
-- menorCollatzMayor 100 == 27
-- ---------------------------------------------------------------------

-- Elsa Domínguez
menorCollatzMayor :: Int -> Integer
menorCollatzMayor x = head [n | n <- [1..], length (collatz n) > x]

-- ---------------------------------------------------------------------
-- Ejercicio 6.5. Definir la función
-- menorCollatzSupera :: Integer -> Integer
-- tal que (menorCollatzSupera x) es el menor número cuya órbita de
-- Collatz tiene algún elemento mayor que x. Por ejemplo,
-- menorCollatzSupera 100 == 15
-- ---------------------------------------------------------------------

-- Elsa Domínguez
menorCollatzSupera :: Integer -> Integer
menorCollatzSupera x = head [n | n <- [1..], any (>x) (collatz n)]

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir, usando takeWhile y map, la función
-- potenciasMenores :: Int -> Int -> [Int]
-- tal que (potenciasMenores x y) es la lista de las potencias de x
-- menores que y. Por ejemplo,
-- potenciasMenores 2 1000 == [2,4,8,16,32,64,128,256,512]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
potenciasMenores :: Int -> Int -> [Int]
potenciasMenores x y = takeWhile (<y) (map (x^) [1..])

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir, usando la criba de Eratóstenes, la constante
-- primos :: Integral a => [a]
-- cuyo valor es la lista de los números primos. Por ejemplo,
-- take 10 primos == [2,3,5,7,11,13,17,19,23,29]
-- ---------------------------------------------------------------------

-- Elsa Domínguez
primos :: Integral a => [a]
primos = criba [2..]

criba (p:xs) = p : criba [x | x <- xs, x `mod` p /= 0]

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir, usando primos, la función
-- primo :: Integral a => a -> Bool
-- tal que (primo n) se verifica si n es primo. Por ejemplo,
-- primo 7 == True
-- primo 9 == False
-- ---------------------------------------------------------------------

-- Elsa Domínguez
primo :: Int -> Bool
primo n = last (takeWhile (<=n) primos) == n

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Definir la función
-- sumaDeDosPrimos :: Int -> [(Int,Int)]
-- tal que (sumaDeDosPrimos n) es la lista de las distintas
-- descomposiciones de n como suma de dos números primos. Por ejemplo,
-- sumaDeDosPrimos 30 == [(7,23),(11,19),(13,17)]
-- sumaDeDosPrimos 10 == [(3,7),(5,5)]
-- Calcular, usando la función sumaDeDosPrimos, el menor número que
-- puede escribirse de 10 formas distintas como suma de dos primos.
-- ---------------------------------------------------------------------

-- Elsa Domínguez
sumaDeDosPrimos :: Int -> [(Int,Int)]
sumaDeDosPrimos n = [(x,n-x) | x <- [2..div n 2], primo x, primo (n-x)]

-- El cálculo es head [n | n <- [4..], length (sumaDeDosPrimos n) == 10]
-- 114

-- ---------------------------------------------------------------------
-- § La lista infinita de factoriales, --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 9.1. Definir, por comprensión, la función
-- factoriales1 :: [Integer]
-- tal que factoriales1 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales1 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

factoriales1 :: [Integer]
factoriales1 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 9.2. Definir, usando zipWith, la función
-- factoriales2 :: [Integer]
-- tal que factoriales2 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales2 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

factoriales2 :: [Integer]
factoriales2 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Definir, por recursión, la función
-- factoriales3 :: [Integer]
-- tal que factoriales3 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales3 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

factoriales3 :: [Integer]
factoriales3 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 9.4. Definir, usando scanl1, la función
-- factoriales4 :: [Integer]
-- tal que factoriales4 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales4 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

factoriales4 :: [Integer]
factoriales4 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 9.5. Definir, usando iterate, la función
-- factoriales5 :: [Integer]
-- tal que factoriales5 es la lista de los factoriales. Por ejemplo,
-- take 10 factoriales5 == [1,1,2,6,24,120,720,5040,40320,362880]
-- ---------------------------------------------------------------------

factoriales5 :: [Integer]
factoriales5 = undefined

-- ---------------------------------------------------------------------
-- § La sucesión de Fibonacci --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 10.1. La sucesión de Fibonacci está definida por
-- f(0) = 0
-- f(1) = 1
-- f(n) = f(n-1)+f(n-2), si n > 1.
--
-- Definir la función
-- fib :: Integer -> Integer
-- tal que (fib n) es el n-ésimo término de la sucesión de Fibonacci.
-- Por ejemplo,
-- fib 8 == 21
-- ---------------------------------------------------------------------

fib :: Integer -> Integer
fib = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 10.2. Definir, por comprensión, la función
-- fibs1 :: [Integer]
-- tal que fibs1 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs1 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

fibs1 :: [Integer]
fibs1 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 10.3. Definir, por recursión, la función
-- fibs2 :: [Integer]
-- tal que fibs2 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs2 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

fibs2 :: [Integer]
fibs2 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 10.4. Definir, por recursión con zipWith, la función
-- fibs3 :: [Integer]
-- tal que fibs3 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs3 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

fibs3 :: [Integer]
fibs3 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 10.5. Definir, por recursión con acumuladores, la función
-- fibs4 :: [Integer]
-- tal que fibs4 es la sucesión de Fibonacci. Por ejemplo,
-- take 10 fibs4 == [0,1,1,2,3,5,8,13,21,34]
-- ---------------------------------------------------------------------

fibs4 :: [Integer]
fibs4 = undefined

-- ---------------------------------------------------------------------
-- § El triángulo de Pascal --
-- ---------------------------------------------------------------------

-- ---------------------------------------------------------------------
-- Ejercicio 11.1. El triángulo de Pascal es un triángulo de números
-- 1
-- 1 1
-- 1 2 1
-- 1 3 3 1
-- 1 4 6 4 1
-- 1 5 10 10 5 1
-- ...............
-- construido de la siguiente forma
-- * la primera fila está formada por el número 1;
-- * las filas siguientes se construyen sumando los números adyacentes
-- de la fila superior y ańadiendo un 1 al principio y al final de la
-- fila.
--
-- Definir, con iterate y zipWith, la función
-- pascal1 :: [[Integer]]
-- tal que pascal es la lista de las líneas del triángulo de Pascal. Por
-- ejemplo,
-- ghci> take 6 pascal1
-- [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1],[1,5,10,10,5,1]]
-- ---------------------------------------------------------------------

pascal1 :: [[Integer]]
pascal1 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 11.2. Definir, con map y zipWith, la función
-- pascal2 :: [[Integer]]
-- tal que pascal es la lista de las líneas del triángulo de Pascal. Por
-- ejemplo,
-- ghci> take 6 pascal2
-- [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1],[1,5,10,10,5,1]]
-- ---------------------------------------------------------------------

-- 2ª definición (con map):
pascal2 :: [[Integer]]
pascal2 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 11.3. Escribir la traza del cálculo de la expresión
-- take 4 pascal2
-- ---------------------------------------------------------------------

</source>

Relación 9

2021-11-30T18:05:07Z

Elsdomgon:

<source lang='haskell'>

-- I1M 2021-22: Rel_9.hs (01 de diciembre de 2021)
-- Funciones de orden superior y definiciones por plegados (II)
-- Departamento de Ciencias de la Computación e Inteligencia Artificial
-- Universidad de Sevilla
-- ============================================================================

-- ============================================================================
-- Librerías auxiliares
-- ============================================================================
import Data.Char
import Data.List
-- El siguiente módulo hay que instalarlo:
--cabal install Primes
import Data.Numbers.Primes
-- ----------------------------------------------------------------------------
-- Ejercicio 1. Se considera la función
-- resultadoPos :: (a -> Integer) -> [a] -> [a]
-- tal que (resultadoPos f xs) es la lista de los elementos de la lista
-- xs tales que el valor de la función f sobre ellos es positivo. Por ejemplo,
-- resultadoPos head [[-1,2],[-9,4],[2,3]] == [[2,3]]
-- resultadoPos sum [[1,2],[9],[-8,3],[],[3,5]] == [[1,2],[9],[3,5]]
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...),
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- -----------------------------------------------------------------------------

-- Elsa Domínguez
resultadoPosC :: (a -> Integer) -> [a] -> [a]
resultadoPosC f xs = [x | x <- xs, f x > 0]

resultadoPosS :: (a -> Integer) -> [a] -> [a]
resultadoPosS f xs = filter g xs
where g x = f x > 0

resultadoPosR :: (a -> Integer) -> [a] -> [a]
resultadoPosR f [] = []
resultadoPosR f (x:xs) | f x > 0 = x : resultadoPosR f xs
| otherwise = resultadoPosR f xs

resultadoPosPR :: (a -> Integer) -> [a] -> [a]
resultadoPosPR f xs = foldr g [] xs
where g prim recu | f prim > 0 = prim : recu
| otherwise = recu

-- ----------------------------------------------------------------------------
-- Ejercicio 2. Se considera la función
-- intercala :: Int -> [Int] -> [Int]
-- tal que (intercala y xs) es la lista que resulta de intercalar el elemento
-- y delante de todos los elementos de la lista xs que sean menores que y.
-- Por ejemplo,
-- intercala 5 [1,2,6,3,7,9] == [5,1,5,2,6,5,3,7,9]
-- intercala 5 [6,7,9,8] == [6,7,9,8]
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
intercalaC :: Int -> [Int] -> [Int]
intercalaC y xs = concat [if x<y then [y,x] else [x] | x <- xs]

intercalaS :: Int -> [Int] -> [Int]
intercalaS y xs = concat (map f xs)
where f x = if x<y then [y,x] else [x]

intercalaR :: Int -> [Int] -> [Int]
intercalaR y [] = []
intercalaR y (x:xs) | x<y = [y,x] ++ intercalaR y xs
| x>y = [x] ++ intercalaR y xs

intercalaPR :: Int -> [Int] -> [Int]
intercalaPR y xs = foldr g [] xs
where g x recu | x<y = [y,x] ++ recu
| x>y = [x] ++ recu

intercalaA :: Int -> [Int] -> [Int]
intercalaA y xs = aux [] xs
where aux v [] = v
aux v (x:xs) | x<y = aux (v++[y,x]) xs
| otherwise = aux (v++[x]) xs

-- ----------------------------------------------------------------------------
-- Ejercicio 3. Se considera la función
-- dec2ent :: [Integer] -> Integer
-- tal que (dec2ent xs) es el número entero cuyas cifras ordenadas son los
-- elementos de la lista xs. Por ejemplo,
-- dec2ent [2,3,4,5] == 2345
-- dec2ent [1..9] == 123456789
--
-- Defie esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

--José Manuel García
dec2ent1 :: [Integer] -> Integer
dec2ent1 xs = read (concat [show x| x <- (sort xs)]) :: Integer

dec2ent2 :: [Integer] -> Integer
dec2ent2 xs = read (concat (map show (sort xs))) :: Integer

dec2ent3 :: [Integer] -> Integer
dec2ent3Aux :: Show a => [a] -> [Char]
dec2ent3Aux [] = []
dec2ent3Aux (x:xs) = (show x) ++ (dec2ent3Aux xs)
dec2ent3 xs = read (dec2ent3Aux (sort xs)) :: Integer

dec2ent4 :: [Integer] -> Integer
dec2ent4 xs = read (concat (foldr f [] (sort xs))) :: Integer
where f prim recu = show prim :recu

-- Elsa Domínguez
dec2entC :: [Integer] -> Integer
dec2entC xs = sum [x*10^i | (x,i) <- zip xs (reverse [0..length xs-1])]

dec2entS :: [Integer] -> Integer
dec2entS xs = sum (map f xs)
where f x = x*10^(length (dropWhile (/=x) xs) -1)

dec2entR :: [Integer] -> Integer
dec2entR [] = 0
dec2entR (x:xs) = x*10^(length xs) + dec2entR xs

dec2entPR :: [Integer] -> Integer
dec2entPR xs = foldr f 0 xs
where f x recu = x*10^(length (dropWhile (/=x) xs) -1) + recu

-- ----------------------------------------------------------------------------
-- Ejercicio 4. Se considera 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, el conjunto de los elementos de la lista xs que no se
-- encuentran en la lista ys. Por ejemplo,
-- diferencia [2,3,5,6] [5,2,7] == [3,6]
-- diferencia [1,3,5,7] [2,4,6] == [1,3,5,7]
-- diferencia [1,3] [1..9] == []
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
diferenciaC :: Eq a => [a] -> [a] -> [a]
diferenciaC xs ys = [x | x <- xs, notElem x ys]

diferenciaS :: Eq a => [a] -> [a] -> [a]
diferenciaS xs ys = concat (map f xs)
where f x | notElem x ys = [x]
| otherwise = []

diferenciaR :: Eq a => [a] -> [a] -> [a]
diferenciaR [] _ = []
diferenciaR (x:xs) ys | notElem x ys = [x] ++ diferenciaR xs ys
| otherwise = diferenciaR xs ys

diferenciaPR :: Eq a => [a] -> [a] -> [a]
diferenciaPR xs ys = foldr g [] xs
where g x recu | notElem x ys = [x] ++ recu
| otherwise = recu

--José Manuel García
diferencia1 :: Eq a => [a] -> [a] -> [a]
diferencia1 xs ys = [x | x <- xs, not (elem x ys) ] -- ++ [y | y <- ys, not (elem y xs) ]

diferencia2 :: Eq a => [a] -> [a] -> [a]
diferencia2 (x:xs) ys = filter f (x:xs)
where f a = not (elem a ys)

diferencia3 :: Eq a => [a] -> [a] -> [a]
diferencia3 [] _ = []
diferencia3 (x:xs) ys | not (elem x ys) = x : (diferencia3 xs ys)
| otherwise = (diferencia3 xs ys)

diferencia4 :: Eq a => [a] -> [a] -> [a]
diferencia4 (x:xs) ys = foldr f [] (x:xs)
where f prim recu | not (elem prim ys) = prim : recu
| otherwise = recu

-- ----------------------------------------------------------------------------
-- Ejercicio 5. Se considera la función
-- primerosYultimos :: [[a]] -> ([a],[a])
-- tal que (primerosYultimos xss) es el par formado por la lista de los
-- primeros elementos de las listas no vacías de xss y la lista de los
-- últimos elementos de las listas no vacías de xss. Por ejemplo,
-- primerosYultimos [[1,2],[5,3,4],[],[9]] == ([1,5,9],[2,4,9])
-- primerosYultimos [[1,2],[1,2,3],[1..4]] == ([1,1,1],[2,3,4])

--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

--José Manuel García
primerosYultimos1 :: [[a]] -> ([a], [a])
primerosYultimos1 xss = ([head x | x <- xss, not (null x)], [last x | x <- xss, not (null x)])

noVacios :: Foldable t => [t a] -> [t a]
noVacios xss = filter (not.null) xss
primerosYultimos2 :: [[a]] -> ([a], [a])
primerosYultimos2 xss = (map head (noVacios xss), map last (noVacios xss))

primeros3 :: [[a]] -> [a]
primeros3 [] = []
primeros3 (xs:xss) | not (null xs) = (head xs) : (primeros3 xss)
| otherwise = (primeros3 xss)
ultimos3 :: [[a]] -> [a]
ultimos3 [] = []
ultimos3 (xs:xss) | not (null xs) = (last xs) : (ultimos3 xss)
| otherwise = (ultimos3 xss)
primerosYultimos3 :: [[a]] -> ([a], [a])
primerosYultimos3 xss = (primeros3 xss, ultimos3 xss )

primeros4 :: Foldable t => t [a] -> [a]
primeros4 xss = foldr p4 [] xss
where p4 prim recu | not (null prim) = head prim : recu
| otherwise = recu
ultimos4 :: Foldable t => t [a] -> [a]
ultimos4 xss = foldr u4 [] xss
where u4 prim recu | not (null prim) = last prim : recu
| otherwise = recu
primerosYultimos4 :: [[a]] -> ([a], [a])
primerosYultimos4 xss = (primeros4 xss, ultimos4 xss)

-- Elsa Domínguez
primerosYultimosC :: [[a]] -> ([a],[a])
primerosYultimosC xss = (concat [(take 1 xs) | xs <- xss], concat [take 1 (reverse xs) | xs <- xss])

primerosYultimosS :: [[a]] -> ([a],[a])
primerosYultimosS xss = (concat (map (take 1) xss), concat (map (take 1) (map reverse xss)))

primerosYultimosR :: [[a]] -> ([a],[a])
primerosYultimosR xss = (primerosR xss, ultimosR xss)

primerosR [] = []
primerosR (xs:xss) | null xs = primerosR xss
| otherwise = [head xs] ++ primerosR xss
ultimosR [] = []
ultimosR (xs:xss) | null xs = ultimosR xss
| otherwise = [last xs] ++ ultimosR xss

primerosYultimosPR :: [[a]] -> ([a],[a])
primerosYultimosPR xss = (primerosPR xss, ultimosPR xss)

primerosPR xss = foldr f [] xss
where f x recu | null x = recu
| otherwise = [head x] ++ recu
ultimosPR xss = foldr f [] xss
where f x recu | null x = recu
| otherwise = [last x] ++ recu

-- ----------------------------------------------------------------------------
-- Ejercicio 6. Una lista hermanada es una lista de números estrictamente
-- positivos en la que cada elemento tiene algún factor primo en común con el
-- siguiente, en caso de que exista, o alguno de los dos es un 1. Por ejemplo,
-- [2,6,3,9,1,5] es una lista hermanada.

-- Se considera la función
-- hermanada :: [Int] -> Bool
-- tal que (hermanada xs) comprueba que la lista xs es hermanada según la
-- definición anterior. Por ejemplo,
-- hermanada [2,6,3,9,1,5] == True
-- hermanada [2,3,5] == False
--
-- Se pide definir esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------
-- Nota: Usa la función 'gcd'
-- ----------------------------------------------------------------------------

--José Manuel García
primo1 :: Integral a => a -> Bool
primo1 x = [1,x]==[a| a<- [1..x], rem x a == 0] -- Me dice si un número es primo
hermanada1 :: [Int] -> Bool
hermanada1 xs = sum [1 | (a,b) <- (zip xs (tail xs)), (if ((a/=1) && (b/=1))
then ((gcd a b /= 1) && (primo1 (gcd a b)))
else True),
a>0, b>0 ] == (length xs) -1
-- a,b > 0 porque tienen que ser extrictamente positivos
-- ((length xs) - 1) == length (zip xs (tail xs))

primo2 :: Integral a => a -> Bool
primo2 x = filter p2 [1..x] == [1,x]
where p2 b = (rem x b == 0)
hermanada2 :: [Int] -> Bool
hermanada2 xs = and (map prop2 (zip xs (tail xs)))
where prop2 (a,b) = if a>0 && b>0
then (if ((a/=1) && (b/=1)) then ((gcd a b /= 1) && (primo2 (gcd a b))) else True)
else False

primo3 :: Integral a => a -> Bool
primo3 n = noHayNumerosDivisoresDe n 2 (n - 1)
noHayNumerosDivisoresDe :: Integral t => t -> t -> t -> Bool
noHayNumerosDivisoresDe n minimo maximo | minimo >= maximo = True
| rem n minimo == 0 = False
| otherwise = noHayNumerosDivisoresDe n (minimo + 1) maximo
hermanada3 :: [Int] -> Bool
hermanada3 [b] = True
hermanada3 (a:b:xs) = (if ((a/=1) && (b/=1)) then ((gcd a b /= 1) && (primo2 (gcd a b))) else True)
&& hermanada3 (b:xs)

hermanada4 xs = undefined

-- ----------------------------------------------------------------------------
-- Ejercicio 7. Un elemento de una lista es permanente si ninguno de los que
-- vienen a continuación en la lista es mayor que él. Consideramos la función
-- permanentes :: [Int] -> [Int]
-- tal que (permanentes xs) es la lista de los elementos permanentes de la
-- lista xs. Por ejemplo,
-- permanentes [80,1,7,8,4] == [80,8,4]

-- Se pide definir esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ---------------------------------------------------------------------------
-- Nota: Usa la función 'tails' de Data.List.
-- ----------------------------------------------------------------------------

--José Manuel García
permanentes1 :: [Int] -> [Int]
permanentes1 xs = [a | (a,b) <- (zip xs (init (tails xs))), a == maximum b ]

permanentes2 :: [Int] -> [Int]
permanentes2 xs = map head (filter p2 (init (tails xs)))
where p2 (x:xs) = x == maximum (x:xs)

comparacion3 :: Ord a => [a] -> [a] -> Bool
comparacion3 a [] = True
comparacion3 a b = a >= b
permanentes3 :: [Int] -> [Int]
permanentes3 [] = []
permanentes3 (x:xs) | [x] `comparacion3` [maximum3 xs] = x : permanentes3 xs
| otherwise = permanentes3 xs
where maximum3 [] = if x < 0 then x else -x
maximum3 xs = maximum xs

permanentes4:: [Int] -> [Int]
permanentes4 (x:xs) = foldr f4 [] (x:xs)
where f4 prim recu | [prim] `comparacion3` [maximum3 recu] = prim : recu
| otherwise = recu
maximum3 [] = if x < 0 then x else -x
maximum3 xs = maximum xs

-- Elsa Domínguez
permanentesC :: [Int] -> [Int]
permanentesC xs = [x | (x, xs') <- zip xs (tails (drop 1 xs)), xs' == [] || x >= maximum xs']

permanentesS :: [Int] -> [Int]
permanentesS xs = filter p xs
where p x = x == maximum (dropWhile (/=x) xs)

permanentesR :: [Int] -> [Int]
permanentesR [] = []
permanentesR [x] = [x]
permanentesR (x:xs) | x >= maximum xs = [x] ++ permanentesR xs
| otherwise = permanentesR xs

permanentesPR :: [Int] -> [Int]
permanentesPR (x:xs) = foldr f [] (x:xs)
where f x recu | x >= maximum' (dropWhile (/=x) xs) = [x] ++ recu
| otherwise = recu
maximum' xs | null xs = 0
| otherwise = maximum xs

-- ---------------------------------------------------------------------
-- Ejercicio 8. Un número entero positivo n es muy primo si es n primo
-- y todos los números que resultan de ir suprimimiendo la última cifra
-- también son primos. Por ejemplo, 7193 es muy primo pues los números
-- 7193, 719, 71 y 7 son todos primos.
--
-- Define la función
-- muyPrimo :: Integer -> Bool
-- que (muyPrimo n) se verifica si n es muy primo. Por ejemplo,
-- muyPrimo 7193 == True
-- muyPrimo 71932 == False
-- --------------------------------------------------------------------

--José Manuel García
esPrimo :: Integral a => a -> Bool
esPrimo x = filter p2 [1..x] == [1,x]
where p2 b = (rem x b == 0)
muyPrimo :: Integer -> Bool
muyPrimo n | esPrimo n = length (show n) == sum [1 | a <- (descomposicion n), esPrimo (read a :: Integer) ]
| otherwise = False
where descomposicion n = [reverse x | x <- (init(tails (reverse (show n))))]
-- Elsa Domínguez
muyPrimo' :: Integer -> Bool
muyPrimo' n = and (map isPrime (lista n))
lista n = [read a :: Integer | a <- tail (inits (show n))]

-- ---------------------------------------------------------------------
-- ¿Cuántos números de cinco cifras son muy primos?
-- ---------------------------------------------------------------------

-- El cálculo es

--José Manuel García
calculoMuyPrimo = sum [1 | x <- [10000..99999], muyPrimo x] -- Tras unos minutos, sale 15.
-- Elsa Domínguez
muyPrimos5cifras = sum [1 | x <- [10000..99999], muyPrimo' x] -- Sale 15

-- ---------------------------------------------------------------------

</source>

Relación 9

2021-11-29T19:56:57Z

Elsdomgon:

<source lang='haskell'>

-- I1M 2021-22: Rel_9.hs (01 de diciembre de 2021)
-- Funciones de orden superior y definiciones por plegados (II)
-- Departamento de Ciencias de la Computación e Inteligencia Artificial
-- Universidad de Sevilla
-- ============================================================================

-- ============================================================================
-- Librerías auxiliares
-- ============================================================================
import Data.Char
import Data.List
-- El siguiente módulo hay que instalarlo:
--cabal install Primes
import Data.Numbers.Primes
-- ----------------------------------------------------------------------------
-- Ejercicio 1. Se considera la función
-- resultadoPos :: (a -> Integer) -> [a] -> [a]
-- tal que (resultadoPos f xs) es la lista de los elementos de la lista
-- xs tales que el valor de la función f sobre ellos es positivo. Por ejemplo,
-- resultadoPos head [[-1,2],[-9,4],[2,3]] == [[2,3]]
-- resultadoPos sum [[1,2],[9],[-8,3],[],[3,5]] == [[1,2],[9],[3,5]]
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...),
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- -----------------------------------------------------------------------------

-- Elsa Domínguez
resultadoPosC :: (a -> Integer) -> [a] -> [a]
resultadoPosC f xs = [x | x <- xs, f x > 0]

resultadoPosS :: (a -> Integer) -> [a] -> [a]
resultadoPosS f xs = filter g xs
where g x = f x > 0
resultadoPosS1 :: (a -> Integer) -> [a] -> [a]
resultadoPosS1 f xs = filter (\ x -> f x > 0) xs

resultadoPosR :: (a -> Integer) -> [a] -> [a]
resultadoPosR f [] = []
resultadoPosR f (x:xs) | f x > 0 = x : resultadoPosR f xs
| otherwise = resultadoPosR f xs

resultadoPosPR :: (a -> Integer) -> [a] -> [a]
resultadoPosPR f xs = foldr g [] xs
where g prim recu | f prim > 0 = prim : recu
| otherwise = recu

-- ----------------------------------------------------------------------------
-- Ejercicio 2. Se considera la función
-- intercala :: Int -> [Int] -> [Int]
-- tal que (intercala y xs) es la lista que resulta de intercalar el elemento
-- y delante de todos los elementos de la lista xs que sean menores que y.
-- Por ejemplo,
-- intercala 5 [1,2,6,3,7,9] == [5,1,5,2,6,5,3,7,9]
-- intercala 5 [6,7,9,8] == [6,7,9,8]
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
intercalaC :: Int -> [Int] -> [Int]
intercalaC y xs = concat [if x<y then [y,x] else [x] | x <- xs]

intercalaS :: Int -> [Int] -> [Int]
intercalaS y xs = concat (map f xs)
where f x = if x<y then [y,x] else [x]

intercalaR :: Int -> [Int] -> [Int]
intercalaR y [] = []
intercalaR y (x:xs) | x<y = [y,x] ++ intercalaR y xs
| x>y = [x] ++ intercalaR y xs

intercalaPR :: Int -> [Int] -> [Int]
intercalaPR y xs = foldr g [] xs
where g x recu | x<y = [y,x] ++ recu
| x>y = [x] ++ recu

intercalaA :: Int -> [Int] -> [Int]
intercalaA y xs = aux [] xs
where aux v [] = v
aux v (x:xs) | x<y = aux (v++[y,x]) xs
| otherwise = aux (v++[x]) xs

-- ----------------------------------------------------------------------------
-- Ejercicio 3. Se considera la función
-- dec2ent :: [Integer] -> Integer
-- tal que (dec2ent xs) es el número entero cuyas cifras ordenadas son los
-- elementos de la lista xs. Por ejemplo,
-- dec2ent [2,3,4,5] == 2345
-- dec2ent [1..9] == 123456789
--
-- Defie esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

--José Manuel García
dec2ent1 :: [Integer] -> Integer
dec2ent1 xs = read (concat [show x| x <- (sort xs)]) :: Integer

dec2ent2 :: [Integer] -> Integer
dec2ent2 xs = read (concat (map show (sort xs))) :: Integer

dec2ent3 :: [Integer] -> Integer
dec2ent3Aux :: Show a => [a] -> [Char]
dec2ent3Aux [] = []
dec2ent3Aux (x:xs) = (show x) ++ (dec2ent3Aux xs)
dec2ent3 xs = read (dec2ent3Aux (sort xs)) :: Integer

dec2ent4 :: [Integer] -> Integer
dec2ent4 xs = read (concat (foldr f [] (sort xs))) :: Integer
where f prim recu = show prim :recu

-- Elsa Domínguez
dec2entC :: [Integer] -> Integer
dec2entC xs = sum [x*10^i | (x,i) <- zip xs (reverse [0..length xs-1])]

dec2entS :: [Integer] -> Integer
dec2entS xs = sum (map f xs)
where f x = x*10^(length (dropWhile (/=x) xs) -1)

dec2entR :: [Integer] -> Integer
dec2entR [] = 0
dec2entR (x:xs) = x*10^(length xs) + dec2entR xs

dec2entPR :: [Integer] -> Integer
dec2entPR xs = foldr f 0 xs
where f x recu = x*10^(length (dropWhile (/=x) xs) -1) + recu

-- ----------------------------------------------------------------------------
-- Ejercicio 4. Se considera 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, el conjunto de los elementos de la lista xs que no se
-- encuentran en la lista ys. Por ejemplo,
-- diferencia [2,3,5,6] [5,2,7] == [3,6]
-- diferencia [1,3,5,7] [2,4,6] == [1,3,5,7]
-- diferencia [1,3] [1..9] == []
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
diferenciaC :: Eq a => [a] -> [a] -> [a]
diferenciaC xs ys = [x | x <- xs, notElem x ys]

diferenciaS :: Eq a => [a] -> [a] -> [a]
diferenciaS xs ys = concat (map f xs)
where f x | notElem x ys = [x]
| otherwise = []

diferenciaR :: Eq a => [a] -> [a] -> [a]
diferenciaR [] _ = []
diferenciaR (x:xs) ys | notElem x ys = [x] ++ diferenciaR xs ys
| otherwise = diferenciaR xs ys

diferenciaPR :: Eq a => [a] -> [a] -> [a]
diferenciaPR xs ys = foldr g [] xs
where g x recu | notElem x ys = [x] ++ recu
| otherwise = recu

--José Manuel García
diferencia1 :: Eq a => [a] -> [a] -> [a]
diferencia1 xs ys = [x | x <- xs, not (elem x ys) ] -- ++ [y | y <- ys, not (elem y xs) ]

diferencia2 :: Eq a => [a] -> [a] -> [a]
diferencia2 (x:xs) ys = filter f (x:xs)
where f a = not (elem a ys)

diferencia3 :: Eq a => [a] -> [a] -> [a]
diferencia3 [] _ = []
diferencia3 (x:xs) ys | not (elem x ys) = x : (diferencia3 xs ys)
| otherwise = (diferencia3 xs ys)

diferencia4 :: Eq a => [a] -> [a] -> [a]
diferencia4 (x:xs) ys = foldr f [] (x:xs)
where f prim recu | not (elem prim ys) = prim : recu
| otherwise = recu

-- ----------------------------------------------------------------------------
-- Ejercicio 5. Se considera la función
-- primerosYultimos :: [[a]] -> ([a],[a])
-- tal que (primerosYultimos xss) es el par formado por la lista de los
-- primeros elementos de las listas no vacías de xss y la lista de los
-- últimos elementos de las listas no vacías de xss. Por ejemplo,
-- primerosYultimos [[1,2],[5,3,4],[],[9]] == ([1,5,9],[2,4,9])
-- primerosYultimos [[1,2],[1,2,3],[1..4]] == ([1,1,1],[2,3,4])

--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

--José Manuel García
primerosYultimos1 :: [[a]] -> ([a], [a])
primerosYultimos1 xss = ([head x | x <- xss, not (null x)], [last x | x <- xss, not (null x)])

noVacios :: Foldable t => [t a] -> [t a]
noVacios xss = filter (not.null) xss
primerosYultimos2 :: [[a]] -> ([a], [a])
primerosYultimos2 xss = (map head (noVacios xss), map last (noVacios xss))

primeros3 :: [[a]] -> [a]
primeros3 [] = []
primeros3 (xs:xss) | not (null xs) = (head xs) : (primeros3 xss)
| otherwise = (primeros3 xss)
ultimos3 :: [[a]] -> [a]
ultimos3 [] = []
ultimos3 (xs:xss) | not (null xs) = (last xs) : (ultimos3 xss)
| otherwise = (ultimos3 xss)
primerosYultimos3 :: [[a]] -> ([a], [a])
primerosYultimos3 xss = (primeros3 xss, ultimos3 xss )

primeros4 :: Foldable t => t [a] -> [a]
primeros4 xss = foldr p4 [] xss
where p4 prim recu | not (null prim) = head prim : recu
| otherwise = recu
ultimos4 :: Foldable t => t [a] -> [a]
ultimos4 xss = foldr u4 [] xss
where u4 prim recu | not (null prim) = last prim : recu
| otherwise = recu
primerosYultimos4 :: [[a]] -> ([a], [a])
primerosYultimos4 xss = (primeros4 xss, ultimos4 xss)

-- Elsa Domínguez
primerosYultimosC :: [[a]] -> ([a],[a])
primerosYultimosC xss = (concat [(take 1 xs) | xs <- xss], concat [take 1 (reverse xs) | xs <- xss])

primerosYultimosS :: [[a]] -> ([a],[a])
primerosYultimosS xss = (concat (map (take 1) xss), concat (map (take 1) (map reverse xss)))

primerosYultimosR :: [[a]] -> ([a],[a])
primerosYultimosR xss = (primerosR xss, ultimosR xss)

primerosR [] = []
primerosR (xs:xss) | null xs = primerosR xss
| otherwise = [head xs] ++ primerosR xss
ultimosR [] = []
ultimosR (xs:xss) | null xs = ultimosR xss
| otherwise = [last xs] ++ ultimosR xss

primerosYultimosPR :: [[a]] -> ([a],[a])
primerosYultimosPR xss = (primerosPR xss, ultimosPR xss)

primerosPR xss = foldr f [] xss
where f x recu | null x = recu
| otherwise = [head x] ++ recu
ultimosPR xss = foldr f [] xss
where f x recu | null x = recu
| otherwise = [last x] ++ recu

-- ----------------------------------------------------------------------------
-- Ejercicio 6. Una lista hermanada es una lista de números estrictamente
-- positivos en la que cada elemento tiene algún factor primo en común con el
-- siguiente, en caso de que exista, o alguno de los dos es un 1. Por ejemplo,
-- [2,6,3,9,1,5] es una lista hermanada.

-- Se considera la función
-- hermanada :: [Int] -> Bool
-- tal que (hermanada xs) comprueba que la lista xs es hermanada según la
-- definición anterior. Por ejemplo,
-- hermanada [2,6,3,9,1,5] == True
-- hermanada [2,3,5] == False
--
-- Se pide definir esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------
-- Nota: Usa la función 'gcd'
-- ----------------------------------------------------------------------------

--José Manuel García
primo1 :: Integral a => a -> Bool
primo1 x = [1,x]==[a| a<- [1..x], rem x a == 0] -- Me dice si un número es primo
hermanada1 :: [Int] -> Bool
hermanada1 xs = sum [1 | (a,b) <- (zip xs (tail xs)), (if ((a/=1) && (b/=1))
then ((gcd a b /= 1) && (primo1 (gcd a b)))
else True),
a>0, b>0 ] == (length xs) -1
-- a,b > 0 porque tienen que ser extrictamente positivos
-- ((length xs) - 1) == length (zip xs (tail xs))

primo2 :: Integral a => a -> Bool
primo2 x = filter p2 [1..x] == [1,x]
where p2 b = (rem x b == 0)
hermanada2 :: [Int] -> Bool
hermanada2 xs = and (map prop2 (zip xs (tail xs)))
where prop2 (a,b) = if a>0 && b>0
then (if ((a/=1) && (b/=1)) then ((gcd a b /= 1) && (primo2 (gcd a b))) else True)
else False

primo3 :: Integral a => a -> Bool
primo3 n = noHayNumerosDivisoresDe n 2 (n - 1)
noHayNumerosDivisoresDe :: Integral t => t -> t -> t -> Bool
noHayNumerosDivisoresDe n minimo maximo | minimo >= maximo = True
| rem n minimo == 0 = False
| otherwise = noHayNumerosDivisoresDe n (minimo + 1) maximo
hermanada3 :: [Int] -> Bool
hermanada3 [b] = True
hermanada3 (a:b:xs) = (if ((a/=1) && (b/=1)) then ((gcd a b /= 1) && (primo2 (gcd a b))) else True)
&& hermanada3 (b:xs)

hermanada4 xs = undefined

-- ----------------------------------------------------------------------------
-- Ejercicio 7. Un elemento de una lista es permanente si ninguno de los que
-- vienen a continuación en la lista es mayor que él. Consideramos la función
-- permanentes :: [Int] -> [Int]
-- tal que (permanentes xs) es la lista de los elementos permanentes de la
-- lista xs. Por ejemplo,
-- permanentes [80,1,7,8,4] == [80,8,4]

-- Se pide definir esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ---------------------------------------------------------------------------
-- Nota: Usa la función 'tails' de Data.List.
-- ----------------------------------------------------------------------------

--José Manuel García
permanentes1 :: [Int] -> [Int]
permanentes1 xs = [a | (a,b) <- (zip xs (init (tails xs))), a == maximum b ]

permanentes2 :: [Int] -> [Int]
permanentes2 xs = map head (filter p2 (init (tails xs)))
where p2 (x:xs) = x == maximum (x:xs)

comparacion3 :: Ord a => [a] -> [a] -> Bool
comparacion3 a [] = True
comparacion3 a b = a >= b
permanentes3 :: [Int] -> [Int]
permanentes3 [] = []
permanentes3 (x:xs) | [x] `comparacion3` [maximum3 xs] = x : permanentes3 xs
| otherwise = permanentes3 xs
where maximum3 [] = if x < 0 then x else -x
maximum3 xs = maximum xs

permanentes4:: [Int] -> [Int]
permanentes4 (x:xs) = foldr f4 [] (x:xs)
where f4 prim recu | [prim] `comparacion3` [maximum3 recu] = prim : recu
| otherwise = recu
maximum3 [] = if x < 0 then x else -x
maximum3 xs = maximum xs

-- Elsa Domínguez
permanentesC :: [Int] -> [Int]
permanentesC xs = [x | (x, xs') <- zip xs (tails (drop 1 xs)), xs' == [] || x >= maximum xs']

permanentesS :: [Int] -> [Int]
permanentesS xs = filter p xs
where p x = x == maximum (dropWhile (/=x) xs)

permanentesR :: [Int] -> [Int]
permanentesR [] = []
permanentesR [x] = [x]
permanentesR (x:xs) | x >= maximum xs = [x] ++ permanentesR xs
| otherwise = permanentesR xs

permanentesPR :: [Int] -> [Int]
permanentesPR (x:xs) = foldr f [] (x:xs)
where f x recu | x >= maximum' (dropWhile (/=x) xs) = [x] ++ recu
| otherwise = recu
maximum' xs | null xs = 0
| otherwise = maximum xs

-- ---------------------------------------------------------------------
-- Ejercicio 8. Un número entero positivo n es muy primo si es n primo
-- y todos los números que resultan de ir suprimimiendo la última cifra
-- también son primos. Por ejemplo, 7193 es muy primo pues los números
-- 7193, 719, 71 y 7 son todos primos.
--
-- Define la función
-- muyPrimo :: Integer -> Bool
-- que (muyPrimo n) se verifica si n es muy primo. Por ejemplo,
-- muyPrimo 7193 == True
-- muyPrimo 71932 == False
-- --------------------------------------------------------------------

--José Manuel García
esPrimo :: Integral a => a -> Bool
esPrimo x = filter p2 [1..x] == [1,x]
where p2 b = (rem x b == 0)
muyPrimo :: Integer -> Bool
muyPrimo n | esPrimo n = length (show n) == sum [1 | a <- (descomposicion n), esPrimo (read a :: Integer) ]
| otherwise = False
where descomposicion n = [reverse x | x <- (init(tails (reverse (show n))))]

-- ---------------------------------------------------------------------
-- ¿Cuántos números de cinco cifras son muy primos?
-- ---------------------------------------------------------------------

-- El cálculo es

--José Manuel García
calculoMuyPrimo = sum [1 | x <- [10000..99999], muyPrimo x] -- Tras unos minutos, sale 15.
-- ---------------------------------------------------------------------

</source>

Relación 9

2021-11-29T18:55:00Z

Elsdomgon:

<source lang='haskell'>

-- I1M 2021-22: Rel_9.hs (01 de diciembre de 2021)
-- Funciones de orden superior y definiciones por plegados (II)
-- Departamento de Ciencias de la Computación e Inteligencia Artificial
-- Universidad de Sevilla
-- ============================================================================

-- ============================================================================
-- Librerías auxiliares
-- ============================================================================
import Data.Char
import Data.List
-- El siguiente módulo hay que instalarlo:
--cabal install Primes
import Data.Numbers.Primes
-- ----------------------------------------------------------------------------
-- Ejercicio 1. Se considera la función
-- resultadoPos :: (a -> Integer) -> [a] -> [a]
-- tal que (resultadoPos f xs) es la lista de los elementos de la lista
-- xs tales que el valor de la función f sobre ellos es positivo. Por ejemplo,
-- resultadoPos head [[-1,2],[-9,4],[2,3]] == [[2,3]]
-- resultadoPos sum [[1,2],[9],[-8,3],[],[3,5]] == [[1,2],[9],[3,5]]
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...),
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- -----------------------------------------------------------------------------

-- Elsa Domínguez
resultadoPosC :: (a -> Integer) -> [a] -> [a]
resultadoPosC f xs = [x | x <- xs, f x > 0]

resultadoPosS :: (a -> Integer) -> [a] -> [a]
resultadoPosS f xs = filter g xs
where g x = f x > 0
resultadoPosS1 :: (a -> Integer) -> [a] -> [a]
resultadoPosS1 f xs = filter (\ x -> f x > 0) xs

resultadoPosR :: (a -> Integer) -> [a] -> [a]
resultadoPosR f [] = []
resultadoPosR f (x:xs) | f x > 0 = x : resultadoPosR f xs
| otherwise = resultadoPosR f xs

resultadoPosPR :: (a -> Integer) -> [a] -> [a]
resultadoPosPR f xs = foldr g [] xs
where g prim recu | f prim > 0 = prim : recu
| otherwise = recu

-- ----------------------------------------------------------------------------
-- Ejercicio 2. Se considera la función
-- intercala :: Int -> [Int] -> [Int]
-- tal que (intercala y xs) es la lista que resulta de intercalar el elemento
-- y delante de todos los elementos de la lista xs que sean menores que y.
-- Por ejemplo,
-- intercala 5 [1,2,6,3,7,9] == [5,1,5,2,6,5,3,7,9]
-- intercala 5 [6,7,9,8] == [6,7,9,8]
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
intercalaC :: Int -> [Int] -> [Int]
intercalaC y xs = concat [if x<y then [y,x] else [x] | x <- xs]

intercalaS :: Int -> [Int] -> [Int]
intercalaS y xs = concat (map f xs)
where f x = if x<y then [y,x] else [x]

intercalaR :: Int -> [Int] -> [Int]
intercalaR y [] = []
intercalaR y (x:xs) | x<y = [y,x] ++ intercalaR y xs
| x>y = [x] ++ intercalaR y xs

intercalaPR :: Int -> [Int] -> [Int]
intercalaPR y xs = foldr g [] xs
where g x recu | x<y = [y,x] ++ recu
| x>y = [x] ++ recu

intercalaA :: Int -> [Int] -> [Int]
intercalaA y xs = aux [] xs
where aux v [] = v
aux v (x:xs) | x<y = aux (v++[y,x]) xs
| otherwise = aux (v++[x]) xs

-- ----------------------------------------------------------------------------
-- Ejercicio 3. Se considera la función
-- dec2ent :: [Integer] -> Integer
-- tal que (dec2ent xs) es el número entero cuyas cifras ordenadas son los
-- elementos de la lista xs. Por ejemplo,
-- dec2ent [2,3,4,5] == 2345
-- dec2ent [1..9] == 123456789
--
-- Defie esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

--José Manuel García
dec2ent1 :: [Integer] -> Integer
dec2ent1 xs = read (concat [show x| x <- (sort xs)]) :: Integer

dec2ent2 :: [Integer] -> Integer
dec2ent2 xs = read (concat (map show (sort xs))) :: Integer

dec2ent3 :: [Integer] -> Integer
dec2ent3Aux :: Show a => [a] -> [Char]
dec2ent3Aux [] = []
dec2ent3Aux (x:xs) = (show x) ++ (dec2ent3Aux xs)
dec2ent3 xs = read (dec2ent3Aux (sort xs)) :: Integer

dec2ent4 :: [Integer] -> Integer
dec2ent4 xs = read (concat (foldr f [] (sort xs))) :: Integer
where f prim recu = show prim :recu

-- Elsa Domínguez
dec2entC :: [Integer] -> Integer
dec2entC xs = sum [x*10^i | (x,i) <- zip xs (reverse [0..length xs-1])]

dec2entS :: [Integer] -> Integer
dec2entS xs = sum (map f xs)
where f x = x*10^(length (dropWhile (/=x) xs) -1)

dec2entR :: [Integer] -> Integer
dec2entR [] = 0
dec2entR (x:xs) = x*10^(length xs) + dec2entR xs

dec2entPR :: [Integer] -> Integer
dec2entPR xs = foldr f 0 xs
where f x recu = x*10^(length (dropWhile (/=x) xs) -1) + recu

-- ----------------------------------------------------------------------------
-- Ejercicio 4. Se considera 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, el conjunto de los elementos de la lista xs que no se
-- encuentran en la lista ys. Por ejemplo,
-- diferencia [2,3,5,6] [5,2,7] == [3,6]
-- diferencia [1,3,5,7] [2,4,6] == [1,3,5,7]
-- diferencia [1,3] [1..9] == []
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
diferenciaC :: Eq a => [a] -> [a] -> [a]
diferenciaC xs ys = [x | x <- xs, notElem x ys]

diferenciaS :: Eq a => [a] -> [a] -> [a]
diferenciaS xs ys = concat (map f xs)
where f x | notElem x ys = [x]
| otherwise = []

diferenciaR :: Eq a => [a] -> [a] -> [a]
diferenciaR [] _ = []
diferenciaR (x:xs) ys | notElem x ys = [x] ++ diferenciaR xs ys
| otherwise = diferenciaR xs ys

diferenciaPR :: Eq a => [a] -> [a] -> [a]
diferenciaPR xs ys = foldr g [] xs
where g x recu | notElem x ys = [x] ++ recu
| otherwise = recu

--José Manuel García
diferencia1 :: Eq a => [a] -> [a] -> [a]
diferencia1 xs ys = [x | x <- xs, not (elem x ys) ] -- ++ [y | y <- ys, not (elem y xs) ]

diferencia2 :: Eq a => [a] -> [a] -> [a]
diferencia2 (x:xs) ys = filter f (x:xs)
where f a = not (elem a ys)

diferencia3 :: Eq a => [a] -> [a] -> [a]
diferencia3 [] _ = []
diferencia3 (x:xs) ys | not (elem x ys) = x : (diferencia3 xs ys)
| otherwise = (diferencia3 xs ys)

diferencia4 :: Eq a => [a] -> [a] -> [a]
diferencia4 (x:xs) ys = foldr f [] (x:xs)
where f prim recu | not (elem prim ys) = prim : recu
| otherwise = recu

-- ----------------------------------------------------------------------------
-- Ejercicio 5. Se considera la función
-- primerosYultimos :: [[a]] -> ([a],[a])
-- tal que (primerosYultimos xss) es el par formado por la lista de los
-- primeros elementos de las listas no vacías de xss y la lista de los
-- últimos elementos de las listas no vacías de xss. Por ejemplo,
-- primerosYultimos [[1,2],[5,3,4],[],[9]] == ([1,5,9],[2,4,9])
-- primerosYultimos [[1,2],[1,2,3],[1..4]] == ([1,1,1],[2,3,4])

--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

--José Manuel García
primerosYultimos1 :: [[a]] -> ([a], [a])
primerosYultimos1 xss = ([head x | x <- xss, not (null x)], [last x | x <- xss, not (null x)])

noVacios :: Foldable t => [t a] -> [t a]
noVacios xss = filter (not.null) xss
primerosYultimos2 :: [[a]] -> ([a], [a])
primerosYultimos2 xss = (map head (noVacios xss), map last (noVacios xss))

primeros3 :: [[a]] -> [a]
primeros3 [] = []
primeros3 (xs:xss) | not (null xs) = (head xs) : (primeros3 xss)
| otherwise = (primeros3 xss)
ultimos3 :: [[a]] -> [a]
ultimos3 [] = []
ultimos3 (xs:xss) | not (null xs) = (last xs) : (ultimos3 xss)
| otherwise = (ultimos3 xss)
primerosYultimos3 :: [[a]] -> ([a], [a])
primerosYultimos3 xss = (primeros3 xss, ultimos3 xss )

primeros4 :: Foldable t => t [a] -> [a]
primeros4 xss = foldr p4 [] xss
where p4 prim recu | not (null prim) = head prim : recu
| otherwise = recu
ultimos4 :: Foldable t => t [a] -> [a]
ultimos4 xss = foldr u4 [] xss
where u4 prim recu | not (null prim) = last prim : recu
| otherwise = recu
primerosYultimos4 :: [[a]] -> ([a], [a])
primerosYultimos4 xss = (primeros4 xss, ultimos4 xss)

-- Elsa Domínguez
primerosYultimosC :: [[a]] -> ([a],[a])
primerosYultimosC xss = (concat [(take 1 xs) | xs <- xss], concat [take 1 (reverse xs) | xs <- xss])

primerosYultimosS :: [[a]] -> ([a],[a])
primerosYultimosS xss = (concat (map (take 1) xss), concat (map (take 1) (map reverse xss)))

primerosYultimosR :: [[a]] -> ([a],[a])
primerosYultimosR xss = (primerosR xss, ultimosR xss)

primerosR [] = []
primerosR (xs:xss) | null xs = primerosR xss
| otherwise = [head xs] ++ primerosR xss
ultimosR [] = []
ultimosR (xs:xss) | null xs = ultimosR xss
| otherwise = [last xs] ++ ultimosR xss

primerosYultimosPR :: [[a]] -> ([a],[a])
primerosYultimosPR xss = (primerosPR xss, ultimosPR xss)

primerosPR xss = foldr f [] xss
where f x recu | null x = recu
| otherwise = [head x] ++ recu
ultimosPR xss = foldr f [] xss
where f x recu | null x = recu
| otherwise = [last x] ++ recu

-- ----------------------------------------------------------------------------
-- Ejercicio 6. Una lista hermanada es una lista de números estrictamente
-- positivos en la que cada elemento tiene algún factor primo en común con el
-- siguiente, en caso de que exista, o alguno de los dos es un 1. Por ejemplo,
-- [2,6,3,9,1,5] es una lista hermanada.

-- Se considera la función
-- hermanada :: [Int] -> Bool
-- tal que (hermanada xs) comprueba que la lista xs es hermanada según la
-- definición anterior. Por ejemplo,
-- hermanada [2,6,3,9,1,5] == True
-- hermanada [2,3,5] == False
--
-- Se pide definir esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------
-- Nota: Usa la función 'gcd'
-- ----------------------------------------------------------------------------

--José Manuel García
primo1 :: Integral a => a -> Bool
primo1 x = [1,x]==[a| a<- [1..x], rem x a == 0] -- Me dice si un número es primo
hermanada1 :: [Int] -> Bool
hermanada1 xs = sum [1 | (a,b) <- (zip xs (tail xs)), (if ((a/=1) && (b/=1))
then ((gcd a b /= 1) && (primo1 (gcd a b)))
else True),
a>0, b>0 ] == (length xs) -1
-- a,b > 0 porque tienen que ser extrictamente positivos
-- ((length xs) - 1) == length (zip xs (tail xs))

primo2 :: Integral a => a -> Bool
primo2 x = filter p2 [1..x] == [1,x]
where p2 b = (rem x b == 0)
hermanada2 :: [Int] -> Bool
hermanada2 xs = and (map prop2 (zip xs (tail xs)))
where prop2 (a,b) = if a>0 && b>0
then (if ((a/=1) && (b/=1)) then ((gcd a b /= 1) && (primo2 (gcd a b))) else True)
else False

primo3 :: Integral a => a -> Bool
primo3 n = noHayNumerosDivisoresDe n 2 (n - 1)
noHayNumerosDivisoresDe :: Integral t => t -> t -> t -> Bool
noHayNumerosDivisoresDe n minimo maximo | minimo >= maximo = True
| rem n minimo == 0 = False
| otherwise = noHayNumerosDivisoresDe n (minimo + 1) maximo
hermanada3 :: [Int] -> Bool
hermanada3 [b] = True
hermanada3 (a:b:xs) = (if ((a/=1) && (b/=1)) then ((gcd a b /= 1) && (primo2 (gcd a b))) else True)
&& hermanada3 (b:xs)

hermanada4 xs = undefined

-- ----------------------------------------------------------------------------
-- Ejercicio 7. Un elemento de una lista es permanente si ninguno de los que
-- vienen a continuación en la lista es mayor que él. Consideramos la función
-- permanentes :: [Int] -> [Int]
-- tal que (permanentes xs) es la lista de los elementos permanentes de la
-- lista xs. Por ejemplo,
-- permanentes [80,1,7,8,4] == [80,8,4]

-- Se pide definir esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ---------------------------------------------------------------------------
-- Nota: Usa la función 'tails' de Data.List.
-- ----------------------------------------------------------------------------

--José Manuel García
permanentes1 :: [Int] -> [Int]
permanentes1 xs = [a | (a,b) <- (zip xs (init (tails xs))), a == maximum b ]

permanentes2 :: [Int] -> [Int]
permanentes2 xs = map head (filter p2 (init (tails xs)))
where p2 (x:xs) = x == maximum (x:xs)

comparacion3 :: Ord a => [a] -> [a] -> Bool
comparacion3 a [] = True
comparacion3 a b = a >= b
permanentes3 :: [Int] -> [Int]
permanentes3 [] = []
permanentes3 (x:xs) | [x] `comparacion3` [maximum3 xs] = x : permanentes3 xs
| otherwise = permanentes3 xs
where maximum3 [] = if x < 0 then x else -x
maximum3 xs = maximum xs

permanentes4:: [Int] -> [Int]
permanentes4 (x:xs) = foldr f4 [] (x:xs)
where f4 prim recu | [prim] `comparacion3` [maximum3 recu] = prim : recu
| otherwise = recu
maximum3 [] = if x < 0 then x else -x
maximum3 xs = maximum xs

-- ---------------------------------------------------------------------
-- Ejercicio 8. Un número entero positivo n es muy primo si es n primo
-- y todos los números que resultan de ir suprimimiendo la última cifra
-- también son primos. Por ejemplo, 7193 es muy primo pues los números
-- 7193, 719, 71 y 7 son todos primos.
--
-- Define la función
-- muyPrimo :: Integer -> Bool
-- que (muyPrimo n) se verifica si n es muy primo. Por ejemplo,
-- muyPrimo 7193 == True
-- muyPrimo 71932 == False
-- --------------------------------------------------------------------

--José Manuel García
esPrimo :: Integral a => a -> Bool
esPrimo x = filter p2 [1..x] == [1,x]
where p2 b = (rem x b == 0)
muyPrimo :: Integer -> Bool
muyPrimo n | esPrimo n = length (show n) == sum [1 | a <- (descomposicion n), esPrimo (read a :: Integer) ]
| otherwise = False
where descomposicion n = [reverse x | x <- (init(tails (reverse (show n))))]

-- ---------------------------------------------------------------------
-- ¿Cuántos números de cinco cifras son muy primos?
-- ---------------------------------------------------------------------

-- El cálculo es

--José Manuel García
calculoMuyPrimo = sum [1 | x <- [10000..99999], muyPrimo x] -- Tras unos minutos, sale 15.
-- ---------------------------------------------------------------------

</source>

Relación 9

2021-11-29T18:34:10Z

Elsdomgon:

<source lang='haskell'>

-- I1M 2021-22: Rel_9.hs (01 de diciembre de 2021)
-- Funciones de orden superior y definiciones por plegados (II)
-- Departamento de Ciencias de la Computación e Inteligencia Artificial
-- Universidad de Sevilla
-- ============================================================================

-- ============================================================================
-- Librerías auxiliares
-- ============================================================================
import Data.Char
import Data.List
-- El siguiente módulo hay que instalarlo:
--cabal install Primes
import Data.Numbers.Primes
-- ----------------------------------------------------------------------------
-- Ejercicio 1. Se considera la función
-- resultadoPos :: (a -> Integer) -> [a] -> [a]
-- tal que (resultadoPos f xs) es la lista de los elementos de la lista
-- xs tales que el valor de la función f sobre ellos es positivo. Por ejemplo,
-- resultadoPos head [[-1,2],[-9,4],[2,3]] == [[2,3]]
-- resultadoPos sum [[1,2],[9],[-8,3],[],[3,5]] == [[1,2],[9],[3,5]]
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...),
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- -----------------------------------------------------------------------------

-- Elsa Domínguez
resultadoPosC :: (a -> Integer) -> [a] -> [a]
resultadoPosC f xs = [x | x <- xs, f x > 0]

resultadoPosS :: (a -> Integer) -> [a] -> [a]
resultadoPosS f xs = filter g xs
where g x = f x > 0
resultadoPosS1 :: (a -> Integer) -> [a] -> [a]
resultadoPosS1 f xs = filter (\ x -> f x > 0) xs

resultadoPosR :: (a -> Integer) -> [a] -> [a]
resultadoPosR f [] = []
resultadoPosR f (x:xs) | f x > 0 = x : resultadoPosR f xs
| otherwise = resultadoPosR f xs

resultadoPosPR :: (a -> Integer) -> [a] -> [a]
resultadoPosPR f xs = foldr g [] xs
where g prim recu | f prim > 0 = prim : recu
| otherwise = recu

-- ----------------------------------------------------------------------------
-- Ejercicio 2. Se considera la función
-- intercala :: Int -> [Int] -> [Int]
-- tal que (intercala y xs) es la lista que resulta de intercalar el elemento
-- y delante de todos los elementos de la lista xs que sean menores que y.
-- Por ejemplo,
-- intercala 5 [1,2,6,3,7,9] == [5,1,5,2,6,5,3,7,9]
-- intercala 5 [6,7,9,8] == [6,7,9,8]
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
intercalaC :: Int -> [Int] -> [Int]
intercalaC y xs = concat [if x<y then [y,x] else [x] | x <- xs]

intercalaS :: Int -> [Int] -> [Int]
intercalaS y xs = concat (map f xs)
where f x = if x<y then [y,x] else [x]

intercalaR :: Int -> [Int] -> [Int]
intercalaR y [] = []
intercalaR y (x:xs) | x<y = [y,x] ++ intercalaR y xs
| x>y = [x] ++ intercalaR y xs

intercalaPR :: Int -> [Int] -> [Int]
intercalaPR y xs = foldr g [] xs
where g x recu | x<y = [y,x] ++ recu
| x>y = [x] ++ recu

intercalaA :: Int -> [Int] -> [Int]
intercalaA y xs = aux [] xs
where aux v [] = v
aux v (x:xs) | x<y = aux (v++[y,x]) xs
| otherwise = aux (v++[x]) xs

-- ----------------------------------------------------------------------------
-- Ejercicio 3. Se considera la función
-- dec2ent :: [Integer] -> Integer
-- tal que (dec2ent xs) es el número entero cuyas cifras ordenadas son los
-- elementos de la lista xs. Por ejemplo,
-- dec2ent [2,3,4,5] == 2345
-- dec2ent [1..9] == 123456789
--
-- Defie esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

--José Manuel García
dec2ent1 :: [Integer] -> Integer
dec2ent1 xs = read (concat [show x| x <- (sort xs)]) :: Integer

dec2ent2 :: [Integer] -> Integer
dec2ent2 xs = read (concat (map show (sort xs))) :: Integer

dec2ent3 :: [Integer] -> Integer
dec2ent3Aux :: Show a => [a] -> [Char]
dec2ent3Aux [] = []
dec2ent3Aux (x:xs) = (show x) ++ (dec2ent3Aux xs)
dec2ent3 xs = read (dec2ent3Aux (sort xs)) :: Integer

dec2ent4 :: [Integer] -> Integer
dec2ent4 xs = read (concat (foldr f [] (sort xs))) :: Integer
where f prim recu = show prim :recu

-- Elsa Domínguez
dec2entC :: [Integer] -> Integer
dec2entC xs = sum [x*10^i | (x,i) <- zip xs (reverse [0..length xs-1])]

dec2entS :: [Integer] -> Integer
dec2entS xs = sum (map f xs)
where f x = x*10^(length (dropWhile (/=x) xs) -1)

dec2entR :: [Integer] -> Integer
dec2entR [] = 0
dec2entR (x:xs) = x*10^(length xs) + dec2entR xs

dec2entPR :: [Integer] -> Integer
dec2entPR xs = foldr f 0 xs
where f x recu = x*10^(length (dropWhile (/=x) xs) -1) + recu

-- ----------------------------------------------------------------------------
-- Ejercicio 4. Se considera 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, el conjunto de los elementos de la lista xs que no se
-- encuentran en la lista ys. Por ejemplo,
-- diferencia [2,3,5,6] [5,2,7] == [3,6]
-- diferencia [1,3,5,7] [2,4,6] == [1,3,5,7]
-- diferencia [1,3] [1..9] == []
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

-- Elsa Domínguez
diferenciaC :: Eq a => [a] -> [a] -> [a]
diferenciaC xs ys = [x | x <- xs, notElem x ys]

diferenciaS :: Eq a => [a] -> [a] -> [a]
diferenciaS xs ys = concat (map f xs)
where f x | notElem x ys = [x]
| otherwise = []

diferenciaR :: Eq a => [a] -> [a] -> [a]
diferenciaR [] _ = []
diferenciaR (x:xs) ys | notElem x ys = [x] ++ diferenciaR xs ys
| otherwise = diferenciaR xs ys

diferenciaPR :: Eq a => [a] -> [a] -> [a]
diferenciaPR xs ys = foldr g [] xs
where g x recu | notElem x ys = [x] ++ recu
| otherwise = recu

--José Manuel García
diferencia1 :: Eq a => [a] -> [a] -> [a]
diferencia1 xs ys = [x | x <- xs, not (elem x ys) ] -- ++ [y | y <- ys, not (elem y xs) ]

diferencia2 :: Eq a => [a] -> [a] -> [a]
diferencia2 (x:xs) ys = filter f (x:xs)
where f a = not (elem a ys)

diferencia3 :: Eq a => [a] -> [a] -> [a]
diferencia3 [] _ = []
diferencia3 (x:xs) ys | not (elem x ys) = x : (diferencia3 xs ys)
| otherwise = (diferencia3 xs ys)

diferencia4 :: Eq a => [a] -> [a] -> [a]
diferencia4 (x:xs) ys = foldr f [] (x:xs)
where f prim recu | not (elem prim ys) = prim : recu
| otherwise = recu

-- ----------------------------------------------------------------------------
-- Ejercicio 5. Se considera la función
-- primerosYultimos :: [[a]] -> ([a],[a])
-- tal que (primerosYultimos xss) es el par formado por la lista de los
-- primeros elementos de las listas no vacías de xss y la lista de los
-- últimos elementos de las listas no vacías de xss. Por ejemplo,
-- primerosYultimos [[1,2],[5,3,4],[],[9]] == ([1,5,9],[2,4,9])
-- primerosYultimos [[1,2],[1,2,3],[1..4]] == ([1,1,1],[2,3,4])

--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

--José Manuel García
primerosYultimos1 :: [[a]] -> ([a], [a])
primerosYultimos1 xss = ([head x | x <- xss, not (null x)], [last x | x <- xss, not (null x)])

noVacios :: Foldable t => [t a] -> [t a]
noVacios xss = filter (not.null) xss
primerosYultimos2 :: [[a]] -> ([a], [a])
primerosYultimos2 xss = (map head (noVacios xss), map last (noVacios xss))

primeros3 :: [[a]] -> [a]
primeros3 [] = []
primeros3 (xs:xss) | not (null xs) = (head xs) : (primeros3 xss)
| otherwise = (primeros3 xss)
ultimos3 :: [[a]] -> [a]
ultimos3 [] = []
ultimos3 (xs:xss) | not (null xs) = (last xs) : (ultimos3 xss)
| otherwise = (ultimos3 xss)
primerosYultimos3 :: [[a]] -> ([a], [a])
primerosYultimos3 xss = (primeros3 xss, ultimos3 xss )

primeros4 :: Foldable t => t [a] -> [a]
primeros4 xss = foldr p4 [] xss
where p4 prim recu | not (null prim) = head prim : recu
| otherwise = recu
ultimos4 :: Foldable t => t [a] -> [a]
ultimos4 xss = foldr u4 [] xss
where u4 prim recu | not (null prim) = last prim : recu
| otherwise = recu
primerosYultimos4 :: [[a]] -> ([a], [a])
primerosYultimos4 xss = (primeros4 xss, ultimos4 xss)

-- ----------------------------------------------------------------------------
-- Ejercicio 6. Una lista hermanada es una lista de números estrictamente
-- positivos en la que cada elemento tiene algún factor primo en común con el
-- siguiente, en caso de que exista, o alguno de los dos es un 1. Por ejemplo,
-- [2,6,3,9,1,5] es una lista hermanada.

-- Se considera la función
-- hermanada :: [Int] -> Bool
-- tal que (hermanada xs) comprueba que la lista xs es hermanada según la
-- definición anterior. Por ejemplo,
-- hermanada [2,6,3,9,1,5] == True
-- hermanada [2,3,5] == False
--
-- Se pide definir esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------
-- Nota: Usa la función 'gcd'
-- ----------------------------------------------------------------------------

--José Manuel García
primo1 :: Integral a => a -> Bool
primo1 x = [1,x]==[a| a<- [1..x], rem x a == 0] -- Me dice si un número es primo
hermanada1 :: [Int] -> Bool
hermanada1 xs = sum [1 | (a,b) <- (zip xs (tail xs)), (if ((a/=1) && (b/=1))
then ((gcd a b /= 1) && (primo1 (gcd a b)))
else True),
a>0, b>0 ] == (length xs) -1
-- a,b > 0 porque tienen que ser extrictamente positivos
-- ((length xs) - 1) == length (zip xs (tail xs))

primo2 :: Integral a => a -> Bool
primo2 x = filter p2 [1..x] == [1,x]
where p2 b = (rem x b == 0)
hermanada2 :: [Int] -> Bool
hermanada2 xs = and (map prop2 (zip xs (tail xs)))
where prop2 (a,b) = if a>0 && b>0
then (if ((a/=1) && (b/=1)) then ((gcd a b /= 1) && (primo2 (gcd a b))) else True)
else False

primo3 :: Integral a => a -> Bool
primo3 n = noHayNumerosDivisoresDe n 2 (n - 1)
noHayNumerosDivisoresDe :: Integral t => t -> t -> t -> Bool
noHayNumerosDivisoresDe n minimo maximo | minimo >= maximo = True
| rem n minimo == 0 = False
| otherwise = noHayNumerosDivisoresDe n (minimo + 1) maximo
hermanada3 :: [Int] -> Bool
hermanada3 [b] = True
hermanada3 (a:b:xs) = (if ((a/=1) && (b/=1)) then ((gcd a b /= 1) && (primo2 (gcd a b))) else True)
&& hermanada3 (b:xs)

hermanada4 xs = undefined

-- ----------------------------------------------------------------------------
-- Ejercicio 7. Un elemento de una lista es permanente si ninguno de los que
-- vienen a continuación en la lista es mayor que él. Consideramos la función
-- permanentes :: [Int] -> [Int]
-- tal que (permanentes xs) es la lista de los elementos permanentes de la
-- lista xs. Por ejemplo,
-- permanentes [80,1,7,8,4] == [80,8,4]

-- Se pide definir esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ---------------------------------------------------------------------------
-- Nota: Usa la función 'tails' de Data.List.
-- ----------------------------------------------------------------------------

--José Manuel García
permanentes1 :: [Int] -> [Int]
permanentes1 xs = [a | (a,b) <- (zip xs (init (tails xs))), a == maximum b ]

permanentes2 :: [Int] -> [Int]
permanentes2 xs = map head (filter p2 (init (tails xs)))
where p2 (x:xs) = x == maximum (x:xs)

comparacion3 :: Ord a => [a] -> [a] -> Bool
comparacion3 a [] = True
comparacion3 a b = a >= b
permanentes3 :: [Int] -> [Int]
permanentes3 [] = []
permanentes3 (x:xs) | [x] `comparacion3` [maximum3 xs] = x : permanentes3 xs
| otherwise = permanentes3 xs
where maximum3 [] = if x < 0 then x else -x
maximum3 xs = maximum xs

permanentes4:: [Int] -> [Int]
permanentes4 (x:xs) = foldr f4 [] (x:xs)
where f4 prim recu | [prim] `comparacion3` [maximum3 recu] = prim : recu
| otherwise = recu
maximum3 [] = if x < 0 then x else -x
maximum3 xs = maximum xs

-- ---------------------------------------------------------------------
-- Ejercicio 8. Un número entero positivo n es muy primo si es n primo
-- y todos los números que resultan de ir suprimimiendo la última cifra
-- también son primos. Por ejemplo, 7193 es muy primo pues los números
-- 7193, 719, 71 y 7 son todos primos.
--
-- Define la función
-- muyPrimo :: Integer -> Bool
-- que (muyPrimo n) se verifica si n es muy primo. Por ejemplo,
-- muyPrimo 7193 == True
-- muyPrimo 71932 == False
-- --------------------------------------------------------------------

--José Manuel García
esPrimo :: Integral a => a -> Bool
esPrimo x = filter p2 [1..x] == [1,x]
where p2 b = (rem x b == 0)
muyPrimo :: Integer -> Bool
muyPrimo n | esPrimo n = length (show n) == sum [1 | a <- (descomposicion n), esPrimo (read a :: Integer) ]
| otherwise = False
where descomposicion n = [reverse x | x <- (init(tails (reverse (show n))))]

-- ---------------------------------------------------------------------
-- ¿Cuántos números de cinco cifras son muy primos?
-- ---------------------------------------------------------------------

-- El cálculo es

--José Manuel García
calculoMuyPrimo = sum [1 | x <- [10000..99999], muyPrimo x] -- Tras unos minutos, sale 15.
-- ---------------------------------------------------------------------

</source>

Relación 9

2021-11-27T12:46:07Z

Elsdomgon:

Relación 9

2021-11-27T12:28:46Z

Elsdomgon:

Relación 8

2021-11-27T12:26:33Z

Elsdomgon:

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

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

2021-11-22T12:19:46Z

Elsdomgon:

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

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

-- ---------------------------------------------------------------------
-- 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
relacionadosC :: (a -> a -> Bool) -> [a] -> Bool
relacionadosC r xs = and [r a b | (a,b) <- 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
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)

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

agrupa :: Eq a => [[a]] -> [[a]]
agrupa = undefined

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

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

-- La comprobación es

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

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

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

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

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

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

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

-- La comprobación es

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

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

-- La comprobación es

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

filtraAplicaP :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaP f p = undefined

-- ---------------------------------------------------------------------
-- 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-17T18:13:03Z

Elsdomgon:

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

-- ---------------------------------------------------------------------
-- Ejercicio 1.3. Comprobar con QuickCheck que las definiciones
-- subconjunto y subconjuntoR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
-- 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
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
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)

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

-- 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
digitos n | n<10 = [n]
| otherwise = digitos (div n 10) ++ [rem n 10]

esDigito :: Integer -> Integer -> Bool
esDigito x n = elem x (digitos 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
numeroDeDigitos :: Integer -> Int
numeroDeDigitos x = length(digitos 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
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
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
-- ---------------------------------------------------------------------

pegaNumerosR :: Integer -> Integer -> Integer
pegaNumerosR x y = undefined

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

-- ---------------------------------------------------------------------
-- 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
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
primerDigitoNR :: Integer -> Integer
primerDigitoNR n = head (digitos n)

-- ---------------------------------------------------------------------
-- Ejercicio 20.3. Comprobar con QuickCheck que las funciones
-- primerDigitoR y primerDigitoNR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández
-- 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
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 = undefined

-- ---------------------------------------------------------------------
-- 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 si los dígitos que 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
capicua :: Integer -> Bool
capicua n = reverse(digitos n) == digitos 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
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
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 equvalentes 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 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 27. Un número x es especial si el número de ocurrencia 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 = undefined

-- El cálculo es

</source>

Relación 7

2021-11-17T17:57:00Z

Elsdomgon:

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

-- ---------------------------------------------------------------------
-- Ejercicio 1.3. Comprobar con QuickCheck que las definiciones
-- subconjunto y subconjuntoR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
-- 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
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
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)

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

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

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 10. Comprobar con QuickCheck si se cumple la siguiente
-- propiedad: (A \ B) ∩ B = ∅.
-- ---------------------------------------------------------------------

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

-- La comprobación es

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

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

-- ---------------------------------------------------------------------
-- Ejercicio 11.3. Comprobar con QuickCheck que producto y productoR
-- son equivalentes.
-- ---------------------------------------------------------------------

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

-- La comprobación es

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

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

-- La comprobación es

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

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

-- La comprobación es

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

numeroBloquesR :: Integer -> Integer
numeroBloquesR = undefined

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

numeroBloquesC :: Integer -> Integer
numeroBloquesC n = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 15.3. Comprobar con QuickCheck que (numeroBloquesC n) es
-- igual a n+n^2.
-- ---------------------------------------------------------------------

-- La propiedad es
prop_numeroBloquesR n = undefined

-- 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
digitos n | n<10 = [n]
| otherwise = digitos (div n 10) ++ [rem n 10]

esDigito :: Integer -> Integer -> Bool
esDigito x n = elem x (digitos 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
numeroDeDigitos :: Integer -> Int
numeroDeDigitos x = length(digitos 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
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
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
-- ---------------------------------------------------------------------

pegaNumerosR :: Integer -> Integer -> Integer
pegaNumerosR x y = undefined

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

-- ---------------------------------------------------------------------
-- 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
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
primerDigitoNR :: Integer -> Integer
primerDigitoNR n = head (digitos n)

-- ---------------------------------------------------------------------
-- Ejercicio 20.3. Comprobar con QuickCheck que las funciones
-- primerDigitoR y primerDigitoNR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández
-- 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
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 = undefined

-- ---------------------------------------------------------------------
-- 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 si los dígitos que 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
capicua :: Integer -> Bool
capicua n = reverse(digitos n) == digitos 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
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
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 equvalentes 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 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 27. Un número x es especial si el número de ocurrencia 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 = undefined

-- El cálculo es

</source>

Relación 6

2021-11-06T14:54:55Z

Elsdomgon:

<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
potencia :: Integer -> Integer -> Integer
potencia _ 0 = 1
potencia x n = x* potencia x (n-1)

-- Nicolás Rodríguez Ruiz, Elsa Domínguez
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
-- La propiedad es
prop_potencia :: Integer -> Integer -> Property
prop_potencia x n = n>=0 ==> x^n == potencia x n

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

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

-- ---------------------------------------------------------------------
-- 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
-- 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
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
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
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
-- 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
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
-- 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
coge :: Int -> [a] -> [a]
coge _ [] = []
coge n (x:xs) | n<=0 = []
| otherwise = x : coge (n-1) xs

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Comprobar con QuickCheck que coge es equivalente a
-- take.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Nicolás Rodríguez Ruiz, Elsa Domínguez
-- 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
sumaCuadradosR :: Integer -> Integer
sumaCuadradosR 0 = 0
sumaCuadradosR n = n^2 + sumaCuadradosR (n-1)
-- Elsa Domínguez
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
-- 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
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
-- 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
digitosR :: Integer -> [Integer]
digitosR n = if n<10 then [n]
else digitosR (div n 10) ++ [rem n 10]
-- ---------------------------------------------------------------------
-- Ejercicio 7.2. Definir, por comprensión, la función
-- digitosC :: Integer -> [Integer]
-- tal que (digitosC n) es la lista de los dígitos del número n. Por
-- ejemplo,
-- digitosC 320274 == [3,2,0,2,7,4]
-- Indicación: Usar las funciones show y read.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
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
-- 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
sumaDigitosR :: Integer -> Integer
sumaDigitosR n = if n<10 then n
else rem n 10 + sumaDigitosR (div n 10)
-- Elsa Domínguez
sumaDigitosR' :: Integer -> Integer
sumaDigitosR' 0 = 0
sumaDigitosR' n | n < 0 = error "no es posible"
| otherwise = rem n 10 + sumaDigitosR (div n 10)

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir, sin usar recursión, la función
-- sumaDigitosNR :: Integer -> Integer
-- tal que (sumaDigitosNR n) es la suma de los dígitos de n. Por ejemplo,
-- sumaDigitosNR 3 == 3
-- sumaDigitosNR 2454 == 15
-- sumaDigitosNR 20045 == 11
-- ---------------------------------------------------------------------
-- Lucía Hernández
sumaDigitosNR :: Integer -> Integer
sumaDigitosNR n = sum (digitosR n)
-- Elsa Domínguez
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
-- 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
listaNumeroR :: [Integer] -> Integer
listaNumeroR [] = 0
listaNumeroR [x] = x
listaNumeroR (x:xs) = x*10^(length (xs)) + listaNumeroR xs
-- Elsa Domínguez
listaNumeroR' :: [Integer] -> Integer
listaNumeroR' [] = 0
listaNumeroR' [x] = x
listaNumeroR' xs = last xs + (listaNumeroR (init xs))*10

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

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Comprobar con QuickCheck que las funciones
-- listaNumeroR y listaNumeroC son equivalentes.
-- ---------------------------------------------------------------------
--Lucía Hernández, Elsa Domínguez
-- 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.

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

2021-11-06T13:56:20Z

Elsdomgon:

<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
potencia :: Integer -> Integer -> Integer
potencia _ 0 = 1
potencia x n = x* potencia x (n-1)

-- Nicolás Rodríguez Ruiz, Elsa Domínguez
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
-- La propiedad es
prop_potencia :: Integer -> Integer -> Property
prop_potencia x n = n>=0 ==> x^n == potencia x n

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

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

-- ---------------------------------------------------------------------
-- 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
-- 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
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
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
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
-- 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
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
-- 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
coge :: Int -> [a] -> [a]
coge _ [] = []
coge n (x:xs) | n<=0 = []
| otherwise = x : coge (n-1) xs

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Comprobar con QuickCheck que coge es equivalente a
-- take.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Nicolás Rodríguez Ruiz, Elsa Domínguez
-- 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
sumaCuadradosR :: Integer -> Integer
sumaCuadradosR 0 = 0
sumaCuadradosR n = n^2 + sumaCuadradosR (n-1)
-- Elsa Domínguez
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
-- 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
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
-- 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
digitosR :: Integer -> [Integer]
digitosR n = if n<10 then [n]
else digitosR (div n 10) ++ [rem n 10]
-- ---------------------------------------------------------------------
-- Ejercicio 7.2. Definir, por comprensión, la función
-- digitosC :: Integer -> [Integer]
-- tal que (digitosC n) es la lista de los dígitos del número n. Por
-- ejemplo,
-- digitosC 320274 == [3,2,0,2,7,4]
-- Indicación: Usar las funciones show y read.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
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
-- 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
sumaDigitosR :: Integer -> Integer
sumaDigitosR n = if n<10 then n
else rem n 10 + sumaDigitosR (div n 10)
-- Elsa Domínguez
sumaDigitosR' :: Integer -> Integer
sumaDigitosR' 0 = 0
sumaDigitosR' n | n < 0 = error "no es posible"
| otherwise = rem n 10 + sumaDigitosR (div n 10)

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir, sin usar recursión, la función
-- sumaDigitosNR :: Integer -> Integer
-- tal que (sumaDigitosNR n) es la suma de los dígitos de n. Por ejemplo,
-- sumaDigitosNR 3 == 3
-- sumaDigitosNR 2454 == 15
-- sumaDigitosNR 20045 == 11
-- ---------------------------------------------------------------------
-- Lucía Hernández
sumaDigitosNR :: Integer -> Integer
sumaDigitosNR n = sum (digitosR n)

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Comprobar con QuickCheck que las funciones sumaDigitosR
-- y sumaDigitosNR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
-- 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
listaNumeroR :: [Integer] -> Integer
listaNumeroR [] = 0
listaNumeroR [x] = x
listaNumeroR (x:xs) = x*10^(length (xs)) + listaNumeroR xs
-- Elsa Domínguez
listaNumeroR' :: [Integer] -> Integer
listaNumeroR' [] = 0
listaNumeroR' [x] = x
listaNumeroR' xs = last xs + (listaNumeroR (init xs))*10

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

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Comprobar con QuickCheck que las funciones
-- listaNumeroR y listaNumeroC son equivalentes.
-- ---------------------------------------------------------------------
--Lucía Hernández, Elsa Domínguez
-- 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.

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

2021-11-06T13:41:57Z

Elsdomgon:

<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
potencia :: Integer -> Integer -> Integer
potencia _ 0 = 1
potencia x n = x* potencia x (n-1)

-- Nicolás Rodríguez Ruiz, Elsa Domínguez
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
-- La propiedad es
prop_potencia :: Integer -> Integer -> Property
prop_potencia x n = n>=0 ==> x^n == potencia x n

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

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

-- ---------------------------------------------------------------------
-- 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
-- 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
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
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
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
-- 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
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
-- 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
coge :: Int -> [a] -> [a]
coge _ [] = []
coge n (x:xs) | n<=0 = []
| otherwise = x : coge (n-1) xs

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Comprobar con QuickCheck que coge es equivalente a
-- take.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Nicolás Rodríguez Ruiz, Elsa Domínguez
-- 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
sumaCuadradosR :: Integer -> Integer
sumaCuadradosR 0 = 0
sumaCuadradosR n = n^2 + sumaCuadradosR (n-1)
-- Elsa Domínguez
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
-- 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
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
-- 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
digitosR :: Integer -> [Integer]
digitosR n = if n<10 then [n]
else digitosR (div n 10) ++ [rem n 10]
-- ---------------------------------------------------------------------
-- Ejercicio 7.2. Definir, por comprensión, la función
-- digitosC :: Integer -> [Integer]
-- tal que (digitosC n) es la lista de los dígitos del número n. Por
-- ejemplo,
-- digitosC 320274 == [3,2,0,2,7,4]
-- Indicación: Usar las funciones show y read.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
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
-- 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
sumaDigitosR :: Integer -> Integer
sumaDigitosR n = if n<10 then n
else rem n 10 + sumaDigitosR (div n 10)
-- Elsa Domínguez
sumaDigitosR' :: Integer -> Integer
sumaDigitosR' 0 = 0
sumaDigitosR' n | n < 0 = error "no es posible"
| otherwise = rem n 10 + sumaDigitosR (div n 10)

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir, sin usar recursión, la función
-- sumaDigitosNR :: Integer -> Integer
-- tal que (sumaDigitosNR n) es la suma de los dígitos de n. Por ejemplo,
-- sumaDigitosNR 3 == 3
-- sumaDigitosNR 2454 == 15
-- sumaDigitosNR 20045 == 11
-- ---------------------------------------------------------------------
-- Lucía Hernández
sumaDigitosNR :: Integer -> Integer
sumaDigitosNR n = sum (digitosR n)

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Comprobar con QuickCheck que las funciones sumaDigitosR
-- y sumaDigitosNR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
-- 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
listaNumeroR :: [Integer] -> Integer
listaNumeroR [] = 0
listaNumeroR [x] = x
listaNumeroR (x:xs) = x*10^(length (xs)) + listaNumeroR xs
-- Elsa Domínguez
listaNumeroR' :: [Integer] -> Integer
listaNumeroR' [] = 0
listaNumeroR' [x] = x
listaNumeroR' xs = last xs + (listaNumeroR (init xs))*10

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

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Comprobar con QuickCheck que las funciones
-- listaNumeroR y listaNumeroC son equivalentes.
-- ---------------------------------------------------------------------
--Lucía Hernández, Elsa Domínguez
-- 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.

-- ---------------------------------------------------------------------
-- 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
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
mayorExponenteC :: Integer -> Integer -> Integer
mayorExponenteC a b = last [s | s<- [0..b], mod b (a^s) == 0]

</source>

Relación 6

2021-11-06T12:29:42Z

Elsdomgon:

<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
potencia :: Integer -> Integer -> Integer
potencia _ 0 = 1
potencia x n = x* potencia x (n-1)

-- Nicolás Rodríguez Ruiz, Elsa Domínguez
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
-- La propiedad es
prop_potencia :: Integer -> Integer -> Property
prop_potencia x n = n>=0 ==> x^n == potencia x n

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

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

-- ---------------------------------------------------------------------
-- 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
-- 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
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
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
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
-- 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
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
-- 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
coge :: Int -> [a] -> [a]
coge _ [] = []
coge n (x:xs) | n<=0 = []
| otherwise = x : coge (n-1) xs

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Comprobar con QuickCheck que coge es equivalente a
-- take.
-- ---------------------------------------------------------------------
-- Lucía Hernández, Nicolás Rodríguez Ruiz
-- 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
sumaCuadradosR :: Integer -> Integer
sumaCuadradosR 0 = 0
sumaCuadradosR n = 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
-- 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
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
-- 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
digitosR :: Integer -> [Integer]
digitosR n = if n<10 then [n]
else digitosR (div n 10) ++ [rem n 10]
-- ---------------------------------------------------------------------
-- Ejercicio 7.2. Definir, por comprensión, la función
-- digitosC :: Integer -> [Integer]
-- tal que (digitosC n) es la lista de los dígitos del número n. Por
-- ejemplo,
-- digitosC 320274 == [3,2,0,2,7,4]
-- Indicación: Usar las funciones show y read.
-- ---------------------------------------------------------------------

-- Lucía Hernández
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
-- 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
sumaDigitosR :: Integer -> Integer
sumaDigitosR n = if n<10 then n
else rem n 10 + sumaDigitosR (div n 10)

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir, sin usar recursión, la función
-- sumaDigitosNR :: Integer -> Integer
-- tal que (sumaDigitosNR n) es la suma de los dígitos de n. Por ejemplo,
-- sumaDigitosNR 3 == 3
-- sumaDigitosNR 2454 == 15
-- sumaDigitosNR 20045 == 11
-- ---------------------------------------------------------------------
-- Lucía Hernández
sumaDigitosNR :: Integer -> Integer
sumaDigitosNR n = sum (digitosR n)

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Comprobar con QuickCheck que las funciones sumaDigitosR
-- y sumaDigitosNR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández
-- 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
listaNumeroR :: [Integer] -> Integer
listaNumeroR [] = 0
listaNumeroR [x] = x
listaNumeroR (x:xs) = x*10^(length (xs)) + 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
listaNumeroC :: [Integer] -> Integer
listaNumeroC xs = sum [x*10^s | (x,s) <- zip(reverse xs) [0..length xs -1]]

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Comprobar con QuickCheck que las funciones
-- listaNumeroR y listaNumeroC son equivalentes.
-- ---------------------------------------------------------------------
--Lucía Hernández
-- 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.

-- ---------------------------------------------------------------------
-- 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
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
mayorExponenteC :: Integer -> Integer -> Integer
mayorExponenteC a b = last [s | s<- [0..b], mod b (a^s) == 0]

</source>

Relación 4

2021-10-30T12:46:22Z

Elsdomgon:

<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
divisores :: Int -> [Int]
divisores n = [x | x<-[1..n], mod n x == 0]
primo :: Int -> Bool
primo n = divisores n == [1,n]

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

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

-- ---------------------------------------------------------------------
-- Ejercicio 2. Un número es libre de cuadrados si no es divisible por el
-- cuadrado de ningún entero mayor que 1. Por ejemplo, 70 es libre de
-- cuadrado porque sólo es divisible por 1, 2, 5, 7 y 70; en cambio, 40
-- no es libre de cuadrados porque es divisible por 2^2.
--
-- Definir la función
-- libreDeCuadrados :: Int -> Bool
-- tal que (libreDeCuadrados x) se verifica si x es libre de cuadrados.
-- Por ejemplo,
-- libreDeCuadrados 70 == True
-- libreDeCuadrados 40 == False
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
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

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

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

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

-- -------------------------------------------------------------
-- 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
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
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
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
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
angelini1 :: Integer -> Bool
angelini1 n = or[c `elem` (show (2*n)) | c <- (show n)]

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir la función
-- unitarios :: Int -> [Int]
-- tal (unitarios n) es la lista de números [n,nn, nnn, ....]. Por
-- ejemplo.
-- take 7 (unitarios 3) == [3,33,333,3333,33333,333333,3333333]
-- take 3 (unitarios 1) == [1,11,111]
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
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
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
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]

-- ---------------------------------------------------------------------
-- 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
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
deBaseABase10 :: Int -> [Int] -> Int
deBaseABase10 b xs = sum [i*( b^n) | (i,n)<- zip xs [0..length xs -1] ]

-- ---------------------------------------------------------------------
-- 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
conPos1 :: [a] -> [(a,Int)]
conPos1 xs = zip xs [0..length xs-1]

-- ---------------------------------------------------------------------
-- 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
pares :: [a] -> [a]
pares cs = [a | (a,b) <- conPos cs, even b]

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

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

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

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

-- ---------------------------------------------------------------------
-- 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
sumaEquidistantes :: Num a => [a] -> [a]
sumaEquidistantes xs = reverse (drop (div (length xs) 2) [a+b | (a,b) <- zip xs (reverse xs)])

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

-- ---------------------------------------------------------------------
-- 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
ultima, primera :: Int -> Int
ultima n = rem n 10
primera n = fromEnum (head(show n)) - 48

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

</source>

Relación 4

2021-10-28T18:57:01Z

Elsdomgon:

<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
divisores :: Int -> [Int]
divisores n = [x | x<-[1..n], mod n x == 0]
primo :: Int -> Bool
primo n = divisores n == [1,n]

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

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

-- ---------------------------------------------------------------------
-- Ejercicio 2. Un número es libre de cuadrados si no es divisible por el
-- cuadrado de ningún entero mayor que 1. Por ejemplo, 70 es libre de
-- cuadrado porque sólo es divisible por 1, 2, 5, 7 y 70; en cambio, 40
-- no es libre de cuadrados porque es divisible por 2^2.
--
-- Definir la función
-- libreDeCuadrados :: Int -> Bool
-- tal que (libreDeCuadrados x) se verifica si x es libre de cuadrados.
-- Por ejemplo,
-- libreDeCuadrados 70 == True
-- libreDeCuadrados 40 == False
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
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

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

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

-- Prof: Falta ver cómo calcular los números especiales de tres cifras!!
-- Lucía Hernández
especial3 = [ 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]]
-- Elsa Domínguez
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
multiplicidad2 a b = sum [1 | x <- [1..length(divisores b)], a^x `elem` (divisores b)]
where divisores n = [ a | a <- [2..n], n `mod` a == 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
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
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
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
angelini :: Integer -> Bool
angelini n = not (null (cifrasIguales n))
where cifrasIguales n = [a | (a,b) <- ns, a == b]
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
angelini1 :: Integer -> Bool
angelini1 n = or[c `elem` (show (2*n)) | c <- (show n)]

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir la función
-- unitarios :: Int -> [Int]
-- tal (unitarios n) es la lista de números [n,nn, nnn, ....]. Por
-- ejemplo.
-- take 7 (unitarios 3) == [3,33,333,3333,33333,333333,3333333]
-- take 3 (unitarios 1) == [1,11,111]
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
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
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"
-- ---------------------------------------------------------------------

masOcurrentes :: Eq a => [a] -> [a]
masOcurrentes xs = undefined

-- ---------------------------------------------------------------------
-- 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
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
deBaseABase10 :: Int -> [Int] -> Int
deBaseABase10 b xs = sum [i*( b^n) | (i,n)<- zip xs [0..length xs -1] ]

-- ---------------------------------------------------------------------
-- 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
conPos1 :: [a] -> [(a,Int)]
conPos1 xs = zip xs [0..length xs-1]

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

pares :: [a] -> [a]
pares cs = undefined

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

perpendiculares :: (Num a, Eq a) => [a] -> [[a]] -> [[a]]
perpendiculares xs yss = undefined

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

longCamino :: [(Float,Float)] -> Float
longCamino xs = undefined

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

-- ---------------------------------------------------------------------
-- 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
sumaEquidistantes :: Num a => [a] -> [a]
sumaEquidistantes xs = reverse (drop (div (length xs) 2) [a+b | (a,b) <- zip xs (reverse xs)])

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

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

ultima, primera :: Int -> Int
ultima n = undefined
primera n = undefined

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

encadenadoC :: [Int] -> Bool
encadenadoC xs = undefined

</source>

Relación 4

2021-10-28T18:51:17Z

Elsdomgon:

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

-- ---------------------------------------------------------------------
-- 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
libreDeCuadrados :: Int -> Bool
libreDeCuadrados n = null [x | x<- cuadrados n, mod n x == 0]
where cuadrados n = [x^2 | x <- [2..n]]

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

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

-- Prof: Falta ver cómo calcular los números especiales de tres cifras!!
-- Lucía Hernández
especial3 = [ 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]]
-- Elsa Domínguez
multiplicidad1 :: Integer -> Integer -> Integer
multiplicidad1 x y = if x == 1 then 1 else sum [1 | n <- [1..y], rem y (x^n) == 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)])]

calificaciones :: [(String,[(String,Int)])] -> String -> [(String,Int)]
calificaciones t p = undefined

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

todasAprobadas :: [(String,[(String,Int)])] -> String -> Bool
todasAprobadas t p = undefined

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

aprobados :: [(String,[(String,Int)])] -> [String]
aprobados t = undefined

-- ---------------------------------------------------------------------
-- 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
angelini :: Integer -> Bool
angelini n = not (null (cifrasIguales n))
where cifrasIguales n = [a | (a,b) <- ns, a == b]
ns = [(a,b) | a <- cifras n, b <- cifras (2*n)]

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

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir la función
-- unitarios :: Int -> [Int]
-- tal (unitarios n) es la lista de números [n,nn, nnn, ....]. Por
-- ejemplo.
-- take 7 (unitarios 3) == [3,33,333,3333,33333,333333,3333333]
-- take 3 (unitarios 1) == [1,11,111]
-- ---------------------------------------------------------------------
-- Lucía Hernández, Elsa Domínguez
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
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"
-- ---------------------------------------------------------------------

masOcurrentes :: Eq a => [a] -> [a]
masOcurrentes xs = undefined

-- ---------------------------------------------------------------------
-- 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
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
deBaseABase10 :: Int -> [Int] -> Int
deBaseABase10 b xs = sum [i*( b^n) | (i,n)<- zip xs [0..length xs -1] ]

-- ---------------------------------------------------------------------
-- 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
conPos1 :: [a] -> [(a,Int)]
conPos1 xs = zip xs [0..length xs-1]

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

pares :: [a] -> [a]
pares cs = undefined

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

perpendiculares :: (Num a, Eq a) => [a] -> [[a]] -> [[a]]
perpendiculares xs yss = undefined

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

longCamino :: [(Float,Float)] -> Float
longCamino xs = undefined

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

-- ---------------------------------------------------------------------
-- 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
sumaEquidistantes :: Num a => [a] -> [a]
sumaEquidistantes xs = reverse (drop (div (length xs) 2) [a+b | (a,b) <- zip xs (reverse xs)])

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

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

ultima, primera :: Int -> Int
ultima n = undefined
primera n = undefined

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

encadenadoC :: [Int] -> Bool
encadenadoC xs = undefined

</source>

Relación 3

2021-10-23T11:21:26Z

Elsdomgon:

<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 [1..n]

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

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

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

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

-- José Manuel García, Lucía Hernández, Adolfo Sagrera Vivancos, Elsa Domínguez
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 3

2021-10-21T18:36:25Z

Elsdomgon:

<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
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
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
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
linea :: Integer -> [Integer]
linea n = [x | x<-[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
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]

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

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

-- ---------------------------------------------------------------------
-- 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
primerAbundanteImpar :: Int
primerAbundanteImpar = head [x | x <- [1,3..], numeroAbundante x]
-- Su cálculo es
-- ghci> primerAbundanteImpar
-- 945

-- ---------------------------------------------------------------------
-- 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
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
-- 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
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
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
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
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
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
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
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
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) | even x && even y && even z = 3
| (even x && even y && odd z)|| (even x && odd y && even z) || (odd x && even y && even z) = 2
| odd x && odd y && odd z = 0
| otherwise = 1
-- Elsa Domínguez
numeroDePares1 :: (Int,Int,Int) -> Int
numeroDePares1 (x,y,z) = sum [1 | a <- [x,y,z], even a]

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

-- ---------------------------------------------------------------------
-- 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
productoEscalar :: [Int] -> [Int] -> Int
productoEscalar xs ys = sum [a*b | (a,b) <- 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
sumaConsecutivos :: [Int] -> [Int]
sumaConsecutivos xs = [a+b | (a,b) <- 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]

-- ---------------------------------------------------------------------
-- 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-16T12:11:01Z

Elsdomgon:

<source lang='haskell'>

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

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

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

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

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

import Test.QuickCheck

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- Lucía Hernández, Elsa Domínguez
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 2

2021-10-13T15:53:16Z

Elsdomgon:

<source lang='haskell'>

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

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

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

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

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

import Test.QuickCheck

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

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

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

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

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

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

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

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

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

-- La propiedad es
prop_raices :: Double -> Double -> Double -> Property
prop_raices a b c = (a /= 0) && not (null (raices a b c)) ==> (sum (raices a b c)) ~= (-b/a) && (product (raices a b c)) ~= (c/a)
-- La comprobación es quickCheck prop_raices
-- +++ OK, passed 100 tests.

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

-- ---------------------------------------------------------------------
-- Ejercicio 11. Los intervalos cerrados se pueden representar mediante
-- una lista de dos números (el primero es el extremo inferior del
-- intervalo y el segundo el superior).
--
-- Definir la función
-- interseccion :: Ord a => [a] -> [a] -> [a]
-- tal que (interseccion i1 i2) es la intersección de los intervalos i1 e
-- i2. Por ejemplo,
-- interseccion [] [3,5] == []
-- interseccion [3,5] [] == []
-- interseccion [2,4] [6,9] == []
-- interseccion [2,6] [6,9] == [6,6]
-- interseccion [2,6] [0,9] == [2,6]
-- interseccion [2,6] [0,4] == [2,4]
-- interseccion [4,6] [0,4] == [4,4]
-- interseccion [5,6] [0,4] == []
-- ---------------------------------------------------------------------
--Lucía Hernández
interseccion :: Ord a => [a] -> [a] -> [a]
interseccion [] _ = []
interseccion _ []= []
interseccion i1 i2 | last i1<head i2 = []
|head i1>last i2 = []
|otherwise = [maximum [head i1,head i2], minimum [last i1,last i2]]
--Laura Arango, Elsa Domínguez
interseccion1 :: Ord a => [a] -> [a] -> [a]
interseccion1 i1 i2 | i1==[] || i2==[] || head i1>last i2 || last i1<head i2 = []
| otherwise = [max (head i1)(head i2), min (last i1)(last i2)]

-- ---------------------------------------------------------------------
-- Ejercicio 12. Comprobar con QuickCheck que la intersección de
-- intervalos es conmutativa.
-- ---------------------------------------------------------------------
--Lucía Hernández, Laura Arango, Elsa Domínguez
-- La propiedad es
prop_interseccion :: Int -> Int -> Int -> Int -> Bool
prop_interseccion a1 a2 b1 b2 = interseccion [a1,a2] [b1,b2] == interseccion [b1,b2] [a1,a2]

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

-- ---------------------------------------------------------------------
-- Ejercicio 13.1. Los números racionales pueden representarse mediante
-- pares de números enteros. Por ejemplo, el número 2/5 puede
-- representarse mediante el par (2,5).
--
-- Definir la función
-- formaReducida :: (Int,Int) -> (Int,Int)
-- tal que (formaReducida x) es la forma reducida del número racional
-- x. Por ejemplo,
-- formaReducida (4,10) == (2,5)
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, Elsa Domínguez
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)
-- ---------------------------------------------------------------------

--Lucía Hernández
sumaRacional :: (Int,Int) -> (Int,Int) -> (Int,Int)
sumaRacional (a,b) (c,d) = if b<d then formaReducida((div s b)*a + c, s)
else formaReducida(a+ (div s d)*c, s)
where s = lcm b d
-- Elsa Domínguez
sumaRacional1 :: (Int,Int) -> (Int,Int) -> (Int,Int)
sumaRacional1 (a,b) (c,d) = formaReducida (a*d + c*b, b*d)

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

-- ---------------------------------------------------------------------
-- Ejercicio 13.5. Definir la función
-- igualdadRacional :: (Int,Int) -> (Int,Int) -> Bool
-- tal que (igualdadRacional x y) se verifica si los números racionales
-- x e y son iguales. Por ejemplo,
-- igualdadRacional (6,9) (10,15) == True
-- igualdadRacional (6,9) (11,15) == False
-- igualdadRacional (0,2) (0,-5) == True
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández
igualdadRacional :: (Int,Int) -> (Int,Int) -> Bool
igualdadRacional (a,b) (c,d) = formaReducida (a,b) == formaReducida (c,d)
-- Laura Arango
igualdadRacional1 :: (Int,Int) -> (Int,Int) -> Bool
igualdadRacional1 (a,b) (c,d) = formaReducida (a,b) == formaReducida (c,d)
|| (a==0 && c==0)
|| (b==0 && d==0)
-- Elsa Domínguez
igualdadRacional2 :: (Int,Int) -> (Int,Int) -> Bool
igualdadRacional2 (a,b) (c,d) | a == 0 && c == 0 = True
| b == 0 && d == 0 = True
| otherwise = 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, Lucía Hernández, Laura Arango, Elsa Domínguez
sumaComplejos :: Complejo -> Complejo -> Complejo
sumaComplejos (x1,x2) (y1,y2) = (x1+y1, x2+y2)

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

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

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

--Lucía Hernández
cuadrante1 :: (Int,Int) -> Int
cuadrante1 (0,_) = 0
cuadrante1 (_,0) = 0
cuadrante1 (x1,x2) | x1>0 && x2>0 = 1
| x1<0 && x2>0 = 2
| x1<0 && x2<0 = 3
| otherwise = 4
--Laura Arango, Elsa Domínguez
cuadrante2 :: (Int,Int) -> Int
cuadrante2 (x1,x2) | x1>0 && x2>0 = 1
| x1<0 && x2>0 = 2
| x1<0 && x2<0 = 3
| x1>0 && x2<0 = 4
| otherwise = 0

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

-- ----------------------------------------------------------------------------
-- Ejercicio 18. Definir la función
-- simetricoV :: (Int,Int) -> (Int,Int)
-- tal que '(simetricoV p)' es el punto simétrico de 'p' respecto del eje
-- vertical. Por ejemplo,
-- simetricoV (2,5) == (-2,5)
-- simetricoV (2,-5) == (-2,-5)
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango
simetricoV :: (Int,Int) -> (Int,Int)
simetricoV (x1,x2) = (-x1,x2)
- Elsa Domínguez
simetricoV1 :: (Int,Int) -> (Int,Int)
simetricoV1 p = (-fst p,snd p)
-- ----------------------------------------------------------------------------
-- Ejercicio 19. Definir la función
-- distancia :: (Float,Float) -> (Float,Float) -> Float
-- tal que '(distancia p1 p2)' es la distancia entre los puntos 'p1' y 'p2'.
-- Por ejemplo,
-- distancia (1,2) (4,6) == 5.0
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, Elsa Domínguez
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, Lucía Hernández, Laura Arango, Elsa Domínguez

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

-- La comprobación es
-- > quickCheck prop_triangular
+++ OK, passed 100 tests.
-- ----------------------------------------------------------------------------
-- Ejercicio 21. Definir la función
-- puntoMedio :: (Float,Float) -> (Float,Float) -> (Float,Float)
-- tal que '(puntoMedio p1 p2)' es el punto medio entre los puntos 'p1' y 'p2'.
-- Por ejemplo,
-- puntoMedio (0,2) (0,6) == (0.0,4.0)
-- puntoMedio (-1,2) (7,6) == (3.0,4.0)
-- ----------------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Laura Arango, Elsa Domínguez
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.
-- ---------------------------------------------------------------------
-- Lucía Hernández
xor1 :: Bool -> Bool -> Bool
xor1 True True = False
xor1 True False = True
xor1 False True = True
xor1 False False = False

-- ---------------------------------------------------------------------
-- Ejercicio 22.2. Definir la función
-- xor2 :: Bool -> Bool -> Bool
-- tal que (xor2 x y) es la disyunción excluyente de x e y, calculada a
-- partir de la tabla de verdad y patrones. Usar 2 ecuaciones, una por
-- cada valor del primer argumento.
-- ---------------------------------------------------------------------
--Lucía Hernández
xor2 :: Bool -> Bool -> Bool
xor2 x y | y/= x = True
| y == x = False

-- ---------------------------------------------------------------------
-- Ejercicio 22.3. Definir la función
-- xor3 :: Bool -> Bool -> Bool
-- tal que (xor3 x y) es la disyunción excluyente de x e y, calculada
-- a partir de la disyunción (||), conjunción (&&) y negación (not).
-- Usar 1 ecuación.
-- ---------------------------------------------------------------------
-- Lucía Hernández
xor3 :: Bool -> Bool -> Bool
xor3 x y = (x && not y) || (y && not x)

-- ---------------------------------------------------------------------
-- Ejercicio 22.4. Definir la función
-- xor4 :: Bool -> Bool -> Bool
-- tal que (xor3 x y) es la disyunción excluyente de x e y, calculada
-- a partir de desigualdad (/=). Usar 1 ecuación.
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
xor4 :: Bool -> Bool -> Bool
xor4 x y = if x == y then False else True
-- Lucía Hernández
xor4' :: Bool -> Bool -> Bool
xor4' x y = if x/=y then True else False
-- ---------------------------------------------------------------------
-- Ejercicio 22.5. Comprobar con QuickCheck que las cuatro definiciones
-- de xor son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández
-- La propiedad es
prop_xor_equivalentes :: Bool -> Bool -> Bool
prop_xor_equivalentes x y = xor1 x y == xor2 x y && xor2 x y == xor3 x y && xor3 x y == xor4 x y

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

-- ---------------------------------------------------------------------
-- Ejercicio 23.1 Definir la función
-- or3 :: Bool -> Bool -> Bool -> Bool
-- tal que (or3 a b c) es la disyunción entre a, b y c; es decir,
-- ocurre a o b o c. Definir la función usando '||'. Por ejemplo,
-- or3 True True False == True
-- or3 False False False == False
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández
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, Lucía Hernández
or3' :: Bool -> Bool -> Bool -> Bool
or3' a b c = or [a,b,c]

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

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

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

-- ---------------------------------------------------------------------
-- Ejercicio 25.2. Definir la función
-- noSiglo20 :: Int -> Bool
-- tal que (noSiglo20 x) indica si el ańo x no perteneció al siglo 20; es decir,
-- si no está comprendido entre el ańo 1901 y 2000.
-- Definirla de tres formas distintas, una usando la función (siglo20 x), otra
-- usando '&&' y otra usando '||'.
--
-- Por ejemplo,
-- noSiglo20 1902 == False
-- noSiglo20 2001 == True
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
noSiglo20 :: Int -> Bool
noSiglo20 x = not (siglo20 x)
noSiglo20' = undefined
noSiglo20'' x = x < 1901 || x >= 2000
-- Lucía Hernández
noSiglo20 :: Int -> Bool
noSiglo20 x = not(siglo20 x)
noSiglo20' x = if x <= 2000 && x > 1901 then False
else True
noSiglo20'' x = x=>2000 || x< 1901
-- Elsa Domínguez
noSiglo20 :: Int -> Bool
noSiglo20 x = siglo20 x == False
noSiglo20' x = not (x >= 1901 && x <= 2000)
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
-- ---------------------------------------------------------------------
-- Lucía Hernández

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

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

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

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

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

-- Lucía Hernández

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 2

2021-10-06T18:33:09Z

Elsdomgon:

<source lang='haskell'>

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

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

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

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

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

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
-- divisionSegura :: Double -> Double -> Double
-- tal que (divisionSegura x y) es x/y si y no es cero y 9999 en caso
-- contrario. Por ejemplo,
-- divisionSegura 7 2 == 3.5
-- divisionSegura 7 0 == 9999.0
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Elsa Domínguez
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, Elsa Domínguez
intercambia :: (a,b) -> (b,a)
intercambia (a,b) = (b,a)
-- Lucía Hernández
intercambia1 :: (a,b) -> (b,a)
intercambia1 p = (snd p, fst p)
-- ---------------------------------------------------------------------
-- Ejercicio 3. Comprobar con QuickCheck que la función intercambia es
-- idempotente; es decir, si se aplica dos veces es lo mismo que no
-- aplicarla ninguna.
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez
-- La propiedad es
prop_intercambia :: (Int,Int) -> Bool
prop_intercambia (a,b) = intercambia (intercambia (a,b)) == (a,b)
-- La comprobación es quickCheck prop_intercambia
+++ OK, passed 100 tests
--Lucía Hernández
-- La propiedad es
prop_intercambia1 :: (Int,Int) -> Bool
prop_intercambia1 p = intercambia1 (intercambia1 p) == p

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

-- Elsa Domínguez
ciclo :: [a] -> [a]
ciclo xs | length xs == 0 = xs
| otherwise = last xs : init xs
--Lucía Hernández
ciclo1 :: [a] -> [a]
ciclo1 xs =if length xs == 0 then []
else last xs:init xs
-- ---------------------------------------------------------------------
-- Ejercicio 4.2. Comprobar que la longitud es un invariante de la
-- función ciclo; es decir, la longitud de (ciclo xs) es la misma que la
-- de xs.
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez, Lucía Hernández
-- La propiedad es
prop_ciclo :: [Int] -> Bool
prop_ciclo xs = length (ciclo xs) == length xs

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

-- ---------------------------------------------------------------------
-- Ejercicio 5. Definir la función
-- numeroMayor :: (Num a, Ord a) => a -> a -> a
-- tal que (numeroMayor x y) es el mayor número de dos cifras que puede
-- construirse con los dígitos x e y. Por ejemplo,
-- numeroMayor 2 5 == 52
-- numeroMayor 5 2 == 52
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez, Lucía Hernández
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
-- Elsa Domínguez
numeroDeRaices1 :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices1 a b c | b^2-4*a*c < 0 = 0
| b^2-4*a*c == 0 = 1
| otherwise = 2
--Lucía Hernández
numeroDeRaices2 :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices2 a b c |(b^2-4*a*c) >0 = 2
|(b^2-4*a*c) == 0 = 1
|otherwise = 0

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir la función
-- raices :: Double -> Double -> Double -> [Double]
-- tal que (raices a b c) es la lista de las raíces reales de la
-- ecuación ax^2 + bx + c = 0. Por ejemplo,
-- raices 1 3 2 == [-1.0,-2.0]
-- raices 1 (-2) 1 == [1.0,1.0]
-- raices 1 0 1 == []
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
raices :: Double -> Double -> Double -> [Double]
raices a b c | b == 0 = []
| otherwise = [(-b+t)/2*a, (-b-t)/2*a]
where t = b^2 - 4*a*c
-- Elsa Domínguez
raices1 :: Double -> Double -> Double -> [Double]
raices1 a b c | b^2-4*a*c == 0 = [-b/2*a, -b/2*a]
| b^2-4*a*c < 0 = []
| b^2-4*a*c > 0 = [(-b+t)/2*a, (-b-t)/2*a]
where t = sqrt (b^2-4*a*c)
--Lucía Hernández
raices2 :: Double -> Double -> Double -> [Double]
raices2 a b c |(b^2-4*a*c) >0 = [(-b+sqrt(b^2-4*a*c))/2*a,(-b-sqrt(b^2-4*a*c))/2*a]
|(b^2-4*a*c) == 0 = [-b/2*a, -b/2*a]
|otherwise = []
-- ---------------------------------------------------------------------
-- 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
--Lucía Hernández
(~=) :: (Fractional a, Ord a) => a -> a -> Bool
x ~= y = if abs(x - y)<0.001 then True
else 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, Lucía Hernández
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 2

2021-10-06T16:53:15Z

Elsdomgon:

<source lang='haskell'>

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

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

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

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

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

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
-- divisionSegura :: Double -> Double -> Double
-- tal que (divisionSegura x y) es x/y si y no es cero y 9999 en caso
-- contrario. Por ejemplo,
-- divisionSegura 7 2 == 3.5
-- divisionSegura 7 0 == 9999.0
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Elsa Domínguez
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, Elsa Domínguez
intercambia :: (a,b) -> (b,a)
intercambia (a,b) = (b,a)
-- Lucía Hernández
intercambia1 :: (a,b) -> (b,a)
intercambia1 p = (snd p, fst p)
-- ---------------------------------------------------------------------
-- Ejercicio 3. Comprobar con QuickCheck que la función intercambia es
-- idempotente; es decir, si se aplica dos veces es lo mismo que no
-- aplicarla ninguna.
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez
-- La propiedad es
prop_intercambia :: (Int,Int) -> Bool
prop_intercambia (a,b) = intercambia (intercambia (a,b)) == (a,b)
-- La comprobación es quickCheck prop_intercambia
+++ OK, passed 100 tests
--Lucía Hernández
-- La propiedad es
prop_intercambia1 :: (Int,Int) -> Bool
prop_intercambia1 p = intercambia1 (intercambia1 p) == p

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

-- Elsa Domínguez
ciclo :: [a] -> [a]
ciclo xs | length xs == 0 = xs
| otherwise = last xs : init xs

-- ---------------------------------------------------------------------
-- Ejercicio 4.2. Comprobar que la longitud es un invariante de la
-- función ciclo; es decir, la longitud de (ciclo xs) es la misma que la
-- de xs.
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez
-- La propiedad es
prop_ciclo :: [Int] -> Bool
prop_ciclo xs = length (ciclo xs) == length xs

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

-- ---------------------------------------------------------------------
-- Ejercicio 5. Definir la función
-- numeroMayor :: (Num a, Ord a) => a -> a -> a
-- tal que (numeroMayor x y) es el mayor número de dos cifras que puede
-- construirse con los dígitos x e y. Por ejemplo,
-- numeroMayor 2 5 == 52
-- numeroMayor 5 2 == 52
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez
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
-- Elsa Domínguez
numeroDeRaices1 :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices1 a b c | b^2-4*a*c < 0 = 0
| b^2-4*a*c == 0 = 1
| otherwise = 2

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir la función
-- raices :: Double -> Double -> Double -> [Double]
-- tal que (raices a b c) es la lista de las raíces reales de la
-- ecuación ax^2 + bx + c = 0. Por ejemplo,
-- raices 1 3 2 == [-1.0,-2.0]
-- raices 1 (-2) 1 == [1.0,1.0]
-- raices 1 0 1 == []
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
raices :: Double -> Double -> Double -> [Double]
raices a b c | b == 0 = []
| otherwise = [(-b+t)/2*a, (-b-t)/2*a]
where t = b^2 - 4*a*c
-- Elsa Domínguez
raices1 :: Double -> Double -> Double -> [Double]
raices1 a b c | b^2-4*a*c == 0 = [-b/2*a]
| b^2-4*a*c < 0 = []
| b^2-4*a*c > 0 = [(-b+t)/2*a, (-b-t)/2*a]
where t = sqrt (b^2-4*a*c)

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

2021-10-06T16:51:54Z

Elsdomgon:

<source lang='haskell'>

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

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

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

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

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

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
-- divisionSegura :: Double -> Double -> Double
-- tal que (divisionSegura x y) es x/y si y no es cero y 9999 en caso
-- contrario. Por ejemplo,
-- divisionSegura 7 2 == 3.5
-- divisionSegura 7 0 == 9999.0
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Elsa Domínguez
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, Elsa Domínguez
intercambia :: (a,b) -> (b,a)
intercambia (a,b) = (b,a)
-- Lucía Hernández
intercambia1 :: (a,b) -> (b,a)
intercambia1 p = (snd p, fst p)
-- ---------------------------------------------------------------------
-- Ejercicio 3. Comprobar con QuickCheck que la función intercambia es
-- idempotente; es decir, si se aplica dos veces es lo mismo que no
-- aplicarla ninguna.
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez
-- La propiedad es
prop_intercambia :: (Int,Int) -> Bool
prop_intercambia (a,b) = intercambia (intercambia (a,b)) == (a,b)
-- La comprobación es quickCheck prop_intercambia
+++ OK, passed 100 tests
--Lucía Hernández
-- La propiedad es
prop_intercambia1 :: (Int,Int) -> Bool
prop_intercambia1 p = intercambia1 (intercambia1 p) == p

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

-- Elsa Domínguez
ciclo :: [a] -> [a]
ciclo xs | length xs == 0 = xs
| otherwise = last xs : init xs

-- ---------------------------------------------------------------------
-- Ejercicio 4.2. Comprobar que la longitud es un invariante de la
-- función ciclo; es decir, la longitud de (ciclo xs) es la misma que la
-- de xs.
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez
-- La propiedad es
prop_ciclo :: [Int] -> Bool
prop_ciclo xs = length (ciclo xs) == length xs

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

-- ---------------------------------------------------------------------
-- Ejercicio 5. Definir la función
-- numeroMayor :: (Num a, Ord a) => a -> a -> a
-- tal que (numeroMayor x y) es el mayor número de dos cifras que puede
-- construirse con los dígitos x e y. Por ejemplo,
-- numeroMayor 2 5 == 52
-- numeroMayor 5 2 == 52
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez
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
-- Elsa Domínguez
numeroDeRaices1 :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices1 a b c | b^2-4*a*c < 0 = 0
| b^2-4*a*c == 0 = 1
| otherwise = 2

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir la función
-- raices :: Double -> Double -> Double -> [Double]
-- tal que (raices a b c) es la lista de las raíces reales de la
-- ecuación ax^2 + bx + c = 0. Por ejemplo,
-- raices 1 3 2 == [-1.0,-2.0]
-- raices 1 (-2) 1 == [1.0,1.0]
-- raices 1 0 1 == []
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
raices :: Double -> Double -> Double -> [Double]
raices a b c | b == 0 = []
| otherwise = [(-b+t)/2*a, (-b-t)/2*a]
where t = b^2 - 4*a*c
-- Elsa Domínguez
raices1 :: Double -> Double -> Double -> [Double]
raices1 a b c | b^2-4*a*c == 0 = [-b/2*a]
| b^2-4*a*c < 0 = []
| b^2-4*a*c > 0 = [(-b+t)/2*a, (-b-t)/2*a]
where t = sqrt (b^2-4*a*c)

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

2021-10-06T16:48:41Z

Elsdomgon:

<source lang='haskell'>

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

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

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

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

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

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
-- divisionSegura :: Double -> Double -> Double
-- tal que (divisionSegura x y) es x/y si y no es cero y 9999 en caso
-- contrario. Por ejemplo,
-- divisionSegura 7 2 == 3.5
-- divisionSegura 7 0 == 9999.0
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Lucía Hernández, Elsa Domínguez
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, Elsa Domínguez
intercambia :: (a,b) -> (b,a)
intercambia (a,b) = (b,a)
-- Lucía Hernández
intercambia1 :: (a,b) -> (b,a)
intercambia1 p = (snd p, fst p)
-- ---------------------------------------------------------------------
-- Ejercicio 3. Comprobar con QuickCheck que la función intercambia es
-- idempotente; es decir, si se aplica dos veces es lo mismo que no
-- aplicarla ninguna.
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero, Elsa Domínguez
-- La propiedad es
prop_intercambia :: (Int,Int) -> Bool
prop_intercambia (a,b) = intercambia (intercambia (a,b)) == (a,b)
-- La comprobación es quickCheck prop_intercambia
+++ OK, passed 100 tests
--Lucía Hernández
-- La propiedad es
prop_intercambia1 :: (Int,Int) -> Bool
prop_intercambia1 p = intercambia1 (intercambia1 p) == p

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

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, Elsa Domínguez
-- 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, Elsa Domínguez
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
-- Elsa Domínguez
numeroDeRaices :: (Num t, Ord t) => t -> t -> t -> Int
numeroDeRaices a b c | b^2-4*a*c < 0 = 0
| b^2-4*a*c == 0 = 1
| otherwise = 2

-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir la función
-- raices :: Double -> Double -> Double -> [Double]
-- tal que (raices a b c) es la lista de las raíces reales de la
-- ecuación ax^2 + bx + c = 0. Por ejemplo,
-- raices 1 3 2 == [-1.0,-2.0]
-- raices 1 (-2) 1 == [1.0,1.0]
-- raices 1 0 1 == []
-- ---------------------------------------------------------------------
-- Ana Sosa Caballero
raices :: Double -> Double -> Double -> [Double]
raices a b c | b == 0 = []
| otherwise = [(-b+t)/2*a, (-b-t)/2*a]
where t = b^2 - 4*a*c
-- Elsa Domínguez
raices :: Double -> Double -> Double -> [Double]
raices a b c | b^2-4*a*c == 0 = [-b/2*a]
| b^2-4*a*c < 0 = []
| b^2-4*a*c > 0 = [(-b+t)/2*a, (-b-t)/2*a]
where t = sqrt (b^2-4*a*c)

-- ---------------------------------------------------------------------
-- 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-10-02T12:04:03Z

Elsdomgon:

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

-- Manuel Alcaide García, Lucía Hernández, Adriana Gordillo Melero, Nicolás Rodríguez Ruiz, Irene Ortega Moncayo, Laura Arango, Ana Sosa Caballero, Adolfo Sagrera Vivancos, Pelayo INfante Pérez, Sara Cerro Torres, Manuel Fco Moreno, Virginia Sánchez, Carmen Blanco, José Manuel Garcia, Rafael Gómez, Jaime Chaves Navarro, Iván García Rodríguez, Elsa Domínguez
media3 x y z = (x+y+z)/3
-- Antonio López García, César Fornis Catalán
media3 x y z = (sum [x,y,z])/3
-- Francisco José Espinosa
media3 x y z = (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
-- ---------------------------------------------------------------------

-- Adriana Gordillo Melero, Nicolás Rodríguez Ruiz, Lucía Hernández, Manuel Fco Moreno, Laura Arango, Ana Sosa Caballero, Sara Cerro Torres, Rafael Gómez, Jaime Chaves Navarro, Iván García Rodríguez
sumamonedas a b c d e = a+b*2+c*5+d*10+e*20
-- Antonio López García, Irene Ortega, César Fornis Catalán, Virginia Sánchez, Elsa Domínguez
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, Carmen Blanco, José Manuel García
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.
-- ---------------------------------------------------------------------

-- 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, Sara Cerro Torres, José Manuel García, Manuel Fco Moreno, Rafael Gómez, Jaime Chaves Navarro, Iván García Rodríguez, Elsa Domínguez
volumenEsfera r = (4/3)*pi*r^3
-- Adolfo Sagrera Vivancos, Carmen Blanco
volumenEsfera r =(4/3)*(pi*r^3)
-- Irene Ortega
volumenEsfera r = pi*(r^3)*4/3
-- Francisco José Espinosa
-- César Fornis Catalán, Virginia Sánchez
volumenEsfera r = (4*pi*r^3)/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, Antonio López García, Lucía González, Nicolás Rodríguez Ruiz, Sara Cerro Torres, Elsa Domínguez
areaDeCoronaCircular r1 r2 = pi*r2^2 - pi*r1^2
--Álvaro Cano, Ana Sosa Caballero, Irene Ortega, César Fornis Catalán,Manuel Fco Moreno, José Manuel García, Rafael Gómez, Iván García Rodríguez
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, Jaime Chaves Navarro
areaDeCoronaCircular r1 r2 = (pi*r2^2)-(pi*r1^2)
-- Carmen Blanco
-- Virginia Sánchez
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, Lucía González, Nicolás Rodríguez Ruiz, Irene Ortega, Carmen Blanco, Manuel Fco Moreno, César Fornis Catalán, Rafael Gómez, Jaime Chaves Navarro, Iván García Rodríguez, Elsa Domínguez
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, Irene Ortega, Nicolás Rodríguez Ruiz, Manuel Fco Moreno, Rafael Gómez, Jaime Chaves Navarro
maxTres x y z = max(max x y)(z)
-- Ana Sosa Caballero, Adolfo Sagrera Vivancos, Iván García Rodríguez
maxTres x y z = max x t
where t = max y z

-- Antonio López García, Lucía González, Carmen Blanco
maxTres x y z = maximum [x,y,z]
--César Fornis Catalán, José Manuel García, Elsa Domínguez
maxTres x y z = max (max 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 , Irene Ortega, Lucía González, Nicolás Rodríguez Ruiz, Carmen Blanco, Adolfo Sagrera Vivancos, José Manuel García, Rafael Gómez, Manuel Fco Moreno, Jaime Chaves Navarro, Iván García Rodríguez, Elsa Domínguez
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, Irene Ortega, Lucía González, Adolfo Sagrera Vivancos, José Manuel García, Rafael Gómez, Manuel Fco Moreno, Jaime Chaves Navarro, Iván García Rodríguez, Elsa Domínguez
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, Irene Ortega, Lucía González, Manuel Fco Moreno, Adolfo Sagrera Vivancos, José Manuel García, Rafael Gómez, Jaime Chaves Navarro, Sara Cerro Torres, Adriana Gordillo, Elsa Domínguez
rango xs = [minimum xs] ++ [maximum xs]
-- Ana Sosa Caballero, Antonio López García, Iván García Rodríguez
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, Lucía Hernández, Manuel Alcaide, Lucía González , Irene Ortega, José Manuel García ,Rafael Gómez, Manuel Fco Moreno, Adolfo Sagrera Vivancos, Jaime Chaves Navarro, Adriana Gordillo, Elsa Domínguez
palindromo xs = xs == reverse xs
--Iván García Rodríguez
palindromo xs = if xs==reverse xs
then "True"
else "False"
-- ---------------------------------------------------------------------
-- 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, Lucía González, Manuel Fco Moreno, Adolfo Sagrera Vivancos, Adriana Gordillo
interior xs = tail (init xs)
--Laura Arango
interior xs = drop 1 (init xs)
--Fernando Ruiz, Antonio López García, Irene Ortega, Jaime Chaves Navarro, Iván García Rodríguez, Elsa Domínguez
interior xs = init (tail xs)
--Manuel Alcaide García
interior xs = init (drop 1 xs)
--José Manuel García
interior xs = reverse (take ((length js)-1) js)
where js = reverse (take ((length xs)-1) 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, Lucía González
finales n xs = drop n xs
-- Lucía Hernández, Adolfo Sagrera Vivancos
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, Fernando Ruiz Mazo, Pelayo Infante, Manuel Fco Moreno, Manuel Alcaide García, Irene Ortega, Adriana Gordillo, Iván García Rodríguez, Elsa Domínguez
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, Adriana Gordillo, Elsa Domínguez
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, Lucía González, Iván García Rodríguez
segmento m n xs = drop (m-1) (take n xs)
-- Fernando Ruiz
segmento m n xs = reverse (drop ((length xs)-n+m-2)(reverse (drop (m-1) xs)))
--Lucía Hernández
segmento m n xs = take (n-m+1)(drop(m-1) xs)
--Manuel Alcaide García, Irene Ortega
segmento m n xs = take (n-(m-1)) (drop (m-1) xs)
--Pelayo Infante
segmento m n xs = drop(m-1) (reverse a)
where a= drop(length xs-n)(reverse 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, Fernando Ruiz, Adriana Gordillo
extremos n xs = take n xs ++ reverse (take n (reverse xs))
-- Irene Ortega, Pelayo Infante, Iván García Rodríguez, Elsa Domínguez
extremos n xs = take n xs ++ drop (length xs-n) 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) (Contraejemplo : mediano 8 10 3)
-- Lucía Hernández
mediano x y z = minimum [maximum [x,y], z] (Contraejemplo : mediano 8 10 3)
-- Antonio López García
mediano x y z = maximum [minimum [x,y], minimum[x,z], minimum[y,z]]
-- Fernando Ruiz Mazo, Irene Ortega
mediano x y z = minimum ([maximum [x,y]] ++ [maximum [y,z]] ++ [maximum [x,z]])
-- Adriana Gordillo, Elsa Domínguez
mediano x y z = (x+y+z)-maximum[x,y,z]-minimum[x,y,z]
-- Lucía Hernández
mediano x y z = maximum [minimum [x,y], minimum [maximum[x,y],z]]
-- Iván García Rodríguez
mediano x y z = max x a where a=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, Lucía Hernández, Irene Ortega, Adriana Gordillo, Elsa Domínguez
tresIguales x y z = x==y && x==z
--Pelayo Infante
tresIguales x y z = x^3==x*y*z
--Iván García Rodríguez
tresIguales x y z = if x==y && y==z
then "True"
else "False"
-- ---------------------------------------------------------------------
-- 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, Lucía Hernández, Adriana Gordillo
tresDiferentes x y z = x/=y && x/=z
-- Ana Sosa Caballero
tresDiferentes x y z = and [x/=y, y/=z, x/=z]
--Irene Ortega
tresDiferentes x y z = x/=y && x/=z && y/=x

-- ---------------------------------------------------------------------
-- 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, Irene Ortega, Elsa Domínguez
cuatroIguales x y z u = tresIguales x y z == True && x==u
-- Lucía Hernández
cuatroIguales x y z u = tresIguales x y z && x==u
-- Adriana Gordillo
cuatroIguales x y z u = x==y && y==z && z==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, Lucía Hernández, Adriana Gordillo, Elsa Domínguez
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
--Lucía Hernández
segundoMinimo xs = minimum (delete(minimum (xs))(nub xs))
-- Adriana Gordillo
segundoMinimo xs = minimum (filter (>minimum xs) xs)
-- Elsa Domínguez
segundoMinimo xs = head (tail(nub (sort xs)))

-- ---------------------------------------------------------------------
-- 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, Elsa Domínguez
kMaximo k xs = reverse (sort (nub xs)) !! (k-1)
--José Manuel Sánchez Parra
kMaximo k xs = maximum(take k xs)
--Lucía Hernández
kMaximo k xs = head(drop(k-1) (reverse(sort (nub xs))))
--Antonio Medinilla Garófano
quitarMaximo xs = delete (maximum xs) xs
kMaximo k xs = maximum ((iterate quitarMaximo (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, Lucía Hernández, José Manuel Sánchez Parra, Elsa Domínguez
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, José Manuel Sánchez Parra, Elsa Domínguez
numPares xs = length (nub (filter even xs))
-- Ana Sosa Caballero
numPares xs = length(group (sort (filter even xs)))
--Lucía Hernández
numPares xs = length(fst(partition even (nub xs)))

</source>

Relación 1

2021-09-25T11:21:02Z

Elsdomgon:

Relación 1

2021-09-25T11:20:29Z

Elsdomgon: