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

Informática (1º Matemáticas)

2022-01-18T18:21:04Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]], [[Relación 9 Sol |Solución ]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]], [[Relación 10 Sol |Solución ]] ]
* '''Relación 11''': Listas infinitas y evaluación perezosa. [ [[Media:Rel_11.hs |Enunciado]], [[Relación 11 |Solución colaborativa]], [[Relación 11 Sol |Solución ]] ]
* '''Relación 12''': Tipos de datos algebraicos (I), Árboles binarios. [ [[Media:Rel_12.hs |Enunciado]], [[Relación 12|Solución colaborativa]], [[Relación 12 Sol |Solución]] ]
* '''Relación 13''': Tipos de datos algebraicos (II), Árboles binarios, expresiones y árboles genéricos. [ [[Media:Rel_13.hs |Enunciado]], [[Relación 13|Solución colaborativa]], [[Relación 13 Sol |Solución ]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Informática (1º Matemáticas)

2022-01-15T18:43:47Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]], [[Relación 9 Sol |Solución ]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]], [[Relación 10 Sol |Solución ]] ]
* '''Relación 11''': Listas infinitas y evaluación perezosa. [ [[Media:Rel_11.hs |Enunciado]], [[Relación 11 |Solución colaborativa]], [[Relación 11 Sol |Solución ]] ]
* '''Relación 12''': Tipos de datos algebraicos (I), Árboles binarios. [ [[Media:Rel_12.hs |Enunciado]], [[Relación 12|Solución colaborativa]], [[Relación 12 Sol |Solución]] ]
* '''Relación 13''': Tipos de datos algebraicos (II), Árboles binarios, expresiones y árboles genéricos. [ [[Media:Rel_13.hs |Enunciado]], [[Relación 13|Solución colaborativa]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Informática (1º Matemáticas)

2022-01-11T12:00:08Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]], [[Relación 9 Sol |Solución ]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]], [[Relación 10 Sol |Solución ]] ]
* '''Relación 11''': Listas infinitas y evaluación perezosa. [ [[Media:Rel_11.hs |Enunciado]], [[Relación 11 |Solución colaborativa]], [[Relación 11 Sol |Solución ]] ]
* '''Relación 12''': Tipos de datos algebraicos (I), Árboles binarios. [ [[Media:Rel_12.hs |Enunciado]], [[Relación 12|Solución colaborativa]] ]
* '''Relación 13''': Tipos de datos algebraicos (II), Árboles binarios, expresiones y árboles genéricos. [ [[Media:Rel_13.hs |Enunciado]], [[Relación 13|Solución colaborativa]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Relación 13 Sol

2022-01-11T11:59:49Z

Mdelamor: Protegió «Relación 13 Sol» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang='haskell'>

-- I1M 2021-22: Relación 13 solución
-- Tipos de datos algebraicos (II).
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

-- En esta relación se presenta ejercicios sobre distintos tipos de
-- datos algebraicos. Concretamente,
-- * Árboles binarios:
-- + Árboles binarios con valores en los nodos.
-- + Árboles binarios con valores en las hojas.
-- + Árboles binarios con valores en las hojas y en los nodos.
-- + Árboles booleanos.
-- * Árboles generales
-- * Expresiones aritméticas
-- + Expresiones aritméticas básicas.
-- + Expresiones aritméticas con una variable.
-- + Expresiones aritméticas con varias variables.
-- + Expresiones aritméticas generales.
-- + Expresiones aritméticas con tipo de operaciones.
-- * Expresiones vectoriales
--
-- Los ejercicios corresponden al tema 9 que se encuentran en
-- http://www.cs.us.es/~jalonso/cursos/temas/tema-9.html

-- ---------------------------------------------------------------------
-- Ejercicio 1.1. Los árboles binarios con valores en los nodos se
-- pueden definir por
-- data Arbol1 a = H1
-- | N1 a (Arbol1 a) (Arbol1 a)
-- deriving (Show, Eq)
-- Por ejemplo, el árbol
-- 9
-- / \
-- / \
-- 8 6
-- / \ / \
-- 3 2 4 5
-- se puede representar por
-- N1 9 (N1 8 (N1 3 H1 H1) (N1 2 H1 H1)) (N1 6 (N1 4 H1 H1) (N1 5 H1 H1))
--
-- Definir por recursión la función
-- sumaArbol :: Num a => Arbol1 a -> a
-- tal (sumaArbol x) es la suma de los valores que hay en el árbol
-- x. Por ejemplo,
-- ghci> sumaArbol (N1 2 (N1 5 (N1 3 H1 H1) (N1 7 H1 H1)) (N1 4 H1 H1))
-- 21
-- ---------------------------------------------------------------------

data Arbol1 a = H1
| N1 a (Arbol1 a) (Arbol1 a)
deriving (Show, Eq)

sumaArbol :: Num a => Arbol1 a -> a
sumaArbol H1 = 0
sumaArbol (N1 x i d) = x + sumaArbol i + sumaArbol d

-- ---------------------------------------------------------------------
-- Ejercicio 1.2. Definir la función
-- mapArbol :: (a -> b) -> Arbol1 a -> Arbol1 b
-- tal que (mapArbol f x) es el árbol que resulta de sustituir cada nodo
-- n del árbol x por (f n). Por ejemplo,
-- ghci> mapArbol (+1) (N1 2 (N1 5 (N1 3 H1 H1) (N1 7 H1 H1)) (N1 4 H1 H1))
-- N1 3 (N1 6 (N1 4 H1 H1) (N1 8 H1 H1)) (N1 5 H1 H1)
-- ---------------------------------------------------------------------

mapArbol :: (a -> b) -> Arbol1 a -> Arbol1 b
mapArbol _ H1 = H1
mapArbol f (N1 x i d) = N1 (f x) (mapArbol f i) (mapArbol f d)

-- ---------------------------------------------------------------------
-- Ejercicio 1.3. Definir la función
-- ramaIzquierda :: Arbol1 a -> [a]
-- tal que (ramaIzquierda a) es la lista de los valores de los nodos de
-- la rama izquierda del árbol a. Por ejemplo,
-- ghci> ramaIzquierda (N1 2 (N1 5 (N1 3 H1 H1) (N1 7 H1 H1)) (N1 4 H1 H1))
-- [2,5,3]
-- ---------------------------------------------------------------------

ramaIzquierda :: Arbol1 a -> [a]
ramaIzquierda H1 = []
ramaIzquierda (N1 x i _) = x : ramaIzquierda i

-- ---------------------------------------------------------------------
-- Ejercicio 1.4. Diremos que un árbol está balanceado si para cada nodo
-- v la diferencia entre el número de nodos (con valor) de sus subárboles
-- izquierdo y derecho es menor o igual que uno.
--
-- Definir la función
-- balanceado :: Arbol1 a -> Bool
-- tal que (balanceado a) se verifica si el árbol a está balanceado. Por
-- ejemplo,
-- balanceado (N1 5 H1 (N1 3 H1 H1)) == True
-- balanceado (N1 5 H1 (N1 3 (N1 4 H1 H1) H1)) == False
-- ---------------------------------------------------------------------

balanceado :: Arbol1 a -> Bool
balanceado H1 = True
balanceado (N1 _ i d) = (abs (numeroNodos i - numeroNodos d) <= 1)
&& balanceado i && balanceado d

-- (numeroNodos a) es el número de nodos del árbol a. Por ejemplo,
-- numeroNodos (N1 5 H1 (N1 3 H1 H1)) == 2
numeroNodos :: Arbol1 a -> Int
numeroNodos H1 = 0
numeroNodos (N1 _ i d) = 1 + numeroNodos i + numeroNodos d

-- ---------------------------------------------------------------------
-- Ejercicio 2. Los árboles binarios con valores en las hojas se pueden
-- definir por
-- data Arbol2 a = H2 a
-- | N2 (Arbol2 a) (Arbol2 a)
-- deriving Show
-- Por ejemplo, los árboles
-- árbol1 árbol2 árbol3 árbol4
-- o o o o
-- / \ / \ / \ / \
-- 1 o o 3 o 3 o 1
-- / \ / \ / \ / \
-- 2 3 1 2 1 4 2 3
-- se representan por
-- arbol1, arbol2, arbol3, arbol4 :: Arbol2 Int
-- arbol1 = N2 (H2 1) (N2 (H2 2) (H2 3))
-- arbol2 = N2 (N2 (H2 1) (H2 2)) (H2 3)
-- arbol3 = N2 (N2 (H2 1) (H2 4)) (H2 3)
-- arbol4 = N2 (N2 (H2 2) (H2 3)) (H2 1)
--
-- Definir la función
-- igualBorde :: Eq a => Arbol2 a -> Arbol2 a -> Bool
-- tal que (igualBorde t1 t2) se verifica si los bordes de los árboles
-- t1 y t2 son iguales. Por ejemplo,
-- igualBorde arbol1 arbol2 == True
-- igualBorde arbol1 arbol3 == False
-- igualBorde arbol1 arbol4 == False
-- ---------------------------------------------------------------------

data Arbol2 a = N2 (Arbol2 a) (Arbol2 a)
| H2 a
deriving Show

arbol1, arbol2, arbol3, arbol4 :: Arbol2 Int
arbol1 = N2 (H2 1) (N2 (H2 2) (H2 3))
arbol2 = N2 (N2 (H2 1) (H2 2)) (H2 3)
arbol3 = N2 (N2 (H2 1) (H2 4)) (H2 3)
arbol4 = N2 (N2 (H2 2) (H2 3)) (H2 1)

igualBorde :: Eq a => Arbol2 a -> Arbol2 a -> Bool
igualBorde t1 t2 = borde t1 == borde t2

-- (borde t) es el borde del árbol t; es decir, la lista de las hojas
-- del árbol t leídas de izquierda a derecha. Por ejemplo,
-- borde arbol4 == [2,3,1]
borde :: Arbol2 a -> [a]
borde (N2 i d) = borde i ++ borde d
borde (H2 x) = [x]

-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Los árboles binarios con valores en las hojas y en los
-- nodos se definen por
-- data Arbol3 a = H3 a
-- | N3 a (Arbol3 a) (Arbol3 a)
-- deriving Show
-- Por ejemplo, los árboles
-- 5 8 5 5
-- / \ / \ / \ / \
-- / \ / \ / \ / \
-- 9 7 9 3 9 2 4 7
-- / \ / \ / \ / \ / \ / \
-- 1 4 6 8 1 4 6 2 1 4 6 2
-- se pueden representar por
-- ej3arbol1, ej3arbol2, ej3arbol3, ej3arbol4 :: Arbol3 Int
-- ej3arbol1 = N3 5 (N3 9 (H3 1) (H3 4)) (N3 7 (H3 6) (H3 8))
-- ej3arbol2 = N3 8 (N3 9 (H3 1) (H3 4)) (N3 3 (H3 6) (H3 2))
-- ej3arbol3 = N3 5 (N3 9 (H3 1) (H3 4)) (H3 2)
-- ej3arbol4 = N3 5 (H3 4) (N3 7 (H3 6) (H3 2))
--
-- Definir la función
-- igualEstructura :: Arbol3 -> Arbol3 -> Bool
-- tal que (igualEstructura a1 a1) se verifica si los árboles a1 y a2
-- tienen la misma estructura. Por ejemplo,
-- igualEstructura ej3arbol1 ej3arbol2 == True
-- igualEstructura ej3arbol1 ej3arbol3 == False
-- igualEstructura ej3arbol1 ej3arbol4 == False
-- ---------------------------------------------------------------------

data Arbol3 a = H3 a
| N3 a (Arbol3 a) (Arbol3 a)
deriving (Show, Eq)

ej3arbol1, ej3arbol2, ej3arbol3, ej3arbol4 :: Arbol3 Int
ej3arbol1 = N3 5 (N3 9 (H3 1) (H3 4)) (N3 7 (H3 6) (H3 8))
ej3arbol2 = N3 8 (N3 9 (H3 1) (H3 4)) (N3 3 (H3 6) (H3 2))
ej3arbol3 = N3 5 (N3 9 (H3 1) (H3 4)) (H3 2)
ej3arbol4 = N3 5 (H3 4) (N3 7 (H3 6) (H3 2))

igualEstructura :: Arbol3 a -> Arbol3 a -> Bool
igualEstructura (H3 _) (H3 _) = True
igualEstructura (N3 _ i1 d1) (N3 _ i2 d2) =
igualEstructura i1 i2 && igualEstructura d1 d2
igualEstructura _ _ = False

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Definir la función
-- algunoArbol :: Arbol3 t -> (t -> Bool) -> Bool
-- tal que (algunoArbol a p) se verifica si algún elemento del árbol a
-- cumple la propiedad p. Por ejemplo,
-- algunoArbol (N3 5 (N3 3 (H3 1) (H3 4)) (H3 2)) (>4) == True
-- algunoArbol (N3 5 (N3 3 (H3 1) (H3 4)) (H3 2)) (>7) == False
-- ---------------------------------------------------------------------

algunoArbol :: Arbol3 a -> (a -> Bool) -> Bool
algunoArbol (H3 x) p = p x
algunoArbol (N3 x i d) p = p x || algunoArbol i p || algunoArbol d p

-- ---------------------------------------------------------------------
-- Ejercicio 3.3. Un elemento de un árbol se dirá de nivel k si aparece
-- en el árbol a distancia k de la raíz.
--
-- Definir la función
-- nivel :: Int -> Arbol3 a -> [a]
-- tal que (nivel k a) es la lista de los elementos de nivel k del árbol
-- a. Por ejemplo,
-- nivel 0 (N3 7 (N3 2 (H3 5) (H3 4)) (H3 9)) == [7]
-- nivel 1 (N3 7 (N3 2 (H3 5) (H3 4)) (H3 9)) == [2,9]
-- nivel 2 (N3 7 (N3 2 (H3 5) (H3 4)) (H3 9)) == [5,4]
-- nivel 3 (N3 7 (N3 2 (H3 5) (H3 4)) (H3 9)) == []
-- ---------------------------------------------------------------------

nivel :: Int -> Arbol3 a -> [a]
nivel 0 (H3 x) = [x]
nivel 0 (N3 x _ _) = [x]
nivel _ (H3 _ ) = []
nivel k (N3 _ i d) = nivel (k-1) i ++ nivel (k-1) d

-- ---------------------------------------------------------------------
-- Ejercicio 3.4. Los divisores medios de un número son los que ocupan
-- la posición media entre los divisores de n, ordenados de menor a
-- mayor. Por ejemplo, los divisores de 60 son
-- [1,2,3,4,5,6,10,12,15,20,30,60] y sus divisores medios son 6 y 10.
--
-- El árbol de factorización de un número compuesto n se construye de la
-- siguiente manera:
-- * la raíz es el número n,
-- * la rama izquierda es el árbol de factorización de su divisor
-- medio menor y
-- * la rama derecha es el árbol de factorización de su divisor
-- medio mayor
-- Si el número es primo, su árbol de factorización sólo tiene una hoja
-- con dicho número. Por ejemplo, el árbol de factorización de 60 es
-- 60
-- / \
-- 6 10
-- / \ / \
-- 2 3 2 5
--
-- Definir la función
-- arbolFactorizacion :: Int -> Arbol3
-- tal que (arbolFactorizacion n) es el árbol de factorización de n. Por
-- ejemplo,
-- arbolFactorizacion 60 == N3 60 (N3 6 (H3 2) (H3 3)) (N3 10 (H3 2) (H3 5))
-- arbolFactorizacion 45 == N3 45 (H3 5) (N3 9 (H3 3) (H3 3))
-- arbolFactorizacion 7 == H3 7
-- arbolFactorizacion 9 == N3 9 (H3 3) (H3 3)
-- arbolFactorizacion 14 == N3 14 (H3 2) (H3 7)
-- arbolFactorizacion 28 == N3 28 (N3 4 (H3 2) (H3 2)) (H3 7)
-- arbolFactorizacion 84 == N3 84 (H3 7) (N3 12 (H3 3) (N3 4 (H3 2) (H3 2)))
-- ---------------------------------------------------------------------

-- 1Ş definición
-- =============
arbolFactorizacion :: Int -> Arbol3 Int
arbolFactorizacion n
| esPrimo n = H3 n
| otherwise = N3 n (arbolFactorizacion x) (arbolFactorizacion y)
where (x,y) = divisoresMedio n

-- (esPrimo n) se verifica si n es primo. Por ejemplo,
-- esPrimo 7 == True
-- esPrimo 9 == False
esPrimo :: Int -> Bool
esPrimo n = divisores n == [1,n]

-- (divisoresMedio n) es el par formado por los divisores medios de
-- n. Por ejemplo,
-- divisoresMedio 30 == (5,6)
-- divisoresMedio 7 == (1,7)
-- divisoresMedio 16 == (4,4)
divisoresMedio :: Int -> (Int,Int)
divisoresMedio n = (n `div` x,x)
where xs = divisores n
x = xs !! (length xs `div` 2)

-- (divisores n) es la lista de los divisores de n. Por ejemplo,
-- divisores 30 == [1,2,3,5,6,10,15,30]
divisores :: Int -> [Int]
divisores n = [x | x <- [1..n], n `rem` x == 0]

-- 2Ş definición
-- =============
arbolFactorizacion2 :: Int -> Arbol3 Int
arbolFactorizacion2 n
| x == 1 = H3 n
| otherwise = N3 n (arbolFactorizacion x) (arbolFactorizacion y)
where (x,y) = divisoresMedio n

-- (divisoresMedio2 n) es el par formado por los divisores medios de
-- n. Por ejemplo,
-- divisoresMedio2 30 == (5,6)
-- divisoresMedio2 7 == (1,7)
divisoresMedio2 :: Int -> (Int,Int)
divisoresMedio2 n = (n `div` x,x)
where m = ceiling (sqrt (fromIntegral n))
x = head [y | y <- [m..n], n `rem` y == 0]

-- ---------------------------------------------------------------------
-- Ejercicio 4. Se consideran los árboles con operaciones booleanas
-- definidos por
-- data ArbolB = HB Bool
-- | Conj ArbolB ArbolB
-- | Disy ArbolB ArbolB
-- | Neg ArbolB
--
-- Por ejemplo, los árboles
-- Conj Conj
-- / \ / \
-- / \ / \
-- Disy Conj Disy Conj
-- / \ / \ / \ / \
-- Conj Neg Neg True Conj Neg Neg True
-- / \ | | / \ | |
-- True False False False True False True False
--
-- se definen por
-- ej1, ej2:: ArbolB
-- ej1 = Conj (Disy (Conj (HB True) (HB False))
-- (Neg (HB False)))
-- (Conj (Neg (HB False))
-- (HB True))
--
-- ej2 = Conj (Disy (Conj (HB True) (HB False))
-- (Neg (HB True)))
-- (Conj (Neg (HB False))
-- (HB True))
--
-- Definir la función
-- valorB :: ArbolB -> Bool
-- tal que (valorB ar) es el resultado de procesar el árbol realizando
-- las operaciones booleanas especificadas en los nodos. Por ejemplo,
-- valorB ej1 == True
-- valorB ej2 == False
-- ---------------------------------------------------------------------

data ArbolB = HB Bool
| Conj ArbolB ArbolB
| Disy ArbolB ArbolB
| Neg ArbolB

ej1, ej2 :: ArbolB
ej1 = Conj (Disy (Conj (HB True) (HB False))
(Neg (HB False)))
(Conj (Neg (HB False))
(HB True))

ej2 = Conj (Disy (Conj (HB True) (HB False))
(Neg (HB True)))
(Conj (Neg (HB False))
(HB True))

valorB:: ArbolB -> Bool
valorB (HB x) = x
valorB (Neg a) = not (valorB a)
valorB (Conj i d) = valorB i && valorB d
valorB (Disy i d) = valorB i || valorB d

-- ---------------------------------------------------------------------
-- Ejercicio 5. Los árboles generales se pueden representar mediante el
-- siguiente tipo de dato
-- data ArbolG a = NG a [ArbolG a]
-- deriving (Eq, Show)
-- Por ejemplo, los árboles
-- 1 3 3
-- / \ /|\ / | \
-- 2 3 / | \ / | \
-- | 5 4 7 5 4 7
-- 4 | /\ | | / \
-- 6 2 1 6 1 2 1
-- / \
-- 2 3
-- |
-- 4
-- se representan por
-- ejG1, ejG2, ejG3 :: ArbolG Int
-- ejG1 = NG 1 [NG 2 [],NG 3 [NG 4 []]]
-- ejG2 = NG 3 [NG 5 [NG 6 []],
-- NG 4 [],
-- NG 7 [NG 2 [], NG 1 []]]
-- ejG3 = NG 3 [NG 5 [NG 6 []],
-- NG 4 [NG 1 [NG 2 [],NG 3 [NG 4 []]]],
-- NG 7 [NG 2 [], NG 1 []]]
--
-- Definir la función
-- ramifica :: ArbolG a -> ArbolG a -> (a -> Bool) -> ArbolG a
-- tal que (ramifica a1 a2 p) el árbol que resulta de ańadir una copia
-- del árbol a2 a los nodos de a1 que cumplen un predicado p. Por
-- ejemplo,
-- ramifica ejG1 (NG 8 []) (>4) => NG 1 [NG 2 [],NG 3 [NG 4 []]]
-- ramifica ejG1 (NG 8 []) (>3) => NG 1 [NG 2 [],NG 3 [NG 4 [NG 8 []]]]
-- ramifica ejG1 (NG 8 []) (>2) => NG 1 [NG 2 [],NG 3 [NG 4 [NG 8 []],NG 8 []]]
-- ramifica ejG1 (NG 8 []) (>1) => NG 1 [NG 2 [NG 8 []],NG 3 [NG 4 [NG 8 []],NG 8 []]]
-- ramifica ejG1 (NG 8 []) (>0) => NG 1 [NG 2 [NG 8 []],NG 3 [NG 4 [NG 8 []],NG 8 []],NG 8 []]
-- ---------------------------------------------------------------------

data ArbolG a = NG a [ArbolG a]
deriving (Eq, Show)

ejG1, ejG2, ejG3 :: ArbolG Int
ejG1 = NG 1 [NG 2 [],NG 3 [NG 4 []]]
ejG2 = NG 3 [NG 5 [NG 6 []],
NG 4 [],
NG 7 [NG 2 [], NG 1 []]]
ejG3 = NG 3 [NG 5 [NG 6 []],
NG 4 [NG 1 [NG 2 [],NG 3 [NG 4 []]]],
NG 7 [NG 2 [], NG 1 []]]

ramifica :: ArbolG a -> ArbolG a -> (a -> Bool) -> ArbolG a
ramifica (NG x as) a2 p
| p x = NG x (as' ++ [a2])
| otherwise = NG x as'
where as' = [ramifica a a2 p | a <- as]

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Definir la función
-- nHojasG :: ArbolG a -> Int
-- tal que (nHojas x) es el número de hojas del árbol x. Por ejemplo,
-- nHojasG ejG1 == 2
-- nHojasG ejG2 == 4
-- nHojasG ejG3 == 5
-- ---------------------------------------------------------------------

nHojasG :: ArbolG a -> Int
nHojasG (NG _ []) = 1
nHojasG (NG _ as) = sum $ map nHojasG as

-- ---------------------------------------------------------------------
-- Ejercicio 5.3. Definir la función
-- profundidad :: ArbolG a -> Int
-- tal que (profundidadG x) es la profundidad del árbol x. Por ejemplo,
-- profundidadG ejG1 == 2
-- profundidadG ejG2 == 2
-- profundidadG ejG3 == 4
-- ---------------------------------------------------------------------

profundidadG :: ArbolG a -> Int
profundidadG (NG _ []) = 0
profundidadG (NG _ as) = 1 + (maximum (map profundidadG as))

-- ---------------------------------------------------------------------
-- Ejercicio 5.4. Definir la función
-- bin2gen :: Arbol3 a -> ArbolG a
-- tal que (bin2gen x) es la traducción del árbol x definido con el tipo
-- "Arbol3" (es decir, árbol binario) a "ArbolG" (es decir, árbol
-- genérico). Por ejemplo,
-- bin2gen (N3 9 (N3 3 (H3 2) (H3 4)) (H3 7)) == (NG 9 [NG 3 [NG 2 [],NG 4 []], NG 7 []])
-- ---------------------------------------------------------------------

bin2gen :: Arbol3 a -> ArbolG a
bin2gen (H3 v) = NG v []
bin2gen (N3 v i d) = NG v [bin2gen i,bin2gen d]

-- ---------------------------------------------------------------------
-- Ejercicio 6.1. Las expresiones aritméticas básicas pueden
-- representarse usando el siguiente tipo de datos
-- data Expr1 = C1 Int
-- | S1 Expr1 Expr1
-- | P1 Expr1 Expr1
-- deriving Show
-- Por ejemplo, la expresión 2*(3+7) se representa por
-- P1 (C1 2) (S1 (C1 3) (C1 7))
--
-- Definir la función
-- valor :: Expr1 -> Int
-- tal que (valor e) es el valor de la expresión aritmética e. Por
-- ejemplo,
-- valor (P1 (C1 2) (S1 (C1 3) (C1 7))) == 20
-- ---------------------------------------------------------------------

data Expr1 = C1 Int
| S1 Expr1 Expr1
| P1 Expr1 Expr1
deriving (Show, Eq)

valor :: Expr1 -> Int
valor (C1 x) = x
valor (S1 x y) = valor x + valor y
valor (P1 x y) = valor x * valor y

-- ---------------------------------------------------------------------
-- Ejercicio 6.2. Definir la función
-- aplica :: (Int -> Int) -> Expr1 -> Expr1
-- tal que (aplica f e) es la expresión obtenida aplicando la función f
-- a cada uno de los números de la expresión e. Por ejemplo,
-- ghci> aplica (+2) (s1 (p1 (c1 3) (c1 5)) (p1 (c1 6) (c1 7)))
-- s1 (p1 (c1 5) (c1 7)) (p1 (c1 8) (c1 9))
-- ghci> aplica (*2) (s1 (p1 (c1 3) (c1 5)) (p1 (c1 6) (c1 7)))
-- s1 (p1 (c1 6) (c1 10)) (p1 (c1 12) (c1 14))
-- ---------------------------------------------------------------------

aplica :: (Int -> Int) -> Expr1 -> Expr1
aplica f (C1 x) = C1 (f x)
aplica f (S1 e1 e2) = S1 (aplica f e1) (aplica f e2)
aplica f (P1 e1 e2) = P1 (aplica f e1) (aplica f e2)

-- ---------------------------------------------------------------------
-- Ejercicio 7.1. Las expresiones aritméticas construidas con una
-- variable (denotada por X), los números enteros y las operaciones de
-- sumar y multiplicar se pueden representar mediante el tipo de datos
-- Expr2 definido por
-- data Expr2 = X
-- | C2 Int
-- | S2 Expr2 Expr2
-- | P2 Expr2 Expr2
-- Por ejemplo, la expresión "X*(13+X)" se representa por
-- "P2 X (S2 (C2 13) X)".
--
-- Definir la función
-- valorE :: Expr2 -> Int -> Int
-- tal que (valorE e n) es el valor de la expresión e cuando se
-- sustituye su variable por n. Por ejemplo,
-- valorE (P2 X (S2 (C2 13) X)) 2 == 30
-- ---------------------------------------------------------------------

data Expr2 = X
| C2 Int
| S2 Expr2 Expr2
| P2 Expr2 Expr2

valorE :: Expr2 -> Int -> Int
valorE X n = n
valorE (C2 a) _ = a
valorE (S2 e1 e2) n = valorE e1 n + valorE e2 n
valorE (P2 e1 e2) n = valorE e1 n * valorE e2 n

-- ---------------------------------------------------------------------
-- Ejercicio 7.2. Definir la función
-- numVars :: Expr2 -> Int
-- tal que (numVars e) es el número de variables en la expresión e. Por
-- ejemplo,
-- numVars (C2 3) == 0
-- numVars X == 1
-- numVars (P2 X (S2 (C2 13) X)) == 2
-- ---------------------------------------------------------------------

numVars :: Expr2 -> Int
numVars X = 1
numVars (C2 _) = 0
numVars (S2 a b) = numVars a + numVars b
numVars (P2 a b) = numVars a + numVars b

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Las expresiones aritméticas con variables pueden
-- representarse usando el siguiente tipo de datos
-- data Expr3 = C3 Int
-- | V3 Char
-- | S3 Expr3 Expr3
-- | P3 Expr3 Expr3
-- deriving Show
-- Por ejemplo, la expresión 2*(a+5) se representa por
-- P3 (C3 2) (S3 (V3 'a') (C3 5))
--
-- Definir la función
-- valor3 :: Expr3 -> [(Char,Int)] -> Int
-- tal que (valor3 x e) es el valor3 de la expresión x en el entorno e (es
-- decir, el valor3 de la expresión donde las variables de x se sustituyen
-- por los valores según se indican en el entorno e). Por ejemplo,
-- ghci> valor3 (P3 (C3 2) (S3 (V3 'a') (V3 'b'))) [('a',2),('b',5)]
-- 14
-- ---------------------------------------------------------------------

data Expr3 = C3 Int
| V3 Char
| S3 Expr3 Expr3
| P3 Expr3 Expr3
deriving (Show, Eq)

valor3 :: Expr3 -> [(Char,Int)] -> Int
valor3 (C3 x) _ = x
valor3 (V3 x) e = head [y | (z,y) <- e, z == x]
valor3 (S3 x y) e = valor3 x e + valor3 y e
valor3 (P3 x y) e = valor3 x e * valor3 y e

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir la función
-- sumas :: Expr3 -> Int
-- tal que (sumas e) es el número de sumas en la expresión e. Por
-- ejemplo,
-- sumas (P3 (V3 'z') (S3 (C3 3) (V3 'x'))) == 1
-- sumas (S3 (V3 'z') (S3 (C3 3) (V3 'x'))) == 2
-- sumas (P3 (V3 'z') (P3 (C3 3) (V3 'x'))) == 0
-- ---------------------------------------------------------------------

sumas :: Expr3 -> Int
sumas (V3 _) = 0
sumas (C3 _) = 0
sumas (S3 x y) = 1 + sumas x + sumas y
sumas (P3 x y) = sumas x + sumas y

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Definir la función
-- sustitucion :: Expr3 -> [(Char, Int)] -> Expr3
-- tal que (sustitucion e s) es la expresión obtenida sustituyendo las
-- variables de la expresión e según se indica en la sustitución s. Por
-- ejemplo,
-- ghci> sustitucion (P3 (V3 'z') (S3 (C3 3) (V3 'x'))) [('x',7),('z',9)]
-- P3 (C3 9) (S3 (C3 3) (C3 7))
-- ghci> sustitucion (P3 (V3 'z') (S3 (C3 3) (V3 'y'))) [('x',7),('z',9)]
-- P3 (C3 9) (S3 (C3 3) (V3 'y'))
-- ---------------------------------------------------------------------

sustitucion :: Expr3 -> [(Char, Int)] -> Expr3
sustitucion e [] = e
sustitucion (V3 c) ((d,n):ps) | c == d = C3 n
| otherwise = sustitucion (V3 c) ps
sustitucion (C3 n) _ = C3 n
sustitucion (S3 e1 e2) ps = S3 (sustitucion e1 ps) (sustitucion e2 ps)
sustitucion (P3 e1 e2) ps = P3 (sustitucion e1 ps) (sustitucion e2 ps)

-- ---------------------------------------------------------------------
-- Ejercicio 8.4. Definir la función
-- reducible :: Expr3 -> Bool
-- tal que (reducible a) se verifica si a es una expresión reducible; es
-- decir, contiene una operación en la que los dos operandos son números.
-- Por ejemplo,
-- reducible (S3 (C3 3) (C3 4)) == True
-- reducible (S3 (C3 3) (V3 'x')) == False
-- reducible (S3 (C3 3) (P3 (C3 4) (C3 5))) == True
-- reducible (S3 (V3 'x') (P3 (C3 4) (C3 5))) == True
-- reducible (S3 (C3 3) (P3 (V3 'x') (C3 5))) == False
-- reducible (C3 3) == False
-- reducible (V3 'x') == False
-- ---------------------------------------------------------------------

reducible :: Expr3 -> Bool
reducible (C3 _) = False
reducible (V3 _) = False
reducible (S3 (C3 _) (C3 _)) = True
reducible (S3 a b) = reducible a || reducible b
reducible (P3 (C3 _) (C3 _)) = True
reducible (P3 a b) = reducible a || reducible b

-- ---------------------------------------------------------------------
-- Ejercicio 9. Las expresiones aritméticas generales se pueden definir
-- usando el siguiente tipo de datos
-- data Expr4 = C4 Int
-- | Y
-- | S4 Expr4 Expr4
-- | R4 Expr4 Expr4
-- | P4 Expr4 Expr4
-- | E4 Expr4 Int
-- deriving (Eq, Show)
-- Por ejemplo, la expresión
-- 3*x - (x+2)^7
-- se puede definir por
-- R4 (P4 (C4 3) Y) (E4 (S4 Y (C4 2)) 7)
--
-- Definir la función
-- maximo :: Expr4 -> [Int] -> (Int,[Int])
-- tal que (maximo e xs) es el par formado por el máximo valor de la
-- expresión e para los puntos de xs y en qué puntos alcanza el
-- máximo. Por ejemplo,
-- ghci> maximo (E4 (S4 (C4 10) (P4 (R4 (C4 1) Y) Y)) 2) [-3..3]
-- (100,[0,1])
-- ---------------------------------------------------------------------

data Expr4 = C4 Int
| Y
| S4 Expr4 Expr4
| R4 Expr4 Expr4
| P4 Expr4 Expr4
| E4 Expr4 Int
deriving (Eq, Show)

maximo :: Expr4 -> [Int] -> (Int,[Int])
maximo e ns = (m,[n | n <- ns, valor4 e n == m])
where m = maximum [valor4 e n | n <- ns]
valor4 :: Expr4 -> Int -> Int
valor4 (C4 x) _ = x
valor4 Y n = n
valor4 (S4 e1 e2) n = valor4 e1 n + valor4 e2 n
valor4 (R4 e1 e2) n = valor4 e1 n - valor4 e2 n
valor4 (P4 e1 e2) n = valor4 e1 n * valor4 e2 n
valor4 (E4 e1 m1) n = valor4 e1 n ^ m1

-- ---------------------------------------------------------------------
-- Ejercicio 10. Las operaciones de suma, resta y multiplicación se
-- pueden representar mediante el siguiente tipo de datos
-- data Op = Su | Re | Mu
-- La expresiones aritméticas con dichas operaciones se pueden
-- representar mediante el siguiente tipo de dato algebraico
-- data Expr5 = C5 Int
-- | A Op Expr5 Expr
-- Por ejemplo, la expresión
-- (7-3)+(2*5)
-- se representa por
-- A Su (A Re (C5 7) (C5 3)) (A Mu (C5 2) (C5 5))
--
-- Definir la función
-- valorEG :: Expr5 -> Int
-- tal que (valorEG e) es el valorEG de la expresión e. Por ejemplo,
-- valorEG (A Su (A Re (C5 7) (C5 3)) (A Mu (C5 2) (C5 5))) == 14
-- valorEG (A Mu (A Re (C5 7) (C5 3)) (A Su (C5 2) (C5 5))) == 28
-- ---------------------------------------------------------------------

data Op = Su | Re | Mu

data Expr5 = C5 Int | A Op Expr5 Expr5

-- 1Ş definición
valorEG :: Expr5 -> Int
valorEG (C5 x) = x
valorEG (A o e1 e2) = aplica2 o (valorEG e1) (valorEG e2)
where aplica2 :: Op -> Int -> Int -> Int
aplica2 Su x y = x+y
aplica2 Re x y = x-y
aplica2 Mu x y = x*y

-- 2Ş definición
valorEG2 :: Expr5 -> Int
valorEG2 (C5 n) = n
valorEG2 (A o x y) = (sig o) (valorEG2 x) (valorEG2 y)
where sig Su = (+)
sig Mu = (*)
sig Re = (-)

-- ---------------------------------------------------------------------
-- Ejercicio 11. Se consideran las expresiones vectoriales formadas por
-- un vector, la suma de dos expresiones vectoriales o el producto de un
-- entero por una expresión vectorial. El siguiente tipo de dato define
-- las expresiones vectoriales
-- data ExpV = Vec Int Int
-- | Sum ExpV ExpV
-- | Mul Int ExpV
-- deriving Show
--
-- Definir la función
-- valorEV :: ExpV -> (Int,Int)
-- tal que (valorEV e) es el valorEV de la expresión vectorial c. Por
-- ejemplo,
-- valorEV (Vec 1 2) == (1,2)
-- valorEV (Sum (Vec 1 2 ) (Vec 3 4)) == (4,6)
-- valorEV (Mul 2 (Vec 3 4)) == (6,8)
-- valorEV (Mul 2 (Sum (Vec 1 2 ) (Vec 3 4))) == (8,12)
-- valorEV (Sum (Mul 2 (Vec 1 2)) (Mul 2 (Vec 3 4))) == (8,12)
-- ---------------------------------------------------------------------

data ExpV = Vec Int Int
| Sum ExpV ExpV
| Mul Int ExpV
deriving Show

-- 1Ş solución
-- ===========
valorEV :: ExpV -> (Int,Int)
valorEV (Vec x y) = (x,y)
valorEV (Sum e1 e2) = (x1+x2,y1+y2)
where (x1,y1) = valorEV e1
(x2,y2) = valorEV e2
valorEV (Mul n e) = (n*x,n*y)
where (x,y) = valorEV e

-- 2Ş solución
-- ===========
valorEV2 :: ExpV -> (Int,Int)
valorEV2 (Vec a b) = (a, b)
valorEV2 (Sum e1 e2) = suma (valorEV2 e1) (valorEV2 e2)
valorEV2 (Mul n e1) = multiplica n (valorEV2 e1)

suma :: (Int,Int) -> (Int,Int) -> (Int,Int)
suma (a,b) (c,d) = (a+c,b+d)

multiplica :: Int -> (Int, Int) -> (Int, Int)
multiplica n (a,b) = (n*a,n*b)

-- ---------------------------------------------------------------------
-- Ejercicio 12. (Examen 12 de marzo de 2015, grupo 4)
-- ---------------------------------------------------------------------
-- Consideremos los árboles binarios con etiquetas en las
-- hojas y en los nodos. Por ejemplo,
-- 5
-- / \
-- 2 4
-- / \
-- 7 1
-- / \
-- 2 3
--
-- Un camino es una sucesión de nodos desde la raiz hasta una hoja. Por
-- ejemplo, [5,2] y [5,4,1,2] son caminos que llevan a 2, mientras que
-- [5,4,1] no es un camino, pues no lleva a una hoja.
--
-- Definimos el tipo de dato Arbol y el ejemplo por
-- data Arbol = H Int | N Arbol Int Arbol
-- deriving Show
--
-- arb1:: Arbol
-- arb1 = N (H 2) 5 (N (H 7) 4 (N (H 2) 1 (H 3)))
--
-- Definir la función
-- maxLong :: Int -> Arbol -> Int
-- tal que (maxLong x a) es la longitud máxima de los caminos que
-- terminan en x. Por ejemplo,
-- maxLong 3 arb1 == 4
-- maxLong 2 arb1 == 4
-- maxLong 7 arb1 == 3
-- ---------------------------------------------------------------------

data Arbol = H Int | N Arbol Int Arbol
deriving Show

arb1:: Arbol
arb1 = N (H 2) 5 (N (H 7) 4 (N (H 2) 1 (H 3)))

-- 1Ş solución (calculando los caminos)
-- ------------------------------------

-- (caminos x a) es la lista de los caminos en el árbol a desde la raíz
-- hasta las hojas x. Por ejemplo,
-- caminos 2 arb1 == [[5,2],[5,4,1,2]]
-- caminos 3 arb1 == [[5,4,1,3]]
-- caminos 1 arb1 == []
caminos :: Int -> Arbol -> [[Int]]
caminos x (H y) | x == y = [[x]]
| otherwise = []
caminos x (N i r d) = map (r:) (caminos x i ++ caminos x d)

maxLong1 :: Int -> Arbol -> Int
maxLong1 x a = maximum (0: map length (caminos x a))

-- 2Ş solución
-- -----------

maxLong2 :: Int -> Arbol -> Int
maxLong2 x a = maximum (0 : aux x a)
where aux x (H y) | x == y = [1]
| otherwise = []
aux x (N i r d) = map (+1) (aux x i ++ aux x d)

-- ---------------------------------------------------------------------
-- Ejercicio 13. (Examen 5 de diciembre de 2017, grupo 1)
-- ---------------------------------------------------------------------
-- Los árboles con un número variable de sucesores se
-- pueden representar mediante el siguiente tipo de dato
-- data Arbol a = N a [Arbol a]
-- deriving Show
-- Por ejemplo, los árboles
-- 1 1 1
-- / \ / \ / \
-- 8 3 8 3 8 3
-- | /|\ /|\ |
-- 4 4 5 6 4 5 6 7
-- se representan por
-- ej1, ej2, ej3 :: Arbol Int
-- ej1 = N 1 [N 8 [],N 3 [N 4 []]]
-- ej2 = N 1 [N 8 [], N 3 [N 4 [], N 5 [], N 6 []]]
-- ej3 = N 1 [N 8 [N 4 [], N 5 [], N 6 []], N 3 [N 7 []]]
--
-- Definir la función
-- caminosDesdeRaiz :: Arbol a -> [[a]]
-- tal que (caminosDesdeRaiz x) es la lista de todos los caminos desde
-- la raiz. Por ejemplo,
-- caminosDesdeRaiz ej1 == [[1,8],[1,3,4]]
-- caminosDesdeRaiz ej2 == [[1,8],[1,3,4],[1,3,5],[1,3,6]]
-- caminosDesdeRaiz ej3 == [[1,8,4],[1,8,5],[1,8,6],[1,3,7]]
-- ---------------------------------------------------------------------

data Arbol a = N a [Arbol a]
deriving Show

ej1, ej2, ej3 :: Arbol Int
ej1 = N 1 [N 8 [],N 3 [N 4 []]]
ej2 = N 1 [N 8 [], N 3 [N 4 [], N 5 [], N 6 []]]
ej3 = N 1 [N 8 [N 4 [], N 5 [], N 6 []], N 3 [N 7 []]]

caminosDesdeRaiz :: Arbol a -> [[a]]
caminosDesdeRaiz (N r []) = [[r]]
caminosDesdeRaiz (N r as) = map (r:) (concatMap caminosDesdeRaiz as)

-- ---------------------------------------------------------------------
-- Ejercicio 14. (Examen 1 de septiembre de 2016)
-- ---------------------------------------------------------------------
-- Los árboles se pueden representar mediante el siguiente
-- tipo de datos
-- data Arbol a = N a [Arbol a]
-- deriving Show
-- Por ejemplo, los árboles
-- 1 3
-- / \ /|\
-- 2 3 / | \
-- | 5 4 7
-- 4 | /\
-- 6 2 1
-- se representan por
-- ej1, ej2 :: Arbol Int
-- ej1 = N 1 [N 2 [],N 3 [N 4 []]]
-- ej2 = N 3 [N 5 [N 6 []], N 4 [], N 7 [N 2 [], N 1 []]
--
-- Definir la función
-- ramasLargas :: Arbol b -> [[b]]
-- tal que (ramasLargas a) es la lista de las ramas más largas del árbol
-- a. Por ejemplo,
-- ramas ej1 == [[1,3,4]]
-- ramas ej2 == [[3,5,6],[3,7,2],[3,7,1]]
-- ---------------------------------------------------------------------

data Arbol a = N a [Arbol a]
deriving Show

ej1, ej2 :: Arbol Int
ej1 = N 1 [N 2 [],N 3 [N 4 []]]
ej2 = N 3 [N 5 [N 6 []], N 4 [], N 7 [N 2 [], N 1 []]]

ramasLargas :: Arbol b -> [[b]]
ramasLargas a = [xs | xs <- todasRamas,
length xs == m]
where todasRamas = ramas a
m = maximum (map length todasRamas)

-- (ramas a) es la lista de todas las ramas del árbol a. Por ejemplo,
-- ramas ej1 == [[1,2],[1,3,4]]
-- ramas ej2 == [[3,5,6],[3,4],[3,7,2],[3,7,1]]
ramas :: Arbol b -> [[b]]
ramas (N x []) = [[x]]
ramas (N x as) = [x : xs | a <- as, xs <- ramas a]

-- 2Ş solución:
ramas2 :: Arbol b -> [[b]]
ramas2 (N x []) = [[x]]
ramas2 (N x as) = concatMap (map (x:)) (map ramas2 as)

</source>

Relación 13 Sol

2022-01-11T11:59:38Z

Mdelamor: Página creada con «<source lang='haskell'> -- I1M 2021-22: Relación 13 solución -- Tipos de datos algebraicos (II). -- Departamento de Ciencias de la Computación e I.A. -- Universidad de…»

Relación 13

2022-01-11T11:59:12Z

Mdelamor: Página creada con «<source lang='haskell'> -- I1M 2021-22: Relación 13 (14 de enero de 2022) -- Tipos de datos algebraicos (II). -- Departamento de Ciencias de la Computación e I.A. -- Uni…»

<source lang='haskell'>

-- I1M 2021-22: Relación 13 (14 de enero de 2022)
-- Tipos de datos algebraicos (II).
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

-- En esta relación se presenta ejercicios sobre distintos tipos de
-- datos algebraicos. Concretamente,
-- * Árboles binarios:
-- + Árboles binarios con valores en los nodos.
-- + Árboles binarios con valores en las hojas.
-- + Árboles binarios con valores en las hojas y en los nodos.
-- + Árboles booleanos.
-- * Árboles generales
-- * Expresiones aritméticas
-- + Expresiones aritméticas básicas.
-- + Expresiones aritméticas con una variable.
-- + Expresiones aritméticas con varias variables.
-- + Expresiones aritméticas generales.
-- + Expresiones aritméticas con tipo de operaciones.
-- * Expresiones vectoriales
--
-- Los ejercicios corresponden al tema 9 que se encuentran en
-- http://www.cs.us.es/~jalonso/cursos/temas/tema-9.html

-- ---------------------------------------------------------------------
-- Ejercicio 1.1. Los árboles binarios con valores en los nodos se
-- pueden definir por
-- data Arbol1 a = H1
-- | N1 a (Arbol1 a) (Arbol1 a)
-- deriving (Show, Eq)
-- Por ejemplo, el árbol
-- 9
-- / \
-- / \
-- 8 6
-- / \ / \
-- 3 2 4 5
-- se puede representar por
-- N1 9 (N1 8 (N1 3 H1 H1) (N1 2 H1 H1)) (N1 6 (N1 4 H1 H1) (N1 5 H1 H1))
--
-- Definir por recursión la función
-- sumaArbol :: Num a => Arbol1 a -> a
-- tal (sumaArbol x) es la suma de los valores que hay en el árbol
-- x. Por ejemplo,
-- ghci> sumaArbol (N1 2 (N1 5 (N1 3 H1 H1) (N1 7 H1 H1)) (N1 4 H1 H1))
-- 21
-- ---------------------------------------------------------------------

data Arbol1 a = H1
| N1 a (Arbol1 a) (Arbol1 a)
deriving (Show, Eq)

sumaArbol :: Num a => Arbol1 a -> a
sumaArbol = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 1.2. Definir la función
-- mapArbol :: (a -> b) -> Arbol1 a -> Arbol1 b
-- tal que (mapArbol f x) es el árbol que resulta de sustituir cada nodo
-- n del árbol x por (f n). Por ejemplo,
-- ghci> mapArbol (+1) (N1 2 (N1 5 (N1 3 H1 H1) (N1 7 H1 H1)) (N1 4 H1 H1))
-- N1 3 (N1 6 (N1 4 H1 H1) (N1 8 H1 H1)) (N1 5 H1 H1)
-- ---------------------------------------------------------------------

mapArbol :: (a -> b) -> Arbol1 a -> Arbol1 b
mapArbol = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 1.3. Definir la función
-- ramaIzquierda :: Arbol1 a -> [a]
-- tal que (ramaIzquierda a) es la lista de los valores de los nodos de
-- la rama izquierda del árbol a. Por ejemplo,
-- ghci> ramaIzquierda (N1 2 (N1 5 (N1 3 H1 H1) (N1 7 H1 H1)) (N1 4 H1 H1))
-- [2,5,3]
-- ---------------------------------------------------------------------

ramaIzquierda :: Arbol1 a -> [a]
ramaIzquierda = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 1.4. Diremos que un árbol está balanceado si para cada nodo
-- v la diferencia entre el número de nodos (con valor) de sus subárboles
-- izquierdo y derecho es menor o igual que uno.
--
-- Definir la función
-- balanceado :: Arbol1 a -> Bool
-- tal que (balanceado a) se verifica si el árbol a está balanceado. Por
-- ejemplo,
-- balanceado (N1 5 H1 (N1 3 H1 H1)) == True
-- balanceado (N1 5 H1 (N1 3 (N1 4 H1 H1) H1)) == False
-- ---------------------------------------------------------------------

balanceado :: Arbol1 a -> Bool
balanceado = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 2. Los árboles binarios con valores en las hojas se pueden
-- definir por
-- data Arbol2 a = H2 a
-- | N2 (Arbol2 a) (Arbol2 a)
-- deriving Show
-- Por ejemplo, los árboles
-- árbol1 árbol2 árbol3 árbol4
-- o o o o
-- / \ / \ / \ / \
-- 1 o o 3 o 3 o 1
-- / \ / \ / \ / \
-- 2 3 1 2 1 4 2 3
-- se representan por
-- arbol1, arbol2, arbol3, arbol4 :: Arbol2 Int
-- arbol1 = N2 (H2 1) (N2 (H2 2) (H2 3))
-- arbol2 = N2 (N2 (H2 1) (H2 2)) (H2 3)
-- arbol3 = N2 (N2 (H2 1) (H2 4)) (H2 3)
-- arbol4 = N2 (N2 (H2 2) (H2 3)) (H2 1)
--
-- Definir la función
-- igualBorde :: Eq a => Arbol2 a -> Arbol2 a -> Bool
-- tal que (igualBorde t1 t2) se verifica si los bordes de los árboles
-- t1 y t2 son iguales. Por ejemplo,
-- igualBorde arbol1 arbol2 == True
-- igualBorde arbol1 arbol3 == False
-- igualBorde arbol1 arbol4 == False
-- ---------------------------------------------------------------------

data Arbol2 a = N2 (Arbol2 a) (Arbol2 a)
| H2 a
deriving Show

arbol1, arbol2, arbol3, arbol4 :: Arbol2 Int
arbol1 = N2 (H2 1) (N2 (H2 2) (H2 3))
arbol2 = N2 (N2 (H2 1) (H2 2)) (H2 3)
arbol3 = N2 (N2 (H2 1) (H2 4)) (H2 3)
arbol4 = N2 (N2 (H2 2) (H2 3)) (H2 1)

igualBorde :: Eq a => Arbol2 a -> Arbol2 a -> Bool
igualBorde t1 t2 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 3.1. Los árboles binarios con valores en las hojas y en los
-- nodos se definen por
-- data Arbol3 a = H3 a
-- | N3 a (Arbol3 a) (Arbol3 a)
-- deriving Show
-- Por ejemplo, los árboles
-- 5 8 5 5
-- / \ / \ / \ / \
-- / \ / \ / \ / \
-- 9 7 9 3 9 2 4 7
-- / \ / \ / \ / \ / \ / \
-- 1 4 6 8 1 4 6 2 1 4 6 2
-- se pueden representar por
-- ej3arbol1, ej3arbol2, ej3arbol3, ej3arbol4 :: Arbol3 Int
-- ej3arbol1 = N3 5 (N3 9 (H3 1) (H3 4)) (N3 7 (H3 6) (H3 8))
-- ej3arbol2 = N3 8 (N3 9 (H3 1) (H3 4)) (N3 3 (H3 6) (H3 2))
-- ej3arbol3 = N3 5 (N3 9 (H3 1) (H3 4)) (H3 2)
-- ej3arbol4 = N3 5 (H3 4) (N3 7 (H3 6) (H3 2))
--
-- Definir la función
-- igualEstructura :: Arbol3 -> Arbol3 -> Bool
-- tal que (igualEstructura a1 a1) se verifica si los árboles a1 y a2
-- tienen la misma estructura. Por ejemplo,
-- igualEstructura ej3arbol1 ej3arbol2 == True
-- igualEstructura ej3arbol1 ej3arbol3 == False
-- igualEstructura ej3arbol1 ej3arbol4 == False
-- ---------------------------------------------------------------------

data Arbol3 a = H3 a
| N3 a (Arbol3 a) (Arbol3 a)
deriving Show

ej3arbol1, ej3arbol2, ej3arbol3, ej3arbol4 :: Arbol3 Int
ej3arbol1 = N3 5 (N3 9 (H3 1) (H3 4)) (N3 7 (H3 6) (H3 8))
ej3arbol2 = N3 8 (N3 9 (H3 1) (H3 4)) (N3 3 (H3 6) (H3 2))
ej3arbol3 = N3 5 (N3 9 (H3 1) (H3 4)) (H3 2)
ej3arbol4 = N3 5 (H3 4) (N3 7 (H3 6) (H3 2))

igualEstructura :: Arbol3 a -> Arbol3 a -> Bool
igualEstructura = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 3.2. Definir la función
-- algunoArbol :: Arbol3 t -> (t -> Bool) -> Bool
-- tal que (algunoArbol a p) se verifica si algún elemento del árbol a
-- cumple la propiedad p. Por ejemplo,
-- algunoArbol3 (N3 5 (N3 3 (H3 1) (H3 4)) (H3 2)) (>4) == True
-- algunoArbol3 (N3 5 (N3 3 (H3 1) (H3 4)) (H3 2)) (>7) == False
-- ---------------------------------------------------------------------

algunoArbol :: Arbol3 a -> (a -> Bool) -> Bool
algunoArbol = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 3.3. Un elemento de un árbol se dirá de nivel k si aparece
-- en el árbol a distancia k de la raíz.
--
-- Definir la función
-- nivel :: Int -> Arbol3 a -> [a]
-- tal que (nivel k a) es la lista de los elementos de nivel k del árbol
-- a. Por ejemplo,
-- nivel 0 (N3 7 (N3 2 (H3 5) (H3 4)) (H3 9)) == [7]
-- nivel 1 (N3 7 (N3 2 (H3 5) (H3 4)) (H3 9)) == [2,9]
-- nivel 2 (N3 7 (N3 2 (H3 5) (H3 4)) (H3 9)) == [5,4]
-- nivel 3 (N3 7 (N3 2 (H3 5) (H3 4)) (H3 9)) == []
-- ---------------------------------------------------------------------

nivel :: Int -> Arbol3 a -> [a]
nivel = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 3.4. Los divisores medios de un número son los que ocupan
-- la posición media entre los divisores de n, ordenados de menor a
-- mayor. Por ejemplo, los divisores de 60 son
-- [1,2,3,4,5,6,10,12,15,20,30,60] y sus divisores medios son 6 y 10.
--
-- El árbol de factorización de un número compuesto n se construye de la
-- siguiente manera:
-- * la raíz es el número n,
-- * la rama izquierda es el árbol de factorización de su divisor
-- medio menor y
-- * la rama derecha es el árbol de factorización de su divisor
-- medio mayor
-- Si el número es primo, su árbol de factorización sólo tiene una hoja
-- con dicho número. Por ejemplo, el árbol de factorización de 60 es
-- 60
-- / \
-- 6 10
-- / \ / \
-- 2 3 2 5
--
-- Definir la función
-- arbolFactorizacion :: Int -> Arbol3
-- tal que (arbolFactorizacion n) es el árbol de factorización de n. Por
-- ejemplo,
-- arbolFactorizacion 60 == N3 60 (N3 6 (H3 2) (H3 3)) (N3 10 (H3 2) (H3 5))
-- arbolFactorizacion 45 == N3 45 (H3 5) (N3 9 (H3 3) (H3 3))
-- arbolFactorizacion 7 == H3 7
-- arbolFactorizacion 14 == N3 14 (H3 2) (H3 7)
-- arbolFactorizacion 28 == N3 28 (N3 4 (H3 2) (H3 2)) (H3 7)
-- arbolFactorizacion 84 == N3 84 (H3 7) (N3 12 (H3 3) (N3 4 (H3 2) (H3 2)))
-- ---------------------------------------------------------------------

arbolFactorizacion :: Int -> Arbol3 Int
arbolFactorizacion n = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 4. Se consideran los árboles con operaciones booleanas
-- definidos por
-- data ArbolB = HB Bool
-- | Conj ArbolB ArbolB
-- | Disy ArbolB ArbolB
-- | Neg ArbolB
--
-- Por ejemplo, los árboles
-- Conj Conj
-- / \ / \
-- / \ / \
-- Disy Conj Disy Conj
-- / \ / \ / \ / \
-- Conj Neg Neg True Conj Neg Neg True
-- / \ | | / \ | |
-- True False False False True False True False
--
-- se definen por
-- ej1, ej2:: ArbolB
-- ej1 = Conj (Disy (Conj (HB True) (HB False))
-- (Neg (HB False)))
-- (Conj (Neg (HB False))
-- (HB True))
--
-- ej2 = Conj (Disy (Conj (HB True) (HB False))
-- (Neg (HB True)))
-- (Conj (Neg (HB False))
-- (HB True))
--
-- Definir la función
-- valorB :: ArbolB -> Bool
-- tal que (valorB ar) es el resultado de procesar el árbol realizando
-- las operaciones booleanas especificadas en los nodos. Por ejemplo,
-- valorB ej1 == True
-- valorB ej2 == False
-- ---------------------------------------------------------------------

data ArbolB = HB Bool
| Conj ArbolB ArbolB
| Disy ArbolB ArbolB
| Neg ArbolB

ej1, ej2:: ArbolB
ej1 = Conj (Disy (Conj (HB True) (HB False))
(Neg (HB False)))
(Conj (Neg (HB False))
(HB True))

ej2 = Conj (Disy (Conj (HB True) (HB False))
(Neg (HB True)))
(Conj (Neg (HB False))
(HB True))

valorB:: ArbolB -> Bool
valorB = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 5. Los árboles generales se pueden representar mediante el
-- siguiente tipo de dato
-- data ArbolG a = NG a [ArbolG a]
-- deriving (Eq, Show)
-- Por ejemplo, los árboles
-- 1 3 3
-- / \ /|\ / | \
-- 2 3 / | \ / | \
-- | 5 4 7 5 4 7
-- 4 | /\ | | / \
-- 6 2 1 6 1 2 1
-- / \
-- 2 3
-- |
-- 4
-- se representan por
-- ejG1, ejG2, ejG3 :: ArbolG Int
-- ejG1 = NG 1 [NG 2 [],NG 3 [NG 4 []]]
-- ejG2 = NG 3 [NG 5 [NG 6 []],
-- NG 4 [],
-- NG 7 [NG 2 [], NG 1 []]]
-- ejG3 = NG 3 [NG 5 [NG 6 []],
-- NG 4 [NG 1 [NG 2 [],NG 3 [NG 4 []]]],
-- NG 7 [NG 2 [], NG 1 []]]
--
-- Definir la función
-- ramifica :: ArbolG a -> ArbolG a -> (a -> Bool) -> ArbolG a
-- tal que (ramifica a1 a2 p) el árbol que resulta de ańadir una copia
-- del árbol a2 a los nodos de a1 que cumplen un predicado p. Por
-- ejemplo,
-- ramifica ejG1 (NG 8 []) (>4) => NG 1 [NG 2 [],NG 3 [NG 4 []]]
-- ramifica ejG1 (NG 8 []) (>3) => NG 1 [NG 2 [],NG 3 [NG 4 [NG 8 []]]]
-- ramifica ejG1 (NG 8 []) (>2) => NG 1 [NG 2 [],NG 3 [NG 4 [NG 8 []],NG 8 []]]
-- ramifica ejG1 (NG 8 []) (>1) => NG 1 [NG 2 [NG 8 []],NG 3 [NG 4 [NG 8 []],NG 8 []]]
-- ramifica ejG1 (NG 8 []) (>0) => NG 1 [NG 2 [NG 8 []],NG 3 [NG 4 [NG 8 []],NG 8 []],NG 8 []]
-- ---------------------------------------------------------------------

data ArbolG a = NG a [ArbolG a]
deriving (Eq, Show)

ejG1, ejG2, ejG3 :: ArbolG Int
ejG1 = NG 1 [NG 2 [],NG 3 [NG 4 []]]
ejG2 = NG 3 [NG 5 [NG 6 []],
NG 4 [],
NG 7 [NG 2 [], NG 1 []]]
ejG3 = NG 3 [NG 5 [NG 6 []],
NG 4 [NG 1 [NG 2 [],NG 3 [NG 4 []]]],
NG 7 [NG 2 [], NG 1 []]]

ramifica :: ArbolG a -> ArbolG a -> (a -> Bool) -> ArbolG a
ramifica = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 5.2. Definir la función
-- nHojasG :: ArbolG a -> Int
-- tal que (nHojas x) es el número de hojas del árbol x. Por ejemplo,
-- nHojasG ejG1 == 2
-- nHojasG ejG2 == 4
-- nHojasG ejG3 == 5
-- ---------------------------------------------------------------------

nHojasG :: ArbolG a -> Int
nHojasG = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 5.3. Definir la función
-- profundidad :: ArbolG a -> Int
-- tal que (profundidadG x) es la profundidad del árbol x. Por ejemplo,
-- profundidadG ejG1 == 2
-- profundidadG ejG2 == 2
-- profundidadG ejG3 == 4
-- ---------------------------------------------------------------------

profundidadG :: ArbolG a -> Int
profundidadG = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 5.4. Definir la función
-- bin2gen :: Arbol3 a -> ArbolG a
-- tal que (bin2gen x) es la traducción del árbol x definido con el tipo
-- "Arbol3" (es decir, árbol binario) a "ArbolG" (es decir, árbol
-- genérico). Por ejemplo,
-- bin2gen (N3 9 (N3 3 (H3 2) (H3 4)) (H3 7)) == (NG 9 [NG 3 [NG 2 [],NG 4 []], NG 7 []])
-- ---------------------------------------------------------------------

bin2gen :: Arbol3 a -> ArbolG a
bin2gen = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 6.1. Las expresiones aritméticas básicas pueden
-- representarse usando el siguiente tipo de datos
-- data Expr1 = C1 Int
-- | S1 Expr1 Expr1
-- | P1 Expr1 Expr1
-- deriving Show
-- Por ejemplo, la expresión 2*(3+7) se representa por
-- P1 (C1 2) (S1 (C1 3) (C1 7))
--
-- Definir la función
-- valor :: Expr1 -> Int
-- tal que (valor e) es el valor de la expresión aritmética e. Por
-- ejemplo,
-- valor (P1 (C1 2) (S1 (C1 3) (C1 7))) == 20
-- ---------------------------------------------------------------------

data Expr1 = C1 Int
| S1 Expr1 Expr1
| P1 Expr1 Expr1
deriving Show

valor :: Expr1 -> Int
valor = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 6.2. Definir la función
-- aplica :: (Int -> Int) -> Expr1 -> Expr1
-- tal que (aplica f e) es la expresión obtenida aplicando la función f
-- a cada uno de los números de la expresión e. Por ejemplo,
-- ghci> aplica (+2) (S1 (P1 (C1 3) (C1 5)) (P1 (C1 6) (C1 7)))
-- S1 (P1 (C1 5) (C1 7)) (P1 (C1 8) (C1 9))
-- ghci> aplica (*2) (S1 (P1 (C1 3) (C1 5)) (P1 (C1 6) (C1 7)))
-- S1 (P1 (C1 6) (C1 10)) (P1 (C1 12) (C1 14))
-- ---------------------------------------------------------------------

aplica :: (Int -> Int) -> Expr1 -> Expr1
aplica = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 7.1. Las expresiones aritméticas construidas con una
-- variable (denotada por X), los números enteros y las operaciones de
-- sumar y multiplicar se pueden representar mediante el tipo de datos
-- Expr2 definido por
-- data Expr2 = X
-- | C2 Int
-- | S2 Expr2 Expr2
-- | P2 Expr2 Expr2
-- Por ejemplo, la expresión "X*(13+X)" se representa por
-- "P2 X (S2 (C2 13) X)".
--
-- Definir la función
-- valorE :: Expr2 -> Int -> Int
-- tal que (valorE e n) es el valor de la expresión e cuando se
-- sustituye su variable por n. Por ejemplo,
-- valorE (P2 X (S2 (C2 13) X)) 2 == 30
-- ---------------------------------------------------------------------

data Expr2 = X
| C2 Int
| S2 Expr2 Expr2
| P2 Expr2 Expr2

valorE :: Expr2 -> Int -> Int
valorE = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 7.2. Definir la función
-- numVars :: Expr2 -> Int
-- tal que (numVars e) es el número de variables en la expresión e. Por
-- ejemplo,
-- numVars (C2 3) == 0
-- numVars X == 1
-- numVars (P2 X (S2 (C2 13) X)) == 2
-- ---------------------------------------------------------------------

numVars :: Expr2 -> Int
numVars = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Las expresiones aritméticas con variables pueden
-- representarse usando el siguiente tipo de datos
-- data Expr3 = C3 Int
-- | V3 Char
-- | S3 Expr3 Expr3
-- | P3 Expr3 Expr3
-- deriving Show
-- Por ejemplo, la expresión 2*(a+5) se representa por
-- P3 (C3 2) (S3 (V3 'a') (C3 5))
--
-- Definir la función
-- valor3 :: Expr3 -> [(Char,Int)] -> Int
-- tal que (valor3 x e) es el valor3 de la expresión x en el entorno e (es
-- decir, el valor3 de la expresión donde las variables de x se sustituyen
-- por los valores según se indican en el entorno e). Por ejemplo,
-- ghci> valor3 (P3 (C3 2) (S3 (V3 'a') (V3 'b'))) [('a',2),('b',5)]
-- 14
-- ---------------------------------------------------------------------

data Expr3 = C3 Int
| V3 Char
| S3 Expr3 Expr3
| P3 Expr3 Expr3
deriving Show

valor3 :: Expr3 -> [(Char,Int)] -> Int
valor3 = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. Definir la función
-- sumas :: Expr3 -> Int
-- tal que (sumas e) es el número de sumas en la expresión e. Por
-- ejemplo,
-- sumas (P3 (V3 'z') (S3 (C3 3) (V3 'x'))) == 1
-- sumas (S3 (V3 'z') (S3 (C3 3) (V3 'x'))) == 2
-- sumas (P3 (V3 'z') (P3 (C3 3) (V3 'x'))) == 0
-- ---------------------------------------------------------------------

sumas :: Expr3 -> Int
sumas = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Definir la función
-- sustitucion :: Expr3 -> [(Char, Int)] -> Expr3
-- tal que (sustitucion e s) es la expresión obtenida sustituyendo las
-- variables de la expresión e según se indica en la sustitución s. Por
-- ejemplo,
-- ghci> sustitucion (P3 (V3 'z') (S3 (C3 3) (V3 'x'))) [('x',7),('z',9)]
-- P3 (C3 9) (S3 (C3 3) (C3 7))
-- ghci> sustitucion (P3 (V3 'z') (S3 (C3 3) (V3 'y'))) [('x',7),('z',9)]
-- P3 (C3 9) (S3 (C3 3) (V3 'y'))
-- ---------------------------------------------------------------------

sustitucion :: Expr3 -> [(Char, Int)] -> Expr3
sustitucion = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 8.4. Definir la función
-- reducible :: Expr3 -> Bool
-- tal que (reducible a) se verifica si a es una expresión reducible; es
-- decir, contiene una operación en la que los dos operandos son números.
-- Por ejemplo,
-- reducible (S3 (C3 3) (C3 4)) == True
-- reducible (S3 (C3 3) (V3 'x')) == False
-- reducible (S3 (C3 3) (P3 (C3 4) (C3 5))) == True
-- reducible (S3 (V3 'x') (P3 (C3 4) (C3 5))) == True
-- reducible (S3 (C3 3) (P3 (V3 'x') (C3 5))) == False
-- reducible (C3 3) == False
-- reducible (V3 'x') == False
-- ---------------------------------------------------------------------

reducible :: Expr3 -> Bool
reducible = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 9. Las expresiones aritméticas generales se pueden definir
-- usando el siguiente tipo de datos
-- data Expr4 = C4 Int
-- | Y
-- | S4 Expr4 Expr4
-- | R4 Expr4 Expr4
-- | P4 Expr4 Expr4
-- | E4 Expr4 Int
-- deriving (Eq, Show)
-- Por ejemplo, la expresión
-- 3*x - (x+2)^7
-- se puede definir por
-- R4 (P4 (C4 3) Y) (E4 (S4 Y (C4 2)) 7)
--
-- Definir la función
-- maximo :: Expr4 -> [Int] -> (Int,[Int])
-- tal que (maximo e xs) es el par formado por el máximo valor de la
-- expresión e para los puntos de xs y en qué puntos alcanza el
-- máximo. Por ejemplo,
-- ghci> maximo (E4 (S4 (C4 10) (P4 (R4 (C4 1) Y) Y)) 2) [-3..3]
-- (100,[0,1])
-- ---------------------------------------------------------------------

data Expr4 = C4 Int
| Y
| S4 Expr4 Expr4
| R4 Expr4 Expr4
| P4 Expr4 Expr4
| E4 Expr4 Int
deriving (Eq, Show)

maximo :: Expr4 -> [Int] -> (Int,[Int])
maximo e ns = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 10. Las operaciones de suma, resta y multiplicación se
-- pueden representar mediante el siguiente tipo de datos
-- data Op = Su | Re | Mu
-- La expresiones aritméticas con dichas operaciones se pueden
-- representar mediante el siguiente tipo de dato algebraico
-- data Expr5 = C5 Int
-- | A Op Expr5 Expr
-- Por ejemplo, la expresión
-- (7-3)+(2*5)
-- se representa por
-- A Su (A Re (C5 7) (C5 3)) (A Mu (C5 2) (C5 5))
--
-- Definir la función
-- valorEG :: Expr5 -> Int
-- tal que (valorEG e) es el valorEG de la expresión e. Por ejemplo,
-- valorEG (A Su (A Re (C5 7) (C5 3)) (A Mu (C5 2) (C5 5))) == 14
-- valorEG (A Mu (A Re (C5 7) (C5 3)) (A Su (C5 2) (C5 5))) == 28
-- ---------------------------------------------------------------------

data Op = Su | Re | Mu

data Expr5 = C5 Int | A Op Expr5 Expr5

valorEG :: Expr5 -> Int
valorEG = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 11. Se consideran las expresiones vectoriales formadas por
-- un vector, la suma de dos expresiones vectoriales o el producto de un
-- entero por una expresión vectorial. El siguiente tipo de dato define
-- las expresiones vectoriales
-- data ExpV = Vec Int Int
-- | Sum ExpV ExpV
-- | Mul Int ExpV
-- deriving Show
--
-- Definir la función
-- valorEV :: ExpV -> (Int,Int)
-- tal que (valorEV e) es el valorEV de la expresión vectorial c. Por
-- ejemplo,
-- valorEV (Vec 1 2) == (1,2)
-- valorEV (Sum (Vec 1 2 ) (Vec 3 4)) == (4,6)
-- valorEV (Mul 2 (Vec 3 4)) == (6,8)
-- valorEV (Mul 2 (Sum (Vec 1 2 ) (Vec 3 4))) == (8,12)
-- valorEV (Sum (Mul 2 (Vec 1 2)) (Mul 2 (Vec 3 4))) == (8,12)
-- ---------------------------------------------------------------------

data ExpV = Vec Int Int
| Sum ExpV ExpV
| Mul Int ExpV
deriving Show

valorEV :: ExpV -> (Int,Int)
valorEV = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 12. (Examen 12 de marzo de 2015, grupo 4)
-- ---------------------------------------------------------------------
-- Consideremos los árboles binarios con etiquetas en las
-- hojas y en los nodos. Por ejemplo,
-- 5
-- / \
-- 2 4
-- / \
-- 7 1
-- / \
-- 2 3
--
-- Un camino es una sucesión de nodos desde la raiz hasta una hoja. Por
-- ejemplo, [5,2] y [5,4,1,2] son caminos que llevan a 2, mientras que
-- [5,4,1] no es un camino, pues no lleva a una hoja.
--
-- Definimos el tipo de dato Arbol y el ejemplo por
-- data Arbol = H Int | N Arbol Int Arbol
-- deriving Show
--
-- arb1:: Arbol
-- arb1 = N (H 2) 5 (N (H 7) 4 (N (H 2) 1 (H 3)))
--
-- Definir la función
-- maxLong :: Int -> Arbol -> Int
-- tal que (maxLong x a) es la longitud máxima de los caminos que
-- terminan en x. Por ejemplo,
-- maxLong 3 arb1 == 4
-- maxLong 2 arb1 == 4
-- maxLong 7 arb1 == 3
-- ---------------------------------------------------------------------

data Arbol = H Int | N Arbol Int Arbol
deriving Show

arb1:: Arbol
arb1 = N (H 2) 5 (N (H 7) 4 (N (H 2) 1 (H 3)))

maxLong :: Int -> Arbol -> Int
maxLong = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 13. (Examen 5 de diciembre de 2017, grupo 1)
-- ---------------------------------------------------------------------
-- Los árboles con un número variable de sucesores se
-- pueden representar mediante el siguiente tipo de dato
-- data ArbolG a = NG a [ArbolG a]
-- deriving Show
-- Por ejemplo, los árboles
-- 1 1 1
-- / \ / \ / \
-- 8 3 8 3 8 3
-- | /|\ /|\ |
-- 4 4 5 6 4 5 6 7
-- se representan por
-- ej21, ej22, ej23 :: ArbolG Int
-- ej21 = NG 1 [NG 8 [],NG 3 [NG 4 []]]
-- ej22 = NG 1 [NG 8 [], NG 3 [NG 4 [], NG 5 [], NG 6 []]]
-- ej23 = NG 1 [NG 8 [NG 4 [], NG 5 [], NG 6 []], NG 3 [NG 7 []]]
--
-- Definir la función
-- caminosDesdeRaiz :: ArbolG a -> [[a]]
-- tal que (caminosDesdeRaiz x) es la lista de todos los caminos desde
-- la raiz. Por ejemplo,
-- caminosDesdeRaiz ej21 == [[1,8],[1,3,4]]
-- caminosDesdeRaiz ej22 == [[1,8],[1,3,4],[1,3,5],[1,3,6]]
-- caminosDesdeRaiz ej23 == [[1,8,4],[1,8,5],[1,8,6],[1,3,7]]
-- ---------------------------------------------------------------------

ej21, ej22, ej23 :: ArbolG Int
ej21 = NG 1 [NG 8 [],NG 3 [NG 4 []]]
ej22 = NG 1 [NG 8 [], NG 3 [NG 4 [], NG 5 [], NG 6 []]]
ej23 = NG 1 [NG 8 [NG 4 [], NG 5 [], NG 6 []], NG 3 [NG 7 []]]

caminosDesdeRaiz :: ArbolG a -> [[a]]
caminosDesdeRaiz = undefined

-- ---------------------------------------------------------------------
-- Ejercicio 14. (Examen 1 de septiembre de 2016)
-- ---------------------------------------------------------------------
-- Los árboles se pueden representar mediante el siguiente
-- tipo de datos
-- data ArbolG a = NG a [ArbolG a]
-- deriving Show
-- Por ejemplo, los árboles
-- 1 3
-- / \ /|\
-- 2 3 / | \
-- | 5 4 7
-- 4 | /\
-- 6 2 1
-- se representan por
-- ej31, ej32 :: ArbolG Int
-- ej31 = NG 1 [NG 2 [],NG 3 [NG 4 []]]
-- ej32 = NG 3 [NG 5 [NG 6 []], NG 4 [], NG 7 [NG 2 [], NG 1 []]
--
-- Definir la función
-- ramasLargas :: ArbolG b -> [[b]]
-- tal que (ramasLargas a) es la lista de las ramas más largas del árbol
-- a. Por ejemplo,
-- ramas ej31 == [[1,3,4]]
-- ramas ej32 == [[3,5,6],[3,7,2],[3,7,1]]
-- ---------------------------------------------------------------------

ej31, ej32 :: ArbolG Int
ej31 = NG 1 [NG 2 [],NG 3 [NG 4 []]]
ej32 = NG 3 [NG 5 [NG 6 []], NG 4 [], NG 7 [NG 2 [], NG 1 []]]

ramasLargas :: ArbolG b -> [[b]]
ramasLargas = undefined

</source>

Archivo:Rel 13.hs

2022-01-11T11:58:38Z

Mdelamor:

Informática (1º Matemáticas)

2022-01-11T11:47:42Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]], [[Relación 9 Sol |Solución ]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]], [[Relación 10 Sol |Solución ]] ]
* '''Relación 11''': Listas infinitas y evaluación perezosa. [ [[Media:Rel_11.hs |Enunciado]], [[Relación 11 |Solución colaborativa]], [[Relación 11 Sol |Solución ]] ]
* '''Relación 12''': Tipos de datos algebraicos (I), Árboles binarios. [ [[Media:Rel_12.hs |Enunciado]], [[Relación 12|Solución colaborativa]] ]
* '''Relación 13''': Tipos de datos algebraicos (II), Árboles binarios, expresiones y árboles genéricos. [ [[Media:Rel_13.hs |Enunciado]], [[Relación 13|Solución colaborativa]], [[Relación 13 Sol |Solución ]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Informática (1º Matemáticas)

2022-01-07T18:39:33Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]], [[Relación 9 Sol |Solución ]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]], [[Relación 10 Sol |Solución ]] ]
* '''Relación 11''': Listas infinitas y evaluación perezosa. [ [[Media:Rel_11.hs |Enunciado]], [[Relación 11 |Solución colaborativa]], [[Relación 11 Sol |Solución ]] ]
* '''Relación 12''': Tipos de datos algebraicos, Árboles binarios. [ [[Media:Rel_12.hs |Enunciado]], [[Relación 12|Solución colaborativa]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Informática (1º Matemáticas)

2021-12-19T18:17:51Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]], [[Relación 9 Sol |Solución ]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]] ]
* '''Relación 11''': Listas infinitas y evaluación perezosa. [ [[Media:Rel_11.hs |Enunciado]], [[Relación 11 |Solución colaborativa]] ]
* '''Relación 12''': Tipos de datos algebraicos, Árboles binarios. [ [[Media:Rel_12.hs |Enunciado]], [[Relación 12|Solución colaborativa]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Relación 12 Sol

2021-12-19T18:17:31Z

Mdelamor: Protegió «Relación 12 Sol» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang='haskell'>

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

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

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

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

import Test.QuickCheck
import Control.Monad

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

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

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

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

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

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

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

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

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

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

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

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

-- La propiedad es
prop_nNodosProfundidad :: Arbol Int -> Bool
prop_nNodosProfundidad x =
nNodos x <= 2 ^ profundidad x - 1

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

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

preorden :: Arbol a -> [a]
preorden (H x) = [x]
preorden (N x i d) = x : (preorden i ++ preorden d)

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

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

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

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

postorden :: Arbol a -> [a]
postorden (H x) = [x]
postorden (N x i d) = postorden i ++ postorden d ++ [x]

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

preordenIt :: Arbol a -> [a]
preordenIt x' = preordenItAux x' []
where preordenItAux (H x) xs = x:xs
preordenItAux (N x i d) xs =
x : preordenItAux i (preordenItAux d xs)

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

-- La propiedad es
prop_preordenIt :: Arbol Int -> Bool
prop_preordenIt x =
preordenIt x == preorden x

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

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

espejo :: Arbol a -> Arbol a
espejo (H x) = H x
espejo (N x i d) = N x (espejo d) (espejo i)

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

-- La propiedad es
prop_espejo :: Arbol Int -> Bool
prop_espejo x =
espejo (espejo x) == x

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

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

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

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

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

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

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

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

takeArbol :: Int -> Arbol a -> Arbol a
takeArbol _ (H x) = H x
takeArbol 0 (N x _ _) = H x
takeArbol n (N x i d) =
N x (takeArbol (n-1) i) (takeArbol (n-1) d)

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

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

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

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

repeatArbol :: a -> Arbol a
repeatArbol x = N x t t
where t = repeatArbol x

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

replicateArbol :: Int -> a -> Arbol a
replicateArbol n = takeArbol n . repeatArbol

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

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

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

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

mapArbol :: (a -> a) -> Arbol a -> Arbol a
mapArbol f (H x) = H (f x)
mapArbol f (N x i d) = N (f x) (mapArbol f i) (mapArbol f d)

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

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

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

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

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

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

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

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

</source>

Relación 12 Sol

2021-12-19T18:17:23Z

Mdelamor: Página creada con «<source lang='haskell'> -- I1M 2021-22: Relación 12 Solución -- Tipos de datos algebraicos: Árboles binarios. -- Departamento de Ciencias de la Computación e I.A. -- U…»

Relación 12

2021-12-19T18:16:45Z

Mdelamor: Página creada con «<source lang='haskell'> -- I1M 2021-22: Relación 12 (7 de enero de 2022) -- Tipos de datos algebraicos: Árboles binarios. -- Departamento de Ciencias de la Computación…»

<source lang='haskell'>

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

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

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

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

import Test.QuickCheck
import Control.Monad

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

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

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

nHojas :: Arbol a -> Int
nHojas = undefined

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

nNodos :: Arbol a -> Int
nNodos = undefined

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

-- La propiedad es
prop_nHojas :: Arbol Int -> Bool
prop_nHojas x = undefined

-- La comprobación es

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

profundidad :: Arbol a -> Int
profundidad = undefined

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

-- La propiedad es
prop_nNodosProfundidad :: Arbol Int -> Bool
prop_nNodosProfundidad x = undefined

-- La comprobación es

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

preorden :: Arbol a -> [a]
preorden = undefined

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

-- La propiedad es
prop_length_preorden :: Arbol Int -> Bool
prop_length_preorden x = undefined

-- La comprobación es

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

postorden :: Arbol a -> [a]
postorden = undefined

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

preordenIt :: Arbol a -> [a]
preordenIt x = undefined

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

-- La propiedad es
prop_preordenIt :: Arbol Int -> Bool
prop_preordenIt x = undefined

-- La comprobación es

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

espejo :: Arbol a -> Arbol a
espejo = undefined

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

-- La propiedad es
prop_espejo :: Arbol Int -> Bool
prop_espejo x = undefined

-- La comprobación es

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

-- La propiedad es
prop_reverse_preorden_espejo :: Arbol Int -> Bool
prop_reverse_preorden_espejo x = undefined

-- La comprobación es

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

-- La propiedad es
prop_recorrido :: Arbol Int -> Bool
prop_recorrido x = undefined

-- La comprobación es

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

takeArbol :: Int -> Arbol a -> Arbol a
takeArbol = undefined

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

-- La propiedad es
prop_takeArbol:: Int -> Arbol Int -> Property
prop_takeArbol n x = undefined

-- La comprobación es

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

repeatArbol :: a -> Arbol a
repeatArbol x = undefined

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

replicateArbol :: Int -> a -> Arbol a
replicateArbol n = undefined

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

-- La propiedad es
prop_replicateArbol :: Int -> Int -> Property
prop_replicateArbol n x = undefined

-- La comprobación es

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

mapArbol :: (a -> a) -> Arbol a -> Arbol a
mapArbol = undefined

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

-- La propiedad es
prop_mapArbol_espejo :: Arbol Int -> Bool
prop_mapArbol_espejo x = undefined

-- La comprobación es

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

-- La propiedad es
prop_map_preorden :: Arbol Int -> Bool
prop_map_preorden x = undefined

-- La comprobación es

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

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

</source>

Archivo:Rel 12.hs

2021-12-19T18:15:44Z

Mdelamor:

Informática (1º Matemáticas)

2021-12-19T18:14:25Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]], [[Relación 9 Sol |Solución ]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]] ]
* '''Relación 11''': Listas infinitas y evaluación perezosa. [ [[Media:Rel_11.hs |Enunciado]], [[Relación 11 |Solución colaborativa]] ]
* '''Relación 12''': Tipos de datos algebraicos, Árboles binarios. [ [[Media:Rel_12.hs |Enunciado]], [[Relación 12|Solución colaborativa]], [[Relación 12 Sol |Solución]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Informática (1º Matemáticas)

2021-12-13T16:58:47Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]], [[Relación 9 Sol |Solución ]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]] ]
* '''Relación 11''': Listas infinitas y evaluación perezosa. [ [[Media:Rel_11.hs |Enunciado]], [[Relación 11 |Solución colaborativa]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Relación 11 Sol

2021-12-13T16:58:32Z

Mdelamor: Protegió «Relación 11 Sol» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang='haskell'>

-- I1M 2021-22: Relación 11 solución
-- Evaluación perezosa y listas infinitas.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

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

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

import Test.QuickCheck

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

-- 1ª definición:
repite1 :: a -> [a]
repite1 x = x : repite1 x

-- 2ª definición:
repite2 :: a -> [a]
repite2 x = ys
where ys = x:ys

-- La 2ª definición es más eficiente:
-- ghci> last (take 100000000 (repite1 5))
-- 5
-- (46.56 secs, 16001567944 bytes)
-- ghci> last (take 100000000 (repite2 5))
-- 5
-- (2.34 secs, 5601589608 bytes)

-- Usaremos como repite la 2ª definición
repite :: a -> [a]
repite = repite2

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

repiteC :: a -> [a]
repiteC x = [x | _ <- [1..]]

-- La función repite2 es más eficiente que repiteC
-- ghci> last (take 10000000 (repiteC 5))
-- 5
-- (6.05 secs, 1,997,740,536 bytes)
-- ghci> last (take 10000000 (repite2 5))
-- 5
-- (0.31 secs, 541,471,280 bytes)

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

repiteFinitaR :: Int -> a -> [a]
repiteFinitaR n x | n <= 0 = []
| otherwise = x : repiteFinitaR (n-1) x

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

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

-- La función repiteFinitaC es más eficiente que repiteFinitaR
-- ghci> last (repiteFinitaR 10000000 5)
-- 5
-- (17.04 secs, 2,475,222,448 bytes)
-- ghci> last (repiteFinitaC 10000000 5)
-- 5
-- (5.43 secs, 1,511,227,176 bytes)

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

repiteFinita :: Int -> a -> [a]
repiteFinita n x = take n (repite x)

-- La función repiteFinita es más eficiente que repiteFinitaC
-- ghci> last (repiteFinitaC 10000000 5)
-- 5
-- (5.43 secs, 1,511,227,176 bytes)
-- ghci> last (repiteFinita 10000000 5)
-- 5
-- (0.29 secs, 541,809,248 bytes)

-- 2ª definición
repiteFinita2 :: Int -> a -> [a]
repiteFinita2 n = take n . repite

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

-- La propiedad es
prop_repiteFinitaEquiv :: Int -> Int -> Bool
prop_repiteFinitaEquiv n x =
repiteFinitaR n x == y &&
repiteFinitaC n x == y &&
repiteFinita n x == y
where y = replicate n x

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

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

-- La propiedad es
prop_repiteFinitaLongitud :: Int -> Int -> Bool
prop_repiteFinitaLongitud n x
| n > 0 = length (repiteFinita n x) == n
| otherwise = null (repiteFinita n x)

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

-- La expresión de la propiedad se puede simplificar
prop_repiteFinitaLongitud2 :: Int -> Int -> Bool
prop_repiteFinitaLongitud2 n x =
length (repiteFinita n x) == (if n > 0 then n else 0)

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

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

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

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

ecoC :: String -> String
ecoC xs = concat [replicate i x | (i,x) <- zip [1..] xs]

-- 2ª definición
ecoC1 :: String -> String
ecoC1 = concat . zipWith replicate [1..]

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

-- 1ª definición
ecoR :: String -> String
ecoR = aux 1
where aux _ [] = []
aux n (x:xs) = replicate n x ++ aux (n+1) xs

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

itera :: (a -> a) -> a -> [a]
itera f x = x : itera f (f x)

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

agrupaR :: Int -> [a] -> [[a]]
agrupaR _ [] = []
agrupaR n xs = take n xs : agrupaR n (drop n xs)

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

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

-- Puede verse su funcionamiento en el siguiente ejemplo,
-- iterate (drop 2) [5..10]
-- ==> [[5,6,7,8,9,10],[7,8,9,10],[9,10],[],[],...
-- map (take 2) (iterate (drop 2) [5..10])
-- ==> [[5,6],[7,8],[9,10],[],[],[],[],...
-- takeWhile (not . null) (map (take 2) (iterate (drop 2) [5..10]))
-- ==> [[5,6],[7,8],[9,10]]

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

-- La propiedad es
prop_AgrupaLongitud :: Int -> [Int] -> Property
prop_AgrupaLongitud n xs =
n > 0 && not (null gs) ==>
and [length g == n | g <- init gs] &&
0 < length (last gs) && length (last gs) <= n
where gs = agrupa n xs

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

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

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

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

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

siguiente :: Integer -> Integer
siguiente n | even n = n `div` 2
| otherwise = 3*n+1

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

collatzR :: Integer -> [Integer]
collatzR 1 = [1]
collatzR n = n : collatzR (siguiente n)

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

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

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

menorCollatzMayor :: Int -> Integer
menorCollatzMayor x = head [y | y <- [1..], length (collatz y) > x]

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

-- 1ª definición
menorCollatzSupera :: Integer -> Integer
menorCollatzSupera x =
head [n | n <- [1..], any (> x) (collatzR n)]

-- 2ª definición
menorCollatzSupera2 :: Integer -> Integer
menorCollatzSupera2 x =
head [y | y <- [1..], maximum (collatz y) > x]

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

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

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

primos :: Integral a => [a]
primos = criba [2..]
where criba [] = []
criba (n:ns) = n : criba (elimina n ns)
elimina n xs = [x | x <- xs, x `mod` n /= 0]

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

primo :: Int -> Bool
primo n = head (dropWhile (<n) primos) == n

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

sumaDeDosPrimos :: Int -> [(Int,Int)]
sumaDeDosPrimos n =
[(x,n-x) | x <- primosN, primo (n-x)]
where primosN = takeWhile (<= (n `div` 2)) primos

-- El cálculo es
-- ghci> head [x | x <- [1..], length (sumaDeDosPrimos x) == 10]
-- 114

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

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

factoriales1 :: [Integer]
factoriales1 = [factorial n | n <- [0..]]

-- (factorial n) es el factorial de n. Por ejemplo,
-- factorial 4 == 24
factorial :: Integer -> Integer
factorial n = product [1..n]

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

factoriales2 :: [Integer]
factoriales2 = 1 : zipWith (*) [1..] factoriales2

-- El cálculo es
-- take 4 factoriales2
-- = take 4 (1 : zipWith (*) [1..] factoriales2)
-- = 1 : take 3 (zipWith (*) [1..] factoriales2)
-- = 1 : take 3 (zipWith (*) [1..] [1|R1]) {R1 es tail factoriales2}
-- = 1 : take 3 (1 : zipWith (*) [2..] [R1])
-- = 1 : 1 : take 2 (zipWith (*) [2..] [1|R2]) {R2 es drop 2 factoriales2}
-- = 1 : 1 : take 2 (2 : zipWith (*) [3..] [R2])
-- = 1 : 1 : 2 : take 1 (zipWith (*) [3..] [2|R3]) {R3 es drop 3 factoriales2}
-- = 1 : 1 : 2 : take 1 (6 : zipWith (*) [4..] [R3])
-- = 1 : 1 : 2 : 6 : take 0 (zipWith (*) [4..] [R3])
-- = 1 : 1 : 2 : 6 : []
-- = [1, 1, 2, 6]

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Comparar el tiempo y espacio necesarios para calcular
-- las siguientes expresiones
-- let xs = take 3000 factoriales1 in (sum xs - sum xs)
-- let xs = take 3000 factoriales2 in (sum xs - sum xs)
-- ---------------------------------------------------------------------

-- El cálculo es
-- ghci> let xs = take 3000 factoriales1 in (sum xs - sum xs)
-- 0
-- (17.51 secs, 5631214332 bytes)
-- ghci> let xs = take 3000 factoriales2 in (sum xs - sum xs)
-- 0
-- (0.04 secs, 17382284 bytes)

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

factoriales3 :: [Integer]
factoriales3 = 1 : aux 1 [1..]
where aux x (y:ys) = z : aux z ys
where z = x*y

-- El cálculo es
-- take 4 factoriales3
-- = take 4 (1 : aux 1 [1..])
-- = 1 : take 3 (aux 1 [1..])
-- = 1 : take 3 (1 : aux 1 [2..])
-- = 1 : 1 : take 2 (aux 1 [2..])
-- = 1 : 1 : take 2 (2 : aux 2 [3..])
-- = 1 : 1 : 2 : take 1 (aux 2 [3..])
-- = 1 : 1 : 2 : take 1 (6 : aux 6 [4..])
-- = 1 : 1 : 2 : 6 : take 0 (aux 6 [4..])
-- = 1 : 1 : 2 : 6 : []
-- = [1,1,2,6]

-- ---------------------------------------------------------------------
-- Ejercicio 9.5. Comparar el tiempo y espacio necesarios para calcular
-- las siguientes expresiones
-- let xs = take 3000 factoriales2 in (sum xs - sum xs)
-- let xs = take 3000 factoriales3 in (sum xs - sum xs)
-- ---------------------------------------------------------------------

-- El cálculo es
-- ghci> let xs = take 3000 factoriales2 in (sum xs - sum xs)
-- 0
-- (0.04 secs, 17382284 bytes)
-- ghci> let xs = take 3000 factoriales3 in (sum xs - sum xs)
-- 0
-- (0.04 secs, 18110224 bytes)

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

factoriales4 :: [Integer]
factoriales4 = 1 : scanl1 (*) [1..]

-- ---------------------------------------------------------------------
-- Ejercicio 9.7. Comparar el tiempo y espacio necesarios para calcular
-- las siguientes expresiones
-- let xs = take 3000 factoriales3 in (sum xs - sum xs)
-- let xs = take 3000 factoriales4 in (sum xs - sum xs)
-- ---------------------------------------------------------------------

-- El cálculo es
-- ghci> let xs = take 3000 factoriales3 in (sum xs - sum xs)
-- 0
-- (0.04 secs, 18110224 bytes)
-- ghci> let xs = take 3000 factoriales4 in (sum xs - sum xs)
-- 0
-- (0.03 secs, 11965328 bytes)

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

factoriales5 :: [Integer]
factoriales5 = map snd (iterate f (1,1))
where f (x,y) = (x+1,x*y)

-- El cálculo es
-- take 4 factoriales5
-- = take 4 (map snd aux)
-- = take 4 (map snd (iterate f (1,1)))
-- = take 4 (map snd [(1,1),(2,1),(3,2),(4,6),...])
-- = take 4 [1,1,2,6,...]
-- = [1,1,2,6]

-- ---------------------------------------------------------------------
-- Ejercicio 9.9. Comparar el tiempo y espacio necesarios para calcular
-- las siguientes expresiones
-- let xs = take 3000 factoriales4 in (sum xs - sum xs)
-- let xs = take 3000 factoriales5 in (sum xs - sum xs)
-- ---------------------------------------------------------------------

-- El cálculo es
-- ghci> let xs = take 3000 factoriales4 in (sum xs - sum xs)
-- 0
-- (0.04 secs, 18110224 bytes)
-- ghci> let xs = take 3000 factoriales5 in (sum xs - sum xs)
-- 0
-- (0.03 secs, 11965760 bytes)

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

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

fib :: Integer -> Integer
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

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

fibs1 :: [Integer]
fibs1 = [fib n | n <- [0..]]

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

fibs2 :: [Integer]
fibs2 = aux 0 1
where aux x y = x : aux y (x+y)

-- ---------------------------------------------------------------------
-- Ejercicio 10.4. Comparar el tiempo y espacio necesarios para calcular
-- las siguientes expresiones
-- let xs = take 30 fibs1 in (sum xs - sum xs)
-- let xs = take 30 fibs2 in (sum xs - sum xs)
-- ---------------------------------------------------------------------

-- El cálculo es
-- ghci> let xs = take 30 fibs1 in (sum xs - sum xs)
-- 0
-- (6.02 secs, 421589672 bytes)
-- ghci> let xs = take 30 fibs2 in (sum xs - sum xs)
-- 0
-- (0.01 secs, 515856 bytes)

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

fibs3 :: [Integer]
fibs3 = 0 : 1: zipWith (+) fibs3 (tail fibs3)

-- ---------------------------------------------------------------------
-- Ejercicio 10.6. Comparar el tiempo y espacio necesarios para calcular
-- las siguientes expresiones
-- let xs = take 40000 fibs2 in (sum xs - sum xs)
-- let xs = take 40000 fibs3 in (sum xs - sum xs)
-- ---------------------------------------------------------------------

-- El cálculo es
-- ghci> let xs = take 40000 fibs2 in (sum xs - sum xs)
-- 0
-- (0.90 secs, 221634544 bytes)
-- ghci> let xs = take 40000 fibs3 in (sum xs - sum xs)
-- 0
-- (1.14 secs, 219448176 bytes)

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

fibs4 :: [Integer]
fibs4 = fs
where (xs,ys,fs) = (zipWith (+) ys fs, 1:xs, 0:ys)

fibs4' :: [Integer]
fibs4' = fs
where fs = 0:ys
ys = 1:xs
xs = zipWith (+) ys fs

-- El cálculo de fibs4 es
-- +------------------------+-----------------+-------------------+
-- | xs = zipWith (+) ys fs | ys = 1:xs | fs = 0:ys |
-- +------------------------+-----------------+-------------------+
-- | | 1:... | 0:... |
-- | | ^ | ^ |
-- | 1:... | 1:1:... | 0:1:1:... |
-- | | ^ | ^ |
-- | 1:2:... | 1:1:2:... | 0:1:1:2:... |
-- | | ^ | ^ |
-- | 1:2:3:... | 1:1:2:3:... | 0:1:1:2:3:... |
-- | | ^ | ^ |
-- | 1:2:3:5:... | 1:1:2:3:5:... | 0:1:1:2:3:5:... |
-- | | ^ | ^ |
-- | 1:2:3:5:8:... | 1:1:2:3:5:8:... | 0:1:1:2:3:5:8:... |
-- +------------------------+-----------------+-------------------+
-- En la tercera columna se va construyendo la sucesión.

-- ---------------------------------------------------------------------
-- Ejercicio 10.8. Comparar el tiempo y espacio necesarios para calcular
-- las siguientes expresiones
-- let xs = take 40000 fibs3 in (sum xs - sum xs)
-- let xs = take 40000 fibs4 in (sum xs - sum xs)
-- ---------------------------------------------------------------------

-- El cálculo es
-- ghci> let xs = take 40000 fibs2 in (sum xs - sum xs)
-- 0
-- (0.90 secs, 221634544 bytes)
-- ghci> let xs = take 40000 fibs4 in (sum xs - sum xs)
-- 0
-- (0.84 secs, 219587064 bytes)

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

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

pascal1 :: [[Integer]]
pascal1 = iterate f [1]
where f xs = zipWith (+) (0:xs) (xs++[0])

-- Por ejemplo,
-- xs = [1,2,1]
-- 0:xs = [0,1,2,1]
-- xs++[0] = [1,2,1,0]
-- + = [1,3,3,1]

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

pascal2 :: [[Integer]]
pascal2 = [1] : map f pascal2
where f xs = zipWith (+) (0:xs) (xs++[0])

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

-- Nota: El cálculo es
-- take 4 pascal
-- = take 4 ([1] : map f pascal)
-- = [1] : (take 3 (map f pascal))
-- = [1] : (take 3 (map f ([1]:R1pascal)))
-- = [1] : (take 3 ((f [1]) : map R1pascal)))
-- = [1] : (take 3 ((zipWith (+) (0:[1]) ([1]++[0]) : map R1pascal)))
-- = [1] : (take 3 ((zipWith (+) [0,1] [1,0]) : map R1pascal)))
-- = [1] : (take 3 ([1,1] : map R1pascal)))
-- = [1] : [1,1] : (take 2 (map R1pascal)))
-- = [1] : [1,1] : (take 2 (map ([1,1]:R2pascal)))
-- = [1] : [1,1] : (take 2 ((f [1,1]) : map R2pascal)))
-- = [1] : [1,1] : (take 2 ((zipWith (+) (0:[1,1]) ([1,1]++[0]) : map R2pascal)))
-- = [1] : [1,1] : (take 2 ((zipWith (+) [0,1,1] [1,1,0]) : map R2pascal)))
-- = [1] : [1,1] : (take 2 ([1,2,1] : map R2pascal)))
-- = [1] : [1,1] : [1,2,1] : (take 1 (map R2pascal)))
-- = [1] : [1,1] : [1,2,1] : (take 1 (map ([1,2,1]:R3pascal)))
-- = [1] : [1,1] : [1,2,1] : (take 1 ((f [1,2,1]) : map R3pascal)))
-- = [1] : [1,1] : [1,2,1] : (take 1 ((zipWith (+) (0:[1,2,1]) ([1,2,1]++[0]) : map R3pascal)))
-- = [1] : [1,1] : [1,2,1] : (take 1 ((zipWith (+) [0,1,2,1] [1,2,1,0]) : map R3pascal)))
-- = [1] : [1,1] : [1,2,1] : (take 1 ([1,3,3,1] : map R3pascal)))
-- = [1] : [1,1] : [1,2,1] : [1,3,3,1] : (take 0 (map R3pascal)))
-- = [1] : [1,1] : [1,2,1] : [1,3,3,1] : []
-- = [[1],[1,1],[1,2,1],[1,3,3,1]]
-- en el cálculo con R1pascal, R2pascal y R3pascal es el triángulo de
-- Pascal sin el primero, los dos primeros o los tres primeros elementos,
-- respectivamente.

</source>

Relación 11 Sol

2021-12-13T16:58:24Z

Mdelamor: Página creada con «<source lang='haskell'> -- I1M 2021-22: Relación 11 solución -- Evaluación perezosa y listas infinitas. -- Departamento de Ciencias de la Computación e I.A. -- Univers…»

Relación 11

2021-12-13T16:57:58Z

Mdelamor: Página creada con «<source lang='haskell'> -- I1M 2021-22: Rel_11.hs (17 de diciembre de 2021) -- Evaluación perezosa y listas infinitas. -- Departamento de Ciencias de la Computación e I.…»

<source lang='haskell'>

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

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

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

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

import Test.QuickCheck

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

repite :: a -> [a]
repite x = undefined

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

repiteC :: a -> [a]
repiteC x = undefined

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

repiteFinitaR :: Int -> a -> [a]
repiteFinitaR n x = undefined

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

repiteFinitaC :: Int -> a -> [a]
repiteFinitaC n x = undefined

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

repiteFinita :: Int -> a -> [a]
repiteFinita n x = undefined

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

-- La propiedad es
prop_repiteFinitaEquiv :: Int -> Int -> Bool
prop_repiteFinitaEquiv n x = undefined

-- La comprobación es

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

-- La propiedad es
prop_repiteFinitaLongitud :: Int -> Int -> Bool
prop_repiteFinitaLongitud n x = undefined

-- La comprobación es

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

-- La propiedad es
prop_repiteFinitaIguales :: Int -> Int -> Bool
prop_repiteFinitaIguales n x = undefined

-- La comprobación es

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

ecoC :: String -> String
ecoC xs = undefined

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

ecoR :: String -> String
ecoR xs = undefined

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

itera :: (a -> a) -> a -> [a]
itera f x = undefined

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

agrupaR :: Int -> [a] -> [[a]]
agrupaR = undefined

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

agrupa :: Int -> [a] -> [[a]]
agrupa n = undefined

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

-- La propiedad es
prop_AgrupaLongitud :: Int -> [Int] -> Property
prop_AgrupaLongitud n xs = undefined

-- La comprobación es

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

-- La segunda propiedad es
prop_AgrupaCombina :: Int -> [Int] -> Property
prop_AgrupaCombina n xs = undefined

-- La comprobación es

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

siguiente :: Integer -> Integer
siguiente n = undefined

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

collatzR :: Integer -> [Integer]
collatzR = undefined

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

collatz :: Integer -> [Integer]
collatz n = undefined

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

menorCollatzMayor :: Int -> Integer
menorCollatzMayor x = undefined

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

menorCollatzSupera :: Integer -> Integer
menorCollatzSupera x = undefined

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

potenciasMenores :: Int -> Int -> [Int]
potenciasMenores x y = undefined

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

primos :: Integral a => [a]
primos = undefined

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

primo :: Int -> Bool
primo n = undefined

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

sumaDeDosPrimos :: Int -> [(Int,Int)]
sumaDeDosPrimos n = undefined

-- El cálculo es

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

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

factoriales1 :: [Integer]
factoriales1 = undefined

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

factoriales2 :: [Integer]
factoriales2 = undefined

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

factoriales3 :: [Integer]
factoriales3 = undefined

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

factoriales4 :: [Integer]
factoriales4 = undefined

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

factoriales5 :: [Integer]
factoriales5 = undefined

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

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

fib :: Integer -> Integer
fib = undefined

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

fibs1 :: [Integer]
fibs1 = undefined

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

fibs2 :: [Integer]
fibs2 = undefined

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

fibs3 :: [Integer]
fibs3 = undefined

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

fibs4 :: [Integer]
fibs4 = undefined

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

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

pascal1 :: [[Integer]]
pascal1 = undefined

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

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

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

</source>

Archivo:Rel 11.hs

2021-12-13T16:57:33Z

Mdelamor:

Informática (1º Matemáticas)

2021-12-13T16:57:21Z

Mdelamor:

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]], [[Relación 9 Sol |Solución ]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]] ]
* '''Relación 11''': Listas infinitas y evaluación perezosa. [ [[Media:Rel_11.hs |Enunciado]], [[Relación 11 |Solución colaborativa]], [[Relación 11 Sol |Solución ]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Relación 9

2021-12-10T15:31:40Z

Mdelamor:

<source lang='haskell'>

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

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

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

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

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

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

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

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

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

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

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

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

--José Manuel García
intercala1 :: (Ord a, Num a) => a -> [a] -> [a]
intercala1 n xs = concat [if a < n then [n,a] else [a] | a<-xs]

intercala2 :: (Ord a, Num a) => a -> [a] -> [a]
intercala22 n xs = concat (map f xs)
where f x = if x < n then [n,x] else [x]

intercala3 :: (Ord a, Num a) => a -> [a] -> [a]
intercala3 n [] = []
intercala3 n (x:xs) = (if x < n then [n,x] else [x]) ++ (intercala3 n (xs))

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

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

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

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

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

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

dec2entS :: [Integer] -> Integer
dec2entS xs = sum (map f (zip xs (reverse [0..length xs-1])))
where f (x,i) = x*10^i

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

dec2entPR :: [Integer] -> Integer
dec2entPR xs = foldr f 0 (zip xs (reverse [0..length xs-1]))
where f (x,i) recu = x*10^i + recu

-- Juan José Calero Vela:

pos :: Integer -> [Integer] -> Integer
pos x [] = 0
pos x (y:xs) = if x==y then 1 else 1 + pos x xs

dec2entC :: [Integer] -> Integer
dec2entC xs = sum [ x*(10^(pos x (reverse xs)-1)) | x<-xs]

-- profesor: solución vista en clase
dec2entS xs = sum (map f (zip xs [n-1,n-2..0]))
where f (x,i) = x * 10^i
n = length xs

--Manuel Alcaide

dec2ent1' :: [Integer] -> Integer
dec2ent1' xs = sum[x*(10^y)|(x,y)<-(zip xs [((length (xs))-1),((length (xs))-2)..0])]

dec2ent2' :: [Integer] -> Integer
dec2ent2' xs = sum (map f (zip xs [((length (xs))-1),((length (xs))-2)..0]))
where f (x,y) = x*(10^y)

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

dec2ent4' :: [Integer] -> Integer
dec2ent4' xs = foldr f 0 $ zip xs [((length xs)-1),((length xs)-2)..0]
where f (x,p) recu = x*(10^p) + recu
-- Adolfo Sagrera Vivancos
dec2ent xs = sum [ x*10^y | (x,y) <- agrupa xs]
agrupa xs = zip xs (reverse[0..length xs-1])
dec2entOS xs = sum (map f (agrupa xs)) where f (x,y) = x*10^y
dec2entR [] = 0
dec2entR (x:xs) = x*10^(length xs) + dec2entR xs

dec2entP xs = foldr f 0 ys where f (x,y) recu = x*10^y + recu
ys = zip xs (reverse[0..length xs-1])
-- ----------------------------------------------------------------------------
-- Ejercicio 4. Se considera la función
-- diferencia :: Eq a => [a] -> [a] -> [a]
-- tal que (diferencia xs ys) es la diferencia entre los conjuntos xs e
-- ys; es decir, el conjunto de los elementos de la lista xs que no se
-- encuentran en la lista ys. Por ejemplo,
-- diferencia [2,3,5,6] [5,2,7] == [3,6]
-- diferencia [1,3,5,7] [2,4,6] == [1,3,5,7]
-- diferencia [1,3] [1..9] == []
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hermanada4 xs = undefined
---------------------------------------------------------------------------------------
--Adriana Gordillo, Elsa Domínguez
hermanadaC :: [Int] -> Bool
hermanadaC xs | elem 0 xs = False
| otherwise = and [(gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y))) | (x,y) <- zip xs (tail xs)]

hermanadaS :: [Int] -> Bool
hermanadaS xs | elem 0 xs = False
| otherwise = and (map f (zip xs (tail xs)))
where f (x,y) = (gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y)))

hermanadaR :: [Int] -> Bool
hermanadaR [x] = True
hermanadaR (x:y:xs) | elem 0 (x:y:xs) = False
| otherwise = ((gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y)))) && hermanadaR (y:xs)

hermanadaPR :: [Int] -> Bool
hermanadaPR xs | elem 0 xs = False
| otherwise = foldr f True (zip xs (tail xs))
where f (x,y) recu = ((gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y)))) && recu

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

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

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

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

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

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

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

permanentesS :: [Int] -> [Int]
permanentesS xs = map fst (filter p (zip xs (tails xs)))
where p (x,i) = x == maximum i

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

permanentesPR :: [Int] -> [Int]
permanentesPR xs = foldr f [] (zip xs (tails xs))
where f (x,i) recu | x == maximum i = [x] ++ recu
| otherwise = recu
-- Adolfo Sagrera
permanentes xs = [ head xs | xs <- (init (tails xs)), head xs == maximum xs]
-- ---------------------------------------------------------------------
-- Ejercicio 8. Un número entero positivo n es muy primo si es n primo
-- y todos los números que resultan de ir suprimimiendo la última cifra
-- también son primos. Por ejemplo, 7193 es muy primo pues los números
-- 7193, 719, 71 y 7 son todos primos.
--
-- Define la función
-- muyPrimo :: Integer -> Bool
-- que (muyPrimo n) se verifica si n es muy primo. Por ejemplo,
-- muyPrimo 7193 == True
-- muyPrimo 71932 == False
-- --------------------------------------------------------------------

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

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

-- El cálculo es

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

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

</source>

Relación 9 Sol

2021-12-10T15:31:23Z

Mdelamor:

<source lang='haskell'>
-- Funciones de orden superior y definiciones por plegados (extra)
-- Departamento de Ciencias de la Computación e Inteligencia Artificial
-- Universidad de Sevilla
-- ============================================================================
-- ============================================================================
-- Librerías auxiliares
-- ============================================================================
import Data.Char
import Data.List
-- cabal install primes
import Data.Numbers.Primes
import Test.QuickCheck

-- ----------------------------------------------------------------------------
-- Ejercicio 1. Se considera la función
-- resultadoPos :: (a -> Integer) -> [a] -> [a]
-- tal que (resultadoPos f xs) es la lista de los elementos de la lista
-- xs tales que el valor de la función f sobre ellos es positivo. Por ejemplo,
-- resultadoPos head [[-1,2],[-9,4],[2,3]] == [[2,3]]
-- resultadoPos sum [[1,2],[9],[-8,3],[],[3,5]] == [[1,2],[9],[3,5]]
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...),
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- -----------------------------------------------------------------------------

-- 1) por comprensión,
resultadoPosC :: (a -> Integer) -> [a] -> [a]
resultadoPosC f xs = [x | x <- xs, f x > 0]

-- 2) por orden superior (map, filter, ...),
resultadoPosS :: (a -> Integer) -> [a] -> [a]
resultadoPosS f xs = filter (\x -> f x > 0) xs

resultadoPosS' f xs = filter lp (zip (map f xs) xs)
where lp (a, b) = a > 0

resultadoPosS'' :: (a -> Integer) -> [a] -> [a]
resultadoPosS'' f = filter ((>0).f)

-- 3) por recursión,
resultadoPosR :: (a -> Integer) -> [a] -> [a]
resultadoPosR _ [] = []
resultadoPosR f (x:xs)
| f x > 0 = x: resultadoPosR f xs
| otherwise = resultadoPosR f xs

-- 4) por plegado (con 'foldr').
resultadoPosP :: (a -> Integer) -> [a] -> [a]
resultadoPosP f = foldr (\x acc -> if f x > 0 then x:acc else acc) []

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

-- 1) por comprensión,
intercalaC :: Int -> [Int] -> [Int]
intercalaC y xs = [x | xs <- xss, x <- xs]
where xss = [if x < y then [y, x] else [x] | x <- xs]

-- 2) por orden superior (map, filter, ...)
intercalaS :: Int -> [Int] -> [Int]
intercalaS y xs = concat (map (\x -> if x < y then [y, x] else [x]) xs)

intercalaS' y xs = concatMap (\ x -> if y > x then [y, x] else [x]) xs

-- 3) por recursión,
intercalaR :: Int -> [Int] -> [Int]
intercalaR _ [] = []
intercalaR y (x:xs)
| x < y = y:x:intercalaR y xs
| otherwise = x:intercalaR y xs

-- 4) por plegado (con 'foldr').
intercalaP :: Int -> [Int] -> [Int]
intercalaP y = foldr (\x acc -> if x < y then y:x:acc else x:acc) []

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

-- 1) por comprensión,
dec2entC :: [Integer] -> Integer
dec2entC xs = sum [x * (10^y) | (x, y) <- zip (reverse xs) [0,1..] ]

-- 2) por orden superior (map, filter, ...)
dec2entS :: [Integer] -> Integer
dec2entS xs = read (map intToDigit (map fromIntegral xs))

dec2entS' :: [Integer] -> Integer
dec2entS' xs = read (filter isDigit (show xs))

dec2entS'' :: [Integer] -> Integer
dec2entS'' xs = sum (map (\(x,n) -> x*10^n) (zip xs [n,(n-1)..]) )
where n = length xs - 1

-- 3) por recursión,
dec2entR :: [Integer] -> Integer
dec2entR xs = dec2entRaux (reverse xs)
dec2entRaux [] = 0
dec2entRaux (x:xs) = x + 10*dec2entRaux xs

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

-- 4) por plegado (con 'foldr').
dec2entP :: [Integer] -> Integer
dec2entP xs = foldr (\ x y -> 10*y + x) 0 (reverse xs)

-- ----------------------------------------------------------------------------
-- Ejercicio 4. Se considera la función
-- diferencia :: Eq a => [a] -> [a] -> [a]
-- tal que (diferencia xs ys) es la diferencia entre los conjuntos xs e
-- ys; es decir, el conjunto de los elementos de la lista xs que no se
-- encuentran en la lista ys. Por ejemplo,
-- diferencia [2,3,5,6] [5,2,7] == [3,6]
-- diferencia [1,3,5,7] [2,4,6] == [1,3,5,7]
-- diferencia [1,3] [1..9] == []
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

-- 1) por comprensión,
diferenciaC :: Eq a => [a] -> [a] -> [a]
diferenciaC xs ys = [x | x <- xs, not (elem x ys)]

-- 2) por orden superior (map, filter, ...)
diferenciaOS :: Eq a => [a] -> [a] -> [a]
diferenciaOS xs ys = filter (\ x -> not (elem x ys)) xs

-- 3) por recursión,
diferenciaR :: Eq a => [a] -> [a] -> [a]
diferenciaR [] _ = []
diferenciaR xs [] = xs
diferenciaR (x:xs) ys
| elem x ys = diferenciaR xs ys
| otherwise = x:diferenciaR xs ys

-- 4) por plegado (con 'foldr').
diferenciaP :: Eq a => [a] -> [a] -> [a]
diferenciaP xs ys = foldr (\x acc -> if elem x ys then acc else x:acc) [] xs

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

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

-- 1) por comprensión,
primerosYultimosC :: [[a]] -> ([a],[a])
primerosYultimosC xss = unzip [(head xs, last xs) | xs <- xss, not (null xs)]

-- 2) por orden superior (map, filter, ...)
primerosYultimosS :: [[a]] -> ([a],[a])
primerosYultimosS xss = unzip (map (\ x -> (head x, last x)) (filter (not.null) xss))

-- 3) por recursión,
primerosYultimosR :: [[a]] -> ([a],[a])
primerosYultimosR xss = unzip (primerosYultimosR' xss)
primerosYultimosR' [] = []
primerosYultimosR' (xs:xss)
| null xs = primerosYultimosR' xss
| otherwise = (head xs, last xs) : primerosYultimosR' xss

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

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

-- 4) por plegado (con 'foldr').
primerosYultimosP xss = unzip (foldr (\ x y -> (head x, last x) : y) [] (filter (/= []) xss))

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

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

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

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

-- hermanos es lo contrario que ser co-primos. Con la siguiente comparación
-- basta
hermanos :: Integral a => a -> a -> Bool
hermanos x y = x == 1 || y == 1 || (gcd x y /= 1)

-- 1) por comprensión,
hermanadaC :: [Int] -> Bool
hermanadaC xs = and [hermanos x y | (x,y) <- zip xs (tail xs)]

-- 2) por orden superior (map, filter, ...)
hermanadaOS :: [Int] -> Bool
hermanadaOS xs = all (\ (x,y) -> hermanos x y) (zip xs (tail xs))

-- 3) por recursión,
hermanadaR :: [Int] -> Bool
hermanadaR [] = True
hermanadaR (x:[]) = True
hermanadaR (x:y:xs) = (hermanos x y) && (hermanadaR (y:xs))

-- 4) por plegado (con 'foldr').
hermanadaP :: [Int] -> Bool
hermanadaP xs = foldr (\ (x,y) z -> (hermanos x y) && z) True (zip xs (tail xs))

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

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

head_permanente :: Ord a => [a] -> Bool
head_permanente (y:[]) = True
head_permanente (y:ys) = (maximum ys <= y)

-- 1) por comprensión,
permanentesC :: [Int] -> [Int]
permanentesC xs = [y | (y:ys) <- tails xs, head_permanente (y:ys)]

-- 2) por orden superior (map, filter, ...)
permanentesS :: [Int] -> [Int]
permanentesS xs = map head (filter head_permanente (init (tails xs)))

-- Por composición de funciones
permanentesS' :: [Int] -> [Int]
permanentesS' = (map head) . (filter head_permanente) . init . tails

-- 3) por recursión,
permanentesR :: [Int] -> [Int]
permanentesR [] = []
permanentesR (x:xs)
| head_permanente (x:xs) = x:permanentesR xs
| otherwise = permanentesR xs

-- 4) por plegado (con 'foldr').
permanentesP :: [Int] -> [Int]
permanentesP xs = foldr (\ys acc -> if head_permanente ys then (head ys):acc else acc) [] (init (tails xs))

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

muyPrimo :: Integer -> Bool
muyPrimo 0 = True
muyPrimo n = isPrime n && (muyPrimo (div n 10))

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

-- El cálculo es
-- length $ filter muyPrimo [10^4..(10^5-1)]
-- > 15
-- ---------------------------------------------------------------------

</source>

Relación 9 Sol

2021-12-10T15:31:12Z

Mdelamor: Protegió «Relación 9 Sol» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang='haskell'>
-- PD Practica 5.2 Solución
-- Funciones de orden superior y definiciones por plegados (II)
-- Departamento de Ciencias de la Computación e Inteligencia Artificial
-- Universidad de Sevilla
-- ============================================================================
-- ============================================================================
-- Librerías auxiliares
-- ============================================================================
import Data.Char
import Data.List
-- cabal install primes
import Data.Numbers.Primes
import Test.QuickCheck

-- ----------------------------------------------------------------------------
-- Ejercicio 1. Se considera la función
-- resultadoPos :: (a -> Integer) -> [a] -> [a]
-- tal que (resultadoPos f xs) es la lista de los elementos de la lista
-- xs tales que el valor de la función f sobre ellos es positivo. Por ejemplo,
-- resultadoPos head [[-1,2],[-9,4],[2,3]] == [[2,3]]
-- resultadoPos sum [[1,2],[9],[-8,3],[],[3,5]] == [[1,2],[9],[3,5]]
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...),
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- -----------------------------------------------------------------------------

-- 1) por comprensión,
resultadoPosC :: (a -> Integer) -> [a] -> [a]
resultadoPosC f xs = [x | x <- xs, f x > 0]

-- 2) por orden superior (map, filter, ...),
resultadoPosS :: (a -> Integer) -> [a] -> [a]
resultadoPosS f xs = filter (\x -> f x > 0) xs

resultadoPosS' f xs = filter lp (zip (map f xs) xs)
where lp (a, b) = a > 0

resultadoPosS'' :: (a -> Integer) -> [a] -> [a]
resultadoPosS'' f = filter ((>0).f)

-- 3) por recursión,
resultadoPosR :: (a -> Integer) -> [a] -> [a]
resultadoPosR _ [] = []
resultadoPosR f (x:xs)
| f x > 0 = x: resultadoPosR f xs
| otherwise = resultadoPosR f xs

-- 4) por plegado (con 'foldr').
resultadoPosP :: (a -> Integer) -> [a] -> [a]
resultadoPosP f = foldr (\x acc -> if f x > 0 then x:acc else acc) []

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

-- 1) por comprensión,
intercalaC :: Int -> [Int] -> [Int]
intercalaC y xs = [x | xs <- xss, x <- xs]
where xss = [if x < y then [y, x] else [x] | x <- xs]

-- 2) por orden superior (map, filter, ...)
intercalaS :: Int -> [Int] -> [Int]
intercalaS y xs = concat (map (\x -> if x < y then [y, x] else [x]) xs)

intercalaS' y xs = concatMap (\ x -> if y > x then [y, x] else [x]) xs

-- 3) por recursión,
intercalaR :: Int -> [Int] -> [Int]
intercalaR _ [] = []
intercalaR y (x:xs)
| x < y = y:x:intercalaR y xs
| otherwise = x:intercalaR y xs

-- 4) por plegado (con 'foldr').
intercalaP :: Int -> [Int] -> [Int]
intercalaP y = foldr (\x acc -> if x < y then y:x:acc else x:acc) []

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

-- 1) por comprensión,
dec2entC :: [Integer] -> Integer
dec2entC xs = sum [x * (10^y) | (x, y) <- zip (reverse xs) [0,1..] ]

-- 2) por orden superior (map, filter, ...)
dec2entS :: [Integer] -> Integer
dec2entS xs = read (map intToDigit (map fromIntegral xs))

dec2entS' :: [Integer] -> Integer
dec2entS' xs = read (filter isDigit (show xs))

dec2entS'' :: [Integer] -> Integer
dec2entS'' xs = sum (map (\(x,n) -> x*10^n) (zip xs [n,(n-1)..]) )
where n = length xs - 1

-- 3) por recursión,
dec2entR :: [Integer] -> Integer
dec2entR xs = dec2entRaux (reverse xs)
dec2entRaux [] = 0
dec2entRaux (x:xs) = x + 10*dec2entRaux xs

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

-- 4) por plegado (con 'foldr').
dec2entP :: [Integer] -> Integer
dec2entP xs = foldr (\ x y -> 10*y + x) 0 (reverse xs)

-- ----------------------------------------------------------------------------
-- Ejercicio 4. Se considera la función
-- diferencia :: Eq a => [a] -> [a] -> [a]
-- tal que (diferencia xs ys) es la diferencia entre los conjuntos xs e
-- ys; es decir, el conjunto de los elementos de la lista xs que no se
-- encuentran en la lista ys. Por ejemplo,
-- diferencia [2,3,5,6] [5,2,7] == [3,6]
-- diferencia [1,3,5,7] [2,4,6] == [1,3,5,7]
-- diferencia [1,3] [1..9] == []
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

-- 1) por comprensión,
diferenciaC :: Eq a => [a] -> [a] -> [a]
diferenciaC xs ys = [x | x <- xs, not (elem x ys)]

-- 2) por orden superior (map, filter, ...)
diferenciaOS :: Eq a => [a] -> [a] -> [a]
diferenciaOS xs ys = filter (\ x -> not (elem x ys)) xs

-- 3) por recursión,
diferenciaR :: Eq a => [a] -> [a] -> [a]
diferenciaR [] _ = []
diferenciaR xs [] = xs
diferenciaR (x:xs) ys
| elem x ys = diferenciaR xs ys
| otherwise = x:diferenciaR xs ys

-- 4) por plegado (con 'foldr').
diferenciaP :: Eq a => [a] -> [a] -> [a]
diferenciaP xs ys = foldr (\x acc -> if elem x ys then acc else x:acc) [] xs

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

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

-- 1) por comprensión,
primerosYultimosC :: [[a]] -> ([a],[a])
primerosYultimosC xss = unzip [(head xs, last xs) | xs <- xss, not (null xs)]

-- 2) por orden superior (map, filter, ...)
primerosYultimosS :: [[a]] -> ([a],[a])
primerosYultimosS xss = unzip (map (\ x -> (head x, last x)) (filter (not.null) xss))

-- 3) por recursión,
primerosYultimosR :: [[a]] -> ([a],[a])
primerosYultimosR xss = unzip (primerosYultimosR' xss)
primerosYultimosR' [] = []
primerosYultimosR' (xs:xss)
| null xs = primerosYultimosR' xss
| otherwise = (head xs, last xs) : primerosYultimosR' xss

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

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

-- 4) por plegado (con 'foldr').
primerosYultimosP xss = unzip (foldr (\ x y -> (head x, last x) : y) [] (filter (/= []) xss))

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

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

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

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

-- hermanos es lo contrario que ser co-primos. Con la siguiente comparación
-- basta
hermanos :: Integral a => a -> a -> Bool
hermanos x y = x == 1 || y == 1 || (gcd x y /= 1)

-- 1) por comprensión,
hermanadaC :: [Int] -> Bool
hermanadaC xs = and [hermanos x y | (x,y) <- zip xs (tail xs)]

-- 2) por orden superior (map, filter, ...)
hermanadaOS :: [Int] -> Bool
hermanadaOS xs = all (\ (x,y) -> hermanos x y) (zip xs (tail xs))

-- 3) por recursión,
hermanadaR :: [Int] -> Bool
hermanadaR [] = True
hermanadaR (x:[]) = True
hermanadaR (x:y:xs) = (hermanos x y) && (hermanadaR (y:xs))

-- 4) por plegado (con 'foldr').
hermanadaP :: [Int] -> Bool
hermanadaP xs = foldr (\ (x,y) z -> (hermanos x y) && z) True (zip xs (tail xs))

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

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

head_permanente :: Ord a => [a] -> Bool
head_permanente (y:[]) = True
head_permanente (y:ys) = (maximum ys <= y)

-- 1) por comprensión,
permanentesC :: [Int] -> [Int]
permanentesC xs = [y | (y:ys) <- tails xs, head_permanente (y:ys)]

-- 2) por orden superior (map, filter, ...)
permanentesS :: [Int] -> [Int]
permanentesS xs = map head (filter head_permanente (init (tails xs)))

-- Por composición de funciones
permanentesS' :: [Int] -> [Int]
permanentesS' = (map head) . (filter head_permanente) . init . tails

-- 3) por recursión,
permanentesR :: [Int] -> [Int]
permanentesR [] = []
permanentesR (x:xs)
| head_permanente (x:xs) = x:permanentesR xs
| otherwise = permanentesR xs

-- 4) por plegado (con 'foldr').
permanentesP :: [Int] -> [Int]
permanentesP xs = foldr (\ys acc -> if head_permanente ys then (head ys):acc else acc) [] (init (tails xs))

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

muyPrimo :: Integer -> Bool
muyPrimo 0 = True
muyPrimo n = isPrime n && (muyPrimo (div n 10))

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

-- El cálculo es
-- length $ filter muyPrimo [10^4..(10^5-1)]
-- > 15
-- ---------------------------------------------------------------------

</source>

Relación 9 Sol

2021-12-10T15:30:59Z

Mdelamor:

Relación 9 Sol

2021-12-10T15:29:50Z

Mdelamor: Página creada con «<source lang='haskell'> -- PD Practica 5.2 Solución -- Funciones de orden superior y definiciones por plegados (II) -- Departamento de Ciencias de la Computación e Inteli…»

<source lang='haskell'>
-- PD Practica 5.2 Solución
-- Funciones de orden superior y definiciones por plegados (II)
-- Departamento de Ciencias de la Computación e Inteligencia Artificial
-- Universidad de Sevilla
-- ============================================================================
-- ============================================================================
-- Librerías auxiliares
-- ============================================================================
import Data.Char
import Data.List
-- cabal install primes
import Data.Numbers.Primes
import Test.QuickCheck

-- ----------------------------------------------------------------------------
-- Ejercicio 1. Se considera la función
-- resultadoPos :: (a -> Integer) -> [a] -> [a]
-- tal que (resultadoPos f xs) es la lista de los elementos de la lista
-- xs tales que el valor de la función f sobre ellos es positivo. Por ejemplo,
-- resultadoPos head [[-1,2],[-9,4],[2,3]] == [[2,3]]
-- resultadoPos sum [[1,2],[9],[-8,3],[],[3,5]] == [[1,2],[9],[3,5]]
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...),
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- -----------------------------------------------------------------------------

-- 1) por comprensión,
resultadoPosC :: (a -> Integer) -> [a] -> [a]
resultadoPosC f xs = [x | x <- xs, f x > 0]

-- 2) por orden superior (map, filter, ...),
resultadoPosS :: (a -> Integer) -> [a] -> [a]
resultadoPosS f xs = filter (\x -> f x > 0) xs

resultadoPosS' f xs = filter lp (zip (map f xs) xs)
where lp (a, b) = a > 0

resultadoPosS'' :: (a -> Integer) -> [a] -> [a]
resultadoPosS'' f = filter ((>0).f)

-- 3) por recursión,
resultadoPosR :: (a -> Integer) -> [a] -> [a]
resultadoPosR _ [] = []
resultadoPosR f (x:xs)
| f x > 0 = x: resultadoPosR f xs
| otherwise = resultadoPosR f xs

-- 4) por plegado (con 'foldr').
resultadoPosP :: (a -> Integer) -> [a] -> [a]
resultadoPosP f = foldr (\x acc -> if f x > 0 then x:acc else acc) []

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

-- 1) por comprensión,
intercalaC :: Int -> [Int] -> [Int]
intercalaC y xs = [x | xs <- xss, x <- xs]
where xss = [if x < y then [y, x] else [x] | x <- xs]

-- 2) por orden superior (map, filter, ...)
intercalaS :: Int -> [Int] -> [Int]
intercalaS y xs = concat (map (\x -> if x < y then [y, x] else [x]) xs)

intercalaS' y xs = concatMap (\ x -> if y > x then [y, x] else [x]) xs

-- 3) por recursión,
intercalaR :: Int -> [Int] -> [Int]
intercalaR _ [] = []
intercalaR y (x:xs)
| x < y = y:x:intercalaR y xs
| otherwise = x:intercalaR y xs

-- 4) por plegado (con 'foldr').
intercalaP :: Int -> [Int] -> [Int]
intercalaP y = foldr (\x acc -> if x < y then y:x:acc else x:acc) []

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

-- 1) por comprensión,
dec2entC :: [Integer] -> Integer
dec2entC xs = sum [x * (10^y) | (x, y) <- zip (reverse xs) [0,1..] ]

-- 2) por orden superior (map, filter, ...)
dec2entS :: [Integer] -> Integer
dec2entS xs = read (map intToDigit (map fromIntegral xs))

dec2entS' :: [Integer] -> Integer
dec2entS' xs = read (filter isDigit (show xs))

dec2entS'' :: [Integer] -> Integer
dec2entS'' xs = sum (map (\(x,n) -> x*10^n) (zip xs [n,(n-1)..]) )
where n = length xs - 1

-- 3) por recursión,
dec2entR :: [Integer] -> Integer
dec2entR xs = dec2entRaux (reverse xs)
dec2entRaux [] = 0
dec2entRaux (x:xs) = x + 10*dec2entRaux xs

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

-- 4) por plegado (con 'foldr').
dec2entP :: [Integer] -> Integer
dec2entP xs = foldr (\ x y -> 10*y + x) 0 (reverse xs)

-- ----------------------------------------------------------------------------
-- Ejercicio 4. Se considera la función
-- diferencia :: Eq a => [a] -> [a] -> [a]
-- tal que (diferencia xs ys) es la diferencia entre los conjuntos xs e
-- ys; es decir, el conjunto de los elementos de la lista xs que no se
-- encuentran en la lista ys. Por ejemplo,
-- diferencia [2,3,5,6] [5,2,7] == [3,6]
-- diferencia [1,3,5,7] [2,4,6] == [1,3,5,7]
-- diferencia [1,3] [1..9] == []
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

-- 1) por comprensión,
diferenciaC :: Eq a => [a] -> [a] -> [a]
diferenciaC xs ys = [x | x <- xs, not (elem x ys)]

-- 2) por orden superior (map, filter, ...)
diferenciaOS :: Eq a => [a] -> [a] -> [a]
diferenciaOS xs ys = filter (\ x -> not (elem x ys)) xs

-- 3) por recursión,
diferenciaR :: Eq a => [a] -> [a] -> [a]
diferenciaR [] _ = []
diferenciaR xs [] = xs
diferenciaR (x:xs) ys
| elem x ys = diferenciaR xs ys
| otherwise = x:diferenciaR xs ys

-- 4) por plegado (con 'foldr').
diferenciaP :: Eq a => [a] -> [a] -> [a]
diferenciaP xs ys = foldr (\x acc -> if elem x ys then acc else x:acc) [] xs

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

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

-- 1) por comprensión,
primerosYultimosC :: [[a]] -> ([a],[a])
primerosYultimosC xss = unzip [(head xs, last xs) | xs <- xss, not (null xs)]

-- 2) por orden superior (map, filter, ...)
primerosYultimosS :: [[a]] -> ([a],[a])
primerosYultimosS xss = unzip (map (\ x -> (head x, last x)) (filter (not.null) xss))

-- 3) por recursión,
primerosYultimosR :: [[a]] -> ([a],[a])
primerosYultimosR xss = unzip (primerosYultimosR' xss)
primerosYultimosR' [] = []
primerosYultimosR' (xs:xss)
| null xs = primerosYultimosR' xss
| otherwise = (head xs, last xs) : primerosYultimosR' xss

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

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

-- 4) por plegado (con 'foldr').
primerosYultimosP xss = unzip (foldr (\ x y -> (head x, last x) : y) [] (filter (/= []) xss))

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

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

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

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

-- hermanos es lo contrario que ser co-primos. Con la siguiente comparación
-- basta
hermanos :: Integral a => a -> a -> Bool
hermanos x y = x == 1 || y == 1 || (gcd x y /= 1)

-- 1) por comprensión,
hermanadaC :: [Int] -> Bool
hermanadaC xs = and [hermanos x y | (x,y) <- zip xs (tail xs)]

-- 2) por orden superior (map, filter, ...)
hermanadaOS :: [Int] -> Bool
hermanadaOS xs = all (\ (x,y) -> hermanos x y) (zip xs (tail xs))

-- 3) por recursión,
hermanadaR :: [Int] -> Bool
hermanadaR [] = True
hermanadaR (x:[]) = True
hermanadaR (x:y:xs) = (hermanos x y) && (hermanadaR (y:xs))

-- 4) por plegado (con 'foldr').
hermanadaP :: [Int] -> Bool
hermanadaP xs = foldr (\ (x,y) z -> (hermanos x y) && z) True (zip xs (tail xs))

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

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

head_permanente :: Ord a => [a] -> Bool
head_permanente (y:[]) = True
head_permanente (y:ys) = (maximum ys < y)

-- 1) por comprensión,
permanentesC :: [Int] -> [Int]
permanentesC xs = [y | (y:ys) <- tails xs, head_permanente (y:ys)]

-- 2) por orden superior (map, filter, ...)
permanentesS :: [Int] -> [Int]
permanentesS xs = map head (filter head_permanente (init (tails xs)))

-- Por composición de funciones
permanentesS' :: [Int] -> [Int]
permanentesS' = (map head) . (filter head_permanente) . init . tails

-- 3) por recursión,
permanentesR :: [Int] -> [Int]
permanentesR [] = []
permanentesR (x:xs)
| head_permanente (x:xs) = x:permanentesR xs
| otherwise = permanentesR xs

-- 4) por plegado (con 'foldr').
permanentesP :: [Int] -> [Int]
permanentesP xs = foldr (\ys acc -> if head_permanente ys then (head ys):acc else acc) [] (init (tails xs))

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

muyPrimo :: Integer -> Bool
muyPrimo 0 = True
muyPrimo n = isPrime n && (muyPrimo (div n 10))

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

-- El cálculo es
-- length $ filter muyPrimo [10^4..(10^5-1)]
-- > 15
-- ---------------------------------------------------------------------

</source>

Informática (1º Matemáticas)

2021-12-10T15:27:16Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]], [[Relación 9 Sol |Solución ]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Relación 8 Sol

2021-12-08T08:58:00Z

Mdelamor:

<source lang='haskell'>

-- I1M 2021-22: Rel_8_sol.hs
-- 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 _ [] = []
segmentos p (x:xs)
| p x = takeWhile p (x:xs) : segmentos p (dropWhile p xs)
| otherwise = segmentos p xs

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

relacionadosC :: (a -> a -> Bool) -> [a] -> Bool
relacionadosC r xs = and [r x y | (x,y) <- zip xs (tail xs)]

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

relacionadosR :: (a -> a -> Bool) -> [a] -> Bool
relacionadosR r (x:y:zs) = r x y && relacionadosR r (y:zs)
relacionadosR _ _ = True

-- ---------------------------------------------------------------------
-- 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 [] = []
agrupa xss
| [] `elem` xss = []
| otherwise = primeros xss : agrupa (restos xss)
where primeros = map head
restos = map tail

-- ---------------------------------------------------------------------
-- 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 =
and [length xs == n | xs <- agrupa xss]
where n = length xss

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

comprueba_agrupa :: IO ()
comprueba_agrupa =
quickCheck prop_agrupa

-- ---------------------------------------------------------------------
-- Ejercicio 4.1. 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 [] = []
concatR (xs:xss) = xs ++ concatR xss

-- ---------------------------------------------------------------------
-- 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 = [f x | x <- xs, p x]

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

filtraAplicaMF :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaMF f p xs = map f (filter p xs)

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

filtraAplicaR :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaR _ _ [] = []
filtraAplicaR f p (x:xs) | p x = f x : filtraAplicaR f p xs
| otherwise = filtraAplicaR f p xs

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

maximumR :: Ord a => [a] -> a
maximumR [x] = x
maximumR (x:y:ys) = max x (maximumR (y:ys))
maximumR _ = error "Imposible"

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

-- ---------------------------------------------------------------------
-- 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 = foldr (++) []

-- ---------------------------------------------------------------------
-- 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 =
concatR xss == ys && concatP xss == ys
where ys = concat xss

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

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

-- La propiedad es
prop_longConcat :: [[Int]] -> Bool
prop_longConcat xss =
length (concatP xss) == sum [length xs | xs <- xss]

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

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

filtraAplicaP :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaP f p = foldr g []
where g x y | p x = f x : y
| otherwise = y

-- La definición por plegado usando lambda es
filtraAplicaP2 :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaP2 f p =
foldr (\x y -> if p x then f x : y else y) []

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

-- 1ª solución
-- Redefinir la relación 'r' con 'rpar' para que se aplique a pares
relacionadosA :: (a -> a -> Bool) -> [a] -> Bool
relacionadosA r xs = all rpar (zip xs (tail xs))
where rpar (x,y) = r x y

-- 2ª solución. La función uncurry hace esa conversión, de función
-- con dos argumentos a función que recibe un par
relacionadosA' :: (a -> a -> Bool) -> [a] -> Bool
relacionadosA' r xs = all (uncurry r) (zip xs (tail xs))

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

-- 1ª solución
relacionadosP :: (a -> a -> Bool) -> [a] -> Bool
relacionadosP r xs = foldr rfpar True (zip xs (tail xs))
where rfpar (x,y) b = (r x y) && b

-- 2ª solución, sin usar el zip, y $ es igual que poner paréntesis hasta
-- el final de la línea
relacionadosP' :: (a -> a -> Bool) -> [a] -> Bool
relacionadosP' r xs = snd $ foldr rfpar (last xs,True) (init xs)
where rfpar x (y,b) = (x,(r x y) && b)

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. (Basado en el ejercicio 4 del primer parcial)
-- Una lista se dirá muy creciente si cada elemento es mayor estricto
-- que el triple del anterior.
-- 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 = relacionadosA relMuyCreciente xs
where relMuyCreciente a b = b > a*3

</source>

Informática (1º Matemáticas)

2021-12-08T08:42:06Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Relación 10 Sol

2021-12-08T08:41:33Z

Mdelamor: Protegió «Relación 10 Sol» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang='haskell'>
-- I1M 2021-22: Relación 10
-- Propiedades del número 2021.
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================

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

-- En esta relación se presentan ejercicios sobre propiedades del número
-- 2021.

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

import Data.Numbers.Primes
import Data.List
import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1.1. Consideramos todos los primos menores que 100:
-- 2, 3, 5, 7, 11, ..., 89, 97
-- y formamos los correspondientes pares de dominó:
-- (2,3), (3,5), (5,7), ..., (83,89), (89,97).
-- La suma de los números en todos los pares es 2021.
--
-- Definir la función
-- sumaDominoPrimos :: Integer -> Integer
-- tal que (sumaDominoPrimos n) es la suma de los números de los pares
-- de dominó formada a partir de los primos menores que n. Por ejemplo,
-- sumaDominoPrimos 100 == 2021
-- sumaDominoPrimos 200 == 8253
-- ---------------------------------------------------------------------

sumaDominoPrimos :: Integer -> Integer
sumaDominoPrimos n = sum (zipWith (+) ps (tail ps))
where ps = takeWhile (<=n) primes

-- ---------------------------------------------------------------------
-- Ejercicio 1.2. Definir la constante
-- sucSumaDominoPrimos :: [Integer]
-- tal que sucSumaDominoPrimos es la sucesión de los números que son
-- suma de pares de dominó formado con números primos. Por ejemplo,
-- λ> take 25 sucSumaDominoPrimos
-- [5,13,25,43,67,97,133,175,227,287,355,433,517,607,707,819,939,1067,
-- 1205,1349,1501,1663,1835,2021,2219]
-- ---------------------------------------------------------------------

sucSumaDominoPrimos :: [Integer]
sucSumaDominoPrimos = tail (map sumaDominoPrimos primes)

-- ---------------------------------------------------------------------
-- Ejercicio 1.3. Definir la sucesión
-- esSumaDominoPrimos :: Integer -> Bool
-- tal que (esSumaDominoPrimos n) se verifica si n es un número de la
-- sucesión anterior. Por ejemplo,
-- esSumaDominoPrimos 2021 == True
-- esSumaDominoPrimos 1234509 == False
-- ---------------------------------------------------------------------

esSumaDominoPrimos :: Integer -> Bool
esSumaDominoPrimos n = n == head (dropWhile (<n) sucSumaDominoPrimos)

-- ---------------------------------------------------------------------
-- Ejercicio 2.1. El número 2021 es la suma de 33 más la suma de los 33
-- primeros números primos.
--
-- Definir la función
-- sumSumaPrimos :: Int -> Integer
-- tal que (sumSumaPrimos n) es la suma de n más los n primeros números
-- primos. Por ejemplo,
-- sumSumaPrimos 33 == 2021
-- sumSumaPrimos 52 == 5641
-- ---------------------------------------------------------------------

sumSumaPrimos :: Int -> Integer
sumSumaPrimos n = fromIntegral n + sum (take n primes)

-- ---------------------------------------------------------------------
-- Ejercicio 2.2. Definir la función
-- esSumSumaPrimos :: Integer -> Bool
-- tal que (esSumSumaPrimos n) se verifica si n es de la suma de m más
-- los m primeros primos, para algún entero m. Por ejemplo,
-- esSumSumaPrimos 2021 == True
-- esSumSumaPrimos 120 == False
-- esSumSumaPrimos 1234567893 == False
-- esSumSumaPrimos 774511387 == True
-- ---------------------------------------------------------------------

-- 1ª solución
-- ===========

esSumSumaPrimos :: Integer -> Bool
esSumSumaPrimos n = n == head (dropWhile (<n) sucSumSumaPrimos)

-- sucSumSumaPrimos es la lista de los números de la forma m más la suma
-- de los m primeros primos. Por ejemplo,
-- take 18 sucSumSumaPrimos
-- [3,7,13,21,33,47,65,85,109,139,171,209,251,295,343,397,457,519]
sucSumSumaPrimos :: [Integer]
sucSumSumaPrimos = map sumSumaPrimos [1..]

-- 2ª solución
-- ===========

esSumSumaPrimos2 :: Integer -> Bool
esSumSumaPrimos2 n = n == head (dropWhile (<n) sucSumSumaPrimos2)

sucSumSumaPrimos2 :: [Integer]
sucSumSumaPrimos2 = zipWith (+) [1..] (scanl1 (+) primes)

-- Comparación de eficiencia:
-- =========================

-- La comparación es
-- λ> esSumSumaPrimos 123456789 == False
-- (11.60 secs, 34,680,466,648 bytes)
-- λ> esSumSumaPrimos2 123456789 == False
-- (0.01 secs, 11,300,288 bytes)
--
-- λ> esSumSumaPrimos 774511387 == True
-- (83.50 secs, 234,694,973,880 bytes)
-- λ> esSumSumaPrimos2 774511387 == True
-- (0.03 secs, 42,326,032 bytes)

-- --------------------------------------------------------------------
-- Ejercicio 3. Un número semiprimo es un número natural que es producto
-- de dos números primos no necesariamente distintos. Por ejemplo, 26 es
-- semiprimo (porque 26 = 2×13) y 49 también lo es (porque 49 = 7×7).
--
-- Definir las funciones
-- esSemiprimo :: Integer -> Bool
-- semiprimos :: [Integer]
-- tales que
-- + (esSemiprimo n) se verifica si n es semiprimo. Por ejemplo,
-- esSemiprimo 26 == True
-- esSemiprimo 49 == True
-- esSemiprimo 8 == False
-- esSemiprimo 2021 == True
-- esSemiprimo (21+10^14) == True
-- + semiprimos es la sucesión de números semiprimos. Por ejemplo,
-- take 10 semiprimos == [4,6,9,10,14,15,21,22,25,26]
-- semiprimos !! 580 == 2021
-- semiprimos !! 10000 == 40886
-- ---------------------------------------------------------------------

-- 1ª definición
-- =============

esSemiprimo1 :: Integer -> Bool
esSemiprimo1 n = any prop ps
where ps = takeWhile (<= (n `div` 2)) primes
prop q = r == 0 && isPrime d
where (d,r) = quotRem n q

semiprimos1 :: [Integer]
semiprimos1 = filter esSemiprimo1 [4..]

-- 2ª definición
-- =============

esSemiprimo2 :: Integer -> Bool
esSemiprimo2 n = length (primeFactors n) == 2

semiprimos2 :: [Integer]
semiprimos2 = filter esSemiprimo2 [4..]

-- Comparación de eficiencia
-- =========================

-- La comparación es
-- λ> semiprimos1 !! 1000 == 3599
-- (0.52 secs, 1,041,413,376 bytes)
-- λ> semiprimos2 !! 1000 == 3599
-- (0.04 secs, 51,977,912 bytes)

-- Por tanto:

esSemiprimo = esSemiprimo2
semiprimos = semiprimos2

-- --------------------------------------------------------------------
-- Ejercicio 4. Un número natural n es un número entero Blum si
-- n = p × q es un semiprimo para el que p y q son distintos primos
-- congruentes con 3 módulo 4. Es decir, p y q tienen que ser de la
-- forma 4 t + 3, para algún número entero t. Los números enteros de
-- esta forma se denominan números primos de Blum. Los primeros enteros
-- de Blum son
-- 21, 33, 57, 69, 77, 93, 129, 133, 141, 161, 177, ...
--
-- Definir las funciones
-- esBlum :: Integer -> Bool
-- sucBlum :: [Integer]
-- tales que
-- + (esBlum n) se verifica si n es un número de Blum. Por ejemplo,
-- esBlum 26 == False
-- esBlum 49 == False
-- esBlum 77 == True
-- esBlum 2021 == True
-- esBlum (21+10^14) == True
-- + sucBlum es la sucesión de números de Blum. Por ejemplo,
-- take 10 sucBlum == [21,33,57,69,77,93,129,133,141,161]
-- sucBlum !! 132 == 2021
-- sucBlum !! 10000 == 186821
-- ---------------------------------------------------------------------

esBlum :: Integer -> Bool
esBlum n = length ps == 2 && p /= q && p `rem` 4 == 3 && q `rem` 4 == 3
where ps = primeFactors n
(p:q:_) = ps

sucBlum :: [Integer]
sucBlum = filter esBlum [4..]

sucBlum2 :: [Integer]
sucBlum2 = filter esBlum semiprimos

-- --------------------------------------------------------------------
-- Ejercicio 5. Un número semiprimo n = p x q es brillante si p y q
-- tienen el mismo número de dígitos.
--
-- Definir las funciones
-- esBrillante :: Integer -> Bool
-- sucBrillantes :: [Integer]
-- tales que
-- + (esBrillante n) se verifica si n es brillante. Por ejemplo,
-- esBrillante 26 == False
-- esBrillante 49 == True
-- esBrillante 77 == False
-- esBrillante 2021 == True
-- esBrillante (21+10^14) == False
-- + sucBrillantes es la sucesión de números brillantes. Por ejemplo,
-- take 10 sucBrillante == [4,6,9,10,14,15,21,25,35,49]
-- sucBrillante !! 130 == 2021
-- sucBrillante !! 10000 == 696649
-- ---------------------------------------------------------------------

esBrillante :: Integer -> Bool
esBrillante n = length ps == 2 && length (show p) == length (show q)
where ps = primeFactors n
p = head ps
q = head (tail ps)

sucBrillante :: [Integer]
sucBrillante = filter esBrillante [4..]

-- --------------------------------------------------------------------
-- Ejercicio 6.1. Un número natural es amable si se puede expresar como
-- suma de, al menos, dos números naturales consecutivos. Por ejemplo,
-- 2021 es amable pues
-- 2021 = 20 + 21 + ... + 65 + 66.
-- La mayoría de los números naturales son amables, por lo que vamos a
-- calcular la lista de los números no amables.
--
-- Los primeros números no amables son
-- 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192,
-- 16384, 32768, 65536, 131072, 262144
--
-- Definir la función
-- sucesionesConSuma :: Int -> [(Int,Int)]
-- tal que (sucesionesConSuma n) es la lista de los pares formados por
-- el primero y por el último elemento de las sucesiones de números
-- naturales consecutivos con suma n. Por ejemplo,
-- sucesionesConSuma 15 == [(1,5),(4,6),(7,8)]
-- sucesionesConSuma 2021 == [(20,66),(26,68),(1010,1011)]
-- length (sucesionesConSuma 2021) == 3
-- length (sucesionesConSuma 3000) == 7
-- ---------------------------------------------------------------------

sucesionesConSuma :: Integer -> [(Integer,Integer)]
sucesionesConSuma n =
[(x,y) | y <- [1..1 + n `div` 2]
, x <- [1..y-1]
, (x+y)*(y-x+1) == 2*n]

-- --------------------------------------------------------------------
-- Ejercicio 6.2. Definir las funciones
-- noAmable :: Integer -> Bool
-- sucNoAmables :: [Integer]
-- tales que
-- + (noAmable n) se verifica si n es un número no amable. Por ejemplo,
-- noAmable 2021 == False
-- noAmable 1024 == True
-- + sucNoAmables es la lista de números naturales no amables. Por
-- ejemplo,
-- take 10 sucNoAmables == [1,2,4,8,16,32,64,128,256,512]
-- ---------------------------------------------------------------------

noAmable :: Integer -> Bool
noAmable n = null (sucesionesConSuma n)

sucNoAmables :: [Integer]
sucNoAmables = filter noAmable [1..]

-- --------------------------------------------------------------------
-- Ejercicio 6.3. Comprobar con QuickCheck que un número natural es no
-- amable si y sólo si es potencia de 2.
-- ---------------------------------------------------------------------

propNoAmable :: Integer -> Bool
propNoAmable n = noAmable m == esPotencia2 m
where m = 1 + abs n

-- (esPotencia2 n) se verifica si n es potencia de 2. Por ejemplo,
-- esPotencia2 16 == True
-- esPotencia2 18 == False
esPotencia2 :: Integer -> Bool
esPotencia2 0 = False
esPotencia2 1 = True
esPotencia2 n = even n && esPotencia2 (n `div` 2)

-- La comprobación es
-- λ> quickCheck propNoAmable
-- +++ OK, passed 100 tests.

-- --------------------------------------------------------------------
-- Ejercicio 7.1. Un número natural se denomina aritmético si la media
-- aritmética de sus divisores es un número entero.
--
-- Definir la función
-- esAritmetico :: Integer -> Bool
-- tal que (esAritmetico n) se verifica si n es un número aritmético.
-- Por ejemplo,
-- esAritmetico 2021 == True
-- esAritmetico 24 == False
-- ---------------------------------------------------------------------

esAritmetico :: Integer -> Bool
esAritmetico n = sum ds `mod` genericLength ds == 0
where ds = divisores n

-- (divisores n) es la lista de los divisores de n. Por ejemplo,
-- divisores 2021 == [2021,1,43,47]
divisores :: Integer -> [Integer]
divisores n = n : [x | x <- [1.. n`div`2], n `rem` x == 0]

-- --------------------------------------------------------------------
-- Ejercicio 7.2. Comprobar con QuickCheck que todos los primos excepto
-- el 2 son aritméticos.
-- ---------------------------------------------------------------------

primosAritmeticos :: Int -> Bool
primosAritmeticos n = all esAritmetico (take n (tail primes))

-- La comprobación es
-- λ> quickCheck primosAritmeticos
-- +++ OK, passed 100 tests.

-- --------------------------------------------------------------------
-- Ejercicio 7.3. Definir la función
-- sucAritmeticosConsecutivos :: Int -> [Integer]
-- tal que (sucAritmeticosConsecutivos n) es una sucesión de n números
-- aritméticos consecutivos. Por ejemplo,
-- λ> sucAritmeticosConsecutivos 5
-- [19,20,21,22,23]
-- λ> sucAritmeticosConsecutivos 20
-- [4955,4956,4957,4958,4959,4960,4961,4962,4963,4964,4965,4966,4967,
-- 4968,4969,4970,4971,4972,4973,4974]
-- ---------------------------------------------------------------------

sucAritmeticosConsecutivos :: Int -> [Integer]
sucAritmeticosConsecutivos n =
head (filter consecutivos (segmentosLongitud n sucAritmeticos))

-- sucAritmeticos es la sucesión de los números aritméticos. Por
-- ejemplo,
-- take 10 sucAritmeticos == [1,3,5,6,7,11,13,14,15,17]
sucAritmeticos :: [Integer]
sucAritmeticos = filter esAritmetico [1..]

-- (segmentosLongitud n xs) es la sucesión de los segmentos de xs de
-- longitud n. Por ejemplo,
-- λ> segmentosLongitud 2 "Sevilla"
-- ["Se","ev","vi","il","ll","la","a",""]
-- λ> segmentosLongitud 3 "Sevilla"
-- ["Sev","evi","vil","ill","lla","la","a",""]
segmentosLongitud :: Int -> [a] -> [[a]]
segmentosLongitud n xs = map (take n) (tails xs)

-- (consecutivos ns) se verifica si ns es una lista de números
-- consecutivos. Por ejemplo,
-- consecutivos [4,5,6] == True
-- consecutivos [4,5,7] == False
consecutivos :: [Integer] -> Bool
consecutivos ns = all (==1) (zipWith (-) (tail ns) ns)

-- Otra definición de consecutivos es
consecutivos2 :: [Integer] -> Bool
consecutivos2 ns = ns == [minimum ns .. maximum ns]

-- --------------------------------------------------------------------
-- Ejercicio 8.1. El número 2021 tiene las propiedades siguientes:
-- + sumándole su inverso es un número palíndromo: 2021 + 1202 = 3223
-- + multiplicándolo por su inverso también lo es: 2021 * 1202 = 2429242
--
-- Definir las funciones
-- masInvPalindromo :: Integer -> Bool
-- prodInvPalindromo :: Integer -> Bool
-- tales que
-- + (masInvPalindromo n) se verifica si n más su inverso es
-- palíndromo. Por ejemplo,
-- masInvPalindromo 2021 == True
-- masInvPalindromo 109 == False
-- + (prodInvPalindromo n) se verifica si n por su inverso es
-- palíndromo. Por ejemplo,
-- prodInvPalindromo 2021 == True
-- prodInvPalindromo 1097 == False
-- ---------------------------------------------------------------------

masInvPalindromo :: Integer -> Bool
masInvPalindromo n = palindromo (n + inversoN n)

-- (inversoN x) es el número obtenido invirtiendo los dígitos de x. Por
-- ejemplo,
-- inversoN 2021 == 1202
inversoN :: Integer -> Integer
inversoN = read . reverse . show

-- (palindromo n) se verifica si n es un palíndromo. Por ejemplo,
-- palindromo 23532 == True
-- palindromo 23352 == False
palindromo :: Integer -> Bool
palindromo n = show n == reverse (show n)

prodInvPalindromo :: Integer -> Bool
prodInvPalindromo n = palindromo (n * inversoN n)

-- --------------------------------------------------------------------
-- Ejercicio 8.2.. Comprobar con QuickCheck que todo número
-- prodInvPalindromo es masInvPalindromo.
-- ---------------------------------------------------------------------

propInvPalindromo :: Integer -> Bool
propInvPalindromo n = not (prodInvPalindromo m) || masInvPalindromo m
where m = 1 + abs n

-- La comprobación es
-- λ> quickCheck propInvPalindromo
-- +++ OK, passed 100 tests.

-- --------------------------------------------------------------------
-- Ejercicio 9. Comprobar que el número 2021 es el menor número
-- natural que verifica las siguientes propiedades:
-- (+) es la concatenación de dos enteros consecutivos (20 y 21)
-- (+) es el producto de dos primos consecutivos (43 y 47)
--
-- Para ello, definir las funciones
-- esConcatConsecutivos :: Integer -> Bool
-- esProdprimosConsecutivos :: Integer -> Bool
-- especiales :: [Integer]
-- tales que
-- + (esConcatConsecutivos n) se verifica si n es la concatenación de
-- dos enteros consecutivos. Por ejemplo,
-- esConcatConsecutivos 2021 == True
-- + (esProdprimosConsecutivos n) se verifica si n es el producto de dos
-- primos consecutivos
-- esProdprimosConsecutivos 2021 == True
-- + espaciales es la lista de números naturales que verifican las dos
-- propiedaes anteriores
-- head especiales == 2021
-- ---------------------------------------------------------------------

-- esConcatConsecutivos
-- ====================

esConcatConsecutivos :: Integer -> Bool
esConcatConsecutivos n =
n == head (dropWhile (<n) concatEnterosConsecutivos)

-- concatEnterosConsecutivos es la lista de números obtenidos
-- concatenando dos enteros consecutivos. Por ejemplo,
-- λ> take 10 concatEnterosConsecutivos
-- [12,23,34,45,56,67,78,89,910,1011]
concatEnterosConsecutivos :: [Integer]
concatEnterosConsecutivos = zipWith pegaNumeros xs (tail xs)
where xs = [1..]

-- (pegaNumeros n m) es el número otenido añadiendo los dígitos de m a
-- continuación de los de n. Por ejemplo,
-- pegaNumeros 23 416 == 23416
pegaNumeros :: Integer -> Integer -> Integer
pegaNumeros n m = read (show n ++ show m)

-- esProdprimosConsecutivos
-- =========================

esProdprimosConsecutivos :: Integer -> Bool
esProdprimosConsecutivos n =
n == head (dropWhile (<n) productoPrimosConsecutivos)

-- productoPrimosConsecutivos es la sucesión de los números que son
-- productos de dos primos consecutivos. Por ejemplo,
-- λ> take 20 productoPrimosConsecutivos
-- [6,15,35,77,143,221,323,437,667,899,1147,1517,1763,2021,2491,3127,
-- 3599,4087,4757,5183]
productoPrimosConsecutivos :: [Integer]
productoPrimosConsecutivos =
zipWith (*) primes (tail primes)

-- especiales
-- ==========

especiales :: [Integer]
especiales = [n | n <- productoPrimosConsecutivos
, esConcatConsecutivos n]

-- concatPrimos es la lista de números obtenidos concatenando dos primos
-- consecutivos. Por ejemplo,
-- λ> take 20 concatPrimos
-- [23,35,57,711,1113,1317,1719,1923,2329,2931,3137,3741,4143,4347,4753,
-- 5359,5961,6167,6771,7173]
concatPrimos :: [Integer]
concatPrimos = zipWith pegaNumeros primes (tail primes)

-- Primer número especial:
-- head especiales == 2021
</source>

Relación 10 Sol

2021-12-08T08:41:25Z

Mdelamor: Página creada con «<source lang='haskell'> -- I1M 2021-22: Relación 10 -- Propiedades del número 2021. -- Departamento de Ciencias de la Computación e I.A. -- Universidad de Sevilla -- ===…»

Relación 10

2021-12-08T08:40:53Z

Archivo:Rel 10.hs

2021-12-08T08:40:18Z

Mdelamor:

Informática (1º Matemáticas)

2021-12-08T08:39:56Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]] ]
* '''Relación 10''': Propiedades del número 2021. [ [[Media:Rel_10.hs |Enunciado]], [[Relación 10 |Solución colaborativa]], [[Relación 10 Sol |Solución ]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Relación 9

2021-12-03T09:52:34Z

Mdelamor:

<source lang='haskell'>

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

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

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

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

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

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

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

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

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

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

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

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

--José Manuel García
intercala1 :: (Ord a, Num a) => a -> [a] -> [a]
intercala1 n xs = concat [if a < n then [n,a] else [a] | a<-xs]

intercala2 :: (Ord a, Num a) => a -> [a] -> [a]
intercala22 n xs = concat (map f xs)
where f x = if x < n then [n,x] else [x]

intercala3 :: (Ord a, Num a) => a -> [a] -> [a]
intercala3 n [] = []
intercala3 n (x:xs) = (if x < n then [n,x] else [x]) ++ (intercala3 n (xs))

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

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

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

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

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

-- Adriana Gordillo, Elsa Domínguez
dec2entC xs = sum[ x*10^e|(x,e)<- zip (reverse xs) [0..length xs-1]]

dec2entS xs =sum( map f ( zip xs [n,n-1..0]))
where n= length xs-1
f (x,i) = x*10^i
dec2entR [] = 0
dec2entR (x:xs) = x*10^(length xs) + dec2entR xs

dec2entP xs = foldr f 0 ( zip xs [n,n-1..0])
where n= length xs-1
f (x,i) recu = x*10^i + recu

-- Juan José Calero Vela:

pos :: Integer -> [Integer] -> Integer
pos x [] = 0
pos x (y:xs) = if x==y then 1 else 1 + pos x xs

dec2entC :: [Integer] -> Integer
dec2entC xs = sum [ x*(10^(pos x (reverse xs)-1)) | x<-xs]

-- profesor: solución vista en clase
dec2entS xs = sum (map f (zip xs [n-1,n-2..0]))
where f (x,i) = x * 10^i
n = length xs

--Manuel Alcaide

dec2ent1' :: [Integer] -> Integer
dec2ent1' xs = sum[x*(10^y)|(x,y)<-(zip xs [((length (xs))-1),((length (xs))-2)..0])]

dec2ent2' :: [Integer] -> Integer
dec2ent2' xs = sum (map f (zip xs [((length (xs))-1),((length (xs))-2)..0]))
where f (x,y) = x*(10^y)

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

dec2ent4' :: [Integer] -> Integer
dec2ent4' xs = foldr f 0 $ zip xs [((length xs)-1),((length xs)-2)..0]
where f (x,p) recu = x*(10^p) + recu

-- ----------------------------------------------------------------------------
-- Ejercicio 4. Se considera la función
-- diferencia :: Eq a => [a] -> [a] -> [a]
-- tal que (diferencia xs ys) es la diferencia entre los conjuntos xs e
-- ys; es decir, el conjunto de los elementos de la lista xs que no se
-- encuentran en la lista ys. Por ejemplo,
-- diferencia [2,3,5,6] [5,2,7] == [3,6]
-- diferencia [1,3,5,7] [2,4,6] == [1,3,5,7]
-- diferencia [1,3] [1..9] == []
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hermanada4 xs = undefined
---------------------------------------------------------------------------------------
--Adriana Gordillo, Elsa Domínguez
hermanadaC :: [Int] -> Bool
hermanadaC xs | elem 0 xs = False
| otherwise = and [(gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y))) | (x,y) <- zip xs (tail xs)]

hermanadaS :: [Int] -> Bool
hermanadaS xs | elem 0 xs = False
| otherwise = and (map f (zip xs (tail xs)))
where f (x,y) = (gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y)))

hermanadaR :: [Int] -> Bool
hermanadaR [x] = True
hermanadaR (x:y:xs) | elem 0 (x:y:xs) = False
| otherwise = ((gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y)))) && hermanadaR (y:xs)

hermanadaPR :: [Int] -> Bool
hermanadaPR xs | elem 0 xs = False
| otherwise = foldr f True (zip xs (tail xs))
where f (x,y) recu = ((gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y)))) && recu

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

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

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

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

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

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

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

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

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

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

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

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

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

-- El cálculo es

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

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

</source>

Relación 9

2021-12-03T09:37:36Z

Mdelamor:

<source lang='haskell'>

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

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

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

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

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

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

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

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

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

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

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

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

--José Manuel García
intercala1 :: (Ord a, Num a) => a -> [a] -> [a]
intercala1 n xs = concat [if a < n then [n,a] else [a] | a<-xs]

intercala2 :: (Ord a, Num a) => a -> [a] -> [a]
intercala22 n xs = concat (map f xs)
where f x = if x < n then [n,x] else [x]

intercala3 :: (Ord a, Num a) => a -> [a] -> [a]
intercala3 n [] = []
intercala3 n (x:xs) = (if x < n then [n,x] else [x]) ++ (intercala3 n (xs))

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

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

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

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

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

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

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

-- profesor: solución vista en clase
dec2entS xs = sum (map f (zip xs [n-1,n-2..0]))
where f (x,i) = x * 10^i
n = length xs -1

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

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

-- ----------------------------------------------------------------------------
-- Ejercicio 4. Se considera la función
-- diferencia :: Eq a => [a] -> [a] -> [a]
-- tal que (diferencia xs ys) es la diferencia entre los conjuntos xs e
-- ys; es decir, el conjunto de los elementos de la lista xs que no se
-- encuentran en la lista ys. Por ejemplo,
-- diferencia [2,3,5,6] [5,2,7] == [3,6]
-- diferencia [1,3,5,7] [2,4,6] == [1,3,5,7]
-- diferencia [1,3] [1..9] == []
--
-- Define esta función
-- 1) por comprensión,
-- 2) por orden superior (map, filter, ...)
-- 3) por recursión,
-- 4) por plegado (con 'foldr').
-- ----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

hermanada4 xs = undefined
---------------------------------------------------------------------------------------
--Adriana Gordillo, Elsa Domínguez
hermanadaC :: [Int] -> Bool
hermanadaC xs | elem 0 xs = False
| otherwise = and [(gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y))) | (x,y) <- zip xs (tail xs)]

hermanadaS :: [Int] -> Bool
hermanadaS xs | elem 0 xs = False
| otherwise = and (map f (zip xs (tail xs)))
where f (x,y) = (gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y)))

hermanadaR :: [Int] -> Bool
hermanadaR [x] = True
hermanadaR (x:y:xs) | elem 0 (x:y:xs) = False
| otherwise = ((gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y)))) && hermanadaR (y:xs)

hermanadaPR :: [Int] -> Bool
hermanadaPR xs | elem 0 xs = False
| otherwise = foldr f True (zip xs (tail xs))
where f (x,y) recu = ((gcd x y == x) || (gcd x y == y) || not (null (primeFactors (gcd x y)))) && recu

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

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

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

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

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

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

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

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

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

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

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

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

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

-- El cálculo es

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

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

</source>

Informática (1º Matemáticas)

2021-11-17T22:32:44Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Relación 9

2021-11-17T22:32:13Z

Mdelamor: Página creada con «<source lang='haskell'> -- I1M 2021-22: Rel_9.hs (01 de diciembre de 2021) -- Funciones de orden superior y definiciones por plegados (II) -- Departamento de Ciencias de l…»

Archivo:Rel 9.hs

2021-11-17T22:31:46Z

Mdelamor:

Relación 8 Sol

2021-11-17T22:31:32Z

Mdelamor: Protegió «Relación 8 Sol» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang='haskell'>

-- I1M 2021-22: Rel_8_sol.hs
-- 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 _ [] = []
segmentos p (x:xs)
| p x = takeWhile p (x:xs) : segmentos p (dropWhile p xs)
| otherwise = segmentos p xs

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

relacionadosC :: (a -> a -> Bool) -> [a] -> Bool
relacionadosC r xs = and [r x y | (x,y) <- zip xs (tail xs)]

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

relacionadosR :: (a -> a -> Bool) -> [a] -> Bool
relacionadosR r (x:y:zs) = r x y && relacionadosR r (y:zs)
relacionadosR _ _ = True

-- ---------------------------------------------------------------------
-- 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 [] = []
agrupa xss
| [] `elem` xss = []
| otherwise = primeros xss : agrupa (restos xss)
where primeros = map head
restos = map tail

-- ---------------------------------------------------------------------
-- 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 =
and [length xs == n | xs <- agrupa xss]
where n = length xss

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

comprueba_agrupa :: IO ()
comprueba_agrupa =
quickCheck prop_agrupa

-- ---------------------------------------------------------------------
-- Ejercicio 4.1. 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 [] = []
concatR (xs:xss) = xs ++ concatR xss

-- ---------------------------------------------------------------------
-- 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 = [f x | x <- xs, p x]

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

filtraAplicaMF :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaMF f p xs = map f (filter p xs)

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

filtraAplicaR :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaR _ _ [] = []
filtraAplicaR f p (x:xs) | p x = f x : filtraAplicaR f p xs
| otherwise = filtraAplicaR f p xs

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

maximumR :: Ord a => [a] -> a
maximumR [x] = x
maximumR (x:y:ys) = max x (maximumR (y:ys))
maximumR _ = error "Imposible"

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

-- ---------------------------------------------------------------------
-- 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 = foldr (++) []

-- ---------------------------------------------------------------------
-- 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 =
concatR xss == ys && concatP xss == ys
where ys = concat xss

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

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

-- La propiedad es
prop_longConcat :: [[Int]] -> Bool
prop_longConcat xss =
length (concatP xss) == sum [length xs | xs <- xss]

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

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

filtraAplicaP :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaP f p = foldr g []
where g x y | p x = f x : y
| otherwise = y

-- La definición por plegado usando lambda es
filtraAplicaP2 :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaP2 f p =
foldr (\x y -> if p x then f x : y else y) []

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

-- Se redefine la relación 'r' con 'rpar' para que se aplique a pares
relacionadosA :: (a -> a -> Bool) -> [a] -> Bool
relacionadosA r xs = all rpar (zip xs (tail xs))
where rpar (x,y) = r x y

-- ---------------------------------------------------------------------
-- 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 r xs = foldr rfpar True (zip xs (tail xs))
where rfpar (x,y) b = (r x y) && b

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. (Basado en el ejercicio 4 del primer parcial)
-- 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 = relacionadosA relMuyCreciente xs
where relMuyCreciente a b = b > a*3

</source>

Relación 8 Sol

2021-11-17T22:31:23Z

Mdelamor: Página creada con «<source lang='haskell'> -- I1M 2021-22: Rel_8_sol.hs -- Funciones de orden superior y definiciones por plegados. -- Departamento de Ciencias de la Computación e I.A. -- U…»

<source lang='haskell'>

-- I1M 2021-22: Rel_8_sol.hs
-- 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 _ [] = []
segmentos p (x:xs)
| p x = takeWhile p (x:xs) : segmentos p (dropWhile p xs)
| otherwise = segmentos p xs

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

relacionadosC :: (a -> a -> Bool) -> [a] -> Bool
relacionadosC r xs = and [r x y | (x,y) <- zip xs (tail xs)]

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

relacionadosR :: (a -> a -> Bool) -> [a] -> Bool
relacionadosR r (x:y:zs) = r x y && relacionadosR r (y:zs)
relacionadosR _ _ = True

-- ---------------------------------------------------------------------
-- 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 [] = []
agrupa xss
| [] `elem` xss = []
| otherwise = primeros xss : agrupa (restos xss)
where primeros = map head
restos = map tail

-- ---------------------------------------------------------------------
-- 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 =
and [length xs == n | xs <- agrupa xss]
where n = length xss

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

comprueba_agrupa :: IO ()
comprueba_agrupa =
quickCheck prop_agrupa

-- ---------------------------------------------------------------------
-- Ejercicio 4.1. 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 [] = []
concatR (xs:xss) = xs ++ concatR xss

-- ---------------------------------------------------------------------
-- 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 = [f x | x <- xs, p x]

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

filtraAplicaMF :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaMF f p xs = map f (filter p xs)

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

filtraAplicaR :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaR _ _ [] = []
filtraAplicaR f p (x:xs) | p x = f x : filtraAplicaR f p xs
| otherwise = filtraAplicaR f p xs

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

maximumR :: Ord a => [a] -> a
maximumR [x] = x
maximumR (x:y:ys) = max x (maximumR (y:ys))
maximumR _ = error "Imposible"

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

-- ---------------------------------------------------------------------
-- 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 = foldr (++) []

-- ---------------------------------------------------------------------
-- 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 =
concatR xss == ys && concatP xss == ys
where ys = concat xss

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

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

-- La propiedad es
prop_longConcat :: [[Int]] -> Bool
prop_longConcat xss =
length (concatP xss) == sum [length xs | xs <- xss]

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

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

filtraAplicaP :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaP f p = foldr g []
where g x y | p x = f x : y
| otherwise = y

-- La definición por plegado usando lambda es
filtraAplicaP2 :: (a -> b) -> (a -> Bool) -> [a] -> [b]
filtraAplicaP2 f p =
foldr (\x y -> if p x then f x : y else y) []

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

-- Se redefine la relación 'r' con 'rpar' para que se aplique a pares
relacionadosA :: (a -> a -> Bool) -> [a] -> Bool
relacionadosA r xs = all rpar (zip xs (tail xs))
where rpar (x,y) = r x y

-- ---------------------------------------------------------------------
-- 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 r xs = foldr rfpar True (zip xs (tail xs))
where rfpar (x,y) b = (r x y) && b

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. (Basado en el ejercicio 4 del primer parcial)
-- 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 = relacionadosA relMuyCreciente xs
where relMuyCreciente a b = b > a*3

</source>

Relación 8

2021-11-17T22:30:44Z

Mdelamor: Página creada con «<source lang='haskell'> -- I1M 2021-22: Rel_8.hs (24 de noviembre de 2021) -- Funciones de orden superior y definiciones por plegados. -- Departamento de Ciencias de la Co…»

<source lang='haskell'>

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

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

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

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

import Test.QuickCheck

-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
-- segmentos :: (a -> Bool) -> [a] -> [a]
-- tal que (segmentos p xs) es la lista de los segmentos de xs cuyos
-- elementos verifican la propiedad p. Por ejemplo,
-- segmentos even [1,2,0,4,9,6,4,5,7,2] == [[2,0,4],[6,4],[2]]
-- segmentos odd [1,2,0,4,9,6,4,5,7,2] == [[1],[9],[5,7]]
-- ---------------------------------------------------------------------

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

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

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

</source>

Archivo:Rel 8.hs

2021-11-17T22:30:15Z

Mdelamor:

Informática (1º Matemáticas)

2021-11-17T22:29:56Z

Mdelamor: /* Relación de Ejercicios */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]
* '''Relación 8''': Funciones de orden superior y definiciones por plegados. [ [[Media:Rel_8.hs |Enunciado]], [[Relación 8 |Solución colaborativa]], [[Relación 8 Sol |Solución ]] ]
* '''Relación 9''': Funciones de orden superior y definiciones por plegados (extra). [ [[Media:Rel_9.hs |Enunciado]], [[Relación 9 |Solución colaborativa]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Informática (1º Matemáticas)

2021-11-17T22:23:22Z

Mdelamor: /* Exámenes */

__TOC__

==Relación de Ejercicios==

En esta página se publicarán las relaciones de ejercicios. Las soluciones se escriben de forma colaborativa por los alumnos del curso y no deben tomarse como definitivas.

* '''Relación 1''': Definiciones por composición sobre números, listas y booleanos. [ [[Media:Rel_1.hs |Enunciado]], [[Relación 1 |Solución colaborativa]], [[Relación 1 Sol |Solución]] ]
* '''Relación 2''': Definiciones con condicionales, guardas o patrones. [ [[Media:Rel_2.hs |Enunciado]], [[Relación 2 |Solución colaborativa]], [[Relación 2 Sol |Solución]] ]
* '''Relación 3''': Definiciones por comprensión. [ [[Media:Rel_3.hs |Enunciado]], [[Relación 3 |Solución colaborativa]], [[Relación 3 Sol |Solución ]] ]
* '''Relación 4''': Definiciones por comprensión (extra). [ [[Media:Rel_4.hs |Enunciado]], [[Relación 4 |Solución colaborativa editada]] ]
* '''Relación 5''': Definiciones por comprensión con cadenas: El cifrado césar. [ [[Media:Rel_5.hs |Enunciado]], [[Relación 5 |Solución colaborativa]], [[Relación 5 Sol |Solución ]] ]
* '''Relación 6''': Definiciones por recursión. [ [[Media:Rel_6.hs |Enunciado]], [[Relación 6 |Solución colaborativa]], [[Relación 6 Sol |Solución]] ]
* '''Relación 7''': Definiciones por recursión y comprensión (extra). [ [[Media:Rel_7.hs |Enunciado]], [[Relación 7 |Solución colaborativa]] ]


==Exámenes Curso Actual==
* '''Examen 1''' ''(12/11/2021)'': [ [[Media:Exam1_G2.hs |Enunciado]], [[Parcial 1 |Solución colaborativa]], [[Parcial 1 Sol |Solución ]] ]
* '''Examen 2''' ''(20/01/2022)''
* '''Examen 3''' ''(08/04/2022)''
* '''Examen 4''' ''(10/06/2022)''
* '''Examen 5''' ''(24/06/2022)''

==Exámenes Cursos Anteriores==
* '''[https://github.com/jaalonso/Examenes_de_PF_con_Haskell/blob/master/README.org Repositorio de Exámenes]'''
* '''Curso 2020/21 Grupo 2''':
** '''[[Examen 11/12/20 |Examen 1]]''' ''(11/12/2020)''
** '''[[Examen 16/02/21 |Examen 2]]''' ''(16/02/2021)''
** '''[[Examen 23/04/21 |Examen 3 Turno 2]]''' ''(23/04/21)''
** '''[[Examen 28/04/21 |Examen 3 Turno 1]]''' ''(28/04/21)''
** '''[[Examen 21/06/21 |Examen 4]]''' ''(21/06/2021)''
** '''[[Examen 05/07/2021 |Examen Julio]]''' ''(05/07/2021)''
** '''[[Examen 07/09/2021 |Examen Septiembre]]''' ''(07/09/2021)''

Examen 07/09/2021

2021-11-17T22:19:31Z

Mdelamor:

<source lang='haskell'>

-- Informática (1º del Grado en Matemáticas)
-- 2ª convocatoria

-- =====================================================================
-- Nombre:
-- Apellidos:
-- UVUS:
-- =====================================================================

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

import Data.Matrix
import qualified Data.Set as S
import qualified Data.Vector as V
import Data.List
import Data.Numbers.Primes
import I1M.Cola

-- ---------------------------------------------------------------------
-- Ejercicio 1. Una permutación de n se representa como una lista de los
-- elementos 1..n. Por ejemplo, la lista [3,1,2,4] representa la
-- permutación tal que corresponde con la transformación:
-- 1 -> 3
-- 2 -> 1
-- 3 -> 2
-- 4 -> 4

-- Definir la función
-- compPermutaciones :: [Int] -> [Int]
-- tal que (compPermutaciones p q) es composición de las permutaciones p
-- y q. Por ejemplo, si p = [1,3,4,2] y q = [3,1,2,4], la composición
-- es:
-- 1 -> 1 -> 3
-- 2 -> 3 -> 2
-- 3 -> 4 -> 4
-- 4 -> 2 -> 1

-- compPermutaciones [1,3,4,2] [3,1,2,4] == [3,2,4,1]

compPermutaciones :: [Int] -> [Int] -> [Int]
compPermutaciones p q =
map snd (comp (zip [1..n] p) (zip [1..n] q))
where n = length p
comp r s = [(x,z) | (x,y) <- r, (y',z) <-s, y == y']

-- ---------------------------------------------------------------------
-- Ejercicio 2. Se tienen n cartas numeradas en un único montón en orden
-- creciente desde arriba hacia abajo; es decir, la carta de más arriba
-- es la número 1, luego sigue la número 2, ...
--
-- Se hace lo siguiente:
-- + se coloca la carta número 1 debajo de todas,
-- + se quita de arriba la carta número 2,
-- + se coloca la carta número 3 debajo de todas,
-- + se quita de arriba la carta número 4,
-- + ...
--
-- El proceso continúa siempre de la misma manera: se coloca la carta de
-- más arriba debajo de todas y se quita la que ha quedado arriba, hasta
-- que quede una única carta.
--
-- Definir la función
-- cartaFinal :: Int -> Int
-- tal que (cartaFinal n) es la carta final que queda en el montón. Por
-- ejemplo,
-- cartaFinal 4 == 1
-- cartaFinal 7 == 7
-- cartaFinal 10 == 5
-- cartaFinal 20 == 9
-- cartaFinal 100 == 73
-- ---------------------------------------------------------------------

-- Usando listas:

cartaFinal :: Int -> Int
cartaFinal n = head (until pred paso [1..n])
where paso (x:xs) = tail (xs++[x])
pred (x:xs) = null xs

-- Usando colas:

cartaFinalC :: Int -> Int
cartaFinalC n = primero (until pred paso cInicial)
where cInicial = foldr inserta vacia [n,n-1..1]
pred c = not (esVacia c) && esVacia (resto c)
paso c = resto (inserta (primero c) (resto c))

-- ---------------------------------------------------------------------
-- Ejercicio 3. Dada una matriz A, de dimensión n×n , sea X_i el
-- conjunto de elementos de la fila i, e Y_j el conjunto de elementos de
-- la columna j, 1 ≤ i, j ≤ n. Decimos que A es dorada si
-- X_1,...,X_n,Y_1,...,Y_n son conjuntos distintos.

-- Definir la función
-- esMatrizDorada :: Ord a => Matrix a -> Bool
-- tal que (esMatrizDorada A) verifique si A es dorada. Por ejemplo,
-- esMatrizDorada (fromLists [[1,2,1],[1,1,1],[2,2,2]]) == False
-- esMatrizDorada (fromLists [[1,2,1],[1,1,1],[3,3,4]]) == True
-- ---------------------------------------------------------------------

esMatrizDorada :: Ord a => Matrix a -> Bool
esMatrizDorada p =
conjDistintosLista (filas p ++ columnas p)
where n = nrows p
filas p = [S.fromList (V.toList (getRow i p)) | i <-[1..n]]
columnas p = [S.fromList (V.toList (getCol i p)) | i <-[1..n]]

conjDistintosLista :: Ord a => [S.Set a] -> Bool
conjDistintosLista [] = True
conjDistintosLista (xs:xss) =
all (not . ((==) xs)) xss && conjDistintosLista xss

-- ---------------------------------------------------------------------
-- Ejercicio 4. Consideremos el problema de construir los árboles
-- etiquetados en las hojas, a partir de una lista xs, de forma que el
-- borde del árbol consista en los elementos de esta lista. Por ejemplo,
-- si xs = [1,2,3], los árboles que se obtienen son los siguientes:

-- . .
-- / \ / \
-- 1 . . 3
-- / \ / \
-- 2 3 1 2

-- Definir la función
-- arboles:: [Int] -> [Arbol]
-- tal que (arboles xs) es la lista de los árboles que se pueden
-- construir de forma que los elementos que constituyen su borde es la
-- lista xs. Por ejemplo,
-- arboles [1..3] = [Nodo (Hoja 1) (Nodo (Hoja 2) (Hoja 3)),
-- Nodo (Nodo (Hoja 1) (Hoja 2)) (Hoja 3)]
-- ----------------------------------------------------------------------------

data Arbol = Hoja Int | Nodo Arbol Arbol
deriving Show

-- Definimos la función arboles, de forma recursiva

arboles:: [Int] -> [Arbol]
arboles [x] = [Hoja x]
arboles (x:xs) = concatMap (prefijos x) (arboles xs)

-- (prefijos x a) es la lista de todas las formas en la que x puede ser
-- insertada como la hoja más a la izquierda en el árbol a. Por ejemplo,
-- si el árbol es
-- .
-- / \
-- 2 3
--
-- hay dos formas de insertar 1 de forma que sea la hoja más a la
-- izquierda:

-- . .
-- / \ / \
-- 1 . . 3
-- / \ / \
-- 2 3 1 2

prefijos:: Int -> Arbol -> [Arbol]
prefijos x a@(Hoja y) = [Nodo (Hoja x) a]
prefijos x a@(Nodo i d) =
(Nodo (Hoja x) a):[Nodo i' d | i' <- prefijos x i]

-- prefijos 1 (Nodo (Hoja 2) (Hoja 3))
-- [Nodo (Hoja 1) (Nodo (Hoja 2) (Hoja 3)),
-- Nodo (Nodo (Hoja 1) (Hoja 2)) (Hoja 3)]

-- arboles [1..3]
-- [Nodo (Hoja 1) (Nodo (Hoja 2) (Hoja 3)),
-- Nodo (Nodo (Hoja 1) (Hoja 2)) (Hoja 3)]

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

</source>

Examen 07/09/2021

2021-11-17T22:18:52Z

Mdelamor: Protegió «Examen 07/09/2021» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang='haskell'>

-- Informática (1º del Grado en Matemáticas)
-- 2ª convocatoria

-- =====================================================================
-- Nombre:
-- Apellidos:
-- UVUS:
-- =====================================================================

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

import Data.Matrix
import qualified Data.Set as S
import qualified Data.Vector as V
import Data.List
import Data.Numbers.Primes
import I1M.Cola

-- ---------------------------------------------------------------------
-- Ejercicio ?. Una permutación de n se representa como una lista de los
-- elementos 1..n. Por ejemplo, la lista [3,1,2,4] representa la
-- permutación tal que corresponde con la transformación:
-- 1 -> 3
-- 2 -> 1
-- 3 -> 2
-- 4 -> 4

-- Definir la función
-- compPermutaciones :: [Int] -> [Int]
-- tal que (compPermutaciones p q) es composición de las permutaciones p
-- y q. Por ejemplo, si p = [1,3,4,2] y q = [3,1,2,4], la composición
-- es:
-- 1 -> 1 -> 3
-- 2 -> 3 -> 2
-- 3 -> 4 -> 4
-- 4 -> 2 -> 1

-- compPermutaciones [1,3,4,2] [3,1,2,4] == [3,2,4,1]

compPermutaciones :: [Int] -> [Int] -> [Int]
compPermutaciones p q =
map snd (comp (zip [1..n] p) (zip [1..n] q))
where n = length p
comp r s = [(x,z) | (x,y) <- r, (y',z) <-s, y == y']

-- ---------------------------------------------------------------------
-- Ejercicio ?. Se tienen n cartas numeradas en un único montón en orden
-- creciente desde arriba hacia abajo; es decir, la carta de más arriba
-- es la número 1, luego sigue la número 2, ...
--
-- Se hace lo siguiente:
-- + se coloca la carta número 1 debajo de todas,
-- + se quita de arriba la carta número 2,
-- + se coloca la carta número 3 debajo de todas,
-- + se quita de arriba la carta número 4,
-- + ...
--
-- El proceso continúa siempre de la misma manera: se coloca la carta de
-- más arriba debajo de todas y se quita la que ha quedado arriba, hasta
-- que quede una única carta.
--
-- Definir la función
-- cartaFinal :: Int -> Int
-- tal que (cartaFinal n) es la carta final que queda en el montón. Por
-- ejemplo,
-- cartaFinal 4 == 1
-- cartaFinal 7 == 7
-- cartaFinal 10 == 5
-- cartaFinal 20 == 9
-- cartaFinal 100 == 73
-- ---------------------------------------------------------------------

-- Usando listas:

cartaFinal :: Int -> Int
cartaFinal n = head (until pred paso [1..n])
where paso (x:xs) = tail (xs++[x])
pred (x:xs) = null xs

-- Usando colas:

cartaFinalC :: Int -> Int
cartaFinalC n = primero (until pred paso cInicial)
where cInicial = foldr inserta vacia [n,n-1..1]
pred c = not (esVacia c) && esVacia (resto c)
paso c = resto (inserta (primero c) (resto c))

-- ---------------------------------------------------------------------
-- Ejercicio ?. Dada una matriz A, de dimensión n×n , sea X_i el
-- conjunto de elementos de la fila i, e Y_j el conjunto de elementos de
-- la columna j, 1 ≤ i, j ≤ n. Decimos que A es dorada si
-- X_1,...,X_n,Y_1,...,Y_n son conjuntos distintos.

-- Definir la función
-- esMatrizDorada :: Ord a => Matrix a -> Bool
-- tal que (esMatrizDorada A) verifique si A es dorada. Por ejemplo,
-- esMatrizDorada (fromLists [[1,2,1],[1,1,1],[2,2,2]]) == False
-- esMatrizDorada (fromLists [[1,2,1],[1,1,1],[3,3,4]]) == True
-- ---------------------------------------------------------------------

esMatrizDorada :: Ord a => Matrix a -> Bool
esMatrizDorada p =
conjDistintosLista (filas p ++ columnas p)
where n = nrows p
filas p = [S.fromList (V.toList (getRow i p)) | i <-[1..n]]
columnas p = [S.fromList (V.toList (getCol i p)) | i <-[1..n]]

conjDistintosLista :: Ord a => [S.Set a] -> Bool
conjDistintosLista [] = True
conjDistintosLista (xs:xss) =
all (not . ((==) xs)) xss && conjDistintosLista xss

-- ---------------------------------------------------------------------
-- Ejercicio ?. Consideremos el problema de construir los árboles
-- etiquetados en las hojas, a partir de una lista xs, de forma que el
-- borde del árbol consista en los elementos de esta lista. Por ejemplo,
-- si xs = [1,2,3], los árboles que se obtienen son los siguientes:

-- . .
-- / \ / \
-- 1 . . 3
-- / \ / \
-- 2 3 1 2

-- Definir la función
-- arboles:: [Int] -> [Arbol]
-- tal que (arboles xs) es la lista de los árboles que se pueden
-- construir de forma que los elementos que constituyen su borde es la
-- lista xs. Por ejemplo,
-- arboles [1..3] = [Nodo (Hoja 1) (Nodo (Hoja 2) (Hoja 3)),
-- Nodo (Nodo (Hoja 1) (Hoja 2)) (Hoja 3)]
-- ----------------------------------------------------------------------------

data Arbol = Hoja Int | Nodo Arbol Arbol
deriving Show

-- Definimos la función arboles, de forma recursiva

arboles:: [Int] -> [Arbol]
arboles [x] = [Hoja x]
arboles (x:xs) = concatMap (prefijos x) (arboles xs)

-- (prefijos x a) es la lista de todas las formas en la que x puede ser
-- insertada como la hoja más a la izquierda en el árbol a. Por ejemplo,
-- si el árbol es
-- .
-- / \
-- 2 3
--
-- hay dos formas de insertar 1 de forma que sea la hoja más a la
-- izquierda:

-- . .
-- / \ / \
-- 1 . . 3
-- / \ / \
-- 2 3 1 2

prefijos:: Int -> Arbol -> [Arbol]
prefijos x a@(Hoja y) = [Nodo (Hoja x) a]
prefijos x a@(Nodo i d) =
(Nodo (Hoja x) a):[Nodo i' d | i' <- prefijos x i]

-- prefijos 1 (Nodo (Hoja 2) (Hoja 3))
-- [Nodo (Hoja 1) (Nodo (Hoja 2) (Hoja 3)),
-- Nodo (Nodo (Hoja 1) (Hoja 2)) (Hoja 3)]

-- arboles [1..3]
-- [Nodo (Hoja 1) (Nodo (Hoja 2) (Hoja 3)),
-- Nodo (Nodo (Hoja 1) (Hoja 2)) (Hoja 3)]

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

</source>

Examen 07/09/2021

2021-11-17T22:18:44Z

Mdelamor: Página creada con «<source lang='haskell'> -- Informática (1º del Grado en Matemáticas) -- 2ª convocatoria -- ===================================================================== -- No…»

<source lang='haskell'>

-- Informática (1º del Grado en Matemáticas)
-- 2ª convocatoria

-- =====================================================================
-- Nombre:
-- Apellidos:
-- UVUS:
-- =====================================================================

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

import Data.Matrix
import qualified Data.Set as S
import qualified Data.Vector as V
import Data.List
import Data.Numbers.Primes
import I1M.Cola

-- ---------------------------------------------------------------------
-- Ejercicio ?. Una permutación de n se representa como una lista de los
-- elementos 1..n. Por ejemplo, la lista [3,1,2,4] representa la
-- permutación tal que corresponde con la transformación:
-- 1 -> 3
-- 2 -> 1
-- 3 -> 2
-- 4 -> 4

-- Definir la función
-- compPermutaciones :: [Int] -> [Int]
-- tal que (compPermutaciones p q) es composición de las permutaciones p
-- y q. Por ejemplo, si p = [1,3,4,2] y q = [3,1,2,4], la composición
-- es:
-- 1 -> 1 -> 3
-- 2 -> 3 -> 2
-- 3 -> 4 -> 4
-- 4 -> 2 -> 1

-- compPermutaciones [1,3,4,2] [3,1,2,4] == [3,2,4,1]

compPermutaciones :: [Int] -> [Int] -> [Int]
compPermutaciones p q =
map snd (comp (zip [1..n] p) (zip [1..n] q))
where n = length p
comp r s = [(x,z) | (x,y) <- r, (y',z) <-s, y == y']

-- ---------------------------------------------------------------------
-- Ejercicio ?. Se tienen n cartas numeradas en un único montón en orden
-- creciente desde arriba hacia abajo; es decir, la carta de más arriba
-- es la número 1, luego sigue la número 2, ...
--
-- Se hace lo siguiente:
-- + se coloca la carta número 1 debajo de todas,
-- + se quita de arriba la carta número 2,
-- + se coloca la carta número 3 debajo de todas,
-- + se quita de arriba la carta número 4,
-- + ...
--
-- El proceso continúa siempre de la misma manera: se coloca la carta de
-- más arriba debajo de todas y se quita la que ha quedado arriba, hasta
-- que quede una única carta.
--
-- Definir la función
-- cartaFinal :: Int -> Int
-- tal que (cartaFinal n) es la carta final que queda en el montón. Por
-- ejemplo,
-- cartaFinal 4 == 1
-- cartaFinal 7 == 7
-- cartaFinal 10 == 5
-- cartaFinal 20 == 9
-- cartaFinal 100 == 73
-- ---------------------------------------------------------------------

-- Usando listas:

cartaFinal :: Int -> Int
cartaFinal n = head (until pred paso [1..n])
where paso (x:xs) = tail (xs++[x])
pred (x:xs) = null xs

-- Usando colas:

cartaFinalC :: Int -> Int
cartaFinalC n = primero (until pred paso cInicial)
where cInicial = foldr inserta vacia [n,n-1..1]
pred c = not (esVacia c) && esVacia (resto c)
paso c = resto (inserta (primero c) (resto c))

-- ---------------------------------------------------------------------
-- Ejercicio ?. Dada una matriz A, de dimensión n×n , sea X_i el
-- conjunto de elementos de la fila i, e Y_j el conjunto de elementos de
-- la columna j, 1 ≤ i, j ≤ n. Decimos que A es dorada si
-- X_1,...,X_n,Y_1,...,Y_n son conjuntos distintos.

-- Definir la función
-- esMatrizDorada :: Ord a => Matrix a -> Bool
-- tal que (esMatrizDorada A) verifique si A es dorada. Por ejemplo,
-- esMatrizDorada (fromLists [[1,2,1],[1,1,1],[2,2,2]]) == False
-- esMatrizDorada (fromLists [[1,2,1],[1,1,1],[3,3,4]]) == True
-- ---------------------------------------------------------------------

esMatrizDorada :: Ord a => Matrix a -> Bool
esMatrizDorada p =
conjDistintosLista (filas p ++ columnas p)
where n = nrows p
filas p = [S.fromList (V.toList (getRow i p)) | i <-[1..n]]
columnas p = [S.fromList (V.toList (getCol i p)) | i <-[1..n]]

conjDistintosLista :: Ord a => [S.Set a] -> Bool
conjDistintosLista [] = True
conjDistintosLista (xs:xss) =
all (not . ((==) xs)) xss && conjDistintosLista xss

-- ---------------------------------------------------------------------
-- Ejercicio ?. Consideremos el problema de construir los árboles
-- etiquetados en las hojas, a partir de una lista xs, de forma que el
-- borde del árbol consista en los elementos de esta lista. Por ejemplo,
-- si xs = [1,2,3], los árboles que se obtienen son los siguientes:

-- . .
-- / \ / \
-- 1 . . 3
-- / \ / \
-- 2 3 1 2

-- Definir la función
-- arboles:: [Int] -> [Arbol]
-- tal que (arboles xs) es la lista de los árboles que se pueden
-- construir de forma que los elementos que constituyen su borde es la
-- lista xs. Por ejemplo,
-- arboles [1..3] = [Nodo (Hoja 1) (Nodo (Hoja 2) (Hoja 3)),
-- Nodo (Nodo (Hoja 1) (Hoja 2)) (Hoja 3)]
-- ----------------------------------------------------------------------------

data Arbol = Hoja Int | Nodo Arbol Arbol
deriving Show

-- Definimos la función arboles, de forma recursiva

arboles:: [Int] -> [Arbol]
arboles [x] = [Hoja x]
arboles (x:xs) = concatMap (prefijos x) (arboles xs)

-- (prefijos x a) es la lista de todas las formas en la que x puede ser
-- insertada como la hoja más a la izquierda en el árbol a. Por ejemplo,
-- si el árbol es
-- .
-- / \
-- 2 3
--
-- hay dos formas de insertar 1 de forma que sea la hoja más a la
-- izquierda:

-- . .
-- / \ / \
-- 1 . . 3
-- / \ / \
-- 2 3 1 2

prefijos:: Int -> Arbol -> [Arbol]
prefijos x a@(Hoja y) = [Nodo (Hoja x) a]
prefijos x a@(Nodo i d) =
(Nodo (Hoja x) a):[Nodo i' d | i' <- prefijos x i]

-- prefijos 1 (Nodo (Hoja 2) (Hoja 3))
-- [Nodo (Hoja 1) (Nodo (Hoja 2) (Hoja 3)),
-- Nodo (Nodo (Hoja 1) (Hoja 2)) (Hoja 3)]

-- arboles [1..3]
-- [Nodo (Hoja 1) (Nodo (Hoja 2) (Hoja 3)),
-- Nodo (Nodo (Hoja 1) (Hoja 2)) (Hoja 3)]

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

</source>

Examen 05/07/2021

2021-11-17T22:18:21Z

Mdelamor: Página creada con «<source lang='haskell'> import Data.List import Data.Maybe import Data.Numbers.Primes import Test.QuickCheck import I1M.PolOperaciones -- -------------------------------…»

<source lang='haskell'>

import Data.List
import Data.Maybe
import Data.Numbers.Primes
import Test.QuickCheck
import I1M.PolOperaciones

-- ---------------------------------------------------------------------
-- Ejercicio 1. Dado un número entero n > 1, se puede transformar en una
-- lista como sigue:
-- + Se comienza con la lista xs formada por los divisores primos de n
-- ordenados de menor a mayor.
-- + A continuación, cada x elemento de xs se sustituye por la lista
-- vacía si x es igual a 2 o por su índice en la sucesión de los
-- números primos si x es distinto de 2.
-- La lista obtenida se llama la codificación de n. Por ejemplo, si n es
-- 3300 en el primer paso se obtiene la lista
-- [2,2,3,5,5,11]
-- y en el segundo,
-- [[],[],[1],[2],[2],[4]]
--
-- Definir las funciones
-- codificacion :: Int -> [[Int]]
-- decodificacion :: [[Int]] -> Int
-- tales que
-- + (codificacion n) es la codificación del número n. Por ejemplo,
-- codificacion 3300 == [[],[],[1],[2],[2],[4]]
-- codificacion 12 == [[],[],[1]]
-- codificacion 324 == [[],[],[1],[1],[1],[1]]
-- codificacion 525 == [[1],[2],[2],[3]]
-- + (decodificacion xss) es el número n tal que su codificación es
-- xss. Por ejemplo,
-- decodificacion [[],[],[1],[2],[2],[4]] == 3300
-- decodificacion [[],[],[1]] == 12
-- decodificacion [[],[],[1],[1],[1],[1]] == 324
-- decodificacion [[1],[2],[2],[3]] == 525
--
-- Comprobar con QuickChek para todo número entero n > 1, si decodifica
-- la codificación de n se obtiene el número n.
-- ---------------------------------------------------------------------

codificacion :: Int -> [[Int]]
codificacion n = map f (primeFactors n)
where f p | p == 2 = []
| otherwise = [indicePrimo p]

-- (indicePrimo p) es la posición de p en la sucesión de los números
-- primos. Por ejemplo,
-- indicePrimo 3 == 1
-- indicePrimo 7 == 3
indicePrimo :: Int -> Int
indicePrimo p = head [i | (i,q) <- zip [0..] primes, q == p]

-- Se puede redefinir como sigue
indicePrimo2 :: Int -> Int
indicePrimo2 = fromJust . (`elemIndex` primes)

decodificacion :: [[Int]] -> Int
decodificacion = product . map g
where g [] = 2
g (x:xs) = primes !! x

-- La propieda es
propCodificacion :: Int -> Bool
propCodificacion n = decodificacion (codificacion m) == m
where m = 2 + abs n

-- La comprobación es
-- λ> quickCheck propCodificacion
-- +++ OK, passed 100 tests.

-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir la función
-- raicesApol :: (Num a, Eq a) => [(a,Int)] -> Polinomio a
-- tal que (raicesApol xs) es el polinomio p tal que el xs s la lista de
-- los pares (x,m), donde x representa una raíz de p y m su
-- multiplicidad. Por ejemplo,
-- λ> raicesApol [(3,2)]
-- x^2 + -6*x + 9
-- λ> raicesApol [(2,3)]
-- x^3 + -6*x^2 + 12*x + -8
-- λ> raicesApol [(1,2),(2,1)]
-- x^3 + -4*x^2 + 5*x + -2
-- ---------------------------------------------------------------------

raicesApol :: (Num a, Eq a) => [(a,Int)] -> Polinomio a
raicesApol xs = foldr multPol polUnidad ps
where ps = [potencia (consPol 1 1 (consPol 0 (-x) polCero)) m | (x,m) <- xs]

-- (potencia p n) es a n-ésima potencia del polinomio p. Por ejemplo,
-- λ> p = consPol 3 2 (consPol 0 10 polCero)
-- λ> p
-- 2*x^3 + 10
-- λ> potencia p 2
-- 4*x^6 + 40*x^3 + 100
-- λ> potencia p 3
-- 8*x^9 + 120*x^6 + 600*x^3 + 1000
potencia :: (Num a, Eq a) => Polinomio a -> Int -> Polinomio a
potencia p 0 = polUnidad
potencia p n = multPol p (potencia p (n-1))

-- ---------------------------------------------------------------------
-- Ejercicio 3. El término
-- maximum (sum [3, y, product [2, z], 7]
-- se puede representar por
-- T "M" [T "S" [N 3, V 'y', T "P" [N 2, V 'z']], N 7
-- donde maximum se representa por "M", sum por "S" y product por "P".
-- Además, el valor del término anterior cuando y se interpreta por 5 y
-- z por 2 es 12.
--
-- En general, los términos aritméticos como los anteriores se pueden
-- definir por
-- data Termino = V Char
-- | N Int
-- | T String [Termino]
-- deriving Show
-- las interpretaciones de las variables son listas de pares, caracteres
-- y enteros
-- type InterpretacionVariables = [(Char, Int)]
-- las interpretaciones de las operaciones son listad de pares, cadenas
-- y funciones de listas de enteros en enteros
-- type InterpretacionOperaciones = [(String, ([Int] -> Int))]
-- y las interpretaciones son pares formados por interpretaciones de
-- variables y de operaciones
-- type Interpretacion = (InterpretacionVariables, InterpretacionOperaciones)
-- Por ejemplo,
-- ejInt1, ejInt2 :: Interpretacion
-- ejInt1 = ([('x',3),('y',5),('z',2)],
-- [("S", sum), ("P", product), ("M", maximum)])
-- ejInt2 = ([('x',1),('y',2),('z',3)],
-- [("S", sum), ("P", product), ("M", minimum)])
-- donde ejInt1 es la interpretación usada anteriormente.
--
-- Definir la función
-- valor :: Termino -> Interpretacion -> Int
-- tal que (valor t i) es el valor del término t en la interpretación
-- i. Por ejemplo,
-- λ> valor (T "M" [T "S" [N 3, V 'y', T "P" [N 2, V 'z']], N 7]) ejInt1
-- 12
-- λ> valor (T "M" [T "S" [N 3, V 'y', T "P" [N 2, V 'z']], N 7]) ejInt2
-- 7
-- ---------------------------------------------------------------------

data Termino = V Char
| N Int
| T String [Termino]
deriving Show

type InterpretacionVariables = [(Char, Int)]

type InterpretacionOperaciones = [(String, ([Int] -> Int))]

type Interpretacion = (InterpretacionVariables, InterpretacionOperaciones)

ejInt1, ejInt2 :: Interpretacion
ejInt1 = ([('x',3),('y',5),('z',2)],
[("S", sum), ("P", product), ("M", maximum)])
ejInt2 = ([('x',1),('y',2),('z',3)],
[("S", sum), ("P", product), ("M", minimum)])

-- λ> valor (T "M" [T "S" [N 3, V 'y', T "P" [N 2, V 'z']], N 7]) ejInt1
-- 12
-- λ> valor (T "M" [T "S" [N 3, V 'y', T "P" [N 2, V 'z']], N 7]) ejInt2
-- 7
valor :: Termino -> Interpretacion -> Int
valor (V x) i = busca x (fst i)
valor (N n) _ = n
valor (T o ts) i = (busca o (snd i)) [valor t i | t <- ts]

-- Auxiliar:
busca :: Eq a1 => a1 -> [(a1, a2)] -> a2
busca z ps = head [v | (u,v) <- ps, z == u]

-- ---------------------------------------------------------------------
-- Ejercicio 4.1. Decimos que un número natural es creciente si sus
-- dígitos son distintos de cero y están ordenados de forma creciente;
-- es decir, cada uno es menor o igual que su siguiente. Por ejemplo,
-- 34468 es número creciente pero 34648 no lo es.
--
-- Definir la función
-- crecientes :: Int -> Integer
-- tal que (crecientes n) es la cantidad de números crecientes con n
-- dígitos. Por ejemplo,
-- crecientes 1 == 9
-- crecientes 2 == 45
-- crecientes 3 == 165
-- crecientes 7 == 6435
-- crecientes 15 == 490314
-- crecientes 30 == 48903492
-- crecientes 100 == 352025629371
-- ---------------------------------------------------------------------

-- 1ª solución
-- ===========

crecientes1 :: Int -> Integer
crecientes1 = genericLength . sucCrecientes

-- (sucCrecientes n) es la lista de las sucesiones crecientes con n
-- dígitos. Por ejemplo,
-- λ> sucCrecientes 2
-- [11,12,13,14,15,16,17,18,19,22,23,24,25,26,27,28,29,33,34,35,36,37,38,
-- 39,44,45,46,47,48,49,55,56,57,58,59,66,67,68,69,77,78,79,88,89,99]
-- λ> take 10 (sucCrecientes 3)
-- [111,112,113,114,115,116,117,118,119,122]
-- λ> take 10 (sucCrecientes 4)
-- [1111,1112,1113,1114,1115,1116,1117,1118,1119,1122]
sucCrecientes :: Int -> [Int]
sucCrecientes n = filter esCreciente [10^(n-1)..10^n-1]

-- (esCreciente n) se verifica si n es creciente. Por ejemplo,
-- esCreciente 3446 == True
-- esCreciente 3464 == False
esCreciente :: Int -> Bool
esCreciente n = sort ns == ns
where ns = show n

-- 2ª solución
-- ===========

crecientes2 :: Int -> Integer
crecientes2 n = sum [crecientesDesde n k | k <- [1..9]]

-- (crecientesDesde n k) es la cantidad de números crecientes con
-- n dígitos cuyo primer dígito es k. Por ejemplo,
-- crecientesDesde 3 9 == 1
-- crecientesDesde 3 8 == 3
-- crecientesDesde 2 8 == 2
-- crecientesDesde 3 8 == 3
-- crecientesDesde 3 7 == 6
crecientesDesde :: Int -> Int -> Integer
crecientesDesde 0 _ = 0
crecientesDesde 1 _ = 1
crecientesDesde n k = sum [crecientesDesde (n-1) j | j <- [k..9]]

-- 3ª solución
-- ===========

crecientes3 :: Int -> Integer
crecientes3 n = sum [p!(n,k) | k <- [1..9]]
where p = matrizCrecientes3 n

-- (matrizCrecientes3 n) es la matriz de n filas y 9 columnas p tal que
-- el valor en la posición (i,j) es cantidad de números crecientes3 con i
-- dígitos, cuyo primer dígito es j. Por ejemplo,
-- λ> matrizCrecientes3 1
-- ┌ ┐
-- │ 1 1 1 1 1 1 1 1 1 │
-- └ ┘
-- λ> matrizCrecientes3 2
-- ┌ ┐
-- │ 1 1 1 1 1 1 1 1 1 │
-- │ 9 8 7 6 5 4 3 2 1 │
-- └ ┘
-- λ> matrizCrecientes3 3
-- ┌ ┐
-- │ 1 1 1 1 1 1 1 1 1 │
-- │ 9 8 7 6 5 4 3 2 1 │
-- │ 45 36 28 21 15 10 6 3 1 │
-- └ ┘
-- λ> matrizCrecientes3 4
-- ┌ ┐
-- │ 1 1 1 1 1 1 1 1 1 │
-- │ 9 8 7 6 5 4 3 2 1 │
-- │ 45 36 28 21 15 10 6 3 1 │
-- │ 165 120 84 56 35 20 10 4 1 │
-- └ ┘
matrizCrecientes3 :: Int -> Matrix Integer
matrizCrecientes3 n = p where
p = matrix n 9 f
f (1,_) = 1
f (i,j) = sum [p!(i-1,k) | k <- [j..9]]

-- 4ª solución
-- ===========

crecientes :: Int -> Integer
crecientes n = sum [p!(n,k) | k <- [1..9]]
where p = matrizCrecientes n

-- (matrizCrecientes n) es la matriz de n filas y 9 columnas p tal que
-- el valor en la posición (i,j) es cantidad de números crecientes con i
-- dígitos, cuyo primer dígito es j. Por ejemplo,
-- λ> matrizCrecientes 1
-- ┌ ┐
-- │ 1 1 1 1 1 1 1 1 1 │
-- └ ┘
-- λ> matrizCrecientes 2
-- ┌ ┐
-- │ 1 1 1 1 1 1 1 1 1 │
-- │ 9 8 7 6 5 4 3 2 1 │
-- └ ┘
-- λ> matrizCrecientes 3
-- ┌ ┐
-- │ 1 1 1 1 1 1 1 1 1 │
-- │ 9 8 7 6 5 4 3 2 1 │
-- │ 45 36 28 21 15 10 6 3 1 │
-- └ ┘
-- λ> matrizCrecientes 4
-- ┌ ┐
-- │ 1 1 1 1 1 1 1 1 1 │
-- │ 9 8 7 6 5 4 3 2 1 │
-- │ 45 36 28 21 15 10 6 3 1 │
-- │ 165 120 84 56 35 20 10 4 1 │
-- └ ┘
matrizCrecientes :: Int -> Matrix Integer
matrizCrecientes n = p where
p = matrix n 9 f
f (1,j) = 1
f (i,9) = 1
f (i,j) = p!(i,j+1) + p!(i-1,j)

-- Comparación de eficiencia
-- =========================

-- La comparación es
-- λ> crecientes1 7
-- 6435
-- (4.97 secs, 12,711,235,024 bytes)
-- λ> crecientes2 7
-- 6435
-- (0.04 secs, 5,723,952 bytes)
-- λ> crecientes3 7
-- 6435
-- (0.01 secs, 225,704 bytes)
-- λ> crecientes 7
-- 6435
-- (0.01 secs, 125,400 bytes)
--
-- λ> crecientes2 17
-- 1081575
-- (2.17 secs, 1,714,280,592 bytes)
-- λ> crecientes3 17
-- 1081575
-- (0.01 secs, 429,152 bytes)
-- λ> crecientes 17
-- 1081575
-- (0.01 secs, 173,024 bytes)
--
-- λ> crecientes3 (10^5)
-- 248105172272950452504148938027057501
-- (3.51 secs, 2,288,167,424 bytes)
-- λ> crecientes (10^5)
-- 248105172272950452504148938027057501
-- (1.02 secs, 441,295,880 bytes)

-- ---------------------------------------------------------------------
-- Ejercicio 4.2. Calcular la cantidad de números crecientes con 123456
-- dígitos.
-- ---------------------------------------------------------------------

-- El cálculo es
-- λ> crecientes4 123456
-- 1338763082311070449095794652369476313

</source>

Examen 21/06/21

2021-11-17T22:17:45Z

Mdelamor: Protegió «Examen 21/06/21» ([Editar=Solo administradores] (indefinido) [Trasladar=Solo administradores] (indefinido))

<source lang='haskell'>

-- Informática (1º del Grado en Matemáticas)
-- 4º examen de evaluación continua (21 de junio de 2021) Grupos A, B y C
-- ============================================================================

-- Nombre:
--
-- Apellidos:
--
-- UVUS:

-- ============================================================================

import qualified Data.Vector as V
import qualified Data.Array as A
import Data.Numbers.Primes
-- Selecciona de estas dos librerías la que hayas utilizado en clase
import GrafoConMatrizDeAdyacencia
-- import I1M.Grafo

import Data.List

-- ============================================================================
-- Ejercicio 1. (2.5 ptos) El complemento de un número positivo N se calcula
-- por el siguiente rocedimiento:
-- Si N es mayor que 9, se toma cada dígito por su valor posicional y se
-- resta del mayor los otros dígitos. Por ejemplo, el complemento de 1448 es
-- 1000 - 400 - 40 - 8 = 552. Cuando N es menor que 10, su complemento es N.
--
-- Definir las funciones
-- cadena :: Integer -> [Integer]
-- conCadena :: Int -> [Integer]
-- tales que
-- + '(cadena n)' es la cadena de primos a partir del número 'n' tal que cada
-- uno es el complemento del anterior. Por ejemplo,
-- cadena 8 == []
-- cadena 7 == [7]
-- cadena 13 == [13,7]
-- cadena 643 == [643,557,443]
-- cadena 18127 == [18127,1873,127,73,67,53,47]
-- cadena 18181213 == [18181213,1818787,181213,18787,1213,787,613,587]
-- + '(conCadena n)' es la lista de números cuyas cadenas tienen 'n'
-- elementos. Por ejemplo,
-- take 6 (conCadena 3) == [23,31,61,67,103,307]
-- [head (conCadena n) | n <- [4..8]] == [37,43,157,18127,181873]
-- ----------------------------------------------------------------------------

complemento :: Integer -> Integer
complemento n =
let c = 10^(length (show n)-1)
in (div n c)*c - (mod n c)

cadena :: Integer -> [Integer]
cadena n
| n < 10 && isPrime n = [n]
| isPrime n = n : cadena (complemento n)
| otherwise = []

conCadena :: Int -> [Integer]
conCadena n =
filter ((==n).length.cadena) primes

-- ============================================================================
-- Ejercicio 2. (2.5 puntos) Un número es innombrable si es divisible por 7 o
-- alguno de sus dígitos es un 7. Un juego infantil consiste en contar
-- saltándose los números innombrables:
-- 1 2 3 4 5 6 ( ) 8 9 10 11 12 13 ( ) 15 16 ( ) 18 ...
--
-- La sucesión de Cantor se obtiene llenando los huecos de la sucesión
-- anterior con la propia sucesión:
-- 1 2 3 4 5 6 (1) 8 9 10 11 12 13 (2) 15 16 (3) 18 19 20 (4) 22 23
-- 24 25 26 (5) (6) 29 30 31 32 33 34 (1) 36 (8) 38 39 40 41 (9) 43
-- 44 45 46 (10) 48 (11) 50 51 52 53 54 55 (12) (13) 58 59 60 61 62
-- (2) 64 65 66 (15) 68 69 (16) (3) (18) (19) (20) (4) (22) (23) (24)
-- (25) 80 81 82 83 (26) 85 86 (5) 88 89 90 (6) 92 93 94 95 96 (29)
-- (30) 99 100
--
-- Definir la lista
-- sucCantor :: [Integer]
-- cuyo valor es la sucesión de Cantor. Por ejemplo,
-- take 100 sucCantor ==
-- [1,2,3,4,5,6, 1 ,8,9,10,11,12,13, 2 ,15,16, 3 ,18,19,20, 4 ,22,23,
-- 24,25,26, 5,6 ,29,30,31,32,33,34, 1 ,36, 8 ,38,39,40,41, 9 ,43,44,
-- 45,46, 10 ,48, 11 ,50,51,52,53,54,55, 12,13 ,58,59,60,61,62, 2 ,64,
-- 65,66, 15 ,68,69, 16,3,18,19,20,4,22,23,24,25, 80,81,82,83, 26 ,85,
-- 86, 5 ,88,89,90, 6 ,92,93,94,95,96, 29,30 ,99,100]
-- sucCantor !! (5+10^6) == 544480
-- sucCantor !! (6+10^6) == 266086
-- ============================================================================

sucCantor :: [Integer]
sucCantor =
mezclaCantor [1..] sucCantor

mezclaCantor :: [Integer] -> [Integer] -> [Integer]
mezclaCantor (x:xs) ys =
if x`mod`7 == 0 || elem '7' (show x)
then (head ys) : mezclaCantor xs (tail ys)
else x : mezclaCantor xs ys

-- ============================================================================
-- Ejercicio 3. (2.5 ptos) Consideremos grafos en los que cada arista está
-- etiquetada con un valor que representa un color (en lugar de un peso). Un
-- camino alternado en este tipo de grafos es un camino que no pasa por dos
-- aristas consecutivas del mismo color.
--
-- Definir la función
-- caminoAlternado :: (A.Ix v, Num p, Eq p) => Grafo v p -> [v] -> Bool
-- tal que '(caminoAlternado g vs)' comprueba que la secuencia de nodos 'vs'
-- del grafo 'g', forma un camino alternado en el grafo. Por ejemplo,
-- caminoAlternado grafo [1,2,4,3,5] == True
-- caminoAlternado grafo [3,1,2,4,6] == False
-- donde 'grafo' es el grafo que se define a continuación (selecciona de las
-- siguientes definiciones de grafos la que hayas utilizado en clase):

-- grafo :: Grafo Int Int
-- grafo = creaGrafo ND (1,6) [(1,2,3),(1,3,1),(1,5,1),(3,5,2),
-- (2,4,1),(2,6,2),(3,4,3),(4,6,1)]

-- grafo :: Grafo Int Int
-- grafo = asignaPesos (creaGrafo ND (1,6) [(1,2),(1,3),(1,5),(3,5),
-- (2,4),(2,6),(3,4),(4,6)])
-- [((1,2),3),((1,3),1),((1,5),1),((3,5),2),
-- ((2,4),1),((2,6),2),((3,4),3),((4,6),1)]

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

caminoAlternado :: (A.Ix v, Num p, Eq p) => Grafo v p -> [v] -> Bool
caminoAlternado g vs =
let as = zip vs (tail vs)
in (all (aristaEn g) as) && -- vs es un camino en g
(and [peso g a1 /= peso g a2 | (a1,a2) <- zip as (tail as)])

-- ============================================================================
-- Ejercicio 4. (2.5 ptos) En una rejilla de 2xN cuadros de longitud se pueden
-- colocar de distintas formas piezas de 2 cuadros de longitud, en horizontal y
-- vertical, de forma que no quede espacio libre en la rejilla. Por ejemplo,
-- una rejilla de 2x12 cuadros de longitud se puede rellenar de la siguiente
-- forma:
--
-- ╔═══╦═╦═╦═╦═══╦═══╦═╦═══╗
-- ╠═══╣ ║ ║ ╠═══╬═══╣ ╠═══╣
-- ╚═══╩═╩═╩═╩═══╩═══╩═╩═══╝
--
-- Definir la función
-- rejillas2N :: Int -> Integer -> Integer
-- tal que '(rejillas2N n m)' es el número de formas distintas de rellenar una
-- rejilla de '2xn' cuadros de longitud con piezas de 2 cuadros de longitud de
-- 'm' colores distintos, calculado mediante la técnica de programación
-- dinámica. Tened en cuenta que no hay ninguna restricción acerca de cómo
-- colocar las piezas de distintos colores. Por ejemplo,
-- rejillas2N 2 2 == 8
-- rejillas2N 2 3 == 18
-- rejillas2N 3 2 == 24
-- rejillas2N 3 3 == 81
-- rejillas2N 20 5 == 1043891906738281250
-- length (show (rejillas2N 100 7)) == 106
-- length (show (rejillas2N 1000 9)) == 1164
-- ----------------------------------------------------------------------------

-- rejillas2N n m =
-- m * (rejillas2N (n-1) m) + m^2 * (rejillas2N (n-2) m)

-- Versión recursiva

rejillas2NR :: Int -> Integer -> Integer
rejillas2NR 0 m = 1
rejillas2NR 1 m = m
rejillas2NR n m =
m * (rejillas2NR (n-1) m) + m^2 * (rejillas2NR (n-2) m)

-- Versión usando programación dinámica

rejillas2N :: Int -> Integer -> Integer
rejillas2N n m =
let v = V.generate (n+1) (\ i -> generaRejillas2N v m i)
in v V.! n

generaRejillas2N :: V.Vector Integer -> Integer -> Int -> Integer
generaRejillas2N v m 0 = 1
generaRejillas2N v m 1 = m
generaRejillas2N v m i =
m * (v V.! (i-1)) + m^2 * (v V.! (i-2))

-- ============================================================================

</source>