Menu Close

Distancias entre primos consecutivos

Los 15 primeros números primos son

   2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47

Las distancias entre los elementos consecutivos son

   1, 2, 2, 4, 2,  4,  2,  4,  6,  2,  6,  4,  2,  4

La distribución de las distancias es

   (1,1), (2,6), (4,5), (6,2)

(es decir, el 1 aparece una vez, el 2 aparece 6 veces, etc.) La frecuencia de las distancias es

   (1,7.142857), (2,42.857143), (4,35.714287), (6,14.285714)

(es decir, el 1 aparece el 7.142857%, el 2 el 42.857143% etc.)

Definir las funciones

  cuentaDistancias        :: Int -> [(Int,Int)]
  frecuenciasDistancias   :: Int -> [(Int,Float)]
  graficas                :: [Int] -> IO ()
  distanciasMasFrecuentes :: Int -> [Int]

tales que

  • (cuentaDistancias n) es la distribución de distancias entre los n primeros primos consecutivos. Por ejemplo,
     λ> cuentaDistancias 15
     [(1,1),(2,6),(4,5),(6,2)]
     λ> cuentaDistancias 100
     [(1,1),(2,25),(4,26),(6,25),(8,7),(10,7),(12,4),(14,3),(18,1)]
  • (frecuenciasDistancias n) es la frecuencia de distancias entre los n primeros primos consecutivos. Por ejemplo,
     λ> frecuenciasDistancias 15
     [(1,7.142857),(2,42.857143),(4,35.714287),(6,14.285714)]
     λ> frecuenciasDistancias 30
     [(1,3.4482758),(2,34.482758),(4,34.482758),(6,24.137932),(8,3.4482758)]
  • (graficas ns) dibuja las gráficas de (frecuenciasDistancias k) para k en ns. Por ejemplo, (graficas [10,20,30]) dibuja
    Distancias_entre_primos_consecutivos1
    (graficas [1000,2000,3000]) dibuja
    Distancias_entre_primos_consecutivos2
    y (graficas [100000,200000,300000]) dibuja
    Distancias_entre_primos_consecutivos3
  • (distanciasMasFrecuentes n) es la lista de las distancias más frecuentes entre los elementos consecutivos de la lista de los n primeros primos. Por ejemplo,
     distanciasMasFrecuentes 15     ==  [2]
     distanciasMasFrecuentes 26     ==  [2,4]
     distanciasMasFrecuentes 32     ==  [4]
     distanciasMasFrecuentes 41     ==  [2,4,6]
     distanciasMasFrecuentes 77     ==  [6]
     distanciasMasFrecuentes 160    ==  [4,6]
     distanciasMasFrecuentes (10^6) == [6]

Comprobar con QuickCheck si para todo n > 160 se verifica que (distanciasMasFrecuentes n) es [6].

Soluciones

import Data.Numbers.Primes
import qualified Data.Map as M 
import Graphics.Gnuplot.Simple
import Test.QuickCheck
 
cuentaDistancias :: Int -> [(Int,Int)]
cuentaDistancias = M.toList . dicDistancias
 
dicDistancias :: Int -> M.Map Int Int
dicDistancias n =
  M.fromListWith (+) (zip (distancias n) (repeat 1))
 
distancias :: Int -> [Int]
distancias n =
  zipWith (-) (tail xs) xs
  where xs = take n primes
 
frecuenciasDistancias :: Int -> [(Int,Float)]
frecuenciasDistancias n =
  [(k,(100 * fromIntegral x) / n1) | (k,x) <- cuentaDistancias n]
  where n1 = fromIntegral (n-1)
 
graficas :: [Int] -> IO ()
graficas ns =
  plotLists [Key Nothing]
            (map frecuenciasDistancias ns)
 
distanciasMasFrecuentes :: Int -> [Int]
distanciasMasFrecuentes n =
  M.keys (M.filter (==m) d)
  where d = dicDistancias n
        m = maximum (M.elems d)
 
-- La propiedad es
prop_distanciasMasFrecuentes :: Int -> Bool
prop_distanciasMasFrecuentes n =
  distanciasMasFrecuentes (161 + abs n) == [6]
Medio

6 soluciones de “Distancias entre primos consecutivos

  1. albcercid
    import Data.Numbers.Primes
    import qualified Data.Map as M
    import Graphics.Gnuplot.Simple
     
    cuentaDistancias        :: Int -> [(Int,Int)]
    cuentaDistancias n = M.toList (crL (M.fromList []) t)
       where t = zipWith f (tail p) (init p)
             p = take n primes
             f x y = x-y
             crL d [] = d
             crL d (a:xs) = crL (M.insertWith (+) a 1 d) xs
     
    frecuenciasDistancias   :: Int -> [(Int,Float)]
    frecuenciasDistancias n = map f (cuentaDistancias n)
        where f (x,y) = (x,100.0*fromIntegral y/fromIntegral (n-1))
     
    graficas                :: [Int] -> IO ()
    graficas xs = plotLists [Key Nothing] (map frecuenciasDistancias xs)
     
    distanciasMasFrecuentes :: Int -> [Int]
    distanciasMasFrecuentes n = map fst (filter ((== (maximum $ map snd t)).snd) t)
          where t = cuentaDistancias n
  2. glovizcas
    cuentaDistancias :: Int -> [(Int,Int)]
    cuentaDistancias n = [(a, cuenta a (diferencias n)) |a <- xs]
                 where xs = (map head(group (sort(diferencias n))))
     
    diferencias n = zipWith (-) (tail (take n $ primes))(take n $ primes)
     
    cuenta n [] = 0
    cuenta n (x:xs) | x == n = 1 + cuenta n xs
                    | otherwise = cuenta n xs
     
     
    frecuenciasDistancias :: Int -> [(Int,Float)]
    frecuenciasDistancias n = [(a, (f(cuenta a (diferencias n))*100.0 / f(total n))) | a <- xs]
             where f = fromIntegral
                   total n =  sum (map snd (cuentaDistancias n))
                   xs = (map head(group (sort(diferencias n))))
     
    graficas :: [Int] -> IO ()
    graficas ns = plotLists [Key Nothing] (map frecuenciasDistancias ns)
  3. enrnarbej
    import Data.List
    import Data.Numbers.Primes
    import Graphics.Gnuplot.Simple
    import Data.Function
    import Test.QuickCheck
     
    cuentaDistancias        :: Int -> [(Int,Int)]
    cuentaDistancias n =  (map (x -> (head x, length x)) . group . sort . take (n-1) . zipWith (-) (tail primes)) primes
     
    frecuenciasDistancias   :: Int -> [(Int,Float)]
    frecuenciasDistancias n = ((x,y) -> (x,f y n)) <$> cuentaDistancias n
                            where
                             f x y = fromIntegral x / fromIntegral (y-1) * 100
     
    graficas                :: [Int] -> IO ()
    graficas = plotLists [Key Nothing] . map frecuenciasDistancias
     
    distanciasMasFrecuentes :: Int -> [Int]
    distanciasMasFrecuentes = map fst . last . groupBy ((==) `on` snd) . sortBy (compare `on` snd) . frecuenciasDistancias
     
    prop_frecuencias :: Int -> Bool
    prop_frecuencias n = distanciasMasFrecuentes (abs n + 161) == [6]
     
    -- *Main> quickCheck prop_frecuencias
    -- +++ OK, passed 100 tests
  4. monlagare
     
    cuentaDistancias        :: Int -> [(Int,Int)]
    cuentaDistancias n = [(a,b) | (a,b) <- zip (nub ys) zs]
              where xs = zipWith (-) (take n primes) (tail (take n primes))
                    ys = sort (map abs xs)
                    zs =  map (length) (group ys)
     
    frecuenciasDistancias   :: Int -> [(Int,Float)]
    frecuenciasDistancias n = [(a,(fromIntegral b)*100.0/fromIntegral d)
                              | (a,b) <- zip xs ys]
                where xs = map (fst) (cuentaDistancias n)
                      ys = map (snd) (cuentaDistancias n)
                      d = sum ys
     
    graficas55                :: [Int] -> IO ()
    graficas55 xs = plotLists [Key Nothing] (map frecuenciasDistancias xs)
     
    distanciasMasFrecuentes :: Int -> [Int]
    distanciasMasFrecuentes n = map fst (filter ((== (maximum (map snd xs))).snd) xs)          where xs = cuentaDistancias n
  5. margarflo5
     
    import Data.Numbers.Primes
    import Data.List
    import Graphics.Gnuplot.Simple
     
    cuentaDist :: [Int] -> [Int]
    cuentaDist [] = []
    cuentaDist [x] = []
    cuentaDist (x:y:xs) = abs (x-y) : cuentaDist (y:xs)
     
    cuentaDistancias :: Int -> [(Int,Int)]
    cuentaDistancias n = zip xs ys 
          where xs = nub ws
                ys = map length (group ws)
                zs = take n primes
                ws = sort (cuentaDist zs)
     
    frecuenciasDist :: Int -> [Float]
    frecuenciasDist n = map (*100) $ map (/m ) ys
      where xs = map snd $ cuentaDistancias n
            ys = map fromIntegral xs
            m =  fromIntegral (n-1)
     
    frecuenciasDistancias :: Int -> [(Int , Float)]
    frecuenciasDistancias n = zip xs (frecuenciasDist n)
      where xs = map fst $ cuentaDistancias n
     
    graficas :: [Int] -> IO ()
    graficas ns = plotLists [Key Nothing] (map frecuenciasDistancias ns)
     
    distanciasMasFrecuentes :: Int -> [Int]
    distanciasMasFrecuentes n =
      [x | (x, y) <- xs , y == maximum (map snd xs)]
      where xs = frecuenciasDistancias n
  6. marlobrip
    import Data.Numbers.Primes
    import Graphics.Gnuplot.Simple
     
    cuentaDistancias :: Int -> [(Int,Int)]
    cuentaDistancias n =
      [(n,apariciones n d) | n <- [1..maximum d], apariciones n d /= 0]
              where d = distancia e
                    e = take n primes
     
    frecuenciasDistancias :: Int -> [(Int,Float)]
    frecuenciasDistancias n = map f (cuentaDistancias n)
        where f (x,y) = (x, 100*(fromIntegral y)/(fromIntegral (n-1)))
     
    graficas  :: [Int] -> IO ()
    graficas xs = plotLists [Key Nothing] (map frecuenciasDistancias xs)          
     
    distanciasMasFrecuentes :: Int -> [Int]        
    distanciasMasFrecuentes n = [ x | (x,y) <- cuentaDistancias n , y == maximum h ]
         where h = map snd (cuentaDistancias n)
     
     
    apariciones :: Int -> [Int] -> Int
    apariciones n (x:xs) | n == x = 1 + apariciones n xs
                         | otherwise = apariciones n xs
    apariciones  _ [] = 0
     
    distancia :: [Int] -> [Int]
    distancia (x:y:xs) = abs (x-y) : distancia (y:xs)
    distancia [x] = []

Escribe tu solución

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.