Raíces enteras de los números primos

Definir la sucesión

   raicesEnterasDePrimos :: [Integer]

1	raicesEnterasDePrimos :: [Integer]

cuyos elementos son las partes enteras de las raíces cuadradas de los números primos. Por ejemplo,

   λ> take 30 raicesEnterasDePrimos
   [1,1,2,2,3,3,4,4,4,5,5,6,6,6,6,7,7,7,8,8,8,8,9,9,9,10,10,10,10,10]
   λ> raicesEnterasDePrimos !!  9963
   322
   λ> raicesEnterasDePrimos !!  9964
   323

λ> take 30 raicesEnterasDePrimos

[1,1,2,2,3,3,4,4,4,5,5,6,6,6,6,7,7,7,8,8,8,8,9,9,9,10,10,10,10,10]

λ> raicesEnterasDePrimos !! 9963

322

λ> raicesEnterasDePrimos !! 9964

323

Comprobar con QuickCheck que la diferencia entre dos términos consecutivos de la sucesión es como máximo igual a 1.

Soluciones

import Data.Numbers.Primes (primes)
import Test.QuickCheck

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

raicesEnterasDePrimos1 :: [Integer]
raicesEnterasDePrimos1 = map raizEntera primes

-- (raizEntera x) es la parte entera de la raíz cuadrada de x. Por
-- ejemplo,
--    raizEntera  8  ==  2
--    raizEntera  9  ==  3
--    raizEntera 10  ==  3
raizEntera :: Integer -> Integer
raizEntera = floor . sqrt . fromIntegral 

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

raicesEnterasDePrimos2 :: [Integer]
raicesEnterasDePrimos2 = map raizEntera2 primes

raizEntera2 :: Integer -> Integer
raizEntera2 n = aux 1
    where aux k | k*k > n   = k-1
                | otherwise = aux (k+1)

-- 3º solución
-- ===========

raicesEnterasDePrimos3 :: [Integer]
raicesEnterasDePrimos3 = aux primes [1..]
    where aux (p:ps) (x:xs) | p > x*x   = aux (p:ps) xs
                            | otherwise = (x-1) : aux ps (x:xs)


-- Comparación de eficiencia
--    ghci> raicesEnterasDePrimos1 !! 400000
--    2408
--    (2.86 secs, 1177922500 bytes)
--    ghci> raicesEnterasDePrimos2 !! 400000
--    2408
--    (3.08 secs, 1177432260 bytes)
--    ghci> raicesEnterasDePrimos3 !! 400000
--    2408
--    (3.88 secs, 1260772112 bytes)

-- En lo sucesivo usaremos la 1ª definición
raicesEnterasDePrimos :: [Integer]
raicesEnterasDePrimos = raicesEnterasDePrimos3

-- La propiedad es
prop_raicesEnterasDePrimos :: Int -> Property
prop_raicesEnterasDePrimos n =
    n >= 0 ==> 
    raicesEnterasDePrimos !! (n+1) - raicesEnterasDePrimos !! n <= 1

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

import Data.Numbers.Primes (primes)

import Test.QuickCheck

-- 1ª solución

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

raicesEnterasDePrimos1 :: [Integer]

raicesEnterasDePrimos1 = map raizEntera primes

-- (raizEntera x) es la parte entera de la raíz cuadrada de x. Por

-- ejemplo,

-- raizEntera 8 == 2

-- raizEntera 9 == 3

-- raizEntera 10 == 3

raizEntera :: Integer -> Integer

raizEntera = floor . sqrt . fromIntegral

-- 2ª solución

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

raicesEnterasDePrimos2 :: [Integer]

raicesEnterasDePrimos2 = map raizEntera2 primes

raizEntera2 :: Integer -> Integer

raizEntera2 n = aux 1

where aux k | k*k > n = k-1

| otherwise = aux (k+1)

-- 3º solución

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

raicesEnterasDePrimos3 :: [Integer]

raicesEnterasDePrimos3 = aux primes [1..]

where aux (p:ps) (x:xs) | p > x*x = aux (p:ps) xs

| otherwise = (x-1) : aux ps (x:xs)

-- Comparación de eficiencia

-- ghci> raicesEnterasDePrimos1 !! 400000

-- 2408

-- (2.86 secs, 1177922500 bytes)

-- ghci> raicesEnterasDePrimos2 !! 400000

-- 2408

-- (3.08 secs, 1177432260 bytes)

-- ghci> raicesEnterasDePrimos3 !! 400000

-- 2408

-- (3.88 secs, 1260772112 bytes)

-- En lo sucesivo usaremos la 1ª definición

raicesEnterasDePrimos :: [Integer]

raicesEnterasDePrimos = raicesEnterasDePrimos3

-- La propiedad es

prop_raicesEnterasDePrimos :: Int -> Property

prop_raicesEnterasDePrimos n =

n >= 0 ==>

raicesEnterasDePrimos !! (n+1) - raicesEnterasDePrimos !! n <= 1

-- La comprobación es

-- λ> quickCheck prop_raicesEnterasDePrimos

-- +++ OK, passed 100 tests.

4 Comentarios

import Data.Numbers.Primes
import Test.QuickCheck
 
raicesEnterasDePrimos :: [Integer]
raicesEnterasDePrimos = map (truncate . sqrt) $ map fromIntegral primes

prop :: Int -> Bool
prop n = 
 abs (raicesEnterasDePrimos !! abs(n) - raicesEnterasDePrimos !! abs(n+1)) <= 1

-- *Main> quickCheck prop
-- +++ OK, passed 100 tests.

import Data.Numbers.Primes

import Test.QuickCheck

raicesEnterasDePrimos :: [Integer]

raicesEnterasDePrimos = map (truncate . sqrt) $ map fromIntegral primes

prop :: Int -> Bool

prop n =

abs (raicesEnterasDePrimos !! abs(n) - raicesEnterasDePrimos !! abs(n+1)) <= 1

-- *Main> quickCheck prop

-- +++ OK, passed 100 tests.

Responder

import Data.Numbers.Primes
import Test.QuickCheck
 
raicesEnterasDePrimos :: [Integer]
raicesEnterasDePrimos = map (floor . sqrt . fromIntegral) primes
 
test :: Int -> Bool
test n = 
 abs (raicesEnterasDePrimos !! abs(n) - raicesEnterasDePrimos !! abs(n+1)) <= 1
 
-- *Main> quickCheck prop
-- +++ OK, passed 100 tests.

import Data.Numbers.Primes

import Test.QuickCheck

raicesEnterasDePrimos :: [Integer]

raicesEnterasDePrimos = map (floor . sqrt . fromIntegral) primes

test :: Int -> Bool

test n =

abs (raicesEnterasDePrimos !! abs(n) - raicesEnterasDePrimos !! abs(n+1)) <= 1

-- *Main> quickCheck prop

-- +++ OK, passed 100 tests.

Responder

import Test.QuickCheck
import Data.Numbers.Primes

raicesEnterasDePrimos :: [Integer]
raicesEnterasDePrimos = [head [x-1 | x <- [1..], x^2>p] | p <- primes]

prop_raices :: Int -> Property
prop_raices n = n>=1 ==> xs !! (n+1) - xs !! n <= 1
                where xs = raicesEnterasDePrimos

-- *Main> quickCheck prop_raices
-- +++ OK, passed 100 tests.

import Test.QuickCheck

import Data.Numbers.Primes

raicesEnterasDePrimos :: [Integer]

raicesEnterasDePrimos = [head [x-1 | x <- [1..], x^2>p] | p <- primes]

prop_raices :: Int -> Property

prop_raices n = n>=1 ==> xs !! (n+1) - xs !! n <= 1

where xs = raicesEnterasDePrimos

-- *Main> quickCheck prop_raices

-- +++ OK, passed 100 tests.

Responder

import Data.Numbers.Primes
import Test.QuickCheck

raicesEnterasDePrimos :: [Integer]
raicesEnterasDePrimos = aux primes [1..]
    where aux (p:ps) (x:xs) | p > x*x   = aux (p:ps) xs
                            | otherwise = (x-1) : aux ps (x:xs)

prop_dif :: Int -> Property
prop_dif n = n > 0 ==>
    abs(raicesEnterasDePrimos!!n - raicesEnterasDePrimos!!(n+1)) <= 1

import Data.Numbers.Primes

import Test.QuickCheck

raicesEnterasDePrimos :: [Integer]

raicesEnterasDePrimos = aux primes [1..]

where aux (p:ps) (x:xs) | p > x*x = aux (p:ps) xs

| otherwise = (x-1) : aux ps (x:xs)

prop_dif :: Int -> Property

prop_dif n = n > 0 ==>

abs(raicesEnterasDePrimos!!n - raicesEnterasDePrimos!!(n+1)) <= 1

Responder

Raíces enteras de los números primos

Soluciones

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico