-- I1M 2021-22: Rel_8.hs (24 de noviembre de 2021)
-- Funciones de orden superior y definiciones por plegados.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================
-- ---------------------------------------------------------------------
-- Introducción --
-- ---------------------------------------------------------------------
-- Esta relación tiene contiene ejercicios con funciones de orden
-- superior y definiciones por plegado correspondientes al tema 7
-- http://www.cs.us.es/~jalonso/cursos/i1m/temas/tema-7.html
-- ---------------------------------------------------------------------
-- Importación de librerías auxiliares --
-- ---------------------------------------------------------------------
import Test.QuickCheck
-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
-- segmentos :: (a -> Bool) -> [a] -> [a]
-- tal que (segmentos p xs) es la lista de los segmentos de xs cuyos
-- elementos verifican la propiedad p. Por ejemplo,
-- segmentos even [1,2,0,4,9,6,4,5,7,2] == [[2,0,4],[6,4],[2]]
-- segmentos odd [1,2,0,4,9,6,4,5,7,2] == [[1],[9],[5,7]]
-- ---------------------------------------------------------------------
segmentos :: (a -> Bool) -> [a] -> [[a]]
segmentos = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 2.1. Definir, por comprensión, la función
-- relacionadosC :: (a -> a -> Bool) -> [a] -> Bool
-- tal que (relacionadosC r xs) se verifica si para todo par (x,y) de
-- elementos consecutivos de xs se cumple la relación r. Por ejemplo,
-- relacionadosC (<) [2,3,7,9] == True
-- relacionadosC (<) [2,3,1,9] == False
-- ---------------------------------------------------------------------
relacionadosC :: (a -> a -> Bool) -> [a] -> Bool
relacionadosC r xs = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 2.2. Definir, por recursión, la función
-- relacionadosR :: (a -> a -> Bool) -> [a] -> Bool
-- tal que (relacionadosR r xs) se verifica si para todo par (x,y) de
-- elementos consecutivos de xs se cumple la relación r. Por ejemplo,
-- relacionadosR (<) [2,3,7,9] == True
-- relacionadosR (<) [2,3,1,9] == False
-- ---------------------------------------------------------------------
relacionadosR :: (a -> a -> Bool) -> [a] -> Bool
relacionadosR = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Definir la función
-- agrupa :: Eq a => [[a]] -> [[a]]
-- tal que (agrupa xss) es la lista de las listas obtenidas agrupando
-- los primeros elementos, los segundos, ... Por ejemplo,
-- agrupa [[1..6],[7..9],[10..20]] == [[1,7,10],[2,8,11],[3,9,12]]
-- agrupa [] == []
-- ---------------------------------------------------------------------
agrupa :: Eq a => [[a]] -> [[a]]
agrupa = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Comprobar con QuickChek que la longitud de todos los
-- elementos de (agrupa xs) es igual a la longitud de xs.
-- ---------------------------------------------------------------------
-- La propiedad es
prop_agrupa :: [[Int]] -> Bool
prop_agrupa xss = undefined
-- La comprobación es
-- ---------------------------------------------------------------------
-- Ejercicio 4. Definir, por recursión, la función
-- concatR :: [[a]] -> [a]
-- tal que (concatR xss) es la concatenación de las listas de xss. Por
-- ejemplo,
-- concatR [[1,3],[2,4,6],[1,9]] == [1,3,2,4,6,1,9]
-- ---------------------------------------------------------------------
concatR :: [[a]] -> [a]
concatR = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 5.1. Definir, por comprensión, la función
-- filtraAplicaC :: (a -> b) -> (a -> Bool) -> [a] -> [b]
-- tal que (filtraAplicaC f p xs) es la lista obtenida aplicándole a los
-- elementos de xs que cumplen el predicado p la función f. Por ejemplo,
-- filtraAplicaC (4+) (<3) [1..7] => [5,6]
-- ---------------------------------------------------------------------
filtraAplicaC :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaC f p xs = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Definir, usando map y filter, la función
-- filtraAplicaMF :: (a -> b) -> (a -> Bool) -> [a] -> [b]
-- tal que (filtraAplicaMF f p xs) es la lista obtenida aplicándole a los
-- elementos de xs que cumplen el predicado p la función f. Por ejemplo,
-- filtraAplicaMF (4+) (<3) [1..7] => [5,6]
-- ---------------------------------------------------------------------
filtraAplicaMF :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaMF f p xs = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 5.3. Definir, por recursión, la función
-- filtraAplicaR :: (a -> b) -> (a -> Bool) -> [a] -> [b]
-- tal que (filtraAplicaR f p xs) es la lista obtenida aplicándole a los
-- elementos de xs que cumplen el predicado p la función f. Por ejemplo,
-- filtraAplicaR (4+) (<3) [1..7] => [5,6]
-- ---------------------------------------------------------------------
filtraAplicaR :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaR = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 6.1. Definir, mediante recursión, la función
-- maximumR :: Ord a => [a] -> a
-- tal que (maximumR xs) es el máximo de la lista xs. Por ejemplo,
-- maximumR [3,7,2,5] == 7
-- maximumR ["todo","es","falso"] == "todo"
-- maximumR ["menos","alguna","cosa"] == "menos"
--
-- Nota: La función maximumR es equivalente a la predefinida maximum.
-- ---------------------------------------------------------------------
maximumR :: Ord a => [a] -> a
maximumR = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 6.2. La función de plegado foldr1 está definida por
-- foldr1 :: (a -> a -> a) -> [a] -> a
-- foldr1 _ [x] = x
-- foldr1 f (x:xs) = f x (foldr1 f xs)
--
-- Definir, mediante plegado con foldr1, la función
-- maximumP :: Ord a => [a] -> a
-- tal que (maximumR xs) es el máximo de la lista xs. Por ejemplo,
-- maximumP [3,7,2,5] == 7
-- maximumP ["todo","es","falso"] == "todo"
-- maximumP ["menos","alguna","cosa"] == "menos"
--
-- Nota: La función maximumP es equivalente a la predefinida maximum.
-- ---------------------------------------------------------------------
maximumP :: Ord a => [a] -> a
maximumP = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 7.1. Definir, usando foldr, la función
-- concatP :: [[a]] -> [a]
-- tal que (concatP xss) es la concatenación de las listas de xss. Por
-- ejemplo,
-- concatP [[1,3],[2,4,6],[1,9]] == [1,3,2,4,6,1,9]
-- ---------------------------------------------------------------------
concatP :: [[a]] -> [a]
concatP = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 7.2. Comprobar con QuickCheck que la funciones concatR,
-- concatP y concat son equivalentes.
-- ---------------------------------------------------------------------
-- La propiedad es
prop_concat :: [[Int]] -> Bool
prop_concat xss = undefined
-- La comprobación es
-- ---------------------------------------------------------------------
-- Ejercicio 7.3. Comprobar con QuickCheck que la longitud de
-- (concatP xss) es la suma de las longitudes de los elementos de xss.
-- ---------------------------------------------------------------------
-- La propiedad es
prop_longConcat :: [[Int]] -> Bool
prop_longConcat xss = undefined
-- La comprobación es
-- ---------------------------------------------------------------------
-- Ejercicio 8. Definir, por plegado, la función
-- filtraAplicaP :: (a -> b) -> (a -> Bool) -> [a] -> [b]
-- tal que (filtraAplicaP f p xs) es la lista obtenida aplicándole a los
-- elementos de xs que cumplen el predicado p la función f. Por ejemplo,
-- filtraAplicaP (4+) (<3) [1..7] => [5,6]
-- ---------------------------------------------------------------------
filtraAplicaP :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaP f p = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 9.1. Definir, con la función all, la función
-- relacionadosA :: (a -> a -> Bool) -> [a] -> Bool
-- tal que (relacionadosA r xs) se verifica si para todo par (x,y) de
-- elementos consecutivos de xs se cumple la relación r. Por ejemplo,
-- relacionadosA (<) [2,3,7,9] == True
-- relacionadosA (<) [2,3,1,9] == False
-- ---------------------------------------------------------------------
relacionadosA :: (a -> a -> Bool) -> [a] -> Bool
relacionadosA = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 9.2. Definir, con la función foldr, la función
-- relacionadosP :: (a -> a -> Bool) -> [a] -> Bool
-- tal que (relacionadosP r xs) se verifica si para todo par (x,y) de
-- elementos consecutivos de xs se cumple la relación r. Por ejemplo,
-- relacionadosP (<) [2,3,7,9] == True
-- relacionadosP (<) [2,3,1,9] == False
-- ---------------------------------------------------------------------
relacionadosP :: (a -> a -> Bool) -> [a] -> Bool
relacionadosP = undefined
-- ---------------------------------------------------------------------
-- Ejercicio 9.3. (Basado en el ejercicio 4 del primer parcial del
-- grupo E de 2017)
-- Una lista se dirá muy creciente si cada elemento es mayor estricto
-- que el triple del siguiente.
-- Empleando tan solo (relacionadosA p xs), define el predicado
-- muyCreciente :: [Integer] -> Bool
-- tal que (muyCreciente xs) se verifica si xs es muy creciente. Por
-- ejemplo:
-- muyCreciente [1,5,23,115] == True
-- muyCreciente [1,2,7,14] == False
-- muyCreciente [7] == True
-- muyCreciente [] == True
-- ---------------------------------------------------------------------
muyCreciente :: [Integer] -> Bool
muyCreciente xs = undefined
![Informática de 1º de Matemáticas [Curso 2021-22, Grupo 2]](/WIKIS/I1M2021G2/resources/assets/logoUS.png)