-- Definiciones por comprensión
-- Departamento de Ciencias de la Computación e I.A.
-- Universidad de Sevilla
-- =====================================================================
-- ---------------------------------------------------------------------
-- Introducción --
-- ---------------------------------------------------------------------
--
-- En esta relación se presentan ejercicios con definiciones por
-- comprensión correspondientes al tema 5.
--
-- ---------------------------------------------------------------------
-- § Librerías auxiliares --
-- ---------------------------------------------------------------------
import Test.QuickCheck
import Data.Char
-- ---------------------------------------------------------------------
-- § Ejercicios propuestos --
-- ---------------------------------------------------------------------
-- ---------------------------------------------------------------------
-- Ejercicio 1. Definir la función
-- subconjunto :: Eq a => [a] -> [a] -> Bool
-- tal que (subconjunto xs ys) se verifica si xs es un subconjunto de
-- ys. por ejemplo,
-- subconjunto [3,2,3] [2,5,3,5] == True
-- subconjunto [3,2,3] [2,5,6,5] == False
-- ---------------------------------------------------------------------
subconjunto :: Eq a => [a] -> [a] -> Bool
subconjunto xs ys = [x | x<-xs, elem x ys] == xs
subconjunto1 :: Eq a => [a] -> [a] -> Bool
subconjunto1 xs ys = [x | x<-xs, notElem x ys] == []
-- o bien null[x|x<-xs, notElem ys]
-- ---------------------------------------------------------------------
-- Ejercicio 2. Definir la función
-- iguales :: Eq a => [a] -> [a] -> Bool
-- tal que (iguales xs ys) se verifica si xs e ys son iguales. Por
-- ejemplo,
-- iguales [3,2,3] [2,3] == True
-- iguales [3,2,3] [2,3,2] == True
-- iguales [3,2,3] [2,3,4] == False
-- ---------------------------------------------------------------------
-- ESTA NO VALE, porque da igualdad de listas (los mismos elementos y
-- orden), No igualdad de conjuntos, los mismos elementos dando igual el
-- orden (ver segundo ejemplo)
iguales1 :: Eq a => [a] -> [a] -> Bool
iguales1 xs ys = xs==ys
-- COMPRENSION:
iguales :: Eq a => [a] -> [a] -> Bool
iguales xs ys = subconjunto xs ys && subconjunto ys xs
-- ---------------------------------------------------------------------
-- Ejercicio 3. Definir la función
-- union :: Eq a => [a] -> [a] -> [a]
-- tal que (union xs ys) es la unión de los conjuntos xs e ys. Por
-- ejemplo,
-- union [3,2,5] [5,7,3,4] == [3,2,5,7,4]
-- ---------------------------------------------------------------------
union :: Eq a => [a] -> [a] -> [a]
union xs ys = xs ++ [x | x<-ys, notElem x xs]
-- No vale xs++ys porque saldrían repetidos
-- ---------------------------------------------------------------------
-- Nota. En los ejercicios de comprobación de propiedades, cuando se
-- trata con igualdades se usa la igualdad conjuntista (definida por la
-- función iguales) en lugar de la igualdad de lista (definida por ==)
-- ---------------------------------------------------------------------
-- ---------------------------------------------------------------------
-- Ejercicio 4. Comprobar con QuickCheck que la unión es conmutativa.
-- ---------------------------------------------------------------------
-- La propiedad es
prop_union_conmutativa :: [Int] -> [Int] -> Bool
prop_union_conmutativa xs ys = iguales (union xs ys) (union ys xs)
-- La comprobación es
-- +++ OK, passed 100 tests.
-- ---------------------------------------------------------------------
-- Ejercicio 5. Definir la función
-- interseccion :: Eq a => [a] -> [a] -> [a]
-- tal que (interseccion xs ys) es la intersección de xs e ys. Por
-- ejemplo,
-- interseccion [3,2,5] [5,7,3,4] == [3,5]
-- interseccion [3,2,5] [9,7,6,4] == []
-- ---------------------------------------------------------------------
-- ELEMENTOS DEL PRIMERO QUE ESTAN EN EL SEGUNDO
interseccion :: Eq a => [a] -> [a] -> [a]
interseccion xs ys = [x |x<-xs, elem x ys]
-- ---------------------------------------------------------------------
-- Ejercicio 6. Comprobar con QuickCheck si se cumple la siguiente
-- propiedad
-- A union (B inter C) = (A union B) inter C
-- donde se considera la igualdad como conjuntos. En el caso de que no
-- se cumpla verificar el contraejemplo calculado por QuickCheck.
-- ---------------------------------------------------------------------
prop_union_interseccion :: [Int] -> [Int] -> [Int] -> Bool
prop_union_interseccion xs ys zs =
iguales
(union xs (interseccion ys zs))
(interseccion (union xs ys) zs)
-- La comprobación es
-- *** Failed! Falsifiable (after 4 tests and 2 shrinks):
-- [0]
-- []
-- []
-- Por tanto, la propiedad no se cumple y un contraejemplo es
-- A = [0], B = [] y C = []
-- ya que entonces,
-- A (B C) = [0] ([] []) = [0] [] = [0]
-- (A B) C = ([0] []) [] = [0] [] = []
-- ---------------------------------------------------------------------
-- Ejercicio 7. Definir la función
-- diferencia :: Eq a => [a] -> [a] -> [a]
-- tal que (diferencia xs ys) es la diferencia entre los conjuntos xs e
-- ys. Por ejemplo,
-- diferencia [3,2,5,6] [5,7,3,4] == [2,6]
-- diferencia [3,2,5] [5,7,3,2] == []
-- ---------------------------------------------------------------------
-- ELEMENTOS DEL PRIMERO QUE NO ESTAN EN EL SEGUNDO
diferencia :: Eq a => [a] -> [a] -> [a]
diferencia xs ys = [x |x<-xs, notElem x ys]
-- ---------------------------------------------------------------------
-- Ejercicio 8. Comprobar con QuickCheck si la diferencia es
-- conmutativa.
-- ---------------------------------------------------------------------
prop_diferencia_conmutativa :: [Int] -> [Int] -> Bool
prop_diferencia_conmutativa xs ys =
iguales (diferencia xs ys) (diferencia ys xs)
-- La comprobación es
-- *** Failed! Falsifiable (after 2 tests and 2 shrinks):
-- []
-- [0]
-- ---------------------------------------------------------------------
-- Ejercicio 9. Comprobar con QuickCheck si se cumple la siguiente
-- propiedad: A \ B es subconjunto de A
-- ---------------------------------------------------------------------
-- La propiedad es
prop_diferencia_subconjunto :: [Int] -> [Int] -> Bool
prop_diferencia_subconjunto xs ys = subconjunto (diferencia xs ys) xs
-- La comprobación es
-- +++ OK, passed 100 tests.
-- ---------------------------------------------------------------------
-- Ejercicio 10. Comprobar con QuickCheck si se cumple la siguiente
-- propiedad: (A \ B) interseccion con B = [] .
-- ---------------------------------------------------------------------
-- La propiedad es
prop_diferencia_interseccion :: [Int] -> [Int] -> Bool
prop_diferencia_interseccion xs ys =
iguales (interseccion (diferencia xs ys) ys) []
-- La comprobación es
-- +++ OK, passed 100 tests.
-- ---------------------------------------------------------------------
-- Ejercicio 11. Definir la función
-- divisoresPrimos :: Int -> [Int]
-- tal que (divisoresPrimos x) es la lista de los divisores primos de x.
-- Por ejemplo,
-- divisoresPrimos 40 == [2,5]
-- divisoresPrimos 70 == [2,5,7]
-- ------------------------------------------------------------------------
-- LOS DIVISORES PRIMOS DE UN NUMERO SON LOS NUMEROS QUE SON FACTORES
-- PERO PRIMOS. EMPEZAMOS DESDE 2 PORQUE EL 1 NO ES PRIMO.
divisoresPrimos :: Int -> [Int]
divisoresPrimos x = [y | y<-[2 .. x], mod x y == 0, primo y]
-- UN NUMERO ES PRIMO SI SUS FACTORES SON UNICAMENTE 1 Y ÉL MISMO
primo x = factores x == [1, x]
-- LOS FACTORES DE UN NUMERO SON AQUELLOS DE 1 HASTA ÉL MISMO TALES QUE
-- AL DIVIDIR EL NUMERO ENTRE ESOS NUMEROS, EL RESTO ES CERO.
factores x = [y |y<-[1 .. x], mod x y == 0]
-- ---------------------------------------------------------------------
-- Ejercicio 12. Un número es libre de cuadrados si no es divisible por el
-- cuadrado de ningún entero mayor que 1. Por ejemplo, 70 es libre de
-- cuadrado porque sólo es divisible por 1, 2, 5, 7 y 70; en cambio, 40
-- no es libre de cuadrados porque es divisible por 2^2.
--
-- Definir la función
-- libreDeCuadrados :: Int -> Bool
-- tal que (libreDeCuadrados x) se verifica si x es libre de cuadrados.
-- Por ejemplo,
-- libreDeCuadrados 70 == True
-- libreDeCuadrados 40 == False
-- ---------------------------------------------------------------------
-- Tendremos que asegurarnos que no existe ningun factor de x que se
-- pueda encontrar en la lista de cuadrados de numeros mayores que
-- 1. Esa lista la da (cuadrados x) pero para que no sea infinita, la
-- cortamos en x porque ningún factor de x va a ser mayor que el propio
-- x.
-- Decir que no existe es decir que es la lista vacia.
libreDeCuadrados :: Int -> Bool
libreDeCuadrados x = x == product (divisoresPrimos x)
-- 2ª definición
libreDeCuadrados2 :: Int -> Bool
libreDeCuadrados2 n =
null [x | x <- [2..n], rem n (x^2) == 0]
-- ---------------------------------------------------------------------
-- Ejercicio 13. [Del problema 21 del Proyecto Euler]. Sea d(n) la suma
-- de los divisores propios de n. Si d(a) = b y d(b) = a, siendo a/= b,
-- decimos que a y b son un par de números amigos. Por ejemplo, los
-- divisores propios de 220 son 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 y
-- 110; por tanto, d(220) = 284. Los divisores propios de 284 son 1, 2,
-- 4, 71 y 142; por tanto, d(284) = 220. Luego, 220 y 284 son dos
-- números amigos.
--
-- Definir la función
-- amigos :: Int -> Int -> Bool
-- tal que (amigos a b) se verifica si a y b son números amigos. Por
-- ejemplo,
-- amigos 6 6 == False
-- amigos 220 248 == False
-- amigos 220 284 == True
-- amigos 100 200 == False
-- amigos 1184 1210 == True
-- ---------------------------------------------------------------------
amigos :: Int -> Int -> Bool
amigos a b = a/=b &&
sum(divprop a) == b &&
sum(divprop b) == a
divprop x = [ y | y<-[1 ..x-1],rem x y == 0]
-- OTRA SOLUCION:
amigos1 :: Int -> Int -> Bool
amigos1 a b = a/=b && d a == b && d b == a
where d x = sum(divprop x)
-- ---------------------------------------------------------------------
-- Ejercicio 14. (Problema 211 del proyecto Euler) Dado un entero
-- positivo n, consideremos la suma de los cuadrados de sus divisores,
-- Por ejemplo,
-- f(10) = 1 + 4 + 25 + 100 = 130
-- f(42) = 1 + 4 + 9 + 36 + 49 + 196 + 441 + 1764 = 2500
-- Decimos que n es especial si f(n) es un cuadrado perfecto. En los
-- ejemplos anteriores, 42 es especial y 10 no lo es.
--
-- Definir la función
-- especial:: Int -> Bool
-- tal que (especial x) se verifica si x es un número es especial. Por
-- ejemplo,
-- especial 42 == True
-- especial 10 == False
-- Calcular todos los números especiales de tres cifras.
-- ---------------------------------------------------------------------
especial:: Int -> Bool
especial n = elem (f n ) [x^2|x<-[1 ..f n]]
f x = sum [y^2| y<- factores x]
-- OTRA:
especial1 :: Int -> Bool
especial1 n = esCuadrado (sum [x^2 | x <- factores n])
-- (esCuadrado n) se verifica si n es un cuadrado perfecto. Por ejemplo,
-- esCuadrado 36 == True
-- esCuadrado 40 == False
esCuadrado :: Int -> Bool
esCuadrado n = y^2 == n
where y = floor (sqrt (fromIntegral n))
especiales3 = [x |x<-[100 .. 999],especial x]
-- ---------------------------------------------------------------------
-- Ejercicio 15. La multiplicidad de x en y es la mayor potencia de x
-- que divide a y. Por ejemplo, la multiplicidad de 2 en 40 es 3 porque
-- 40 es divisible por 2^3 y no lo es por 2^4. Además, la multiplicidad
-- de 1 en cualquier número se supone igual a 1.
--
-- Definir la función
-- multiplicidad :: Integer -> Integer -> Integer
-- tal que (multiplicidad x y) es la
-- multiplicidad de x en y. Por ejemplo,
-- multiplicidad 2 40 == 3
-- multiplicidad 5 40 == 1
-- multiplicidad 3 40 == 0
-- multiplicidad 1 40 == 1
-- ---------------------------------------------------------------------
multiplicidad :: Integer -> Integer -> Integer
multiplicidad 1 _ = 1
multiplicidad x y =
head [n | n <- [0..], y `rem` (x^n) == 0, y `rem` (x^(n+1)) /= 0]
-- -------------------------------------------------------------
-- Ejercicio 16.1. Sea t una lista de pares de la forma
-- (nombre, [(asig_1, nota_1),...,(asig_k, nota.k)])
-- Por ejemplo,
-- t1 = [("Ana",[("Alg",1),("Cal",3),("Inf",8),("Fis",2)]),
-- ("Juan",[("Alg",5),("Cal",1),("Inf",2),("Fis",9)]),
-- ("Alba",[("Alg",5),("Cal",6),("Inf",6),("Fis",5)]),
-- ("Pedro",[("Alg",9),("Cal",5),("Inf",3),("Fis",1)])]
-- Definir la función
-- calificaciones :: [(String,[(String,Int)])] -> String -> [(String,Int)]
-- tal que (calificaciones t p) es la lista de las calificaciones de la
-- persona p en la lista t. Por ejemplo,
-- ghci> calificaciones t1 "Pedro"
-- [("Alg",9),("Cal",5),("Inf",3),("Fis",1)]
-- ---------------------------------------------------------------------
t1 :: [(String,[(String,Int)])]
t1 = [("Ana",[("Alg",1),("Cal",3),("Inf",8),("Fis",2)]),
("Juan",[("Alg",5),("Cal",1),("Inf",2),("Fis",9)]),
("Alba",[("Alg",5),("Cal",6),("Inf",6),("Fis",5)]),
("Pedro",[("Alg",9),("Cal",5),("Inf",3),("Fis",1)])]
calificaciones :: [(String,[(String,Int)])] -> String -> [(String,Int)]
calificaciones t p = head [xs | (x,xs) <- t, x == p]
-- ---------------------------------------------------------------------
-- Ejercicio 16.2. Definir la función
-- todasAprobadas :: [(String,[(String,Int)])] -> String -> Bool
-- tal que (todasAprobadas t p) se cumple si en la lista t, p tiene
-- todas las asignaturas aprobadas. Por ejemplo,
-- todasAprobadas t1 "Alba" == True
-- todasAprobadas t1 "Pedro" == False
-- ---------------------------------------------------------------------
todasAprobadas :: [(String,[(String,Int)])] -> String -> Bool
todasAprobadas t p = numeroAprobados t p == numeroAsignaturas t p
numeroAprobados t p = length [n | (_,n) <- calificaciones t p, n >= 5]
numeroAsignaturas t p = length (calificaciones t p)
-- OTRA SOLUCION:
todasAprobadas1 :: [(String,[(String,Int)])] -> String -> Bool
todasAprobadas1 t p = and [x>=5 | (_,x) <- calificaciones t p]
-- ---------------------------------------------------------------------
-- Ejercicio 16.3. Definir la función
-- aprobados :: [(String,[(String,Int)])] -> [String]
-- tal que (aprobados t) es la lista de los alumnos de la lista de notas
-- t que han aprobado todas las asignaturas.Por ejemplo,
-- ghci> aprobados t1 == ["Alba"]
-- ---------------------------------------------------------------------
aprobados :: [(String,[(String,Int)])] -> [String]
aprobados t = [p | (p,_) <- t, todasAprobadas t p]
-- ---------------------------------------------------------------------
-- Ejercicio 17. Un número n es de Angelini si n y 2n tienen algún
-- dígito común. Por ejemplo, 2014 es un número de Angelini ya que 2014
-- y su doble (4028) comparten los dígitos 4 y 0.
--
-- Definir la función
-- angelini :: Integer -> Bool
-- tal que (angelini n) se verifica si n es un número de Angelini. Por
-- ejemplo,
-- angelini 2014 == True
-- angelini 2067 == False
-- ---------------------------------------------------------------------
angelini :: Integer -> Bool
angelini n = not (null [x | x <- show n, x `elem` show (2*n)])
-- ---------------------------------------------------------------------
-- Ejercicio 18.1. Definir la función
-- unitarios :: Int -> [Int]
-- tal (unitarios n) es la lista de números [n,nn, nnn, ....]. Por
-- ejemplo.
-- take 7 (unitarios 3) == [3,33,333,3333,33333,333333,3333333]
-- take 3 (unitarios 1) == [1,11,111]
-- ---------------------------------------------------------------------
unitarios :: Int -> [Int]
unitarios x = [x*(div (10^n-1) 9) | n <- [1 ..]]
-- Otra:
unitarios1 :: Int -> [Int]
unitarios1 x = iterate por10Mas x
where por10Mas y = y*10+x
-- ---------------------------------------------------------------------
-- Ejercicio 18.2. Definir la función
-- multiplosUnitarios :: Int -> Int -> Int -> [Int]
-- tal que (multiplosUnitarios x y n) es la lista de los n primeros
-- múltiplos de x cuyo único dígito es y. Por ejemplo,
-- multiplosUnitarios 7 1 2 == [111111,111111111111]
-- multiplosUnitarios 11 3 5 == [33,3333,333333,33333333,3333333333]
-- ---------------------------------------------------------------------
multiplosUnitarios :: Int -> Int -> Int -> [Int]
multiplosUnitarios x y n = take n [z | z <- unitarios y, mod z x == 0]
-- ---------------------------------------------------------------------
-- Ejercicio 19. Definir la función
-- masOcurrentes :: Eq a => [a] -> [a]
-- tal que (masOcurrentes xs) es la lista de los elementos de xs que
-- ocurren el máximo número de veces. Por ejemplo,
-- masOcurrentes [1,2,3,4,3,2,3,1,4] == [3,3,3]
-- masOcurrentes [1,2,3,4,5,2,3,1,4] == [1,2,3,4,2,3,1,4]
-- masOcurrentes "Salamanca" == "aaaa"
-- ---------------------------------------------------------------------
masOcurrentes :: Eq a => [a] -> [a]
masOcurrentes xs = [x | x <- xs, ocurrencias x xs == m]
where m = maximum [ocurrencias x xs | x <-xs]
-- (ocurrencias x xs) es el número de ocurrencias de x en xs. Por
-- ejemplo,
-- ocurrencias 1 [1,2,3,4,3,2,3,1,4] == 2
ocurrencias x xs = length [x' | x' <- xs, x == x']
-- ---------------------------------------------------------------------
-- Ejercicio 20. La suma de la serie
-- 1/1^2 + 1/2^2 + 1/3^2 + 1/4^2 + ...
-- es pi^2/6. Por tanto, pi se puede aproximar mediante la raíz cuadrada
-- de 6 por la suma de la serie.
--
-- Definir la función aproximaPi tal que (aproximaPi n) es la aproximación
-- de pi obtenida mediante n términos de la serie. Por ejemplo,
-- aproximaPi 4 == 2.9226129861250305
-- aproximaPi 1000 == 3.1406380562059946
-- ---------------------------------------------------------------------
aproximaPi n = sqrt (6 * sum [1/x^2 | x <- [1..n]])
-- ---------------------------------------------------------------------
-- Ejercicio 21. Una representación de 20 en base 2 es [0,0,1,0,1] pues
-- 20 = 1*2^2 + 1*2^4. Y una representación de 46 en base 3 es [1,0,2,1]
-- pues 46 = 1*3^0 + 0*3^1 + 2*3^2 + 1*3^3.
--
-- Definir la función
-- deBaseABase10 :: Int -> [Int] -> Int
-- tal que (deBaseABase10 b xs) es el número n tal que su representación
-- en base b es xs. Por ejemplo,
-- deBaseABase10 2 [0,0,1,0,1] == 20
-- deBaseABase10 2 [1,1,0,1] == 11
-- deBaseABase10 3 [1,0,2,1] == 46
-- deBaseABase10 5 [0,2,1,3,1,4,1] == 2916
-- ---------------------------------------------------------------------
deBaseABase10 :: Int -> [Int] -> Int
deBaseABase10 b xs = sum [y*b^n | (y,n) <- zip xs [0..]]
-- ---------------------------------------------------------------------
-- Ejercicio 22.1. Definir la función
-- conPos :: [a] -> [(a,Int)]
-- tal que (conPos xs) es la lista obtenida a partir de xs especificando
-- las posiciones de sus elementos. Por ejemplo,
-- conPos [1,5,0,7] == [(1,0),(5,1),(0,2),(7,3)]
-- ---------------------------------------------------------------------
conPos :: [a] -> [(a,Int)]
conPos xs =
zip xs [0..]
-- ---------------------------------------------------------------------
-- Ejercicio 22.2. Definir la
-- pares :: [a] -> [a]
-- tal que (pares cs) es la cadena formada por los caracteres en
-- posición par de cs. Por ejemplo,
-- pares "el cielo sobre berlin" == "e il or eln"
-- ---------------------------------------------------------------------
pares :: [a] -> [a]
pares cs = [c | (c,n) <- conPos cs, even n]
-- ---------------------------------------------------------------------
-- Ejercicio 23. Dos listas xs, ys de la misma longitud son
-- perpendiculares si el producto escalar de ambas es 0, donde el
-- producto escalar de dos listas de enteros xs e ys viene
-- dado por la suma de los productos de los elementos correspondientes.
--
-- Definir la función
-- perpendiculares :: (Num a, Eq a) => [a] -> [[a]] -> [[a]]
-- tal que (perpendiculares xs yss) es la lista de los elementos de yss
-- que son perpendiculares a xs. Por ejemplo,
-- ghci> perpendiculares [1,0,1] [[0,1,0], [2,3,1], [-1,7,1],[3,1,0]]
-- [[0,1,0],[-1,7,1]]
-- ---------------------------------------------------------------------
perpendiculares :: (Num a, Eq a) => [a] -> [[a]] -> [[a]]
perpendiculares xs yss = [ys | ys <- yss, productoEscalar xs ys == 0]
productoEscalar :: Num a => [a] -> [a] -> a
productoEscalar xs ys =
sum [x*y | (x,y) <- zip xs ys]
-- ---------------------------------------------------------------------
-- Ejercicio 24. Dada una lista de números enteros, definiremos el
-- mayor salto como el mayor valor de las diferencias (en valor
-- absoluto) entre números consecutivos de la lista. Por ejemplo, dada
-- la lista [2,5,-3] las distancias son
-- 3 (valor absoluto de la resta 2 - 5) y
-- 8 (valor absoluto de la resta de 5 y (-3))
-- Por tanto, su mayor salto es 8. No está definido el mayor salto para
-- listas con menos de 2 elementos
--
-- Definir la función
-- mayorSalto :: [Integer] -> Integer
-- tal que (mayorSalto xs) es el mayor salto de la lista xs. Por
-- ejemplo,
-- mayorSalto [1,5] == 4
-- mayorSalto [10,-10,1,4,20,-2] == 22
-- ---------------------------------------------------------------------
mayorSalto :: [Integer] -> Integer
mayorSalto xs = maximum [abs (x-y) | (x,y) <- zip xs (tail xs)]
-- ---------------------------------------------------------------------
-- Ejercicio 25. Definir la función
-- longCamino :: [(Float,Float)] -> Float
-- tal que (longCamino xs) es la longitud del camino determinado por los
-- puntos del plano listados en xs. Por ejemplo,
-- longCamino [(0,0),(1,0),(2,1),(2,0)] == 3.4142137
-- ---------------------------------------------------------------------
longCamino :: [(Float,Float)] -> Float
longCamino xs = sum [sqrt ((a-c)^2+(b-d)^2)| ((a,b),(c,d)) <- zip xs (tail xs)]
-- ---------------------------------------------------------------------
-- Ejercicio 26. Definir la función
-- numeroConsecutivos :: (Num a, Eq a) => [a] -> Int
-- tal que (numeroConsecutivosC xs) es la cantidad de números
-- consecutivos que aparecen al comienzo de la lista xs. Por ejemplo,
-- numeroConsecutivosC [1,3,5,7,9] == 1
-- numeroConsecutivosC [1,2,3,4,5,7,9] == 5
-- numeroConsecutivosC [] == 0
-- ---------------------------------------------------------------------
numeroConsecutivos :: (Num a, Eq a) => [a] -> Int
numeroConsecutivos [] = 0
numeroConsecutivos xs =
1 + length [x | (x,y) <- zip xs (tail xs), y == x+1]
-- ---------------------------------------------------------------------
-- Ejercicio 27. Definir la función
-- sumaEquidistantes :: Num a => [a] -> [a]
-- tal que (sumaEquidistantes xs) es la lista sumando el primer elemento
-- de xs con el último, el segundo con el penúltimo y así
-- sucesivamente. Por ejemplo,
-- sumaEquidistantes [6,5,3,1] == [7,8]
-- sumaEquidistantes [6,5,3] == [9,10]
-- sumaEquidistantes [3,2,3,2] == [5,5]
-- sumaEquidistantes [6,5,3,1,2,0,4,7,8,9] == [15,13,10,5,2]
-- ---------------------------------------------------------------------
sumaEquidistantes :: Num a => [a] -> [a]
sumaEquidistantes xs = take n [x+y | (x,y) <- zip xs (reverse xs)]
where m = length xs
n | even m = m `div` 2
| otherwise = 1 + (m `div` 2)
-- Ejemplo:
-- [6,5,3,1], [1,3,5,6] -> [(6,1), (5,3),(3,5),(1,6)] ->[7,8,8,7]-> [7,8]
-- [6,5,3], [3,5,6] -> [(6,3),(5,5),(3,6)]->[9,10,9] ->[9,10]
-- ---------------------------------------------------------------------
-- Ejercicio 28. La distancia entre dos números es el valor absoluto de
-- su diferencia. Por ejemplo, la distancia entre 2 y 5 es 3.
--
-- Definir la función
-- cercanos :: [Int] -> [Int] -> [(Int,Int)]
-- tal que (cercanos xs ys) es la lista de pares de elementos de xs e ys
-- cuya distancia es mínima. Por ejemplo,
-- cercanos [3,7,2,1] [5,11,9] == [(3,5),(7,5),(7,9)]
-- ---------------------------------------------------------------------
cercanos :: [Int] -> [Int] -> [(Int,Int)]
cercanos xs ys =
[(x,y) | (x,y) <- pares, abs (x-y) == m]
where pares = [(x,y) | x <- xs, y <- ys]
m = minimum [abs (x-y) | (x,y) <- pares]
-- ---------------------------------------------------------------------
-- Ejercicio 29. [De la IMO 1996]. Una sucesión [a(0),a(1),...,a(n)]
-- se denomina cuadrática si para cada i {1, 2,..., n} se cumple que
-- |a(i) a(i-1)| = i^2 .
--
-- Definir la función
-- esCuadratica :: [Int] -> Bool
-- tal que (esCuadratica xs) se verifica si xs cuadrática. Por ejemplo,
-- esCuadratica [2,1,-3,6] == True
-- esCuadratica [2,1,3,5] == False
-- esCuadratica [3,4,8,17,33,58,94,45,-19,-100] == True
-- ---------------------------------------------------------------------
esCuadratica :: [Int] -> Bool
esCuadratica xs =
and [abs (y-x) == i^2 | ((x,y),i) <- zip (adyacentes xs) [1..]]
adyacentes xs = zip xs (tail xs)
-- ---------------------------------------------------------------------
-- Ejercicio 30.1. Definir las funciones
-- ultima, primera :: Int -> Int
-- tales que
-- * (ultima n) es la última cifra del número natural n y
-- * (primera n) es la primera cifra del número natural n.
-- Por ejemplo,
-- ultima 711 = 1
-- primera 711 = 7
-- ---------------------------------------------------------------------
ultima, primera :: Int -> Int
ultima n = n `rem` 10
ultima1 n = read [last (show n)]
primera n = read [head (show n)]
-- ---------------------------------------------------------------------
-- Ejercicio 30.2. Definir la función
-- encadenadoC :: [Int] -> Bool
-- tal que (encadenadoC xs) se verifica si xs es una lista de enteros
-- positivos encadenados (es decir, la última cifra de cada número
-- coincide con la primera del siguiente en la lista). Por ejemplo,
-- encadenadoC [711,1024,413,367] == True
-- encadenadoC [711,1024,213,367] == False
-- ---------------------------------------------------------------------
encadenadoC :: [Int] -> Bool
encadenadoC xs =
and [ultima x == primera y | (x,y) <- zip xs (tail xs)]
libreDeCuadrados1 x = null [ n | n <- [2..x], mod x (n^2) /=0 ]
![Informática de 1º de Matemáticas [Curso 2021-22, Grupo 3]](/WIKIS/I1M2021G3/resources/assets/logoUS.png)