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

PorJosé A. Alonso 3-marzo-201525-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]]

4 Comentarios

productos :: Int -> Int -> [[Int]]
productos n k=  [xs| xs<-map (take n) (tails [1..k]), product xs== k, length xs == n]

1 2	productos :: Int -> Int -> [[Int]] productos n k= [xs\| xs<-map (take n) (tails [1..k]), product xs== k, length xs == n]

Responder

Aquí dejo el ejercicio completo.

import Test.QuickCheck
import Data.List (tails)

productos :: Integer -> Integer -> [[Integer]]
productos n k =  [xs | xs <- map (take n') (tails [1..k]), 
                       product xs == k, 
                       length xs == n']
    where n' = fromIntegral n
 
productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos = 
    [x | x <- [1..],
         not (null (productos 2 x)) && not (null (productos 3 x))]
 
propiedad :: Integer -> Integer -> Property
propiedad n x = n /= 0 && x /= 0 ==> 
                productos n' (product [x'..x'+n'-1]) == [[x'..x'+n'-1]]
    where n' = abs n
          x' = abs x

import Test.QuickCheck

import Data.List (tails)

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

productos n k = [xs | xs <- map (take n') (tails [1..k]),

product xs == k,

length xs == n']

where n' = fromIntegral n

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos =

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

not (null (productos 2 x)) && not (null (productos 3 x))]

propiedad :: Integer -> Integer -> Property

propiedad n x = n /= 0 && x /= 0 ==>

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

where n' = abs n

x' = abs x

Responder

import Test.QuickCheck

productos :: Integer -> Integer -> [[Integer]]
productos n m = [[z..z+n-1] | z <- [1..x], product[z..z+n-1] == m]
    where x = head $ filter (\y -> y^n >= m) [2..] 
 
prop_productos :: Integer -> Integer -> Property
prop_productos n x = 
    n > 0 && x > 0 ==>
    productos n (product [x..x+n-1]) == [[x..x+n-1]]
 
-- Comprobación
--    *Main> quickCheck prop_productos
--    +++ OK, passed 100 tests.
 
productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos = filter f [1..]
    where f n = (not.null) (productos 2 n) && (not.null) (productos 3 n)

import Test.QuickCheck

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

productos n m = [[z..z+n-1] | z <- [1..x], product[z..z+n-1] == m]

where x = head $ filter (\y -> y^n >= m) [2..]

prop_productos :: Integer -> Integer -> Property

prop_productos n x =

n > 0 && x > 0 ==>

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

-- Comprobación

-- *Main> quickCheck prop_productos

-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos = filter f [1..]

where f n = (not.null) (productos 2 n) && (not.null) (productos 3 n)

Responder

import Test.QuickCheck

productos :: Integer -> Integer -> [[Integer]]
productos n x
    | x == product l = [l]
    | otherwise = []
    where l = last $ takeWhile (\y -> product y <= x) (aux n [1..])
          aux n (k:ks) = take (fromIntegral n) (k:ks) : aux n ks

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

-- La comprobación es
-- *Main> quickCheck prop_productos
-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]
productosDe2y3consecutivos = take 2 [n | n <- [3..], prodDe2y3consec n]
    where prodDe2y3consec n = and [not (null (productos k n)) | k <- [2,3]]

-- El cálculo es
-- *Main> productosDe2y3consecutivos
-- [6,210]

import Test.QuickCheck

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

productos n x

| x == product l = [l]

| otherwise = []

where l = last $ takeWhile (\y -> product y <= x) (aux n [1..])

aux n (k:ks) = take (fromIntegral n) (k:ks) : aux n ks

-- La propiedad es

prop_productos :: Integer -> Integer -> Property

prop_productos n x =

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

-- La comprobación es

-- *Main> quickCheck prop_productos

-- +++ OK, passed 100 tests.

productosDe2y3consecutivos :: [Integer]

productosDe2y3consecutivos = take 2 [n | n <- [3..], prodDe2y3consec n]

where prodDe2y3consec n = and [not (null (productos k n)) | k <- [2,3]]

-- El cálculo es

-- *Main> productosDe2y3consecutivos

-- [6,210]

Responder

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

Soluciones

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico