Munchausen numbers: Difference between revisions

A [[wp:Munchausen number|Munchausen number]] is a natural number ''n'' the sum of whose digits (in base 10), each raised to the power of itself, equals ''n''.

 

 

For instance: &nbsp; <big> 3435 = 3³ + 4⁴ + 3³ + 5⁵ </big>

 

;Task

 

 

;Also see:

 

=={{header|ALGOL 68}}==

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

FI

OD

{{out}}

<pre>

 

Alternative that finds all 4 Munchausen numbers. As noted by the Pascal sample, we only need to consider one arrangement of the digits of each number (e.g. we only need to consider 3345, not 3435, 3453, etc.). This also relies on the non-standard 0^0 = 0.

# Munchausen numbers with 11+ digits #

# table of Nth powers - note 0^0 is 0 for Munchausen numbers, not 1 #

OD

OD

{{out}}

<pre>

=={{header|ALGOL W}}==

{{Trans|ALGOL 68}}

% note that 6^6 is 46 656 so we only need to consider numbers consisting of 0 to 5 %

begin

end

 

{{out}}

<pre>

</pre>

 

 

 

-- isMunchausen :: Int -> Bool

(class of n is integer) and ¬

end isMunchausen

 

 

on run

 

 

 

-- enumFromTo :: Int -> Int -> [Int]

on enumFromTo(m, n)

else

end if

end enumFromTo

 

-- filter :: (a -> Bool) -> [a] -> [a]

set lst to {}

set lng to length of xs

end script

end if

{{Out}}

 

=={{header|AWK}}==

# syntax: GAWK -f MUNCHAUSEN_NUMBERS.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

=={{header|BASIC}}==

This should need only minimal modification to work with any old-style BASIC that supports user-defined functions. The call to <code>INT</code> in line 10 is needed because the exponentiation operator may return a (floating-point) value that is slightly too large.

20 FOR I=0 TO 5

30 FOR J=0 TO 5

100 NEXT K

110 NEXT J

{{out}}

<pre> 1

==={{header|Sinclair ZX81 BASIC}}===

Works with 1k of RAM. The word <code>FAST</code> in line 10 shouldn't be taken <i>too</i> literally. We don't have <code>DEF FN</code>, so the expression for exponentiation-where-zero-to-the-power-zero-equals-zero is written out inline.

20 FOR I=0 TO 5

30 FOR J=0 TO 5

110 NEXT J

120 NEXT I

{{out}}

<pre>1

 

=={{header|BBC BASIC}}==

FOR i% = 0 TO 5

FOR j% = 0 TO 5

= 0

ELSE

{{out}}

<pre> 1

3435</pre>

 

=={{header|C}}==

Adapted from Zack Denton's code posted on [https://zach.se/munchausen-numbers-and-how-to-find-them/ Munchausen Numbers and How to Find Them].

#include <math.h>

 

}

return 0;

{{out}}

<pre>1

 

=={{header|C sharp|C#}}==

 

foreach (var i in Enumerable.Range(1,5000)

.Where(n => n == n.ToString()

.Sum(x => Math.Pow(toInt(x), toInt(x)))))

{{out}}

<pre>1

=== Faster version ===

{{Trans|Kotlin}}

 

namespace Munchhausen

}

}

<pre>0

1

 

=={{header|C++}}==

#include <math.h>

#include <iostream>

return 0;

}

{{out}}

<pre>

 

=={{header|Clojure}}==

(:require [clojure.math.numeric-tower :as math])

(:use [criterium.core])

 

(println (find-numbers 5000))

{{Output}}

<pre>

(1 3435)

</pre>

 

=={{header|D}}==

{{trans|C}}

 

void main() {

}

}

{{out}}

<pre>1

3435</pre>

 

=={{header|Elixir}}==

@pow for i <- 0..9, into: %{}, do: {i, :math.pow(i,i) |> round}

Enum.each(1..5000, fn i ->

if Munchausen.number?(i), do: IO.puts i

 

{{out}}

1

3435

</pre>

 

=={{header|FreeBASIC}}==

===Version 1===

' Cache n ^ n for the digits 1 to 9

' Note than 0 ^ 0 specially treated as 0 (not 1) for this purpose

Print "Press any key to quit"

 

{{out}}

<pre>The Munchausen numbers between 0 and 500000000 are :

438579088</pre>

===Version 2===

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>0

438579088</pre>

 

 

{{out}}

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import(

}

fmt.Println()

 

{{out}}

 

=={{header|Haskell}}==

 

isMunchausen :: Integer -> Bool

 

main :: IO ()

{{out}}

<pre>[1,3435]</pre>

 

 

 

isMunchausen :: Int -> Bool

 

main :: IO ()

 

{{Out}}

 

=={{header|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 it with an equality test to filter those integers:

 

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

 

Note that [[wp:Munchausen_number|wikipedia]] claims that 0=0^0 in the context of Munchausen numbers. It's not clear why this should be (1 is the multiplicative identity and if you do not multiply it by zero it should still be 1), but it's easy enough to implement. Note also that this does not change the result for this task:

 

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

 

=={{header|Java}}==

Adapted from Zack Denton's code posted on [https://zach.se/munchausen-numbers-and-how-to-find-them/ Munchausen Numbers and How to Find Them].

public class Main {

public static void main(String[] args) {

}

 

{{out}}

<pre>1 (munchausen)

=== Faster version ===

{{trans|Kotlin}}

 

static final long[] cache = new long[10];

return sum == n;

}

<pre>0

1

 

=={{header|JavaScript}}==

===ES6===

 

.filter(n => n == n.toString().split('')

.reduce((a, b) => a+Math.pow(parseInt(b),parseInt(b)), 0)))

{{out}}

<pre>1

Or, composing reusable primitives:

 

'use strict';

 

// isMunchausen :: Int -> Bool

 

 

 

 

 

 

 

 

=={{header|Julia}}==

 

{{out}}

=={{header|Kotlin}}==

As it doesn't take long to find all 4 known Munchausen numbers, we will test numbers up to 500 million here rather than just 5000:

 

val powers = IntArray(10)

for (i in 0..500000000) if (isMunchausen(i))print ("$i ")

println()

 

{{out}}

The Munchausen numbers between 0 and 500 million are:

0 1 3435 438579088

</pre>

 

=={{header|Lua}}==

local sum, nStr, digit = 0, tostring(n)

for pos = 1, #nStr do

digit = tonumber(nStr:sub(pos, pos))

sum = sum + digit ^ digit

end

return sum == n

for i = 1, 5000 do

if isMunchausen(i) then print(i) end

{{out}}

<pre>1

3435</pre>

 

{{out}}

<pre>{1,3435}</pre>

 

=={{header|Pascal}}==

tried to speed things up.Only checking one arrangement of 123456789 instead of all 9! = 362880 permutations.This ist possible, because summing up is commutative.

So I only have to create [http://rosettacode.org/wiki/Combinations_with_repetitions Combinations_with_repetitions] and need to check, that the number and the sum of power of digits have the same amount in every possible digit. This means, that a combination of the digits of number leads to the sum of power of digits. Therefore I need leading zero's.

uses

sysutils;

writeln('Check Count ',cnt);

end.

{{Out}}

<pre> 1 000000001

 

=={{header|Perl}}==

for my $n (1..5000) {

print "$n\n" if $n == sum( map { $_**$_ } split(//,$n) );

{{out}}

<pre>1

 

=={{header|Phix}}==

function munchausen(integer n)

integer n0 = n

while n!=0 do

n = floor(n/10)

end while

end function

{{out}}

<pre>

1

3435

</pre>

 

=={{header|PicoLisp}}==

(and

(=

'((N) (** N N))

(mapcar format (chop N)) ) )

{{out}}

<pre>

3435</pre>

 

 

=={{header|Pure}}==

digits n::number = loop n [] with

loop n l = loop (n div 10) ((n mod 10):l) if n > 0;

(map (\d -> d^d)

(digits n)); end;

{{out}}

<pre>[1,3435]</pre>

 

=={{header|Python}}==

if i == sum(int(x) ** int(x) for x in str(i)):

{{out}}

<pre>1

3435</pre>

 

 

 

(define (expt:0^0=1 r p)

(check-true (munchausen-number? 3435))

(check-false (munchausen-number? 3))

 

{{out}}

<pre>1

=={{header|REXX}}==

===version 1===

If n=m(n) Then

Say n

res=res+c**c

End

{{out}}

<pre>D:\mau>rexx munch

This REXX version uses the requirement that &nbsp; '''0**0''' &nbsp; equals zero.

 

 

For the high limit of &nbsp; '''5,000''', &nbsp; optimization isn't needed. &nbsp; But for much higher limits, optimization becomes significant.

parse arg z . /*obtain optional argument from the CL.*/

@is='is a Münchhausen number.'; do j=1 for z /* [↓] traipse through all the numbers*/

if isMunch(j) then say right(j, 11) @is

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

1 is a Münchhausen number.

 

===version 3===

parse arg z . /*obtain optional argument from the CL.*/

@is='is a Münchhausen number.'; do j=1 for z /* [↓] traipse through all the numbers*/

if isMunch(j) then say right(j, 11) @is

if $>ox then return 0 /*is sum too large?*/

do while x\=='' & $<=ox /*any more digits ?*/

end /*while*/

 

=={{header|Ring}}==

# Project : Munchausen numbers

 

limit = 5000

ok

next

Output:

<pre>

</pre>

 

=={{header|Ruby}}==

{{out}}

<pre>

 

=={{header|Rust}}==

let mut solutions = Vec::new();

 

 

println!("Munchausen numbers below 5_000 : {:?}", solutions);

{{out}}

<pre>

=={{header|Scala}}==

Adapted from Zack Denton's code posted on [https://zach.se/munchausen-numbers-and-how-to-find-them/ Munchausen Numbers and How to Find Them].

object Munch {

def main(args: Array[String]): Unit = {

}

}

{{out}}

<pre>1 (munchausen)

3435 (munchausen)</pre>

 

=={{header|Sidef}}==

n.digits.map{|d| d**d }.sum == n

}

 

{{out}}

<pre>

</pre>

 

 

Option Explicit

 

IsMunchausen = (Tot = Number)

End Function

{{out}}

<pre>1 is a munchausen number.

3435 is a munchausen number.</pre>

 

for i = 1 to 5000

if Munch(i) Then

 

End Function

{{out}}

<pre>

1 is a Munchausen number

3435 is a Munchausen number

</pre>

 

=={{header|zkl}}==

{{out}}

<pre>