Menu Close

Sucesión de números parientes

Se dice que dos números naturales son parientes sitienen exactamente un factor primo en común, independientemente de su multiplicidad. Por ejemplo,

  • Los números 12 (2²·3) y 40 (2³·5) son parientes, pues tienen al 2 como único factor primo en común.
  • Los números 49 (7²) y 63 (3²·7) son parientes, pues tienen al 7 como único factor primo en común.
  • Los números 12 (2²·3) y 30 (2·3·5) no son parientes, pues tienen dos factores primos en común.
  • Los números 49 (7²) y 25 (5²) no son parientes, pues no tienen factores primos en común.

Se dice que una lista de números naturales es una secuencia de parientes si cada par de números consecutivos son parientes. Por ejemplo,

  • La lista [12,40,35,28] es una secuencia de parientes.
  • La lista [12,30,21,49] no es una secuencia de parientes.

Definir la función

   secuenciaParientes :: [Integer] -> Bool

tal que (secuenciaParientes xs) se verifica si xs es una secuencia de parientes. Por ejemplo,

   secuenciaParientes [12,40,35,28]           ==  True
   secuenciaParientes [12,30,21,49]           ==  False
   secuenciaParientes [2^n | n <- [1..2000]]  ==  True

Soluciones

import Data.List (intersect, nub)
import Data.Numbers.Primes (primes, primeFactors)
 
-- (parientes x y) se verifica si x e y son parientes. Por ejemplo,
--    parientes 12 40  ==  True
--    parientes 49 63  ==  True
--    parientes 12 30  ==  False
--    parientes 49 25  ==  False
 
-- 1ª definición (con gcd)
parientes1 :: Integer -> Integer -> Bool
parientes1 x y =
    length [p | p <- takeWhile (<= d) primes, d `mod` p == 0] == 1 
    where d = gcd x y
 
-- 2ª definición (con primeFactors)
parientes2 :: Integer -> Integer -> Bool
parientes2 0 0 = False
parientes2 x y = 
    length (nub (primeFactors x `intersect` primeFactors y)) == 1
 
-- Comparación de eficiencia
--    ghci> parientes1 (2^25) (2^25)
--    True
--    (34.34 secs, 15974866184 bytes)
--    ghci> parientes2 (2^25) (2^25)
--    True
--    (0.01 secs, 3093024 bytes)
 
-- Usaremos la 2ª definición
parientes :: Integer -> Integer -> Bool
parientes = parientes2
 
-- Definiciones de secuenciaParientes 
-- ==================================
 
-- 1ª definición (por recursión)
secuenciaParientes :: [Integer] -> Bool
secuenciaParientes []         = True
secuenciaParientes [x]        = True
secuenciaParientes (x1:x2:xs) =
    parientes x1 x2 && secuenciaParientes (x2:xs)
 
-- 2ª definición (por recursión con 2 ecuaciones)
secuenciaParientes2 :: [Integer] -> Bool
secuenciaParientes2 (x1:x2:xs) =
    parientes x1 x2 && secuenciaParientes2 (x2:xs)
secuenciaParientes2 _         = True
 
-- 3ª definición (sin recursión):
secuenciaParientes3 :: [Integer] -> Bool
secuenciaParientes3 xs = all (\(x,y) -> parientes x y) (zip xs (tail xs)) 
 
-- 4ª definición
secuenciaParientes4 :: [Integer] -> Bool
secuenciaParientes4 xs = all (uncurry parientes) (zip xs (tail xs))
Inicial

4 soluciones de “Sucesión de números parientes

  1. Jesús Navas Orozco
    import Data.List (intersect, group)
    import Data.Numbers.Primes (primeFactors)
     
    secuenciaParientes :: [Integer] -> Bool
    secuenciaParientes xs = aux xs
        where aux [x] = True
              aux (x:y:xs) = length (group (intersect (primeFactors x) (primeFactors y)))==1 
                             && aux (y:xs)
    • Jesús Navas Orozco
      import Data.List (intersect, nub)
      import Data.Numbers.Primes (primeFactors)
       
      secuenciaParientes :: [Integer] -> Bool
      secuenciaParientes []                   = True
      secuenciaParientes [_]                  = True
      secuenciaParientes (x:y:xs) | ys == [0] = False
                                  | otherwise = length (nub ys) ==1 && 
                                                secuenciaParientes (y:xs)
          where ys = intersect (primeFactors x) (primeFactors y)
      • Jesús Navas Orozco
        secuenciaParientes :: [Integer] -> Bool
        secuenciaParientes (x:y:xs)| ys == [0] = False
                                   | otherwise = length (nub ys) ==1 && secuenciaParientes (y:xs)
               where ys = intersect (primeFactors x) (primeFactors y)
        secuenciaParientes _ = True
  2. Pedro Martín Chávez
    import Data.List (intersect, group)
    import Data.Numbers.Primes (primeFactors)
     
    secuenciaParientes :: [Integer] -> Bool
    secuenciaParientes p@(x:xs) = and [parientes x y | (x,y) <- zip p xs]
        where parientes x y =
                  1 == (length $ group $ intersect (primeFactors x) (primeFactors y))

Escribe tu solución

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