Productos simultáneos de dos y tres números consecutivos

PorJosé A. Alonso 25-abril-201625-abril-2021

Definir la función

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

1	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     ==  []

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]]

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

Usando productos, definir la función

   productosDe2y3consecutivos :: [Integer]

1	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

1	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
-- =============

-- Se puede reducir el intervalo de búsqueda teniendo en cuenta las
-- siguientes desigualdades
--    y*(y+1)* ... (y+n-1) = x
--    y^n <= x <= (y+n-1)^n
--    y <= x^(1/n), x^(1/n)-n+1 <= y
--    x^(1/n)-n+1 <= y <= x^(1/n)

productos2 :: Integer -> Integer -> [[Integer]]
productos2 n x = [[z..z+n-1] | z <- [y-n+1..y],
                               product [z..z+n-1] == x]
    where y = floor ((fromIntegral x)**(1/(fromIntegral n)))

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
--    ghci> quickCheck prop_productos
--    +++ OK, passed 100 tests.
--    (0.10 secs, 26409644 bytes)

productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos = [x| x <- [1..], 
                                 let ys = productos 2 x,
                                 not (null ys), 
                                 let zs = productos 3 x,
                                 not (null zs)] 

-- El cálculo es
--    ghci> take 2 productosDe2y3consecutivos
--    [6,210]
--    ghci> productos 2 210
--    [[14,15]]
--    ghci> productos 3 210
--    [[5,6,7]]

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

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

-- Se puede reducir el intervalo de búsqueda teniendo en cuenta las

-- siguientes desigualdades

-- y*(y+1)* ... (y+n-1) = x

-- y^n <= x <= (y+n-1)^n

-- y <= x^(1/n), x^(1/n)-n+1 <= y

-- x^(1/n)-n+1 <= y <= x^(1/n)

productos2 :: Integer -> Integer -> [[Integer]]

productos2 n x = [[z..z+n-1] | z <- [y-n+1..y],

product [z..z+n-1] == x]

where y = floor ((fromIntegral x)**(1/(fromIntegral n)))

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

-- ghci> quickCheck prop_productos

-- +++ OK, passed 100 tests.

-- (0.10 secs, 26409644 bytes)

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos = [x| x <- [1..],

let ys = productos 2 x,

not (null ys),

let zs = productos 3 x,

not (null zs)]

-- El cálculo es

-- ghci> take 2 productosDe2y3consecutivos

-- [6,210]

-- ghci> productos 2 210

-- [[14,15]]

-- ghci> productos 3 210

-- [[5,6,7]]

10 Comentarios

import Data.List
import Test.QuickCheck

productos :: Integer -> Integer -> [[Integer]]
productos  n x = 
    [xs | xs <- consecutivosMenores x, 
          genericLength xs == n,
          product xs == x]

consecutivosMenores ::Integer-> [[Integer]]
consecutivosMenores x = 
    [xs | xs <- subsequences ys , 
          xs `isInfixOf` ys]
    where ys = takeWhile (<=x) [1..]

prop_producto ::Integer->Integer->Property
prop_producto n x =
    n > 0 && x > 0 ==> 
      productos n (product [x..x+n-1]) == [[x..x+n-1]]

-- ghci> quickCheckWith (stdArgs {maxSize=3}) prop_producto
--- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos = 
    [x | x <- [1..], 
         not (null (productos 2 x)),
         not (null (productos 3 x))]

import Data.List

import Test.QuickCheck

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

productos n x =

[xs | xs <- consecutivosMenores x,

genericLength xs == n,

product xs == x]

consecutivosMenores ::Integer-> [[Integer]]

consecutivosMenores x =

[xs | xs <- subsequences ys ,

xs `isInfixOf` ys]

where ys = takeWhile (<=x) [1..]

prop_producto ::Integer->Integer->Property

prop_producto n x =

n > 0 && x > 0 ==>

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

-- ghci> quickCheckWith (stdArgs {maxSize=3}) prop_producto

--- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos =

[x | x <- [1..],

not (null (productos 2 x)),

not (null (productos 3 x))]

Responder

productos :: Integer -> Integer -> [[Integer]]
productos n x = 
    [ xs | xs <- listaConsecutivas' n x, 
           product xs == x, 
           genericLength xs == n ]

listaConsecutivas' :: (Enum t, Eq a, Num t, Num a) => a -> t -> [[t]]
listaConsecutivas' n y = [listaConsecutivas x n | x <- [1..y]]

listaConsecutivas :: (Eq a, Num t, Num a) => t -> a -> [t]
listaConsecutivas _ 0 = []
listaConsecutivas x 1 = [x]
listaConsecutivas x n = x : listaConsecutivas (x+1) (n-1)

prop_productos :: Integer -> Integer -> Property
prop_productos n x = 
    n > 0 && x > 0 ==> productos n (product [x..x+n-1]) == [[x..x+n-1]]

-- *Main> quickCheckWith (stdArgs {maxSize=3}) prop_productos
-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos = 
    [x | x <- [1..], not (null (productos 2 x)), not (null (productos 3 x))]

-- *Main> head productosDe2y3consecutivos
-- 6

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

productos n x =

[ xs | xs <- listaConsecutivas' n x,

product xs == x,

genericLength xs == n ]

listaConsecutivas' :: (Enum t, Eq a, Num t, Num a) => a -> t -> [[t]]

listaConsecutivas' n y = [listaConsecutivas x n | x <- [1..y]]

listaConsecutivas :: (Eq a, Num t, Num a) => t -> a -> [t]

listaConsecutivas _ 0 = []

listaConsecutivas x 1 = [x]

listaConsecutivas x n = x : listaConsecutivas (x+1) (n-1)

prop_productos :: Integer -> Integer -> Property

prop_productos n x =

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

-- *Main> quickCheckWith (stdArgs {maxSize=3}) prop_productos

-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos =

[x | x <- [1..], not (null (productos 2 x)), not (null (productos 3 x))]

-- *Main> head productosDe2y3consecutivos

-- 6

Responder

import Data.Numbers.Primes
import Data.List
import Test.QuickCheck

productos :: Integer -> Integer -> [[Integer]]
productos x n = 
    [z | z <- [genericTake x  (genericDrop p [1..n]) | p <- [0..n-1]],
         product z == n,   
         genericLength z == x]

propiedad :: Integer -> Integer -> Property
propiedad x n = 
    x > 0 && n > 0 ==> productos n (product [x..x+n-1]) == [[x..x+n-1]]

-- λ>  quickCheckWith (stdArgs {maxSize=3}) propiedad
-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos = 
    [n | n <- [1..], productos 2 n /= [], productos 3 n /= []]

import Data.Numbers.Primes

import Data.List

import Test.QuickCheck

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

productos x n =

[z | z <- [genericTake x (genericDrop p [1..n]) | p <- [0..n-1]],

product z == n,

genericLength z == x]

propiedad :: Integer -> Integer -> Property

propiedad x n =

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

-- λ> quickCheckWith (stdArgs {maxSize=3}) propiedad

-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos =

[n | n <- [1..], productos 2 n /= [], productos 3 n /= []]

Responder

-- Observamos que si x se descompone como producto de n enteros consecutivos, 
-- lo hace de forma única; en consecuencia, basta calcular el primer entero 
-- a partir de cuyos n-1 sucesores obtengamos x.
-- Utilizando funciones recursivas y distinguiendo casos para facilitar el 
-- cálculo:

productos :: Integer -> Integer -> [[Integer]]
productos n x 
    | n == 1    = [[x]]
    | odd x     = []
    | null xs   = []
    | otherwise = [consecutivos n (head xs)]
    where xs = [y | y <- [1..div x n], 
                    div (f (y+n-1)) (f (y-1)) == x]
          f = factorial

consecutivos :: Integer -> Integer -> [Integer]
consecutivos 0 _ = []
consecutivos n y = y : consecutivos (n-1) (y+1)

factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n-1)

prop_productosNconsecutivos :: Integer -> Integer -> Property
prop_productosNconsecutivos n x = 
    n > 0 && x > 0 ==> 
      productos n (product [x..x+n-1]) == [[x..x+n-1]]

productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos = 
    [x | x <- [1..], p (productos 2 x) && p (productos 3 x)]
    where p = not . null

-- Observamos que si x se descompone como producto de n enteros consecutivos,

-- lo hace de forma única; en consecuencia, basta calcular el primer entero

-- a partir de cuyos n-1 sucesores obtengamos x.

-- Utilizando funciones recursivas y distinguiendo casos para facilitar el

-- cálculo:

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

productos n x

| n == 1 = [[x]]

| odd x = []

| null xs = []

| otherwise = [consecutivos n (head xs)]

where xs = [y | y <- [1..div x n],

div (f (y+n-1)) (f (y-1)) == x]

f = factorial

consecutivos :: Integer -> Integer -> [Integer]

consecutivos 0 _ = []

consecutivos n y = y : consecutivos (n-1) (y+1)

factorial :: Integer -> Integer

factorial 0 = 1

factorial n = n * factorial (n-1)

prop_productosNconsecutivos :: Integer -> Integer -> Property

prop_productosNconsecutivos n x =

n > 0 && x > 0 ==>

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

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos =

[x | x <- [1..], p (productos 2 x) && p (productos 3 x)]

where p = not . null

Responder

import Data.List
import Test.QuickCheck

productos :: Integer -> Integer -> [[Integer]]
productos n x = 
    filter (\zs -> genericLength zs == n) 
           $ aux (takeWhile (<= x) $ iterate (1+) 1)
    where aux [] = []
          aux xs | product (genericTake n xs) == x = 
                     (genericTake n xs) : aux (tail xs)
                 | otherwise = aux (tail 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]]

-- quickCheckWith (stdArgs {maxSize=3}) prop_productos
-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos = 
    [x | x <- [1..], productos 2 x /= [], productos 3 x /= []]

-- *Main>  head productosDe2y3consecutivos
-- 6

import Data.List

import Test.QuickCheck

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

productos n x =

filter (\zs -> genericLength zs == n)

$ aux (takeWhile (<= x) $ iterate (1+) 1)

where aux [] = []

aux xs | product (genericTake n xs) == x =

(genericTake n xs) : aux (tail xs)

| otherwise = aux (tail 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]]

-- quickCheckWith (stdArgs {maxSize=3}) prop_productos

-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos =

[x | x <- [1..], productos 2 x /= [], productos 3 x /= []]

-- *Main> head productosDe2y3consecutivos

-- 6

Responder

import Test.QuickCheck

productos :: Integer -> Integer -> [[Integer]]
productos n k = busca k [1..n] [n+1..]
  where busca :: Integer -> [Integer] -> [Integer] -> [[Integer]]
        busca k xs@(_:zs) (y:ys) | p > k     = []
                                 | p == k    = [xs]
                                 | otherwise = busca k (zs ++ [y]) ys
          where p = product xs

prop_prod :: (Positive Integer) -> (Positive Integer) -> Bool
prop_prod (Positive n) (Positive x) =
     productos n (product [x..x+n-1]) == [[x..x+n-1]]
--     λ> quickCheck prop_prod
--     +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos =
    [x | x <- [1..], (not . null) (productos 2 x),
                     (not . null) (productos 3 x)]
--     λ> head productosDe2y3consecutivos  ==  6
--     True

import Test.QuickCheck

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

productos n k = busca k [1..n] [n+1..]

where busca :: Integer -> [Integer] -> [Integer] -> [[Integer]]

busca k xs@(_:zs) (y:ys) | p > k = []

| p == k = [xs]

| otherwise = busca k (zs ++ [y]) ys

where p = product xs

prop_prod :: (Positive Integer) -> (Positive Integer) -> Bool

prop_prod (Positive n) (Positive x) =

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

-- λ> quickCheck prop_prod

-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos =

[x | x <- [1..], (not . null) (productos 2 x),

(not . null) (productos 3 x)]

-- λ> head productosDe2y3consecutivos == 6

-- True

Responder

Por simple curiosidad, una pequeña comprobación de la demostración de Mordell.

--     λ> take 2 (productosDe2y3consecutivos)
--     [6,210]

--     λ> take 3 (productosDe2y3consecutivos)
--     [6,210Interrupted.

prop_Mordell :: (Positive Integer) -> Bool
prop_Mordell (Positive 6)   = True
prop_Mordell (Positive 210) = True
prop_Mordell (Positive x)   =
      null (productos 2 x) || null (productos 3 x)
--     λ> quickCheck prop_Mordell
--     +++ OK, passed 100 tests.

-- λ> take 2 (productosDe2y3consecutivos)

-- [6,210]

-- λ> take 3 (productosDe2y3consecutivos)

-- [6,210Interrupted.

prop_Mordell :: (Positive Integer) -> Bool

prop_Mordell (Positive 6) = True

prop_Mordell (Positive 210) = True

prop_Mordell (Positive x) =

null (productos 2 x) || null (productos 3 x)

-- λ> quickCheck prop_Mordell

-- +++ OK, passed 100 tests.

Responder

import Test.QuickCheck

productos :: Integer -> Integer -> [[Integer]]
productos n x = [take (fromIntegral n) (iterate (+1) y)| y<- [1..x],
                 product (take (fromIntegral n) (iterate (+1) y)) == x]

prop_productos :: Integer -> Integer -> Property
prop_productos n x = n>0 && x>0 ==> productos n (product [x..x+n-1]) ==
                     [[x..x+n-1]]

-- *Main> quickCheckWith (stdArgs {maxSize=3}) prop_productos
-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos = [x | x <- [1..], productos 2 x /= [] &&
                                       productos 3 x /= []]

-- *Main>  head productosDe2y3consecutivos
-- 6

import Test.QuickCheck

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

productos n x = [take (fromIntegral n) (iterate (+1) y)| y<- [1..x],

product (take (fromIntegral n) (iterate (+1) y)) == x]

prop_productos :: Integer -> Integer -> Property

prop_productos n x = n>0 && x>0 ==> productos n (product [x..x+n-1]) ==

[[x..x+n-1]]

-- *Main> quickCheckWith (stdArgs {maxSize=3}) prop_productos

-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos = [x | x <- [1..], productos 2 x /= [] &&

productos 3 x /= []]

-- *Main> head productosDe2y3consecutivos

-- 6

Responder

productos :: Integer -> Integer -> [[Integer]]
productos n x = lista v x ys
    where ys = [1..]
          v = fromIntegral n

lista _ _ [] = []
lista n x (y:ys) 
    | product (take n (y:ys)) == x = (take n (y:ys)) : (lista n x ys)
    | product (take n (y: ys)) < x = lista n x ys
    | otherwise                    = []

productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos = 
    [x | x<-[1..], (productos 2 x) /= [] && (productos 3 x) /=[]]

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

productos n x = lista v x ys

where ys = [1..]

v = fromIntegral n

lista _ _ [] = []

lista n x (y:ys)

| product (take n (y:ys)) == x = (take n (y:ys)) : (lista n x ys)

| product (take n (y: ys)) < x = lista n x ys

| otherwise = []

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos =

[x | x<-[1..], (productos 2 x) /= [] && (productos 3 x) /=[]]

Responder

productos :: Integer -> Integer -> [[Integer]]
productos 1 n = [[n]]
productos m n | xss == [] || product xs /= n = []
              | otherwise = [xs]
    where xss = takeWhile (\xs -> product xs <= n) [[a+1..a+m] | a <- [0..]]
          xs = last xss
         
prod2y3 :: [Integer]
prod2y3 = [x | x <- [2..], notElem [] [productos 2 x, productos 3 x]]

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

productos 1 n = [[n]]

productos m n | xss == [] || product xs /= n = []

| otherwise = [xs]

where xss = takeWhile (\xs -> product xs <= n) [[a+1..a+m] | a <- [0..]]

xs = last xss

prod2y3 :: [Integer]

prod2y3 = [x | x <- [2..], notElem [] [productos 2 x, productos 3 x]]

Responder

Productos simultáneos de dos y tres números consecutivos

Soluciones

10 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

10 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico