digitosPi ::[Integer]
digitosPi = g(1,0,1,1,3,3)where
g (q,r,t,k,n,l)=if4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div(10*(3*q+r)) t -10*n, l)else g (q*k, (2*q+r)*l, t*l, k+1, div(q*(7*k+2)+r*l)(t*l), l+2)
digitosPi :: [Integer]
digitosPi = g(1,0,1,1,3,3) where
g (q,r,t,k,n,l) =
if 4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div (10*(3*q+r)) t - 10*n, l)
else g (q*k, (2*q+r)*l, t*l, k+1, div (q*(7*k+2)+r*l) (t*l), l+2)
Por ejemplo,
λ> take 25 digitosPi
[3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4,6,2,6,4,3]
λ> take 25 digitosPi
[3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4,6,2,6,4,3]
La distribución de los primeros 25 dígitos de pi es [0,2,3,5,3,3,3,1,2,3] ya que el 0 no aparece, el 1 ocurre 2 veces, el 3 ocurre 3 veces, el 4 ocurre 5 veces, …
Usando digitosPi, definir las siguientes funciones
distribucionDigitosPi :: Int -> [Int]
frecuenciaDigitosPi :: Int -> [Double]
distribucionDigitosPi :: Int -> [Int]
frecuenciaDigitosPi :: Int -> [Double]
tales que
(distribucionDigitosPi n) es la distribución de los n primeros dígitos de pi. Por ejemplo,
import Data.Array
import Data.List (group, sort)
digitosPi ::[Integer]
digitosPi = g(1,0,1,1,3,3)where
g (q,r,t,k,n,l)=if4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div(10*(3*q+r)) t -10*n, l)else g (q*k, (2*q+r)*l, t*l, k+1, div(q*(7*k+2)+r*l)(t*l), l+2)-- 1ª definición-- =============
distribucionDigitosPi ::Int->[Int]
distribucionDigitosPi n =
elems (accumArray (+)0(0,9)[(i,1)| i <-take n digitosPi])
frecuenciaDigitosPi ::Int->[Double]
frecuenciaDigitosPi n =[100*(fromIntegral x / m)| x <- distribucionDigitosPi n]where m =fromIntegral n
-- 2ª definición-- =============
distribucionDigitosPi2 ::Int->[Int]
distribucionDigitosPi2 n =[length xs -1| xs <- group (sort (take n digitosPi ++[0..9]))]
frecuenciaDigitosPi2 ::Int->[Double]
frecuenciaDigitosPi2 n =[100*(fromIntegral x / m)| x <- distribucionDigitosPi2 n]where m =fromIntegral n
-- Comparación de eficiencia-- =========================-- λ> last (take 5000 digitosPi)-- 2-- (4.47 secs, 3,927,848,448 bytes)-- λ> frecuenciaDigitosPi 5000-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]-- (0.01 secs, 0 bytes)-- λ> frecuenciaDigitosPi2 5000-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]-- (0.02 secs, 0 bytes)
import Data.Array
import Data.List (group, sort)
digitosPi :: [Integer]
digitosPi = g(1,0,1,1,3,3) where
g (q,r,t,k,n,l) =
if 4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div (10*(3*q+r)) t - 10*n, l)
else g (q*k, (2*q+r)*l, t*l, k+1, div (q*(7*k+2)+r*l) (t*l), l+2)
-- 1ª definición
-- =============
distribucionDigitosPi :: Int -> [Int]
distribucionDigitosPi n =
elems (accumArray (+) 0 (0,9) [ (i,1)
| i <- take n digitosPi])
frecuenciaDigitosPi :: Int -> [Double]
frecuenciaDigitosPi n =
[100 * (fromIntegral x / m) | x <- distribucionDigitosPi n]
where m = fromIntegral n
-- 2ª definición
-- =============
distribucionDigitosPi2 :: Int -> [Int]
distribucionDigitosPi2 n =
[length xs - 1 | xs <- group (sort (take n digitosPi ++ [0..9]))]
frecuenciaDigitosPi2 :: Int -> [Double]
frecuenciaDigitosPi2 n =
[100 * (fromIntegral x / m) | x <- distribucionDigitosPi2 n]
where m = fromIntegral n
-- Comparación de eficiencia
-- =========================
-- λ> last (take 5000 digitosPi)
-- 2
-- (4.47 secs, 3,927,848,448 bytes)
-- λ> frecuenciaDigitosPi 5000
-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]
-- (0.01 secs, 0 bytes)
-- λ> frecuenciaDigitosPi2 5000
-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]
-- (0.02 secs, 0 bytes)
Otras soluciones
Se pueden escribir otras soluciones en los comentarios.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>
se pueden calcular el número pi con la precisión que se desee. Por ejemplo,
λ> import Data.Number.CReal
λ> showCReal 60 pi
"3.141592653589793238462643383279502884197169399375105820974945"
λ> import Data.Number.CReal
λ> showCReal 60 pi
"3.141592653589793238462643383279502884197169399375105820974945"
importa la librería y calcula el número pi con 60 decimales.
La distribución de las diferencias de los dígitos consecutivos para los 18 primeros n dígitos de pi se calcula como sigue: los primeros 18 dígitos de pi son
(graficas ns f) dibuja en el fichero f las gráficas de las distribuciones de las diferencias de los dígitos consecutivos para los primeros n dígitos de pi, para n en ns. Por ejemplo, al evaluar (graficas [100,250..4000] «distribucionDDCpi.png» se escribe en el fichero «distribucionDDCpi.png» la siguiente gráfica
Soluciones
import Data.Number.CReal
import Graphics.Gnuplot.Simple
import Data.Array
-- λ> digitosPi 18-- [3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3]
digitosPi ::Int->[Int]
digitosPi n =init[read[c]| c <-(x:xs)]where(x:_:xs)= showCReal n pi-- λ> diferenciasConsecutivos (digitosPi 18)-- [2,-3,3,-4,-4,7,-4,1,2,-2,-3,-1,2,-2,6,1,-1]
diferenciasConsecutivos ::Num a =>[a]->[a]
diferenciasConsecutivos xs =zipWith(-) xs (tail xs)
distribucionDDCpi ::Int->[Int]
distribucionDDCpi =
distribucion . diferenciasConsecutivos . digitosPi
where distribucion xs =
elems (accumArray (+)0(-9,9)(zip xs (repeat1)))
graficas ::[Int]-> FilePath ->IO()
graficas ns f =
plotLists [Key Nothing, PNG f][puntos n | n <- ns]where puntos ::Int->[(Int,Int)]
puntos n =zip[-9..9](distribucionDDCpi n)
import Data.Number.CReal
import Graphics.Gnuplot.Simple
import Data.Array
-- λ> digitosPi 18
-- [3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3]
digitosPi :: Int -> [Int]
digitosPi n = init [read [c] | c <- (x:xs)]
where (x:_:xs) = showCReal n pi
-- λ> diferenciasConsecutivos (digitosPi 18)
-- [2,-3,3,-4,-4,7,-4,1,2,-2,-3,-1,2,-2,6,1,-1]
diferenciasConsecutivos :: Num a => [a] -> [a]
diferenciasConsecutivos xs =
zipWith (-) xs (tail xs)
distribucionDDCpi :: Int -> [Int]
distribucionDDCpi =
distribucion . diferenciasConsecutivos . digitosPi
where distribucion xs =
elems (accumArray (+) 0 (-9,9) (zip xs (repeat 1)))
graficas :: [Int] -> FilePath -> IO ()
graficas ns f =
plotLists [Key Nothing, PNG f]
[puntos n | n <- ns]
where puntos :: Int -> [(Int,Int)]
puntos n = zip [-9..9] (distribucionDDCpi n)
Pensamiento
Doy consejo, a fuer de viejo:
nunca sigas mi consejo.
digitosPi ::[Integer]
digitosPi = g(1,0,1,1,3,3)where
g (q,r,t,k,n,l)=if4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div(10*(3*q+r)) t -10*n, l)else g (q*k, (2*q+r)*l, t*l, k+1, div(q*(7*k+2)+r*l)(t*l), l+2)
digitosPi :: [Integer]
digitosPi = g(1,0,1,1,3,3) where
g (q,r,t,k,n,l) =
if 4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div (10*(3*q+r)) t - 10*n, l)
else g (q*k, (2*q+r)*l, t*l, k+1, div (q*(7*k+2)+r*l) (t*l), l+2)
Por ejemplo,
λ> take 25 digitosPi
[3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4,6,2,6,4,3]
λ> take 25 digitosPi
[3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4,6,2,6,4,3]
La distribución de los primeros 25 dígitos de pi es [0,2,3,5,3,3,3,1,2,3] ya que el 0 no aparece, el 1 ocurre 2 veces, el 3 ocurre 3 veces, el 4 ocurre 5 veces, …
Usando digitosPi, definir las siguientes funciones
distribucionDigitosPi :: Int -> [Int]
frecuenciaDigitosPi :: Int -> [Double]
distribucionDigitosPi :: Int -> [Int]
frecuenciaDigitosPi :: Int -> [Double]
tales que
(distribucionDigitosPi n) es la distribución de los n primeros dígitos de pi. Por ejemplo,
import Data.Array
import Data.List (group, sort)
digitosPi ::[Integer]
digitosPi = g(1,0,1,1,3,3)where
g (q,r,t,k,n,l)=if4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div(10*(3*q+r)) t -10*n, l)else g (q*k, (2*q+r)*l, t*l, k+1, div(q*(7*k+2)+r*l)(t*l), l+2)-- 1ª definición-- =============
distribucionDigitosPi ::Int->[Int]
distribucionDigitosPi n =
elems (accumArray (+)0(0,9)[(i,1)| i <-take n digitosPi])
frecuenciaDigitosPi ::Int->[Double]
frecuenciaDigitosPi n =[100*(fromIntegral x / m)| x <- distribucionDigitosPi n]where m =fromIntegral n
-- 2ª definición-- =============
distribucionDigitosPi2 ::Int->[Int]
distribucionDigitosPi2 n =[length xs -1| xs <- group (sort (take n digitosPi ++[0..9]))]
frecuenciaDigitosPi2 ::Int->[Double]
frecuenciaDigitosPi2 n =[100*(fromIntegral x / m)| x <- distribucionDigitosPi2 n]where m =fromIntegral n
-- Comparación de eficiencia-- =========================-- λ> last (take 5000 digitosPi)-- 2-- (4.47 secs, 3,927,848,448 bytes)-- λ> frecuenciaDigitosPi 5000-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]-- (0.01 secs, 0 bytes)-- λ> frecuenciaDigitosPi2 5000-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]-- (0.02 secs, 0 bytes)
import Data.Array
import Data.List (group, sort)
digitosPi :: [Integer]
digitosPi = g(1,0,1,1,3,3) where
g (q,r,t,k,n,l) =
if 4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div (10*(3*q+r)) t - 10*n, l)
else g (q*k, (2*q+r)*l, t*l, k+1, div (q*(7*k+2)+r*l) (t*l), l+2)
-- 1ª definición
-- =============
distribucionDigitosPi :: Int -> [Int]
distribucionDigitosPi n =
elems (accumArray (+) 0 (0,9) [(i,1)
| i <- take n digitosPi])
frecuenciaDigitosPi :: Int -> [Double]
frecuenciaDigitosPi n =
[100 * (fromIntegral x / m) | x <- distribucionDigitosPi n]
where m = fromIntegral n
-- 2ª definición
-- =============
distribucionDigitosPi2 :: Int -> [Int]
distribucionDigitosPi2 n =
[length xs - 1 | xs <- group (sort (take n digitosPi ++ [0..9]))]
frecuenciaDigitosPi2 :: Int -> [Double]
frecuenciaDigitosPi2 n =
[100 * (fromIntegral x / m) | x <- distribucionDigitosPi2 n]
where m = fromIntegral n
-- Comparación de eficiencia
-- =========================
-- λ> last (take 5000 digitosPi)
-- 2
-- (4.47 secs, 3,927,848,448 bytes)
-- λ> frecuenciaDigitosPi 5000
-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]
-- (0.01 secs, 0 bytes)
-- λ> frecuenciaDigitosPi2 5000
-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]
-- (0.02 secs, 0 bytes)
Pensamiento
¿Cuál es la verdad? ¿El río
que fluye y pasa
donde el barco y el barquero
son también ondas de agua?
¿O este soñar del marino
siempre con ribera y ancla?
La distribución de las diferencias de los dígitos consecutivos para los 18 primeros dígitos de pi se calcula como sigue: los primeros 18 dígitos de pi son
(graficas ns f) dibuja en el fichero f las gráficas de las distribuciones de las diferencias de los dígitos consecutivos para los primeros n dígitos de pi, para n en ns. Por ejemplo, al evaluar (graficas [100,250..4000] «distribucionDDCpi.png» se escribe en el fichero «distribucionDDCpi.png» la siguiente gráfica
digitosPi :: [Integer]
digitosPi = g(1,0,1,1,3,3) where
g (q,r,t,k,n,l) =
if 4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div (10*(3*q+r)) t - 10*n, l)
else g (q*k, (2*q+r)*l, t*l, k+1, div (q*(7*k+2)+r*l) (t*l), l+2)
digitosPi :: [Integer]
digitosPi = g(1,0,1,1,3,3) where
g (q,r,t,k,n,l) =
if 4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div (10*(3*q+r)) t - 10*n, l)
else g (q*k, (2*q+r)*l, t*l, k+1, div (q*(7*k+2)+r*l) (t*l), l+2)
Por ejemplo,
λ> take 25 digitosPi
[3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4,6,2,6,4,3]
λ> take 25 digitosPi
[3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4,6,2,6,4,3]
La distribución de los primeros 25 dígitos de pi es [0,2,3,5,3,3,3,1,2,3] ya que el 0 no aparece, el 1 ocurre 2 veces, el 3 ocurre 3 veces, el 4 ocurre 5 veces, …
Usando digitosPi, definir las siguientes funciones
distribucionDigitosPi :: Int -> [Int]
frecuenciaDigitosPi :: Int -> [Double]
distribucionDigitosPi :: Int -> [Int]
frecuenciaDigitosPi :: Int -> [Double]
tales que
(distribucionDigitosPi n) es la distribución de los n primeros dígitos de pi. Por ejemplo,
import Data.Array
import Data.List (group, sort)
digitosPi ::[Integer]
digitosPi = g(1,0,1,1,3,3)where
g (q,r,t,k,n,l)=if4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div(10*(3*q+r)) t -10*n, l)else g (q*k, (2*q+r)*l, t*l, k+1, div(q*(7*k+2)+r*l)(t*l), l+2)-- 1ª definición-- =============
distribucionDigitosPi ::Int->[Int]
distribucionDigitosPi n =
elems (accumArray (+)0(0,9)[(i,1)| i <-take n digitosPi])
frecuenciaDigitosPi ::Int->[Double]
frecuenciaDigitosPi n =[100*(fromIntegral x / m)| x <- distribucionDigitosPi n]where m =fromIntegral n
-- 2ª definición-- =============
distribucionDigitosPi2 ::Int->[Int]
distribucionDigitosPi2 n =[length xs -1| xs <- group (sort (take n digitosPi ++[0..9]))]
frecuenciaDigitosPi2 ::Int->[Double]
frecuenciaDigitosPi2 n =[100*(fromIntegral x / m)| x <- distribucionDigitosPi2 n]where m =fromIntegral n
-- Comparación de eficiencia-- =========================-- λ> last (take 5000 digitosPi)-- 2-- (4.47 secs, 3,927,848,448 bytes)-- λ> frecuenciaDigitosPi 5000-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]-- (0.01 secs, 0 bytes)-- λ> frecuenciaDigitosPi2 5000-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]-- (0.02 secs, 0 bytes)
import Data.Array
import Data.List (group, sort)
digitosPi :: [Integer]
digitosPi = g(1,0,1,1,3,3) where
g (q,r,t,k,n,l) =
if 4*q+r-t < n*t
then n : g (10*q, 10*(r-n*t), t, k, div (10*(3*q+r)) t - 10*n, l)
else g (q*k, (2*q+r)*l, t*l, k+1, div (q*(7*k+2)+r*l) (t*l), l+2)
-- 1ª definición
-- =============
distribucionDigitosPi :: Int -> [Int]
distribucionDigitosPi n =
elems (accumArray (+) 0 (0,9) [(i,1)
| i <- take n digitosPi])
frecuenciaDigitosPi :: Int -> [Double]
frecuenciaDigitosPi n =
[100 * (fromIntegral x / m) | x <- distribucionDigitosPi n]
where m = fromIntegral n
-- 2ª definición
-- =============
distribucionDigitosPi2 :: Int -> [Int]
distribucionDigitosPi2 n =
[length xs - 1 | xs <- group (sort (take n digitosPi ++ [0..9]))]
frecuenciaDigitosPi2 :: Int -> [Double]
frecuenciaDigitosPi2 n =
[100 * (fromIntegral x / m) | x <- distribucionDigitosPi2 n]
where m = fromIntegral n
-- Comparación de eficiencia
-- =========================
-- λ> last (take 5000 digitosPi)
-- 2
-- (4.47 secs, 3,927,848,448 bytes)
-- λ> frecuenciaDigitosPi 5000
-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]
-- (0.01 secs, 0 bytes)
-- λ> frecuenciaDigitosPi2 5000
-- [9.32,10.62,9.92,9.2,10.16,10.5,10.26,9.76,9.84,10.42]
-- (0.02 secs, 0 bytes)