Mayor producto de n dígitos consecutivos de un número

Definir la función

   mayorProducto :: Int -> Integer -> Integer

1	mayorProducto :: Int -> Integer -> Integer

tal que (mayorProducto n x) es el mayor producto de n dígitos consecutivos del número x (suponiendo que x tiene al menos n dígitos). Por ejemplo,

   mayorProducto 2 325                  ==  10
   mayorProducto 5 11111                ==  1
   mayorProducto 5 113111               ==  3
   mayorProducto 5 110111               ==  0
   mayorProducto 5 10151112             ==  10
   mayorProducto 5 101511124            ==  10
   mayorProducto 5 (product [1..1000])  ==  41472

mayorProducto 2 325 == 10

mayorProducto 5 11111 == 1

mayorProducto 5 113111 == 3

mayorProducto 5 110111 == 0

mayorProducto 5 10151112 == 10

mayorProducto 5 101511124 == 10

mayorProducto 5 (product [1..1000]) == 41472

Soluciones

import Data.List (inits, tails)
import Data.Char (digitToInt)

-- 1ª solución
-- ===========

mayorProducto1 :: Int -> Integer -> Integer
mayorProducto1 n x = 
    maximum [product xs | xs <- segmentos n (cifras x)]

-- (cifras x) es la lista de las cifras del número x, de derecha a
-- izquierda. Por ejemplo, 
--    cifras 325  ==  [5,2,3]
cifras :: Integer -> [Integer]
cifras x 
    | x < 10    = [x]
    | otherwise = r : cifras q
    where (q,r) = quotRem x 10

-- (segmentos n xs) es la lista de los segmentos de longitud n de la
-- lista xs. Por ejemplo,
--    segmentos 2 [3,5,4,6]  ==  [[3,5],[5,4],[4,6]]
segmentos :: Int -> [Integer] -> [[Integer]]
segmentos n xs = take (length xs - n + 1) (map (take n) (tails xs))

-- 2ª solución
-- ===========

mayorProducto2 :: Int -> Integer -> Integer
mayorProducto2 n x = maximum (aux ns)
    where ns     = [read [d] | d <- show x]
          aux xs | length xs < n = []
                 | otherwise     = product (take n xs) : aux (tail xs)

-- 3ª solución
-- ===========

mayorProducto3 :: Int -> Integer -> Integer
mayorProducto3 n = maximum . 
                   map (product . take n) .
                   filter ((>=n) . length) .
                   tails . 
                   cifras

-- 4ª solución
-- ===========

mayorProducto4 :: Int -> Integer -> Integer
mayorProducto4 n = maximum . 
                   map (product . map (fromIntegral . digitToInt)) . 
                   filter ((==n) . length) . 
                   concatMap inits . 
                   tails .
                   show

-- ---------------------------------------------------------------------
-- Comparación de soluciones                                          --
-- ---------------------------------------------------------------------

-- Tiempo (en segundos) del cálculo de (mayorProducto4 5 (product [1..]))
-- 
--    | Def | 10   | 100  | 1000 | 5000  |
--    |-----+------+------+------+-------|
--    | 1   | 0.01 | 0.01 | 0.04 |  0.34 |
--    | 2   | 0.01 | 0.01 | 0.07 |  2.86 |
--    | 3   | 0.01 | 0.01 | 0.06 | 12.48 |
--    | 4   | 0.00 | 0.12 |      |       |
...

import Data.List (inits, tails)

import Data.Char (digitToInt)

-- 1ª solución

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

mayorProducto1 :: Int -> Integer -> Integer

mayorProducto1 n x =

maximum [product xs | xs <- segmentos n (cifras x)]

-- (cifras x) es la lista de las cifras del número x, de derecha a

-- izquierda. Por ejemplo,

-- cifras 325 == [5,2,3]

cifras :: Integer -> [Integer]

cifras x

| x < 10 = [x]

| otherwise = r : cifras q

where (q,r) = quotRem x 10

-- (segmentos n xs) es la lista de los segmentos de longitud n de la

-- lista xs. Por ejemplo,

-- segmentos 2 [3,5,4,6] == [[3,5],[5,4],[4,6]]

segmentos :: Int -> [Integer] -> [[Integer]]

segmentos n xs = take (length xs - n + 1) (map (take n) (tails xs))

-- 2ª solución

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

mayorProducto2 :: Int -> Integer -> Integer

mayorProducto2 n x = maximum (aux ns)

where ns = [read [d] | d <- show x]

aux xs | length xs < n = []

| otherwise = product (take n xs) : aux (tail xs)

-- 3ª solución

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

mayorProducto3 :: Int -> Integer -> Integer

mayorProducto3 n = maximum .

map (product . take n) .

filter ((>=n) . length) .

tails .

cifras

-- 4ª solución

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

mayorProducto4 :: Int -> Integer -> Integer

mayorProducto4 n = maximum .

map (product . map (fromIntegral . digitToInt)) .

filter ((==n) . length) .

concatMap inits .

tails .

show

-- ---------------------------------------------------------------------

-- Comparación de soluciones --

-- ---------------------------------------------------------------------

-- Tiempo (en segundos) del cálculo de (mayorProducto4 5 (product [1..]))

-- | Def | 10 | 100 | 1000 | 5000 |

-- |-----+------+------+------+-------|

-- | 1 | 0.01 | 0.01 | 0.04 | 0.34 |

-- | 2 | 0.01 | 0.01 | 0.07 | 2.86 |

-- | 3 | 0.01 | 0.01 | 0.06 | 12.48 |

-- | 4 | 0.00 | 0.12 | | |

...

4 Comentarios

mayorProducto :: Int -> Integer -> Integer
mayorProducto n x = maximum $ map product (segmentos n (digitos x))
           where digitos x =  [read [y]|y<-show x]

segmentos :: Int -> [a] -> [[a]]
segmentos n xs | length xs < n = []
               | otherwise = take n xs : segmentos n (tail xs)

mayorProducto n x = maximum $ map product (segmentos n (digitos x))

where digitos x = [read [y]|y<-show x]

segmentos :: Int -> [a] -> [[a]]

segmentos n xs | length xs < n = []

| otherwise = take n xs : segmentos n (tail xs)

Responder

import Data.List (tails)
import Data.Char (digitToInt)
import Data.List.Split (splitWhen) 

mayorProducto :: Int -> Integer -> Integer
mayorProducto n =
  maximum . (0:) . concatMap m . splitWhen (==0) . map (toInteger.digitToInt) . show
  where m xs = map (product.take n) $ take (length xs - n + 1) $ tails xs

import Data.List (tails)

import Data.List.Split (splitWhen)

mayorProducto n =

maximum . (0:) . concatMap m . splitWhen (==0) . map (toInteger.digitToInt) . show

where m xs = map (product.take n) $ take (length xs - n + 1) $ tails xs

import Data.List

mayorProducto :: Int -> Integer -> Integer
mayorProducto n x = maximum $ map product (consecutivos n x)

consecutivos :: Int -> Integer -> [[Integer]]
consecutivos n x =
    [xs | xs <- subsequences $ ds, isInfixOf xs ds, length xs == n]
        where ds = digitos x

digitos :: Integer -> [Integer]
digitos n = [read [x] | x <- show n]

import Data.List

mayorProducto n x = maximum $ map product (consecutivos n x)

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

consecutivos n x =

[xs | xs <- subsequences $ ds, isInfixOf xs ds, length xs == n]

where ds = digitos x

digitos :: Integer -> [Integer]

digitos n = [read [x] | x <- show n]

-- Si el producto máximo está acotado y el nº es *MUY* grande (>10^2000) merece la pena ésta
mayorProducto3 :: Int -> Integer -> Int
mayorProducto3 n x = maximum [V.product (V.slice i n v) | i <- [0 .. V.length v - n]]
                     where v = (V.fromList . map digitToInt . show) x -- << coste alto

-- Si el producto máximo está acotado y el nº es *MUY* grande (>10^2000) merece la pena ésta

mayorProducto3 :: Int -> Integer -> Int

mayorProducto3 n x = maximum [V.product (V.slice i n v) | i <- [0 .. V.length v - n]]

where v = (V.fromList . map digitToInt . show) x -- << coste alto

Mayor producto de n dígitos consecutivos de un número

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