Munchausen numbers

Munchausen numbers is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Definition of Munchausen numbers

A Munchausen number is a natural number n the sum of whose digits (in base 10), each raised to the power of itself, is n itself.

Task requirements

Finds all Munchausen numbers between 1 and 5000

ALGOL 68

<lang algol68># Find Munchausen Numbers between 1 and 5000 #

1. note that 6^6 is 46 656 so we only need to cosider numbers consisting of 0 to 5 #

1. table of Nth powers #

[]INT nth power = ([]INT( 1, 1, 2 * 2, 3 * 3 * 3, 4 * 4 * 4 * 4, 5 * 5 * 5 * 5 * 5 ))[ AT 0 ];

FOR d1 FROM 0 TO 5 DO

   INT d1 part = d1 * 1000;
   FOR d2 FROM 0 TO 5 DO
       INT d2 part = d2 * 100; 
       FOR d3 FROM 0 TO 5 DO
           INT d3 part = d3 * 10;
           FOR d4 FROM 0 TO 5 DO
               INT digit power sum := 0;
               IF d1 > 0 THEN
                   digit power sum := nth power[ d1 ]
                                    + nth power[ d2 ]
                                    + nth power[ d3 ]
                                    + nth power[ d4 ]
               ELIF d2 > 0 THEN
                   digit power sum := nth power[ d2 ]
                                    + nth power[ d3 ]
                                    + nth power[ d4 ]
               ELIF d3 > 0 THEN
                   digit power sum := nth power[ d3 ]
                                    + nth power[ d4 ]
               ELSE
                   digit power sum := nth power[ d4 ]
               FI;
               INT number          = d1 part + d2 part + d3 part + d4;
               IF digit power sum = number THEN
                   print( ( whole( number, 0 ), newline ) )
               FI
           OD
       OD
   OD

OD</lang>

Output:

1
3435

C

Adapted from Zack Denton's code posted on Munchausen Numbers and How to Find Them. <lang C>#include <stdio.h>

1. include <math.h>

int main() {

   for (int i = 1; i < 5000; i++) {
       // loop through each digit in i
       // e.g. for 1000 we get 0, 0, 0, 1.
       int sum = 0;
       for (int number = i; number > 0; number /= 10) {
           int digit = number % 10;
           // find the sum of the digits 
           // raised to themselves 
           sum += pow(digit, digit);
       }
       if (sum == i) {
           // the sum is equal to the number
           // itself; thus it is a 
           // munchausen number
           printf("%i\n", i);
       } 
   }
   return 0;

}</lang>

Output:

1
3435

C#

<lang csharp>Func<char, int> toInt = c => c-'0';

foreach (var i in Enumerable.Range(1,5000) .Where(n => n == n.ToString() .Sum(x => Math.Pow(toInt(x), toInt(x))))) Console.WriteLine(i);</lang>

Output:

1
3435

Haskell

<lang haskell>import Data.List (unfoldr)

isMunchausen :: Integer -> Bool isMunchausen n = (n ==) $ sum $ map (\x -> x^x) $ unfoldr digit n where

 digit 0 = Nothing
 digit n = Just (r,q) where (q,r) = n `divMod` 10

main :: IO () main = print $ filter isMunchausen [1..5000]</lang>

Output:

[1,3435]

J

Here, it would be useful to have a function which sums the powers of the digits of a number. Once we have that we can use that with an equality test to filter those integers:

<lang J> munch=: +/@(^~@(10&#.inv))

  (#~ ] = munch"0) 1+i.5000

1 3435</lang>

JavaScript

<lang javascript>for (let i of [...Array(5000).keys()] .filter(n => n == n.toString().split() .reduce((a, b) => a+Math.pow(parseInt(b),parseInt(b)), 0))) console.log(i);</lang>

Output:

1
3435

Perl 6

<lang perl6>sub is_munchausen ( Int $n ) {

   constant @powers = 0, |map { $_ ** $_ }, 1..9;
   $n == @powers[$n.comb].sum;

} .say if .&is_munchausen for 1..5000;</lang>

Output:

1
3435

Scala

Adapted from Zack Denton's code posted on Munchausen Numbers and How to Find Them. <lang Scala> object Munch {

 def main(args: Array[String]): Unit = {
   import scala.math.pow
   for (i <- 1 to 5000)
     if (i == (i.toString.toCharArray.map(d => pow(d.asDigit,d.asDigit))).sum)
       println( i + " (munchausen)")
 }

} </lang>

Output:

1
3435

zkl

<lang zkl>[1..5000].filter(fcn(n){ n==n.split().reduce(fcn(s,n){ s + n.pow(n) },0) }) .println();</lang>

Output:

L(1,3435)