Menu Close

Números dígito potenciales

 

Un número entero x es dígito potencial de orden n si x es la suma de los dígitos de x elevados a n. Por ejemplo,

  • 153 es un dígito potencial de orden 3 ya que 153 = 1^3+5^3+3^3
  • 4150 es un dígito potencial de orden 5 ya que 4150 = 4^5+1^5+5^5+0^5

Un número x es dígito auto potencial si es un dígito potencial de orden n, donde n es el número de dígitos de n. Por ejemplo, 153 es un número dígito auto potencial.

Definir las funciones

   digitosPotencialesOrden :: Integer -> [Integer]
   digitosAutoPotenciales  :: [Integer]

tales que

  • (digitosPotencialesOrden n) es la lista de los números dígito potenciales de orden n. Por ejemplo,
     take 6 (digitosPotencialesOrden 3)  ==  [0,1,153,370,371,407]
     take 5 (digitosPotencialesOrden 4)  ==  [0,1,1634,8208,9474]
     take 8 (digitosPotencialesOrden 5)  ==  [0,1,4150,4151,54748,92727,93084,194979]
     take 3 (digitosPotencialesOrden 6)  ==  [0,1,548834]
  • digitosAutoPotenciales es la lista de los números dígito auto potenciales. Por ejemplo,
     λ> take 20 digitosAutoPotenciales
     [0,1,2,3,4,5,6,7,8,9,153,370,371,407,1634,8208,9474,54748,92727,93084]

Soluciones

import Data.List (genericLength)
import Data.Char (digitToInt)
 
-- 1ª definición de digitosPotencialesOrden
-- ========================================
 
digitosPotencialesOrden :: Integer -> [Integer]
digitosPotencialesOrden n =
  [x | x <- [0..]
     , esDigitoPotencialOrden n x]
 
esDigitoPotencialOrden :: Integer -> Integer -> Bool
esDigitoPotencialOrden n x =
  x == sum [y^n | y <- digitos x]
 
digitos :: Integer -> [Integer]
digitos x = [read [d] | d <- show x] 
 
-- 2ª definición de digitosPotencialesOrden
-- ========================================
 
digitosPotencialesOrden2 :: Integer -> [Integer]
digitosPotencialesOrden2 n =
  filter (esDigitoPotencialOrden2 n) [0..]
 
esDigitoPotencialOrden2 :: Integer -> Integer -> Bool
esDigitoPotencialOrden2 n x =
  x == sum (map (^n) (digitos2 x))
 
digitos2 :: Integer -> [Integer]
digitos2 = map (toInteger . digitToInt) . show
 
-- 3ª definición de digitosPotencialesOrden
-- ========================================
 
--    digitosPotencialesOrden3 3  ==  [0,1,153,370,371,407]
--    digitosPotencialesOrden3 4  ==  [0,1,1634,8208,9474]
digitosPotencialesOrden3 :: Integer -> [Integer]
digitosPotencialesOrden3 n =
  filter (esDigitoPotencialOrden2 n) [0..10^d-1]
  where d = maximoNDigitosPotencialesOrden n 
 
-- (maximoNDigitosPotencialesOrden n) es el máximo número de dígitos de
-- los números dígitos potenciales de orden d. Por ejemplo,
--    maximoNDigitosPotencialesOrden 3  ==  5
--    maximoNDigitosPotencialesOrden 5  ==  7
maximoNDigitosPotencialesOrden :: Integer -> Integer
maximoNDigitosPotencialesOrden n =
  head (dropWhile (\d -> d*9^n >= 10^(d-1)) [1..])
 
-- 1ª definición de esDigitoAutoPotencial
-- ======================================
 
esDigitoAutoPotencial :: Integer -> Bool
esDigitoAutoPotencial x =
  esDigitoPotencialOrden (genericLength (show x)) x
 
digitosAutoPotenciales :: [Integer]
digitosAutoPotenciales =
  filter esDigitoAutoPotencial [0..]
 
-- 2ª definición de esDigitoAutoPotencial
-- ======================================
 
digitosAutoPotenciales2 :: [Integer]
digitosAutoPotenciales2 =
  0: concat [[x | x <- [10^k..10^(k+1)-1], esDigitoPotencialOrden (k+1) x]
            | k <- [0..]]
Medio

3 soluciones de “Números dígito potenciales

  1. alerodrod5
    digitosPotencialesOrden :: Integer -> [Integer]
    digitosPotencialesOrden x =
      [n | n <- [0..]
         , (sum (map (^x) (cifras n))) == n]
     
    cifras :: Integer -> [Integer]
    cifras n | n < 10    = [n]
             | otherwise = cifras (n `div` 10) ++ [n `rem` 10]
     
    digitosAutoPotenciales :: [Integer]
    digitosAutoPotenciales =
      [x | x <- [0..]
         , (sum (map (^u x) (cifras x))) == x]
      where u x = length (cifras x)
  2. angruicam1
    import Data.Char (digitToInt)
     
    digitosPotencialesOrden :: Integer -> [Integer]
    digitosPotencialesOrden n =
      [x | x <- [0..]
         , (sum . map ((^n) . toInteger . digitToInt) . show) x == x]
     
    digitosAutoPotenciales :: [Integer]
    digitosAutoPotenciales =
      [y | y <- [0..]
         , (sum . map ((^length (show y)) . toInteger . digitToInt) . show) y == y]
  3. menvealer
    digitosPotencialesOrden :: Integer -> [Integer]
    digitosPotencialesOrden n =
      [x | x <- [0..]
         , x == sum (zipWith (^) (digitos x) (repeat n))]
     
    digitos :: Integer -> [Integer]
    digitos x = map toInteger (map (digitToInt) (show x))
     
    digitosAutoPotenciales :: [Integer]
    digitosAutoPotenciales =
      [x | x <- [0..]
         , (sum . map (^length (digitos x))) (digitos x) == x]

Los comentarios están cerrados.