Menu Close

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

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. angruicam1
    menor :: Integer -> Integer
    menor n =
      read (show y
            ++ replicate (fromEnum x)9++ replicate (fromEnum n)0)
      where (x,y) = divMod n 9
    • 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. 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. antnavoro
    menor :: Integer -> Integer
    menor n = (y+1)*10^(n+x)-10^n
      where (x,y) = divMod n 9
  4. alerodrod5
     
    menor :: Integer -> Integer
    menor n = 10^n* ((r + 1) * 10^d - 1)
      where (d,r) = divMod n 9
  5. 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. 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. 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.