Menu Close

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

Definir la función

   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

Soluciones

import Test.QuickCheck
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. Por ejemplo, 
--    cifras 325  ==  [3,2,5]
cifras :: Integer -> [Integer]
cifras x = map (toInteger . digitToInt) (show x)
 
-- (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 (mayorProducto 5 (product [1..n]))
-- 
--    | Def | 500  | 1000 | 5000 | 10000 
--    | 1   | 0.01 | 0.02 | 0.06 | 0.11
--    | 2   | 0.01 | 0.03 | 0.80 | 3.98
--    | 3   | 0.01 | 0.03 | 0.82 | 4.13
--    | 4   | 2.77 |      |      |

Pensamiento

A las palabras de amor
les sienta bien su poquito
de exageración.

Antonio Machado

5 soluciones de “Mayor producto de n dígitos consecutivos de un número

  1. frahidzam
    import Data.List (genericLength, genericTake)
    mayorProducto :: Int -> Integer -> Integer
    mayorProducto n x = maximum [product xs | xs <- fracciona (fromIntegral n) (digitosG x)]
     
    fracciona :: Integer -> [Integer] -> [[Integer]]
    fracciona n xs | genericLength xs >= n = (genericTake n xs):fracciona n (tail xs)
                   | otherwise = [] 
     
    digitosG :: Integer -> [Integer]
    digitosG n = [read [a] | a <- show n]
  2. adogargon
    digitos :: Integer -> [Integer]
    digitos x = [read [y] | y <- (show x)]
     
    sonProductos :: Int -> [Integer] -> [Integer]
    sonProductos 1 xs = xs 
    sonProductos n xs = zipWith (*) (sonProductos (n-1) xs) (completa (n-1) xs)
     
    mayorProducto :: Int -> Integer -> Integer
    mayorProducto n x = maximum ( sonProductos n (digitos x))
     
    completa :: Int -> [Integer] -> [Integer]
    completa n xs = (replicate n 0)++ xs
  3. javmarcha1
    import Data.List
     
    mayorProducto :: Int -> Integer -> Integer
    mayorProducto n x = maximum[product xs | xs <- dividirEn n (digitos x)]
     
    digitos :: Integer -> [Integer]
    digitos x = [read [y] | y <- show x]
     
    dividirEn :: Int -> [Integer] -> [[Integer]]
    dividirEn n xs | (length xs) >= n = (take n xs):dividirEn n (tail xs)
                   | otherwise = []
  4. luipromor
    mayorProducto :: Int -> Integer -> Integer
    mayorProducto n x = aux (n-1)  [ read [y] | y <- show x] 0
      where aux _ [] b = b
            aux a (x:xs) b | length xs < a = b
                           | otherwise = aux a xs ( max b  ( x * product ( take a xs)))
  5. danmorper2
    mayorProducto :: Int -> Integer -> Integer
    mayorProducto n x = maximum $ map product xs
      where
        xs=listas (digitos x) n
     
    digitos :: Integer -> [Integer]
    digitos n = [read [x] | x <- show n]
     
    listas xs s | length xs<s= []
                | otherwise   = ys:(listas (drop 1 xs) s)
        where
          ys=take s xs

Escribe tu solución

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