I1M2013: Ejercicios de definiciones por comprensión (2) y gráficos

En la clase de hoy del curso Informática (de 1º de Grado en Matemáticas) se han comentado las soluciones de los ejercicios 8 a 14 de la 4ª relación sobre definiciones por comprensión. Además, se ha introducido la representación de gráficas con gnuplot.

Los ejercicios y sus soluciones se muestran a continuación

-- ---------------------------------------------------------------------
-- Ejercicio 8.1. Definir la función aproxE tal que (aproXE n) es la
-- lista cuyos elementos son los términos de la sucesión (1+1/m)**m
-- desde 1 hasta n. Por ejemplo, 
--    aproxE 1 == [2.0]
--    aproxE 4 == [2.0,2.25,2.37037037037037,2.44140625]
-- ---------------------------------------------------------------------

aproxE n = [(1+1/m)**m | m <- [1..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 8.2. ¿Cuál es el límite de la sucesión (1+1/m)**m ?
-- ---------------------------------------------------------------------

-- El límite de la sucesión es el número e. 

-- ---------------------------------------------------------------------
-- Ejercicio 8.3. Definir la función errorE tal que (errorE x) es el
-- menor número de términos de la sucesión (1+1/m)**m necesarios para
-- obtener su límite con un error menor que x. Por ejemplo,
--    errorAproxE 0.1    ==  13.0
--    errorAproxE 0.01   ==  135.0
--    errorAproxE 0.001  ==  1359.0
-- Indicación: En Haskell, e se calcula como (exp 1).
-- ---------------------------------------------------------------------

errorAproxE x = head [m | m <- [1..], abs((exp 1) - (1+1/m)**m) < x]

-- ---------------------------------------------------------------------
-- Ejercicio 9.1. Definir la función aproxLimSeno tal que 
-- (aproxLimSeno n) es la lista cuyos elementos son los términos de la
-- sucesión  
--    sen(1/m) 
--    --------
--      1/m 
-- desde 1 hasta n. Por ejemplo,
--    aproxLimSeno 1 == [0.8414709848078965]
--    aproxLimSeno 2 == [0.8414709848078965,0.958851077208406]
-- ---------------------------------------------------------------------

aproxLimSeno n = [sin(1/m)/(1/m) | m <- [1..n]] 

-- ---------------------------------------------------------------------
-- Ejercicio 9.2. ¿Cuál es el límite de la sucesión sen(1/m)/(1/m) ?
-- ---------------------------------------------------------------------

-- El límite es 1.

-- ---------------------------------------------------------------------
-- Ejercicio 9.3. Definir la función errorLimSeno tal que 
-- (errorLimSeno x) es el menor número de términos de la sucesión 
-- sen(1/m)/(1/m) necesarios para obtener su límite con un error menor
-- que x. Por ejemplo, 
--    errorLimSeno 0.1     ==   2.0
--    errorLimSeno 0.01    ==   5.0
--    errorLimSeno 0.001   ==  13.0
--    errorLimSeno 0.0001  ==  41.0
-- ---------------------------------------------------------------------

errorLimSeno x = head [m | m <- [1..], abs(1 - sin(1/m)/(1/m)) < x]

-- ---------------------------------------------------------------------
-- Ejercicio 10.1. Definir la función calculaPi tal que (calculaPi n) es
-- la aproximación del número pi calculada mediante la expresión
--    4*(1 - 1/3 + 1/5 - 1/7 + ...+ (-1)**n/(2*n+1))
-- Por ejemplo,
--    calculaPi 3    ==  2.8952380952380956
--    calculaPi 300  ==  3.1449149035588526
-- ---------------------------------------------------------------------

calculaPi n = 4 * sum [(-1)**x/(2*x+1) | x <- [0..n]]

-- ---------------------------------------------------------------------
-- Ejercicio 10.2. Definir la función errorPi tal que 
-- (errorPi x) es el menor número de términos de la serie
--    4*(1 - 1/3 + 1/5 - 1/7 + ...+ (-1)**n/(2*n+1))
-- necesarios para obtener pi con un error menor que x. Por ejemplo,
--    errorPi 0.1    ==   9.0
--    errorPi 0.01   ==  99.0
--    errorPi 0.001  ==  999.0
-- ---------------------------------------------------------------------

errorPi x = head [n | n <- [1..], abs (pi - (calculaPi n)) < x]

-- ---------------------------------------------------------------------
-- Ejercicio 11. Definir la función ocurrenciasDelMaximo tal que
-- (ocurrenciasDelMaximo xs) es el par formado por el mayor de los
-- números de xs y el número de veces que este aparece en la lista
-- xs, si la lista es no vacía y es (0,0) si xs es la lista vacía. Por
-- ejemplo,  
--    ocurrenciasDelMaximo [1,3,2,4,2,5,3,6,3,2,1,8,7,6,5]  ==  (8,1)
--    ocurrenciasDelMaximo [1,8,2,4,8,5,3,6,3,2,1,8]        ==  (8,3)
--    ocurrenciasDelMaximo [8,8,2,4,8,5,3,6,3,2,1,8]        ==  (8,4)
-- ---------------------------------------------------------------------

ocurrenciasDelMaximo [] = (0,0)
ocurrenciasDelMaximo xs = (maximum xs, sum [1 | y <- xs, y == maximum xs])

-- ---------------------------------------------------------------------
-- Ejercicio 12. Definir, por comprensión, la función tienenS tal que
-- (tienenS xss) es la lista de las longitudes de las cadenas de xss que
-- contienen el caracter 's' en mayúsculas o minúsculas. Por ejemplo, 
--    tienenS ["Este","es","un","examen","de","hoy","Suerte"]  ==  [4,2,6]
--    tienenS ["Este"]                                         ==  [4]
--    tienenS []                                               ==  []
--    tienenS [" "]                                            ==  []
-- ---------------------------------------------------------------------

tienenS xss = [length xs | xs <- xss, (elem 's' xs) || (elem 'S' xs)]

-- ---------------------------------------------------------------------
-- Ejercicio 13. Decimos que una lista está algo ordenada si para todo
-- par de elementos consecutivos se cumple que el primero es menor o
-- igual que el doble del segundo. Definir, por comprensión, la función
-- (algoOrdenada xs) que se verifica si la lista xs está algo ordenada. 
-- Por ejemplo, 
--    algoOrdenada [1,3,2,5,3,8]  ==  True
--    algoOrdenada [3,1]          ==  False
-- ---------------------------------------------------------------------

algoOrdenada xs = and [x <= 2*y | (x,y) <- zip xs (tail xs)]

-- ---------------------------------------------------------------------
-- Ejercicio 14.1. Definir, por comprensión, la función tripletas tal 
-- que (tripletas xs) es la listas de tripletas de elementos
-- consecutivos de la lista xs. Por ejemplo,
--    tripletas [8,7,6,5,4] == [[8,7,6],[7,6,5],[6,5,4]]
--    tripletas "abcd"      == ["abc","bcd"]
--    tripletas [2,4,3]     == [[2,3,4]]
--    tripletas [2,4]       == []
-- ---------------------------------------------------------------------

-- 1ª definición:
tripletas xs = 
    [[a,b,c] | ((a,b),c) <- zip (zip xs (tail xs)) (tail (tail xs))]

-- 2ª definición:
tripletas2 xs = 
    [[xs!!n,xs!!(n+1),xs!!(n+2)] | n <- [0..length xs -3]]

-- 3ª definición:
tripletas3 xs = [take 3 (drop n xs) | n <- [0..length xs - 3]]

-- ---------------------------------------------------------------------
-- Ejercicio 14.2. Definir la función tresConsecutivas tal que
-- (tresConsecutivas x ys) se verifica si x ocurre tres veces seguidas
-- en la lista ys. Por ejemplo,
--    tresConsecutivas 3 [1,4,2,3,3,4,3,5,3,4,6]  ==  False
--    tresConsecutivas 'a' "abcaaadfg"            ==  True
-- ---------------------------------------------------------------------

tresConsecutivas x ys = elem [x,x,x] (tripletas ys)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

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

-- Ejercicio 8.1. Definir la función aproxE tal que (aproXE n) es la

-- lista cuyos elementos son los términos de la sucesión (1+1/m)**m

-- desde 1 hasta n. Por ejemplo,

-- aproxE 1 == [2.0]

-- aproxE 4 == [2.0,2.25,2.37037037037037,2.44140625]

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

aproxE n = [(1+1/m)**m | m <- [1..n]]

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

-- Ejercicio 8.2. ¿Cuál es el límite de la sucesión (1+1/m)**m ?

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

-- El límite de la sucesión es el número e.

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

-- Ejercicio 8.3. Definir la función errorE tal que (errorE x) es el

-- menor número de términos de la sucesión (1+1/m)**m necesarios para

-- obtener su límite con un error menor que x. Por ejemplo,

-- errorAproxE 0.1 == 13.0

-- errorAproxE 0.01 == 135.0

-- errorAproxE 0.001 == 1359.0

-- Indicación: En Haskell, e se calcula como (exp 1).

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

errorAproxE x = head [m | m <- [1..], abs((exp 1) - (1+1/m)**m) < x]

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

-- Ejercicio 9.1. Definir la función aproxLimSeno tal que

-- (aproxLimSeno n) es la lista cuyos elementos son los términos de la

-- sucesión

-- sen(1/m)

-- --------

-- 1/m

-- desde 1 hasta n. Por ejemplo,

-- aproxLimSeno 1 == [0.8414709848078965]

-- aproxLimSeno 2 == [0.8414709848078965,0.958851077208406]

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

aproxLimSeno n = [sin(1/m)/(1/m) | m <- [1..n]]

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

-- Ejercicio 9.2. ¿Cuál es el límite de la sucesión sen(1/m)/(1/m) ?

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

-- El límite es 1.

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

-- Ejercicio 9.3. Definir la función errorLimSeno tal que

-- (errorLimSeno x) es el menor número de términos de la sucesión

-- sen(1/m)/(1/m) necesarios para obtener su límite con un error menor

-- que x. Por ejemplo,

-- errorLimSeno 0.1 == 2.0

-- errorLimSeno 0.01 == 5.0

-- errorLimSeno 0.001 == 13.0

-- errorLimSeno 0.0001 == 41.0

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

errorLimSeno x = head [m | m <- [1..], abs(1 - sin(1/m)/(1/m)) < x]

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

-- Ejercicio 10.1. Definir la función calculaPi tal que (calculaPi n) es

-- la aproximación del número pi calculada mediante la expresión

-- 4*(1 - 1/3 + 1/5 - 1/7 + ...+ (-1)**n/(2*n+1))

-- Por ejemplo,

-- calculaPi 3 == 2.8952380952380956

-- calculaPi 300 == 3.1449149035588526

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

calculaPi n = 4 * sum [(-1)**x/(2*x+1) | x <- [0..n]]

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

-- Ejercicio 10.2. Definir la función errorPi tal que

-- (errorPi x) es el menor número de términos de la serie

-- 4*(1 - 1/3 + 1/5 - 1/7 + ...+ (-1)**n/(2*n+1))

-- necesarios para obtener pi con un error menor que x. Por ejemplo,

-- errorPi 0.1 == 9.0

-- errorPi 0.01 == 99.0

-- errorPi 0.001 == 999.0

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

errorPi x = head [n | n <- [1..], abs (pi - (calculaPi n)) < x]

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

-- Ejercicio 11. Definir la función ocurrenciasDelMaximo tal que

-- (ocurrenciasDelMaximo xs) es el par formado por el mayor de los

-- números de xs y el número de veces que este aparece en la lista

-- xs, si la lista es no vacía y es (0,0) si xs es la lista vacía. Por

-- ejemplo,

-- ocurrenciasDelMaximo [1,3,2,4,2,5,3,6,3,2,1,8,7,6,5] == (8,1)

-- ocurrenciasDelMaximo [1,8,2,4,8,5,3,6,3,2,1,8] == (8,3)

-- ocurrenciasDelMaximo [8,8,2,4,8,5,3,6,3,2,1,8] == (8,4)

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

ocurrenciasDelMaximo [] = (0,0)

ocurrenciasDelMaximo xs = (maximum xs, sum [1 | y <- xs, y == maximum xs])

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

-- Ejercicio 12. Definir, por comprensión, la función tienenS tal que

-- (tienenS xss) es la lista de las longitudes de las cadenas de xss que

-- contienen el caracter 's' en mayúsculas o minúsculas. Por ejemplo,

-- tienenS ["Este","es","un","examen","de","hoy","Suerte"] == [4,2,6]

-- tienenS ["Este"] == [4]

-- tienenS [] == []

-- tienenS [" "] == []

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

tienenS xss = [length xs | xs <- xss, (elem 's' xs) || (elem 'S' xs)]

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

-- Ejercicio 13. Decimos que una lista está algo ordenada si para todo

-- par de elementos consecutivos se cumple que el primero es menor o

-- igual que el doble del segundo. Definir, por comprensión, la función

-- (algoOrdenada xs) que se verifica si la lista xs está algo ordenada.

-- Por ejemplo,

-- algoOrdenada [1,3,2,5,3,8] == True

-- algoOrdenada [3,1] == False

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

algoOrdenada xs = and [x <= 2*y | (x,y) <- zip xs (tail xs)]

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

-- Ejercicio 14.1. Definir, por comprensión, la función tripletas tal

-- que (tripletas xs) es la listas de tripletas de elementos

-- consecutivos de la lista xs. Por ejemplo,

-- tripletas [8,7,6,5,4] == [[8,7,6],[7,6,5],[6,5,4]]

-- tripletas "abcd" == ["abc","bcd"]

-- tripletas [2,4,3] == [[2,3,4]]

-- tripletas [2,4] == []

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

-- 1ª definición:

tripletas xs =

[[a,b,c] | ((a,b),c) <- zip (zip xs (tail xs)) (tail (tail xs))]

-- 2ª definición:

tripletas2 xs =

[[xs!!n,xs!!(n+1),xs!!(n+2)] | n <- [0..length xs -3]]

-- 3ª definición:

tripletas3 xs = [take 3 (drop n xs) | n <- [0..length xs - 3]]

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

-- Ejercicio 14.2. Definir la función tresConsecutivas tal que

-- (tresConsecutivas x ys) se verifica si x ocurre tres veces seguidas

-- en la lista ys. Por ejemplo,

-- tresConsecutivas 3 [1,4,2,3,3,4,3,5,3,4,6] == False

-- tresConsecutivas 'a' "abcaaadfg" == True

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

tresConsecutivas x ys = elem [x,x,x] (tripletas ys)

Para la presentación de las gráficas se han usado los siguientes ejemplos

import Graphics.Gnuplot.Simple

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

dib1 =
    plotList [] puntos
    where puntos :: [(Int,Int)]
          puntos = [(x,x^2) | x <- [-100..100]]

dib2 =
    plotFunc [] [-100..100] cuadrado
    where cuadrado :: Int -> Int
          cuadrado x = x^2

dib3 =
    plotFuncs [] [-100..100] [cuadrado, cuadrado2]
    where cuadrado, cuadrado2 :: Int -> Int
          cuadrado x  = x^2
          cuadrado2 x = x^2 + 1000

-- Aproximación de E (Ejercicio 8)
-- ===============================

dibAproxE1 n = 
    plotList [] puntos
    where puntos  :: [(Float,Float)]
          puntos = [(m,(1+1/m)**m) | m <- [1..n]]

dibAproxE2 n = 
    plotFunc [] [1..n] aproxE'
        where aproxE' :: Float -> Float
              aproxE' n = (1+1/n)**n

dibAproxE3 n = 
    plotFuncs [] [1..n] [aproxE', constE]
        where aproxE', constE :: Float -> Float
              aproxE' n = (1+1/n)**n
              constE n  = exp 1

-- Límite del seno (Ejercicio 9)
-- =============================

dibAproxLS1 n = 
    plotList [] puntos
    where puntos  :: [(Float,Float)]
          puntos = [(m,sin(1/m)/(1/m)) | m <- [1..n]]

dibAproxLS2 n = 
    plotFunc [] [1..n] aproxLS'
        where aproxLS' :: Float -> Float
              aproxLS' m = sin(1/m)/(1/m)

dibAproxLS3 n = 
    plotFuncs [] [1..n] [aproxLS', const1]
        where aproxLS', const1 :: Float -> Float
              aproxLS' m = sin(1/m)/(1/m)
              const1 m   = 1

-- Aproximación de pi (ejercicio 10)
-- =================================

dibAproxPi n = 
    plotFuncs [] [1..n] [aproxPi, constPi]
        where aproxPi, constPi :: Float -> Float
              aproxPi m = 4 * sum [(-1)**x/(2*x+1) | x <- [0..m]]
              constPi m = pi

import Graphics.Gnuplot.Simple

-- Introducción

-- ============

dib1 =

plotList [] puntos

where puntos :: [(Int,Int)]

puntos = [(x,x^2) | x <- [-100..100]]

dib2 =

plotFunc [] [-100..100] cuadrado

where cuadrado :: Int -> Int

cuadrado x = x^2

dib3 =

plotFuncs [] [-100..100] [cuadrado, cuadrado2]

where cuadrado, cuadrado2 :: Int -> Int

cuadrado x = x^2

cuadrado2 x = x^2 + 1000

-- Aproximación de E (Ejercicio 8)

-- ===============================

dibAproxE1 n =

plotList [] puntos

where puntos :: [(Float,Float)]

puntos = [(m,(1+1/m)**m) | m <- [1..n]]

dibAproxE2 n =

plotFunc [] [1..n] aproxE'

where aproxE' :: Float -> Float

aproxE' n = (1+1/n)**n

dibAproxE3 n =

plotFuncs [] [1..n] [aproxE', constE]

where aproxE', constE :: Float -> Float

aproxE' n = (1+1/n)**n

constE n = exp 1

-- Límite del seno (Ejercicio 9)

-- =============================

dibAproxLS1 n =

plotList [] puntos

where puntos :: [(Float,Float)]

puntos = [(m,sin(1/m)/(1/m)) | m <- [1..n]]

dibAproxLS2 n =

plotFunc [] [1..n] aproxLS'

where aproxLS' :: Float -> Float

aproxLS' m = sin(1/m)/(1/m)

dibAproxLS3 n =

plotFuncs [] [1..n] [aproxLS', const1]

where aproxLS', const1 :: Float -> Float

aproxLS' m = sin(1/m)/(1/m)

const1 m = 1

-- Aproximación de pi (ejercicio 10)

-- =================================

dibAproxPi n =

plotFuncs [] [1..n] [aproxPi, constPi]

where aproxPi, constPi :: Float -> Float

aproxPi m = 4 * sum [(-1)**x/(2*x+1) | x <- [0..m]]

constPi m = pi

Se puede imprimir o compartir con