Menu Close

Menor número divisible por 10^n cuyos dígitos suman n

José A. Alonso,

Definir la función

   menor :: Integer -> Integer

tal que (menor n) es el menor número divisible por 10^n cuyos dígitos suman n. Por ejemplo,

   menor 5   ==  500000
   menor 20  ==  29900000000000000000000

Soluciones

import Data.List (genericLength, genericReplicate)
 
menor :: Integer -> Integer
menor n = read (show (n-9*a) ++
                genericReplicate a '9' ++
                genericReplicate n '0')
  where a = n `div` 9
Medio
, , ,

8 soluciones de “Menor número divisible por 10^n cuyos dígitos suman n”

  1. Responder
    angruicam1 
    menor :: Integer -> Integer
menor n =
  read (show y
        ++ replicate (fromEnum x) ‘9’
        ++ replicate (fromEnum n) ‘0’)
  where (x,y) = divMod n 9
    • Responder
      jorcatote

      Una idea parecida a la tuya usando un poco la librería Control.Applicative :)

      import Data.List (genericReplicate)
 
menor :: Integer -> Integer
menor = read
      . concat
      . ([show . (`mod`9), m '9' . (`div` 9), m '0'] <*>)
      . pure
  where m = flip genericReplicate
  2. Responder
    mansangon10 
    import Data.Char
 
menor :: Integer -> Integer
menor n = head [x | x <- [10^n,2*10^n..] , sumaDigitos x == n]
 
sumaDigitos :: Integer -> Integer
sumaDigitos = fromIntegral . sum . map digitToInt . show
  3. Responder
    antnavoro 
    menor :: Integer -> Integer
menor n = (y+1)*10^(n+x)-10^n
  where (x,y) = divMod n 9
  4. Responder
    alerodrod5 
     
menor :: Integer -> Integer
menor n = 10^n* ((r + 1) * 10^d - 1)
  where (d,r) = divMod n 9
  5. Responder
    albcarcas1 
    menor :: Integer -> Integer
menor n = a*10^c*(b+1) - a
  where b = mod n 9
        c = div n 9
        a = 10^n
  6. Responder
    carbremor 
    -- He hecho dos observaciones para realizar la función:
-- 1. El número siempre acaba en n ceros
-- 2. El resto de dígitos es 9, excepto la primera cifra
 
menor :: Integer -> Integer
menor n = menorNumero n * 10 ^ n
 
-- Comprobación de la eficiencia
 
-- λ> menor 20
-- 29900000000000000000000
-- (0.26 secs, 94,720 bytes)
 
-- λ> menor 5
-- 500000
-- (0.01 secs, 76,920 bytes)
 
-- menorNumero calcula, como su nombre indica, el menor número
-- cuyos dígitos suman n. Sabemos que será un número que comience
-- por x y esté seguido por (x `mod` 9) nueves
 
menorNumero :: (Num n, Ord n) => n -> n
menorNumero 0 = 0
menorNumero x = d + 10 * menorNumero (x - d)
    where d = min 9 x
 
-- λ> menorNumero 25
-- 799
-- (0.04 secs, 78,192 bytes)
  7. Responder
    carbremor 
     
-- Otra versión más eficiente
 
-- Se basa en lo siguiente
-- 20 `divMod` 9  ⇒ (2,2)
-- 20 = 2 + (2 * 9) = 2 + 9 + 9      ⇒ 299
 
 
menor :: Integer -> Integer
menor n = ((r + 1) * (10 ^ q) - 1) * (10 ^ n)
    where (q, r) = n `quotRem` 9
 
-- λ> menor 20
-- 29900000000000000000000
-- (0.01 secs, 93,272 bytes)

Escribe tu solución

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