Menu Close

Productos de dos y tres números consecutivos

Definir la función

   productos :: Integer -> Integer -> [[Integer]]

tal que (productos n x) es las listas de n elementos consecutivos cuyo producto es x. Por ejemplo,

   productos 2 6     ==  [[2,3]]
   productos 3 6     ==  [[1,2,3]]
   productos 4 1680  ==  [[5,6,7,8]]
   productos 2 5     ==  []

Comprobar con QuickCheck que si n > 0 y x > 0, entonces

   productos n (product [x..x+n-1]) == [[x..x+n-1]]

Usando productos, definir la función

   productosDe2y3consecutivos :: [Integer]

cuyos elementos son los números naturales (no nulos) que pueden expresarse simultáneamente como producto de dos y tres números consecutivos. Por ejemplo,

   head productosDe2y3consecutivos  ==  6

Nota. Según demostró Mordell en 1962, productosDe2y3consecutivos sólo tiene dos elementos.

Soluciones

import Test.QuickCheck
 
-- 1ª definición
productos1 :: Integer -> Integer -> [[Integer]]
productos1 n x =
  [[y..y+n-1] | y <- [1..x]
              , product [y..y+n-1] == x]
 
-- 2ª definición
productos2 :: Integer -> Integer -> [[Integer]]
productos2 n x =
  [[z..z+n-1] | z <- [1..y]
              , product [z..z+n-1] == x]
  where y = head (filter (\y -> y^n >= x) [2..])
 
productos :: Integer -> Integer -> [[Integer]]
productos = productos2
 
prop_productos n x =
  n > 0 && x > 0 ==> productos n (product [x..x+n-1]) == [[x..x+n-1]]
 
-- La comprobación es
--    λ> quickCheck prop_productos
--    +++ OK, passed 100 tests.
--    (0.10 secs, 26409644 bytes)
 
productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos =
  [x | x <- [1..] 
     , (not . null) (productos 2 x)
     , (not . null) (productos 3 x)]
 
-- El cálculo es
--    λ> take 2 productosDe2y3consecutivos
--    [6,210]
--    λ> productos 2 210
--    [[14,15]]
--    λ> productos 3 210
--    [[5,6,7]]

Otras soluciones

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

Pensamiento

“El verdadero viaje de descubrimiento no consiste en buscar nuevos paisajes sino en tener nuevos ojos.”

Marcel Proust.

6 soluciones de “Productos de dos y tres números consecutivos

  1. anthormol
    import Test.QuickCheck
     
    productos :: Integer -> Integer -> [[Integer]]
    productos n x = aux (f n x) []
      where aux xs ys
              | length xs < m = ys
              | product (take m xs) == x = aux (drop m xs) ((take m xs) : ys)
              | otherwise = aux (tail xs) ys
            f n x = takeWhile (p -> product (take m [p,p-1..]) <= x) [1..x]
            m = fromIntegral n
     
    prop_productos :: Integer -> Integer -> Property
    prop_productos n x =
      n > 0 && x > 0
      ==>
      productos n (product [x..x+n-1]) == [[x..x+n-1]]
     
    -- λ> quickCheck prop_productos
    -- +++ OK, passed 100 tests; 332 discarded.
     
    productosDe2y3consecutivos :: [Integer]
    productosDe2y3consecutivos =
      [x | x <- [1..], productos 2 x /= [] && productos 3 x /= []]
     
    -- λ> take 2 productosDe2y3consecutivos
    -- [6,210]
  2. Enrique Zubiría
    productos :: Integer -> Integer -> [[Integer]]
    productos n x = productos' n x [1..x]
     
    productos' :: Integer -> Integer -> [Integer] -> [[Integer]]
    productos' n x subLista
      | fromIntegral (length subLista) < n = []
      | product aux == x = [aux]
      | otherwise = productos' n x (tail subLista)
      where aux = take (fromIntegral n::Int) subLista
     
    productosDe2y3consecutivos :: [Integer]
    productosDe2y3consecutivos =
      [x | x <- [1..]
         , productos 2 x /= [] && productos 3 x /= []]
  3. juabaerui
    import Test.QuickCheck
     
    productos :: Integer -> Integer -> [[Integer]]
    productos n x = aux n x 1
      where aux n x m
              | y == x    = xs : aux n x (m+1)
              | y < x     = aux n x (m+1)
              | otherwise = []
              where xs = [m,m+1..m+n-1]
                    y  = product xs
     
    prop_productos :: Integer -> Integer -> Property
    prop_productos n x =
      n > 0 && x > 0
      ==>
      productos n (product [x..x+n-1]) == [[x..x+n-1]]
     
    -- λ> quickCheck prop_productos
    -- +++ OK, passed 100 tests.
     
    productosDe2y3consecutivos :: [Integer]
    productosDe2y3consecutivos =
      [x | x <- [2..],
           not (null (productos 2 x)),
           not (null (productos 3 x))]
  4. Enrique Zubiría

    Había olvidado la propiedad y el cálculo de los dos números que pueden expresarse simultáneamente como producto de dos y tres números consecutivos. Aquí va completo:

    import Test.QuickCheck
     
    productos :: Integer -> Integer -> [[Integer]]
    productos n x = productos' n x [1..x]
     
    productos' :: Integer -> Integer -> [Integer] -> [[Integer]]
    productos' n x subLista
      | fromIntegral (length subLista) < n = []
      | product aux == x                   = [aux]
      | otherwise                          = productos' n x (tail subLista)
      where aux = take (fromIntegral n::Int) subLista
     
    prop_productos :: Integer -> Integer -> Property
    prop_productos n x =
      n > 0 && x > 0
      ==>
      productos n (product lista) == [lista]
      where lista = [x..x+n-1]
     
    productosDe2y3consecutivos :: [Integer]
    productosDe2y3consecutivos =
      [x | x <- [1..],
           productos 2 x /= [] && productos 3 x /= []]
     
    -- *Main> take 2 productosDe2y3consecutivos
    -- [6,210]
  5. jespalgon1
    productos :: Integer -> Integer -> [[Integer]]
    productos n x =
      [[a..(a+n-1)] | a <- [1..(x-n+1)],
                      product [a..(a+n-1)] == x]
     
    productosDe2y3consecutivos :: [Integer]
    productosDe2y3consecutivos =
      [x | x <- [4..],
           not (null (productos 2 x)) &&
           not (null (productos 3 x))]
  6. javjimord
    import Test.QuickCheck
    import Data.List (subsequences)
     
    productos :: Integer -> Integer -> [[Integer]]
    productos n x = [xs | xs <- subsequences [1..x] , consecutivos xs , product xs == x , genericLength xs == n]
     
    consecutivos :: [Integer] -> Bool
    consecutivos [] = True
    consecutivos [_] = True
    consecutivos (x:y:zs)
      | y == x+1 = consecutivos (y:zs)
      | otherwise = False
     
    prop_Productos :: Integer -> Integer -> Property
    prop_Productos n x = n > 0 && x > 0 ==> productos n (product [x..x+n-1]) == [[x..x+n-1]]
     
    productosDe2y3consecutivos :: [Integer]
    productosDe2y3consecutivos = [x | x <- [1..] , (not(null( productos 2 x))) && (not(null( productos 3 x)))]

Escribe tu solución

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