Step by Step solution about How to resolve the algorithm Own digits power sum step by step in the Haskell programming language

This Haskell program defines functions to find the power sums of a number's own digits. It also includes a generic function for generating combinations with repetitions, which is used in the main logic.

Explanation:

1. ownDigitsPowerSums:

   • Takes an integer n.
   • Generates combinations of digits from 0 to 9 with repetition allowed (ns).
   • Applies the go function to each combination to check if its power sum matches the original number.
   • Returns a sorted list of these matching combinations.

2. go:

   • Converts the list xs of digits into a single integer m by summing up each digit raised to the power of n.
   • Checks if the digits of m match the input digits xs. If they do, it returns m; otherwise, it returns an empty list.

3. digitsMatch:

   • Converts the given value n to a string and extracts its individual digits.
   • Compares the sorted list of digits in ds with the sorted list of digits derived from n. Returns True if they are equal, indicating that the power sum matches the original number.

4. combsWithRep:

   • A generic function to generate combinations with replacement.
   • Takes an integer k (number of elements in combination) and a list of elements xs.
   • Uses a recursive helper function comb to construct the combinations.

5. digits:

   • Converts the given value n to a string and returns a list of its individual digits.

Example Usage:

The main function demonstrates the program by:

• Printing the power sums of numbers in the range [3, 8].
• Printing the power sums of the number 9 (which has a special property).

import Data.List (sort)

------------------- OWN DIGITS POWER SUM -----------------

ownDigitsPowerSums :: Int -> [Int]
ownDigitsPowerSums n = sort (ns >>= go)
  where
    ns = combsWithRep n [0 .. 9]
    go xs
      | digitsMatch m xs = [m]
      | otherwise = []
      where
        m = foldr ((+) . (^ n)) 0 xs

digitsMatch :: Show a => a -> [Int] -> Bool
digitsMatch n ds =
  sort ds == sort (digits n)

--------------------------- TEST -------------------------
main :: IO ()
main = do
  putStrLn "N ∈ [3 .. 8]"
  mapM_ print ([3 .. 8] >>= ownDigitsPowerSums)
  putStrLn ""
  putStrLn "N=9"
  mapM_ print $ ownDigitsPowerSums 9

------------------------- GENERIC ------------------------
combsWithRep ::
  (Eq a) =>
  Int ->
  [a] ->
  [[a]]
combsWithRep k xs = comb k []
  where
    comb 0 ys = ys
    comb n [] = comb (pred n) (pure <$> xs)
    comb n peers = comb (pred n) (peers >>= nextLayer)
      where
        nextLayer ys@(h : _) =
          (: ys) <$> dropWhile (/= h) xs

digits :: Show a => a -> [Int]
digits n = (\x -> read [x] :: Int) <$> show n