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

Relación 7

2021-11-17T18:50:15Z

Sarcertor:

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

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

-- ---------------------------------------------------------------------
-- 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-17T18:08:46Z

Sarcertor:

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

--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-17T08:16:50Z

Sarcertor:

<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
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
subconjuntoR :: Eq a => [a] -> [a] -> Bool
subconjuntoR [] _ = True
subconjuntoR (x:xs) ys | elem x ys = subconjuntoR xs ys
| otherwise = False

-- ---------------------------------------------------------------------
-- Ejercicio 1.3. Comprobar con QuickCheck que las definiciones
-- subconjunto y subconjuntoR son equivalentes.
-- ---------------------------------------------------------------------
-- Lucía Hernández
-- 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
iguales :: Eq a => [a] -> [a] -> Bool
iguales xs ys = subconjuntoR xs ys && subconjuntoR ys xs

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

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Definir, por comprensió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

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

-- La comprobación es

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

-- La comprobación es

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

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

-- La comprobación es

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

-- ---------------------------------------------------------------------
-- 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
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
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
-- La propiedad es
prop_diferencia :: [Int] -> [Int] -> Bool
prop_diferencia xs ys = diferenciaR xs ys == diferencia xs ys

-- La comprobación es

-- ---------------------------------------------------------------------
-- Ejercicio 8. Comprobar con QuickCheck si la diferencia es
-- conmutativa.
-- ---------------------------------------------------------------------
-- Lucía Hernández

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)

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

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

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

2021-10-19T16:38:03Z

Sarcertor:

<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, Elena Delgado, Víctor Fernández
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, Víctor Fernández
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
-- Elena Delgado
sumaMonedas a b c d e = a+b*2+c*5+d*10+e*20

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

-- 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, Elena Delgado, Víctor Fernández
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, Víctor Fernández
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, Elena Delgado
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, Elena Delgado, Víctor Fernández, Sara Cerro Torres
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, Víctor Fernández, Sara Cerro Torres
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, Elena Delgado
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, Víctor Fernández, Sara Cerro Torres
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, Víctor Fernández, Sara Cerro Torres
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, Víctor Fernández, Sara Cerro Torres
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, Víctor Fernández, Sara Cerro Torres
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, Víctor Fernández, Sara Cerro Torres
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)
--Nicolás Rodríguez Ruiz
interior xs = reverse(tail(reverse(tail xs)))
-- ---------------------------------------------------------------------
-- Ejercicio 12. Definir la función finales tal que (finales n xs) es la
-- lista formada por los n finales elementos de xs. Por ejemplo,
-- finales 3 [2,5,4,7,9,6] == [7,9,6]
-- ---------------------------------------------------------------------
--Álvaro Cano, Víctor Fernández
finales n xs = drop n xs
-- Lucía Hernández, Adolfo Sagrera Vivancos, Nicolás Rodríguez Ruiz
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, Lucía González, Sara Cerro Torres
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, Víctor Fernández
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, Manuel Fco Moreno, Iván García Rodríguez, Adolfo Sagrera Vivancos, Sara Cerro Torres
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, José Manuel García
segmento m n xs = take (n-m+1)(drop(m-1) xs)
--Manuel Alcaide García, Irene Ortega, Nicolás Rodríguez Ruiz
segmento m n xs = take (n-(m-1)) (drop (m-1) xs)
--Pelayo Infante,]
-- ---------------------------------------------------------------------
--Víctor Fernández
extremos n xs = take n xs ++ drop h xs
where h = length xs - n
--Laura Arango
extremos n xs = take n xs ++ finales n XS
-- Ana Sosa Caballero, Lucía Hernández, Fernando Ruiz, Adriana Gordillo, Manuel Fco Moreno,Adolfo Sagrera Vivancos, Nicolás Rodríguez Ruiz, Lucía González
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, José Manuel García
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, Adolfo Sagrera Vivancos, Manuel Fco Moreno, Víctor Fernández, Sara Cerro Torres
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, Manuel Fco Moreno, Elsa Domínguez, Nicolás Rodríguez Ruiz, Víctor Fernández, Sara Cerro Torres
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"
-- Adolfo Sagrera Vivancos, Lucía González
tresIguales x y z = x==y && y==z
--José Manuel García
tresIguales x y z = if x == y && x == 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, Víctor Fernández, Sara Cerro Torres
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
-- Adolfo Sagrera Vivancos, Lucía González, Manuel Fco Moreno
tresDiferentes x y z = x/=y && y/=z && x/=z
--Nicolás Rodríguez Ruiz
tresDiferentes x y z = not(x==y || x==z || z==y)
--José Manuel García
tresDiferentes x y z = if x /= y && x /= z && y /= z then True else False
-- ---------------------------------------------------------------------
-- 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, Elsa Domínguez, Lucía González
cuatroIguales x y z u = tresIguales x y z == True && x==u
-- Lucía Hernández, Nicolás Rodríguez Ruiz, Adolfo Sagrera Vivancos, Manuel Fco Moreno, Adriana Gordillo, Irene Ortega, Sara Cerro Torres
cuatroIguales x y z u = tresIguales x y z && x==u
-- José Manuel García
cuatroIguales x y z u = x==y && y==z && z==u
-- Alereyvil
cuatroiguales' x y z u = if x==y && y==z && z==u
then True
else False
--Víctor Fernández
cuatroIguales x y z u = and [tresIguales x y z, u == x]
-- ---------------------------------------------------------------------
-- 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, Lucía González, Manuel Fco Moreno, Adolfo Sagrera Vivancos, José Manuel García, Irene Ortega, Víctor Fernández, Sara Cerro Torres
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, Sara Cerro Torres
segundoMinimo xs = sort (nub xs) !! 1
--Lucía Hernández, Irene Ortega
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)))
-- Manuel Fco Moreno
segundoMinimo xs = last (take 2 (sort(nub xs)))
--Pelayo Infante, Lucía González
segundoMinimo xs = head ( drop 1 (sort (nub xs)))
-- Adolfo Sagrera Vivancos
segundoMinimo xs = minimum (drop 1(sort(nub xs)))
--José Manuel García
segundoMinimo xs = minimum (delete (minimum js) js)
where js = nub xs
--Víctor Fernández
segundoMinimo xs = (drop 1(take 2 (sort (nub 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, Lucía González, Manuel Fco Moreno, Sara Cerro Torres
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))
--Fernando Ruiz Mazo
kMaximoRecursivo k xs = if k==1 then maximum(nub(xs)) else kMaximoRecursivo (k-1) (init(sort(nub xs)))
-- Adolfo Sagrera Vivancos
kMaximo k xs = maximum(drop (k-1)(reverse(sort(nub xs))))
--César Fornis Catalán
kMaximo k xs = head(drop (k-1) (reverse(sort(nub xs))))
--José Manuel García
kMaximo k xs = head (js \\ (take (k-1) js))
where js = reverse (sort (nub xs))
--Nicolás Rodríguez Ruiz
kMaximo k xs = sort(nub xs) !! ((length (nub(xs))) - k)
-- Alereyvil
kMaximo' k xs = take k ys
where ys == sort xs
-- ---------------------------------------------------------------------
-- 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, Manuel Fco Moreno, Lucía Hernández, José Manuel Sánchez Parra, Elsa Domínguez, Lucía González, Adolfo Sagrera Vivancos, Irene Ortega, Sara Cerro Torres
numPermut xs = length (permutations xs)
--Nicolás Rodríguez Ruiz, José Manuel García
numPermut xs = product [1..(length xs)]
--César Fornis Catalán
numPermut xs = length (permutations(nub 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, Sara Cerro Torres
numPares xs = length (nub (filter even xs))
-- Ana Sosa Caballero
numPares xs = length(group (sort (filter even xs)))
--Lucía Hernández, Adolfo Sagrera Vivancos, José Manuel García
numPares xs = length(fst(partition even (nub xs)))
--Lucía González, Manuel Fco Moreno
numPares xs = length (filter even (nub xs))
</source>

Relación 1

2021-09-30T17:36:50Z

Sarcertor:

<source lang='haskell'>

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

import Data.List

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

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

media3 x y z = undefined
-- Miguel Ángel Martínez
media3 x y z = .sdfsdfadf
-- Manuel Alcaide García, Lucía Hernández, Adriana Gordillo Melero, 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
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
media3 x y z = (x+y+z)/3
-- Francisco José Espinosa
-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir la función sumaMonedas tal que
-- (sumaMonedas a b c d e) es la suma de los euros correspondientes a
-- a monedas de 1 euro, b de 2 euros, c de 5 euros, d 10 euros y
-- e de 20 euros. Por ejemplo,
-- sumaMonedas 0 0 0 0 1 == 20
-- sumaMonedas 0 0 8 0 3 == 100
-- sumaMonedas 1 1 1 1 1 == 38
-- ---------------------------------------------------------------------

sumaMonedas a b c d e = undefined
-- Adriana Gordillo Melero, Nicolás Rodríguez Ruiz, Lucía Hernández, Manuel Fco Moreno, Laura Arango, Ana Sosa Caballero, Sara Cerro Torres, Rafael Gómez, Jaime Chaves Navarro
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
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.
-- ---------------------------------------------------------------------

volumenEsfera r = undefined
-- Adriana Gordillo Melero, Lucía Hernández, Nicolás Rodríguez Ruiz, Laura Arango, Ana Sosa Caballero, Antonio López García, Lucía González, Pelayo Infante, Sara Cerro Torres, José Manuel García, Manuel Fco Moreno, Rafael Gómez, Jaime Chaves Navarro
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
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,
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
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
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
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
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
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
rango xs = [minimum xs] ++ [maximum xs]
-- Ana Sosa Caballero, Antonio López García
rango xs = [minimum xs, maximum xs]

-- ---------------------------------------------------------------------
-- Ejercicio 10. Definir la función palindromo tal que (palindromo xs) se
-- verifica si xs es un palíndromo; es decir, es lo mismo leer xs de
-- izquierda a derecha que de derecha a izquierda. Por ejemplo,
-- palindromo [3,2,5,2,3] == True
-- palindromo [3,2,5,6,2,3] == False
-- ---------------------------------------------------------------------
--Álvaro Cano, José Manuel Sánchez Parra, Laura Arango, Ana Sosa Caballero, Antonio López García, Lucía Hernández, Manuel Alcaide, Lucía González , Irene Ortega, José Manuel García ,Rafael Gómez, Adolfo Sagrera Vivancos, Jaime Chaves Navarro
palindromo xs = xs == reverse xs

-- ---------------------------------------------------------------------
-- Ejercicio 11. Definir la función interior tal que (interior xs) es la
-- lista obtenida eliminando los extremos de la lista xs. Por ejemplo,
-- interior [2,5,3,7,3] == [5,3,7]
-- interior [2..7] == [3,4,5,6]
-- ---------------------------------------------------------------------
--Lucía Hernández, Ana Sosa Caballero, Lucía González, Adolfo Sagrera Vivancos
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
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 Alcaide García, Irene Ortega
finales n xs = drop (length xs - n) xs
-- ---------------------------------------------------------------------
-- Ejercicio 13. Definir la función segmento tal que (segmento m n xs) es
-- la lista de los elementos de xs comprendidos entre las posiciones m y
-- n. Por ejemplo,
-- segmento 3 4 [3,4,1,2,7,9,0] == [1,2]
-- segmento 3 5 [3,4,1,2,7,9,0] == [1,2,7]
-- segmento 5 3 [3,4,1,2,7,9,0] == []
-- ---------------------------------------------------------------------

--Laura Arango
segmento m n xs = drop (m-1) (reverse (drop a ys))
where a = length xs - n
ys = reverse XS
-- Ana Sosa Caballero, Antonio López García, Lucía González
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
extremos n xs = take n xs ++ reverse (take n (reverse xs))
-- Irene Ortega, Pelayo Infante
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]])

-- ---------------------------------------------------------------------
-- 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
tresIguales x y z = x==y && x==z
--Pelayo Infante
tresIguales x y z = x^3==x*y*z
-- ---------------------------------------------------------------------
-- Ejercicio 17. Definir la función tresDiferentes tal que
-- (tresDiferentes x y z) se verifica si los elementos x, y y z son
-- distintos. Por ejemplo,
-- tresDiferentes 3 5 2 == True
-- tresDiferentes 3 5 3 == False
-- ---------------------------------------------------------------------

--Laura Arango, Lucía Hernández
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
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

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

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

--Laura Arango, Ana Sosa Caballero
kMaximo k xs = reverse (sort (nub xs)) !! (k-1)
--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
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
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-29T08:11:07Z

Sarcertor:

Relación 1

2021-09-29T08:06:56Z

Sarcertor: