marzo 2021 – Página 3

Números con cuadrados con dígitos pares

PorJosé A. Alonso 17-marzo-202124-marzo-2021

Definir la lista

   numerosConCuadradosConDigitosPares :: [Integer]

1	numerosConCuadradosConDigitosPares :: [Integer]

cuyos elementos son los números cuyos cuadrados tienen todos sus dígitos pares. Por ejemplo,

   λ> take 20 numerosConCuadradosConDigitosPares
   [0,2,8,20,22,68,78,80,92,162,168,200,202,220,262,298,478,492,498,668]

1 2	λ> take 20 numerosConCuadradosConDigitosPares [0,2,8,20,22,68,78,80,92,162,168,200,202,220,262,298,478,492,498,668]

Comprobar con QuickCheck que numerosConCuadradosConDigitosPares es infinita; es decir, para cualquier n posee algún elemento mayor que n.

Soluciones

import Test.QuickCheck

numerosConCuadradosConDigitosPares :: [Integer]
numerosConCuadradosConDigitosPares =
  filter tieneCuadradoConDigitosPares [0..]

-- (tieneCuadradoConDigitosPares n) se verifica si todos los dígitos de
-- n^2 son pares. Por ejemplo,
--    tieneCuadradoConDigitosPares 78  ==  True
--    tieneCuadradoConDigitosPares 76  ==  False
tieneCuadradoConDigitosPares :: Integer -> Bool
tieneCuadradoConDigitosPares n =
  tieneDigitosPares (n^2)

-- (tieneDigitosPares n) se verifica si todos los dígitos de n son
-- pares. Por ejemplo,
--    tieneDigitosPares 426  ==  True
--    tieneDigitosPares 436  ==  False
tieneDigitosPares :: Integer -> Bool
tieneDigitosPares n =
  all even (digitos n)

-- (digitos n) es la lista de los dígitos de n. Por ejemplo,
--    digitos 325  ==  [3,2,5]
digitos :: Integer -> [Int]
digitos n =
  [read [c] | c <- show n]

-- La propiedad es
prop_infinito :: Integer -> Bool
prop_infinito n =
  not (null (dropWhile (<= n) numerosConCuadradosConDigitosPares))

-- La comprobación es
--    λ> quickCheck prop_infinito
--    +++ OK, passed 100 tests.

import Test.QuickCheck

numerosConCuadradosConDigitosPares :: [Integer]

numerosConCuadradosConDigitosPares =

filter tieneCuadradoConDigitosPares [0..]

-- (tieneCuadradoConDigitosPares n) se verifica si todos los dígitos de

-- n^2 son pares. Por ejemplo,

-- tieneCuadradoConDigitosPares 78 == True

-- tieneCuadradoConDigitosPares 76 == False

tieneCuadradoConDigitosPares :: Integer -> Bool

tieneCuadradoConDigitosPares n =

tieneDigitosPares (n^2)

-- (tieneDigitosPares n) se verifica si todos los dígitos de n son

-- pares. Por ejemplo,

-- tieneDigitosPares 426 == True

-- tieneDigitosPares 436 == False

tieneDigitosPares :: Integer -> Bool

tieneDigitosPares n =

all even (digitos n)

-- (digitos n) es la lista de los dígitos de n. Por ejemplo,

-- digitos 325 == [3,2,5]

digitos :: Integer -> [Int]

digitos n =

[read [c] | c <- show n]

-- La propiedad es

prop_infinito :: Integer -> Bool

prop_infinito n =

not (null (dropWhile (<= n) numerosConCuadradosConDigitosPares))

-- La comprobación es

-- λ> quickCheck prop_infinito

-- +++ OK, passed 100 tests.

Nuevas soluciones

En los comentarios se pueden escribir nuevas soluciones.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Cálculo de pi mediante la fórmula de Bauer

PorJosé A. Alonso 16-marzo-202123-marzo-2021

El pasado 10 de marzo se publicó en Twitter un mensaje con una fórmula de Bauer para el cálculo de pi

Los primeros valores son

   λ> 2/1
   2.0
   λ> 2/(1 - 5*(1/2)^3)
   5.333333333333333
   λ> 2/(1 - 5*(1/2)^3 + 9*((1*3)/(2*4))^3)
   2.354022988505747
   λ> 2/(1 - 5*(1/2)^3 + 9*((1*3)/(2*4))^3 - 13*((1*3*5)/(2*4*6))^3)
   4.416172506738545

λ> 2/1

2.0

λ> 2/(1 - 5*(1/2)^3)

5.333333333333333

λ> 2/(1 - 5*(1/2)^3 + 9*((1*3)/(2*4))^3)

2.354022988505747

λ> 2/(1 - 5*(1/2)^3 + 9*((1*3)/(2*4))^3 - 13*((1*3*5)/(2*4*6))^3)

4.416172506738545

Definir las funciones

   aproximacionPi :: Int -> Double
   grafica        :: [Int] -> IO ()

1 2	aproximacionPi :: Int -> Double grafica :: [Int] -> IO ()

tales que

(aproximacionPi n) es la n-ésima aproximación de pi con la fórmula de Bauer. Por ejemplo,

     aproximacionPi 0         ==  2.0
     aproximacionPi 1         ==  5.333333333333333
     aproximacionPi 2         ==  2.354022988505747
     aproximacionPi 3         ==  4.416172506738545
     aproximacionPi (10^2)    ==  2.974407762733626
     aproximacionPi (10^2+1)  ==  3.3277148010019233
     aproximacionPi (10^3)    ==  3.0865454975585744
     aproximacionPi (10^3+1)  ==  3.1986099487445463
     aproximacionPi (10^4)    ==  3.1239682112773868
     aproximacionPi (10^4+1)  ==  3.1594161911246594
     aproximacionPi (10^5)    ==  3.135997665507836
     aproximacionPi (10^5+1)  ==  3.147207613460776
     pi                       ==  3.141592653589793

aproximacionPi 0 == 2.0

aproximacionPi 1 == 5.333333333333333

aproximacionPi 2 == 2.354022988505747

aproximacionPi 3 == 4.416172506738545

aproximacionPi (10^2) == 2.974407762733626

aproximacionPi (10^2+1) == 3.3277148010019233

aproximacionPi (10^3) == 3.0865454975585744

aproximacionPi (10^3+1) == 3.1986099487445463

aproximacionPi (10^4) == 3.1239682112773868

aproximacionPi (10^4+1) == 3.1594161911246594

aproximacionPi (10^5) == 3.135997665507836

aproximacionPi (10^5+1) == 3.147207613460776

pi == 3.141592653589793

(grafica xs) dibuja la gráfica de las k-ésimas aproximaciones de pi para k en xs. Por ejemplo, (grafica [0..99]) dibuja

Soluciones

import Graphics.Gnuplot.Simple (Attribute (Key, PNG), plotList)

aproximacionPi :: Int -> Double
aproximacionPi n =
  aproximacionesPi !! n

aproximacionesPi :: [Double]
aproximacionesPi =
  map (2/)
      (scanl1 (+)
              (zipWith (*)
                       [fromIntegral ((-1)^n*(4*n+1))| n <- [0..]]
                       (1 : scanl1 (*) [(x/y)^3 | (x,y) <- zip [1,3..] [2,4..]])))

-- Gráfica
-- =======

grafica :: [Int] -> IO ()
grafica xs =
  plotList [ Key Nothing
           -- , PNG "Calculo_de_pi_mediante_la_formula_de_Bauer_1.png"
           ]
           [(k,aproximacionPi k) | k <- xs]

import Graphics.Gnuplot.Simple (Attribute (Key, PNG), plotList)

aproximacionPi :: Int -> Double

aproximacionPi n =

aproximacionesPi !! n

aproximacionesPi :: [Double]

aproximacionesPi =

map (2/)

(scanl1 (+)

(zipWith (*)

[fromIntegral ((-1)^n*(4*n+1))| n <- [0..]]

(1 : scanl1 (*) [(x/y)^3 | (x,y) <- zip [1,3..] [2,4..]])))

-- Gráfica

-- =======

grafica :: [Int] -> IO ()

grafica xs =

plotList [ Key Nothing

-- , PNG "Calculo_de_pi_mediante_la_formula_de_Bauer_1.png"

]

[(k,aproximacionPi k) | k <- xs]

Nuevas soluciones

En los comentarios se pueden escribir nuevas soluciones.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Cálculo de pi mediante la fórmula de Euler

PorJosé A. Alonso 15-marzo-202122-marzo-2021

El pasado 6 de marzo se publicó en Twitter un mensaje con una fórmula de Euler para el cálculo de pi

Definir las funciones

   aproximacionPi :: Int -> Double
   grafica        :: [Int] -> IO ()

1 2	aproximacionPi :: Int -> Double grafica :: [Int] -> IO ()

tales que

(aproximacionPi n) es la n-ésima aproximación de pi con la fórmula de Euler. Por ejemplo,

     aproximacionPi 1        ==  2.449489742783178
     aproximacionPi 10       ==  3.04936163598207
     aproximacionPi 100      ==  3.1320765318091053
     aproximacionPi 1000     ==  3.1406380562059946
     aproximacionPi 10000    ==  3.1414971639472147
     aproximacionPi 100000   ==  3.141583104326456
     aproximacionPi 1000000  ==  3.1415916986605086
     pi                      ==  3.141592653589793

aproximacionPi 1 == 2.449489742783178

aproximacionPi 10 == 3.04936163598207

aproximacionPi 100 == 3.1320765318091053

aproximacionPi 1000 == 3.1406380562059946

aproximacionPi 10000 == 3.1414971639472147

aproximacionPi 100000 == 3.141583104326456

aproximacionPi 1000000 == 3.1415916986605086

pi == 3.141592653589793

(grafica xs) dibuja la gráfica de las k-ésimas aproximaciones de pi para k en xs. Por ejemplo, (grafica [1..100]) dibuja

Soluciones

import Graphics.Gnuplot.Simple (Attribute (Key, PNG), plotList)

aproximacionPi :: Int -> Double
aproximacionPi n =
  sqrt (6 * sum [1/k^2 | k <- [1.0..fromIntegral n]])

grafica :: [Int] -> IO ()
grafica xs =
  plotList [ Key Nothing
           -- , PNG "Calculo_de_pi_mediante_la_formula_de_Euler_1.png"
           ]
           [(k,aproximacionPi k) | k <- xs]

import Graphics.Gnuplot.Simple (Attribute (Key, PNG), plotList)

aproximacionPi :: Int -> Double

aproximacionPi n =

sqrt (6 * sum [1/k^2 | k <- [1.0..fromIntegral n]])

grafica :: [Int] -> IO ()

grafica xs =

plotList [ Key Nothing

-- , PNG "Calculo_de_pi_mediante_la_formula_de_Euler_1.png"

]

[(k,aproximacionPi k) | k <- xs]

Nuevas soluciones

En los comentarios se pueden escribir nuevas soluciones.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Representaciones de un número como potencia

PorJosé A. Alonso 12-marzo-202119-marzo-2021

El número 512 se puede escribir de tres maneras como potencias:

   512 = 2⁹ = 8³ = 512¹

1	512 = 2⁹ = 8³ = 512¹

Definir las funciones

   potencias       :: Integer -> [(Integer,Integer)]
   numeroPotencias :: Integer -> Int

1 2	potencias :: Integer -> [(Integer,Integer)] numeroPotencias :: Integer -> Int

tales que

(potencias x) es la lista de las representaciones de x como potencias de números enteros positivos. Por ejemplo,

     potencias 7      ==  [(7,1)]
     potencias 8      ==  [(2,3),(8,1)]
     potencias 512    ==  [(2,9),(8,3),(512,1)]
     potencias 16384  ==  [(2,14),(4,7),(128,2),(16384,1)]
     potencias 65536  ==  [(2,16),(4,8),(16,4),(256,2),(65536,1)]

potencias 7 == [(7,1)]

potencias 8 == [(2,3),(8,1)]

potencias 512 == [(2,9),(8,3),(512,1)]

potencias 16384 == [(2,14),(4,7),(128,2),(16384,1)]

potencias 65536 == [(2,16),(4,8),(16,4),(256,2),(65536,1)]

(numeroPotencias x) de las representaciones de x como potencias de números enteros positivos. Por ejemplo,

     numeroPotencias 7          ==  1
     numeroPotencias 8          ==  2
     numeroPotencias 512        ==  3
     numeroPotencias 16384      ==  4
     numeroPotencias 65536      ==  5
     numeroPotencias (2^(10^5)) ==  36

numeroPotencias 7 == 1

numeroPotencias 8 == 2

numeroPotencias 512 == 3

numeroPotencias 16384 == 4

numeroPotencias 65536 == 5

numeroPotencias (2^(10^5)) == 36

Soluciones

import Data.List (group,genericLength)
import Data.Numbers.Primes (primeFactors)

potencias :: Integer -> [(Integer,Integer)]
potencias x = [(a^d,b `div` d) | d <- divisores b]
  where ps = factorizacionPrima x
        b   = mcd (map snd ps)
        a   = product [c^(e `div` b) | (c,e) <- ps]

-- (divisores x) es la lista de los divisores de x. Por ejemplo,
--    divisores 120  ==  [1,2,3,4,5,6,8,10,12,15,20,24,30,40,60,120]
divisores :: Integer -> [Integer]
divisores x =
  [y | y <- [1..x], x `mod` y == 0]

-- (factorizacionPrima x) es la factorización prima de x. Por ejemplo,
--    factorizacionPrima 1200  ==  [(2,4),(3,1),(5,2)]
factorizacionPrima :: Integer -> [(Integer,Integer)]
factorizacionPrima x =
  [(head xs, genericLength xs) | xs <- group (primeFactors x)]

-- (mcd xs) es el máximo común divisor de xs. Por ejemplo,
--    mcd [12,30,42]  ==  6
mcd :: Integral a => [a] -> a
mcd xs = foldr1 gcd xs

-- 1ª definición de numeroPotencias
-- ================================

--    numeroPotencias 7          ==  1
--    numeroPotencias 8          ==  2
--    numeroPotencias 512        ==  3
--    numeroPotencias 16384      ==  4
--    numeroPotencias 65536      ==  5
--    numeroPotencias (2^(10^5)) ==  36
numeroPotencias :: Integer -> Int
numeroPotencias = length . potencias

-- 2ª definición de numeroPotencias
-- ================================

numeroPotencias2 :: Integer -> Int
numeroPotencias2 n =
  numeroDivisores (mcd (map length (group (primeFactors n))))

-- (numeroDivisores n) es el número de divisores de n. Por ejemplo,
--    numeroDivisores 12  ==  6
--    numeroDivisores 14  ==  4
numeroDivisores :: Int -> Int
numeroDivisores =
  product . map ((+1) . length) . group . primeFactors

-- Comparación de eficiencia de numeroPotencias
-- ============================================

-- La comparación es
--    λ> numeroPotencias (2^(10^5))
--    36
--    (0.40 secs, 707,287,312 bytes)
--    λ> numeroPotencias2 (2^(10^5))
--    36
--    (0.35 secs, 675,954,872 bytes)

import Data.List (group,genericLength)

import Data.Numbers.Primes (primeFactors)

potencias :: Integer -> [(Integer,Integer)]

potencias x = [(a^d,b `div` d) | d <- divisores b]

where ps = factorizacionPrima x

b = mcd (map snd ps)

a = product [c^(e `div` b) | (c,e) <- ps]

-- (divisores x) es la lista de los divisores de x. Por ejemplo,

-- divisores 120 == [1,2,3,4,5,6,8,10,12,15,20,24,30,40,60,120]

divisores :: Integer -> [Integer]

divisores x =

[y | y <- [1..x], x `mod` y == 0]

-- (factorizacionPrima x) es la factorización prima de x. Por ejemplo,

-- factorizacionPrima 1200 == [(2,4),(3,1),(5,2)]

factorizacionPrima :: Integer -> [(Integer,Integer)]

factorizacionPrima x =

[(head xs, genericLength xs) | xs <- group (primeFactors x)]

-- (mcd xs) es el máximo común divisor de xs. Por ejemplo,

-- mcd [12,30,42] == 6

mcd :: Integral a => [a] -> a

mcd xs = foldr1 gcd xs

-- 1ª definición de numeroPotencias

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

-- numeroPotencias 7 == 1

-- numeroPotencias 8 == 2

-- numeroPotencias 512 == 3

-- numeroPotencias 16384 == 4

-- numeroPotencias 65536 == 5

-- numeroPotencias (2^(10^5)) == 36

numeroPotencias :: Integer -> Int

numeroPotencias = length . potencias

-- 2ª definición de numeroPotencias

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

numeroPotencias2 :: Integer -> Int

numeroPotencias2 n =

numeroDivisores (mcd (map length (group (primeFactors n))))

-- (numeroDivisores n) es el número de divisores de n. Por ejemplo,

-- numeroDivisores 12 == 6

-- numeroDivisores 14 == 4

numeroDivisores :: Int -> Int

numeroDivisores =

product . map ((+1) . length) . group . primeFactors

-- Comparación de eficiencia de numeroPotencias

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

-- La comparación es

-- λ> numeroPotencias (2^(10^5))

-- 36

-- (0.40 secs, 707,287,312 bytes)

-- λ> numeroPotencias2 (2^(10^5))

-- 36

-- (0.35 secs, 675,954,872 bytes)

Nuevas soluciones

En los comentarios se pueden escribir nuevas soluciones.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Cálculo de pi mediante la fórmula de Brouncker

PorJosé A. Alonso 11-marzo-202118-marzo-2021

El mes de marzo es el mes de pi, ya que el 14 de marzo (3/14) es el día de pi. Con ese motivo, el pasado 3 de marzo se publicó en Twitter un mensaje con la fórmula de Brouncker para el cálculo de pi

La primeras aproximaciones son

     a(1) = 4                                  =  4
     a(2) = 4/(1+1^2)                          =  2.0
     a(3) = 4/(1+1^2/(2+3^2))                  =  3.666666666666667
     a(4) = 4/(1+1^2/(2+3^2/(2+5^2)))          =  2.8
     a(5) = 4/(1+1^2/(2+3^2/(2+5^2/(2+7^2))))  =  3.395238095238095

a(1) = 4 = 4

a(2) = 4/(1+1^2) = 2.0

a(3) = 4/(1+1^2/(2+3^2)) = 3.666666666666667

a(4) = 4/(1+1^2/(2+3^2/(2+5^2))) = 2.8

a(5) = 4/(1+1^2/(2+3^2/(2+5^2/(2+7^2)))) = 3.395238095238095

Definir las funciones

   aproximacionPi :: Int -> Double
   grafica        :: [Int] -> IO ()

1 2	aproximacionPi :: Int -> Double grafica :: [Int] -> IO ()

tales que

(aproximacionPi n) es la n-ésima aproximación de pi con la fórmula de Brouncker. Por ejemplo,

     aproximacionPi 1      ==  4.0
     aproximacionPi 2      ==  2.0
     aproximacionPi 3      ==  3.666666666666667
     aproximacionPi 4      ==  2.8
     aproximacionPi 5      ==  3.395238095238095
     aproximacionPi 10     ==  3.0301437124966535
     aproximacionPi 1000   ==  3.1405916523380406
     aproximacionPi 1001   ==  3.142592653839793
     aproximacionPi 10000  ==  3.141492643588543
     aproximacionPi 10001  ==  3.1416926535900433
     pi                    ==  3.141592653589793

aproximacionPi 1 == 4.0

aproximacionPi 2 == 2.0

aproximacionPi 3 == 3.666666666666667

aproximacionPi 4 == 2.8

aproximacionPi 5 == 3.395238095238095

aproximacionPi 10 == 3.0301437124966535

aproximacionPi 1000 == 3.1405916523380406

aproximacionPi 1001 == 3.142592653839793

aproximacionPi 10000 == 3.141492643588543

aproximacionPi 10001 == 3.1416926535900433

pi == 3.141592653589793

(grafica xs) dibuja la gráfica de las k-ésimas aproximaciones de pi para k en xs. Por ejemplo, (grafica [10..100]) dibuja

Soluciones

import Graphics.Gnuplot.Simple (Attribute (Key, PNG), plotList)

-- 1ª solución
-- ===========

aproximacionPi :: Int -> Double
aproximacionPi 1 = 4
aproximacionPi n = 4/(1 + 1/(aux 1 3))
  where aux a b | a == n-1  = 1
                | otherwise = 2 + (b^2)/(aux (a+1) (b+2))

-- El cálculo es
--    aproximacionPi 2
--      = 4/(1 + 1/(aux 1 3))
--      = 4/(1 + 1/1)
--      = 2.0
--
--    aproximacionPi 3
--      = 4/(1 + 1/(aux 1 3))
--      = 4/(1 + 1/(2 + 3^2/(aux 2 5))
--      = 4/(1 + 1/(2 + 3^2/1))
--      = 3.666666666666667
--
--    aproximacionPi 4
--      = 4/(1 + 1/(aux 1 3))
--      = 4/(1 + 1/(2 + 3^2/(aux 2 5))
--      = 4/(1 + 1/(2 + 3^2/(2 + 5^2/(aux 3 7))))
--      = 4/(1 + 1/(2 + 3^2/(2 + 5^2/1)))
--      = 2.8

-- 2ª solución
-- ===========

aproximacionPi2 :: Int -> Double
aproximacionPi2 n =
  aproximacionFC n fraccionPi

-- fraccionPi es la representación de la fracción continua de pi como un
-- par de listas infinitas.
fraccionPi :: [(Integer, Integer)]
fraccionPi = zip (0 : 1 : [2,2..]) (4 : map (^2) [1,3..])

-- (aproximacionFC n fc) es la n-ésima aproximación de la fracción
-- continua fc (como un par de listas).
aproximacionFC :: Int -> [(Integer, Integer)] -> Double
aproximacionFC n =
  foldr (\(a,b) z -> fromIntegral a + fromIntegral b / z) 1 . take n

-- Gráfica
-- =======

grafica :: [Int] -> IO ()
grafica xs =
  plotList [ Key Nothing
           -- , PNG "Calculo_de_pi_mediante_la_formula_de_Brouncker_1.png"
           ]
           [(k,aproximacionPi k) | k <- xs]

import Graphics.Gnuplot.Simple (Attribute (Key, PNG), plotList)

-- 1ª solución

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

aproximacionPi :: Int -> Double

aproximacionPi 1 = 4

aproximacionPi n = 4/(1 + 1/(aux 1 3))

where aux a b | a == n-1 = 1

| otherwise = 2 + (b^2)/(aux (a+1) (b+2))

-- El cálculo es

-- aproximacionPi 2

-- = 4/(1 + 1/(aux 1 3))

-- = 4/(1 + 1/1)

-- = 2.0

-- aproximacionPi 3

-- = 4/(1 + 1/(aux 1 3))

-- = 4/(1 + 1/(2 + 3^2/(aux 2 5))

-- = 4/(1 + 1/(2 + 3^2/1))

-- = 3.666666666666667

-- aproximacionPi 4

-- = 4/(1 + 1/(aux 1 3))

-- = 4/(1 + 1/(2 + 3^2/(aux 2 5))

-- = 4/(1 + 1/(2 + 3^2/(2 + 5^2/(aux 3 7))))

-- = 4/(1 + 1/(2 + 3^2/(2 + 5^2/1)))

-- = 2.8

-- 2ª solución

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

aproximacionPi2 :: Int -> Double

aproximacionPi2 n =

aproximacionFC n fraccionPi

-- fraccionPi es la representación de la fracción continua de pi como un

-- par de listas infinitas.

fraccionPi :: [(Integer, Integer)]

fraccionPi = zip (0 : 1 : [2,2..]) (4 : map (^2) [1,3..])

-- (aproximacionFC n fc) es la n-ésima aproximación de la fracción

-- continua fc (como un par de listas).

aproximacionFC :: Int -> [(Integer, Integer)] -> Double

aproximacionFC n =

foldr (\(a,b) z -> fromIntegral a + fromIntegral b / z) 1 . take n

-- Gráfica

-- =======

grafica :: [Int] -> IO ()

grafica xs =

plotList [ Key Nothing

-- , PNG "Calculo_de_pi_mediante_la_formula_de_Brouncker_1.png"

]

[(k,aproximacionPi k) | k <- xs]

Nuevas soluciones

En los comentarios se pueden escribir nuevas soluciones.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Meses: marzo 2021

Números con cuadrados con dígitos pares

Soluciones

Nuevas soluciones

Cálculo de pi mediante la fórmula de Bauer

Soluciones

Nuevas soluciones

Cálculo de pi mediante la fórmula de Euler

Soluciones

Nuevas soluciones

Representaciones de un número como potencia

Soluciones

Nuevas soluciones

Cálculo de pi mediante la fórmula de Brouncker

Soluciones

Nuevas soluciones

Entradas recientes

Buscar

Correo electrónico