Sucesión de trazas de dígitos de pi

PorJosé A. Alonso 17-febrero-201724-febrero-2017

El fichero Digitos_de_pi.txt contiene el número pi con un millón de decimales; es decir,

   3.1415926535897932384626433832 ... 83996346460422090106105779458151

1	3.1415926535897932384626433832 ... 83996346460422090106105779458151

Las matrices de orden 1×1, 2×2, …, 5×5 formadas por los primeros dígitos de pi son

   ( 3 )  ( 3 1 )  ( 3 1 4 )  ( 3 1 4 1 )  ( 3 1 4 1 5 )
          ( 4 1 )  ( 1 5 9 )  ( 5 9 2 6 )  ( 9 2 6 5 3 )
                   ( 2 6 5 )  ( 5 3 5 8 )  ( 5 8 9 7 9 )
                              ( 9 7 9 3 )  ( 3 2 3 8 4 )
                                           ( 6 2 6 4 3 )

( 3 ) ( 3 1 ) ( 3 1 4 ) ( 3 1 4 1 ) ( 3 1 4 1 5 )

( 4 1 ) ( 1 5 9 ) ( 5 9 2 6 ) ( 9 2 6 5 3 )

( 2 6 5 ) ( 5 3 5 8 ) ( 5 8 9 7 9 )

( 9 7 9 3 ) ( 3 2 3 8 4 )

( 6 2 6 4 3 )

y sus trazas (es decir, sumas de los elementos de la diagonal principal) son 3, 4, 13, 20 y 25, respectivamente.

Definir la función

   trazas :: Int -> IO [Int]

1	trazas :: Int -> IO [Int]

tal que (trazas n) es la lista de las trazas de las matrices de orden 1×1, 2×2, 3×3, …, nxn formadas por los primeros dígitos de pi. Por ejemplo,

   λ> trazas 20
   [3,4,13,20,25,30,19,32,41,59,62,64,58,75,62,60,80,99,78,108]
   λ> ts <- trazas 1000
   λ> maximum ts
   4644
   λ> maximum <$> trazas 1000
   4644

λ> trazas 20

[3,4,13,20,25,30,19,32,41,59,62,64,58,75,62,60,80,99,78,108]

λ> ts <- trazas 1000

λ> maximum ts

4644

λ> maximum <$> trazas 1000

4644

Soluciones

import Data.Char (digitToInt)
import Data.Matrix (fromList, trace)

trazas :: Int -> IO [Int]
trazas n = do
  (d:_:ds) <- readFile "Digitos_de_pi.txt"
  let xs = map digitToInt (d:ds)
  return [trace (fromList k k xs) | k <- [1..n]]

import Data.Char (digitToInt)

import Data.Matrix (fromList, trace)

trazas :: Int -> IO [Int]

trazas n = do

(d:_:ds) <- readFile "Digitos_de_pi.txt"

let xs = map digitToInt (d:ds)

return [trace (fromList k k xs) | k <- [1..n]]

7 Comentarios

trazasA1 :: Int -> IO [Int]
trazas :: Int -> IO [Int]
trazas n = do
  (x:coma:xs) <- readFile "Digitos_de_pi.txt"
  return [trace $ fromList k k (map (read.(:[])) $ take (k^2) (x:xs)::[Int])
         | k <- [1..n]]

trazasA1 :: Int -> IO [Int]

trazas :: Int -> IO [Int]

trazas n = do

(x:coma:xs) <- readFile "Digitos_de_pi.txt"

return [trace $ fromList k k (map (read.(:[])) $ take (k^2) (x:xs)::[Int])

| k <- [1..n]]

Responder

import qualified Data.Vector as V
import Data.Char (digitToInt)

trazas :: Int -> IO [Int]
trazas x = do
  a <- readFile "Digitos_de_pi.txt"
  let c = (V.fromList (map digitToInt $ '3':(tail $ tail a)))
  return [traza2 n c | n <-  [1..x]]
                     
traza2 :: Int -> V.Vector Int -> Int                    
traza2 n xs = sum [ xs V.! x | x <- [0,n+1..(n+1)*(n-1)]]

import qualified Data.Vector as V

import Data.Char (digitToInt)

trazas :: Int -> IO [Int]

trazas x = do

a <- readFile "Digitos_de_pi.txt"

let c = (V.fromList (map digitToInt $ '3':(tail $ tail a)))

return [traza2 n c | n <- [1..x]]

traza2 :: Int -> V.Vector Int -> Int

traza2 n xs = sum [ xs V.! x | x <- [0,n+1..(n+1)*(n-1)]]

Responder

import qualified Data.Vector as V
import Data.Char (digitToInt)

trazas :: Int -> IO [Int]
trazas n = do
  a <- readFile "Digitos_de_pi.txt"
  let xs = (V.fromList . map (digitToInt) . take (n^2)) ('3' : drop 2 a)
  return [(sum . map (xs V.!)) [0,1+x..x^2-1] | x <- [1..n]]

import qualified Data.Vector as V

import Data.Char (digitToInt)

trazas :: Int -> IO [Int]

trazas n = do

a <- readFile "Digitos_de_pi.txt"

let xs = (V.fromList . map (digitToInt) . take (n^2)) ('3' : drop 2 a)

return [(sum . map (xs V.!)) [0,1+x..x^2-1] | x <- [1..n]]

Responder

import Data.Matrix
import Data.Char

trazas :: Int -> IO [Int]
trazas n = do
  x:y:xs <- readFile "Digitos_de_pi.txt"
  let xs' = map digitToInt (x:xs)
  return [trace (fromList x x xs') | x <- [1..n]]

import Data.Matrix

import Data.Char

trazas :: Int -> IO [Int]

trazas n = do

x:y:xs <- readFile "Digitos_de_pi.txt"

let xs' = map digitToInt (x:xs)

return [trace (fromList x x xs') | x <- [1..n]]

Responder

trazas :: Int -> IO [Int]
trazas n = do
  (x:_:xs) <- readFile "Digitos_de_pi.txt"
  return $ [sum $ take i $ choose i (x:xs) | i <- [1..n]]
  where choose :: Int -> String -> [Int]
        choose n (x:xs) = read [x] : choose n (drop n xs)

trazas :: Int -> IO [Int]

trazas n = do

(x:_:xs) <- readFile "Digitos_de_pi.txt"

return $ [sum $ take i $ choose i (x:xs) | i <- [1..n]]

where choose :: Int -> String -> [Int]

choose n (x:xs) = read [x] : choose n (drop n xs)

Responder

trazas :: Int -> IO [Int]
trazas n = do
  a <- readFile digPi'
  return [sum $ listaTraza x (take z (map digitToInt a))
         | (x,z) <- zip [1..n] (cuadrados n)]

digPi' :: String
digPi' = "Digitos_de_pi.txt"

cuadrados :: Int -> [Int]
cuadrados n = [i*i | i <- [1..n*n]]

listaTraza :: Int -> [Int] -> [Int]
listaTraza _ [] = []
listaTraza n (x:xs)
  | n >= length xs = [x]
  | otherwise      = x : listaTraza n (drop n xs)

trazas :: Int -> IO [Int]

trazas n = do

a <- readFile digPi'

return [sum $ listaTraza x (take z (map digitToInt a))

| (x,z) <- zip [1..n] (cuadrados n)]

digPi' :: String

digPi' = "Digitos_de_pi.txt"

cuadrados :: Int -> [Int]

cuadrados n = [i*i | i <- [1..n*n]]

listaTraza :: Int -> [Int] -> [Int]

listaTraza _ [] = []

listaTraza n (x:xs)

| n >= length xs = [x]

| otherwise = x : listaTraza n (drop n xs)

Responder

cescarde dice:

19-febrero-2017 a las 20:32

He modificado el archivo Dígitos_de_pi.txt para que aparezca todos los dígitos de pi sin el punto . que separa el 3 del 1 al principio: 3.14159… Es decir: 314159…

Responder

Sucesión de trazas de dígitos de pi

Soluciones

7 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

7 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico