Munchausen numbers: Difference between revisions

('''Munchausen''' is also spelled: '''Münchhausen'''.)

 

 

;Task

 

 

:* The OEIS entry: [[oeis:A046253| A046253]]

:* The Wikipedia entry: [[wp:Perfect_digit-to-digit_invariant| Perfect digit-to-digit invariant, redirected from ''Munchausen Number'']]

 

=={{header|360 Assembly}}==

MUNCHAU CSECT

USING MUNCHAU,R12 base register

PG DC CL12' ' buffer

REGEQU

{{out}}

<pre>

3435

</pre>

 

=={{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

{{trans|Visual Basic .NET}}

Search covers all 11 digit numbers (as pointed out elsewhere, 11*(9^9) has only 10 digits, so there are no Munchausen numbers with 11+ digits), not just the first half of the 9 digit numbers. Computation time is under 1.5 seconds.

 

static class Program

}

}

{{out}}

<pre>0

 

=={{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>

</pre>

 

 

=={{header|Common Lisp}}==

;;; check4munch maximum &optional b

;;; Return a list with all Munchausen numbers less then or equal to maximum.

(let ((dm (divmod n base)))

(n2base (car dm) base (cons (cadr dm) digits)))))

 

{{Out}}

T

</pre>

 

=={{header|D}}==

{{trans|C}}

 

void main() {

}

}

{{out}}

<pre>1

Needs a modern Dc due to <code>~</code>.

Use <code>S1S2l2l1/L2L1%</code> instead of <code>~</code> to run it in older Dcs.

[p] sp

[z d d lM x =p z 5001>L ] sL

Cosmetic: The stack is dirty after execution. The loop <code>L</code> needs a fix if that is a problem.

 

=={{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}}

3435

</pre>

 

=={{header|Factor}}==

prettyprint sequences ;

 

: munchausen? ( n -- ? )

dup 1 digit-groups dup [ ^ ] 2map sum = ;

 

{{out}}

<pre>

</pre>

 

 

 

 

 

=={{header|Fortran}}==

{{trans|360 Assembly}}

===Fortran IV===

DO 2 I=1,5000

IS=0

1 II=IR

2 IF(IS.EQ.I) WRITE(*,*) I

{{out}}

<pre>

</pre>

===Fortran 77===

DO I=1,5000

IS=0

IF(IS.EQ.I) WRITE(*,*) I

END DO

{{out}}

<pre>

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

isMunchausen =

 

main :: IO ()

{{Out}}

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

 

=={{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';

 

// MAIN ---

return main();

{{Out}}

 

=={{header|jq}}==

{{works with|jq|1.5}}

 

def ismunchausen:

 

# Munchausen numbers from 1 to 5000 inclusive:

{{out}}

 

=={{header|Julia}}==

{{works with|Julia|1.0}}

 

{{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}}

</pre>

 

{{trans|C#}}

 

# Munchausen

 

{{out}}

<pre>Answers: [1, 3435]</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

 

=={{header|M2000 Interpreter}}==

Module Munchausen {

Inventory p=0:=0,1:=1

}

Munchausen

Using Array instead of Inventory

Module Münchhausen {

Dim p(0 to 9)

}

Münchhausen

{{out}}

<pre>

</pre>

 

{{out}}

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

=={{header|min}}==

{{works with|min|0.19.3}}

1 :i

{{out}}

<pre>

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,ReadChar;

 

ReadChar;

 

=={{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>

1

3435</pre>

 

=={{header|PowerBASIC}}==

{{trans|FreeBASIC}}(Translated from the FreeBasic Version 2 example.)

#DIM ALL

#COMPILER PBCC 6

CON.PRINT "execution time:" & STR$(t) & " ms; hit any key to end program"

CON.WAITKEY$

{{out}}

<pre> 0

 

=={{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|PureBasic}}==

{{trans|C}}

Declare main()

 

EndIf

Next

{{out}}

<pre>1

 

=={{header|Python}}==

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

{{out}}

<pre>1

 

{{Works with|Python|3}}

 

from functools import (reduce)

 

if __name__ == '__main__':

<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

 

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>

 

=={{header|SuperCollider}}==

 

<pre>

 

=={{header|Swift}}==

 

func isMünchhausen(_ n: Int) -> Bool {

for i in 1...5000 where isMünchhausen(i) {

print(i)

{{out}}

<pre>1

3435</pre>

 

=={{header|TI-83 BASIC}}==

{{works with|TI-83 BASIC|TI-84Plus 2.55MP}}

{{trans|Fortran}}

0→S:I→K

For(J,1,4)

End

If S=I:Disp I

{{out}}

<pre>

Execution time: 15 min

 

 

Option Explicit

 

IsMunchausen = (Tot = Number)

End Function

{{out}}

<pre>1 is a munchausen number.

 

=={{header|VBScript}}==

for i = 1 to 5000

if Munch(i) Then

 

End Function

{{out}}

<pre>

=={{header|Visual Basic}}==

{{trans|FreeBASIC}}(Translated from the FreeBasic Version 2 example.)

 

Declare Function GetTickCount Lib "kernel32.dll" () As Long

res = res & "execution time:" & Str$(t) & " ms"

MsgBox res

{{out}}

<pre> 0

{{trans|FreeBASIC}}(Translated from the FreeBasic Version 2 example.)<br/>

Computation time is under 4 seconds on tio.run.

 

Module Program

Next

End Sub

{{out}}

<pre>0

3435

438579088</pre>

=={{header|zkl}}==

{{out}}

<pre>