Menu Close

Huecos de Aquiles

Un número de Aquiles es un número natural n que es potente (es decir, si p es un divisor primo de n, entonces p² también lo es) y no es una potencia perfecta (es decir, no existen números naturales m y k tales que n es igual a m^k). Por ejemplo,

  • 108 es un número de Aquiles proque es un número potente (ya que su factorización es 2^2 · 3^3, sus divisores primos son 2 and 3 y sus cuadrados (2^2 = 4 y 3^2 = 9) son divisores de 108. Además, 108 no es una potencia perfecta.
  • 360 no es un número de Aquiles ya que 5 es un divisor primo de 360, pero 5^2 = 15 no lo es.
  • 784 no es un número de Aquiles porque, aunque es potente, es una potencia perfecta ya que 784 = 28^2.

Los primeros números de Aquiles son

   72, 108, 200, 288, 392, 432, 500, 648, 675, 800, 864, 968, 972, ...

Definir las funciones

   esAquiles              :: Integer -> Bool
   huecosDeAquiles        :: [Integer]
   graficaHuecosDeAquiles :: Int -> IO ()

tales que

  • (esAquiles x) se verifica si x es un número de Aquiles. Por ejemplo,
     esAquiles 108         ==  True
     esAquiles 360         ==  False
     esAquiles 784         ==  False
     esAquiles 5425069447  ==  True
     esAquiles 5425069448  ==  True
  • huecosDeAquiles es la sucesión de la diferencias entre los números de Aquiles consecutivos. Por ejemplo,
     λ> take 15 huecosDeAquiles
     [36,92,88,104,40,68,148,27,125,64,104,4,153,27,171]
  • (graficaHuecosDeAquiles n) dibuja la gráfica de los n primeros huecos de Aquiles. Por ejemplo, (graficaHuecosDeAquiles 160) dibuja

Soluciones

import Data.List (group)
import Data.Numbers.Primes (primeFactors)
import Graphics.Gnuplot.Simple
 
-- Definición de esAquiles
-- =======================
 
esAquiles :: Integer -> Bool
esAquiles x = esPotente x && noEsPotenciaPerfecta x
 
-- (esPotente x) se verifica si x es potente. Por ejemplo,
--    esPotente 108  ==  True
--    esPotente 360  ==  False
--    esPotente 784  ==  True
esPotente :: Integer -> Bool
esPotente x = all (>1) (exponentes x)
 
-- (exponentes x) es la lista de los exponentes en la factorización de
-- x. Por ejemplo,
--    exponentes 108  ==  [2,3]
--    exponentes 360  ==  [3,2,1]
--    exponentes 784  ==  [4,2]
exponentes :: Integer -> [Int]
exponentes x = map length (group (primeFactors x))
 
-- (noEsPotenciaPerfecta x) se verifica si x no es una potencia
-- perfecta. Por ejemplo,
--    noEsPotenciaPerfecta 108  ==  True
--    noEsPotenciaPerfecta 360  ==  True
--    noEsPotenciaPerfecta 784  ==  False
noEsPotenciaPerfecta :: Integer -> Bool
noEsPotenciaPerfecta x = foldl1 gcd (exponentes x) == 1 
 
-- Definición de huecosDeAquiles
-- =============================
 
huecosDeAquiles :: [Integer]
huecosDeAquiles = zipWith (-) (tail aquiles) aquiles
 
-- aquiles es la sucesión de los números de Aquiles. Por ejemplo, 
--    λ> take 15 aquiles
--    [72,108,200,288,392,432,500,648,675,800,864,968,972,1125,1152]
aquiles :: [Integer]
aquiles = filter esAquiles [2..]
 
-- Definición de graficaHuecosDeAquiles
-- ====================================
 
graficaHuecosDeAquiles :: Int -> IO ()
graficaHuecosDeAquiles n =
  plotList [ Key Nothing
           , PNG "Huecos_de_Aquiles.png"
           ]
           (take n huecosDeAquiles)

Pensamiento

Tengo a mis amigos
en mi soledad;
cuando estoy con ellos
¡qué lejos están!

Antonio Machado

Avanzado

5 soluciones de “Huecos de Aquiles

  1. frahidzam
    esAquiles :: Integer -> Bool
    esAquiles n = minimum xs > 1 && gcdL xs == 1
      where xs = map length $ group $ primeFactors n
            gcdL = foldl1 gcd
     
    huecosDeAquiles :: [Integer]
    huecosDeAquiles = restaDos [a | a <- [2..], esAquiles a]
     
    restaDos :: [Integer] -> [Integer]
    restaDos (x:y:xs) = (y-x):restaDos (y:xs)
     
    graficaHuecosDeAquiles :: Int -> IO ()
    graficaHuecosDeAquiles n = plotList [Key Nothing] (take n huecosDeAquiles)
  2. adogargon
    esAquiles :: Integer -> Bool
    esAquiles x = (all (>1) ys) && mcd (nub ys) == 1
      where ys = map length ( group ( primeFactors x))
     
    mcd :: [Int] -> Int
    mcd xs = foldl1 gcd xs
     
    huecosDeAquiles  :: [Integer]
    huecosDeAquiles = map ((x,y)->y-x) (zip xs (tail xs))
      where xs = filter esAquiles [2..]
     
    graficaHuecosDeAquiles :: Int -> IO ()
    graficaHuecosDeAquiles n = plotList [] (take n huecosDeAquiles)
  3. luipromor
    esAquiles              :: Integer -> Bool
    esAquiles n = and [ mod n (x^2) == 0 | x <-  nub (primeFactors n)] && aux  n
      where aux y = mcd (exponentes y) <= 1
            mcd = foldl1 gcd
            exponentes y = map length $ group ( primeFactors y)
     
    huecosDeAquiles        :: [Integer]
    huecosDeAquiles = [ y -x | (x,y) <- zip aquiles (tail aquiles)] 
      where aquiles = filter esAquiles [2..]
     
    graficaHuecosDeAquiles :: Int -> IO ()
    graficaHuecosDeAquiles n = plotList [] $ take n huecosDeAquiles
  4. javmarcha1
    import Data.Numbers.Primes
    import Data.List
    import Graphics.Gnuplot.Simple
     
    esAquiles :: Integer -> Bool
    esAquiles x = and(map (>1) d) && or(map (odd) d) && length(nub(primeFactors x)) /= 1 && length(nub d) /= 1
       where d = [ length xs | xs <- group(primeFactors x)]
     
    numerosDeAquiles :: [Integer]
    numerosDeAquiles = [ x | x <- [1..], esAquiles x]
     
    huecosDeAquiles :: [Integer]
    huecosDeAquiles = [ x-y | (x,y) <- zip (tail numerosDeAquiles) (numerosDeAquiles)]
     
    graficaHuecosDeAquiles :: Int -> IO ()
    graficaHuecosDeAquiles n = plotList [] (take n huecosDeAquiles)
  5. danmorper2

    import Data.List
    import Data.Numbers.Primes
    import Graphics.Gnuplot.Simple
    
    lapotensialoko :: Integer -> Bool
    lapotensialoko 1 = False
    lapotensialoko n = aux (group (primeFactors n))
    
    aux :: [[Integer]]-> Bool
    aux (xs:xss) | (length xs)>=2 && (null xss)=True
                      | (length xs)>=2 =True && (aux xss)
                      | otherwise=False
    lista :: Integer -> [(Integer,Integer)]
    lista n =[(x,y) | x<-[2..d], y<-[2..z]]
      where
        z=round (logBase (fromIntegral 2) (fromIntegral n))
        d=round (sqrt (fromIntegral n))
    perfesto :: Integer -> Bool
    perfesto 1= True
    perfesto n= esono xs n
      where
        xs=takeWhile (\(x,y)-> (fst (x,y))<n) (lista n)
    esono (x:xs) n | a^b==n = True
                           | a^b==n && (null xs) = True
                           | null xs=False
                           | otherwise = False || (esono xs n)
      where
        a=fst x
        b= snd x
    esAquiles :: Integer -> Bool
    esAquiles n=(lapotensialoko n)&&(not (perfesto n))
    
    numeros = [x | x<-[0..], esAquiles x]
    
    huecosDeAquiles :: [Integer]
    huecosDeAquiles = [ abs (x-y) | (x,y)<-xs]
      where
        xs=zip (numeros) (tail(numeros))
    graficaHuecosDeAquiles :: Int -> IO ()
    graficaHuecosDeAquiles n = plotList [Key Nothing] (take n huecosDeAquiles)
    

Escribe tu solución

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