Munchausen numbers: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

I i == sum(String(i).map(x -> Int(x) ^ Int(x)))

 

{{out}}

 

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

MUNCHAU CSECT

USING MUNCHAU,R12 base register

PG DC CL12' ' buffer

REGEQU

{{out}}

<pre>

 

=={{header|8080 Assembly}}==

puts: equ 9 ; CP/M syscall to print string

org 100h

pop d ; Restore DE

ret

 

{{out}}

<pre>3435

0001</pre>

 

=={{header|Ada}}==

 

procedure Munchausen is

end loop;

Ada.Text_IO.New_Line;

 

{{out}}

 

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

{{works with|Dyalog APL}}

 

 

{{out}}

=={{header|AppleScript}}==

===Functional===

 

-- isMunchausen :: Int -> Bool

end script

end if

{{Out}}

 

===Iterative===

More straightforwardly:

 

repeat with i from 1 to 5000

if (i > 0) then

end repeat

 

{{Out}}

 

=={{header|Arturo}}==

n = sum map split to :string n 'digit [

d: to :integer digit

if munchausen? x ->

print x

 

{{out}}

<pre>1

3435</pre>

 

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

 

=={{header|BQN}}==

IsMnch ← ⊢=+´∘(⋆˜ Dgts)

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

(1 3435)

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

 

=={{header|COBOL}}==

PROGRAM-ID. MUNCHAUSEN.

ADD-DIGIT-POWER.

COMPUTE POWER-SUM =

{{out}}

<pre> 1

 

=={{header|Cowgol}}==

 

sub digitPowerSum(n: uint16): (sum: uint32) is

end if;

n := n + 1;

 

{{out}}

 

<pre>1

3435</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|Delphi}}==

See [https://rosettacode.org/wiki/Munchausen_numbers#Pascal Pascal].

 

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

 

=={{header|F sharp|F#}}==

let power x = toFloat x ** toFloat x |> int

let isMunchausen n = n = (string n |> Seq.map char |> Seq.map power |> Seq.sum)

 

{{out}}

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

 

=={{header|Factor}}==

prettyprint sequences ;

 

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

 

{{out}}

<pre>

 

=={{header|FALSE}}==

$$0\[$][

$10/$@\10*-

]#

%=[$.10,]?

 

{{out}}

 

=={{header|FOCAL}}==

 

02.10 S M=N;S S=0

02.50 I (N-S)2.7,2.6,2.7

02.60 T %4,N,!

 

{{out}}

=={{header|Forth}}==

{{works with|GNU Forth|0.7.0}}

: dig.num \ returns input number and the number of its digits ( n -- n n1 )

dup

i check.num = if i . cr

then loop ;

{{out}}

<pre>

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

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

3435

438579088</pre>

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import(

}

fmt.Println()

 

{{out}}

 

=={{header|Haskell}}==

 

isMunchausen :: Integer -> Bool

 

main :: IO ()

{{out}}

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

The Haskell libraries provide a lot of flexibility – we could also reduce the sum and map (above) down to a single foldr:

 

 

isMunchausen :: Int -> Bool

 

main :: IO ()

 

Or, without digitToInt, but importing join, swap and bool.

import Data.Bool (bool)

import Data.Tuple (swap)

 

isMunchausen :: Integer -> Bool

isMunchausen =

 

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

 

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

 

=={{header|Lambdatalk}}==

{def munch

{lambda {:w}

1

3435

 

=={{header|langur}}==

{{trans|C#}}

 

# Munchausen

 

 

 

{{out}}

 

=={{header|Lua}}==

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

for pos = 1, #nStr do

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>

 

=={{header|MAD}}==

DIMENSION P(5)

 

VECTOR VALUES FMT = $I4*$

 

{{out}}

 

=={{header|Maple}}==

local num_digits;

num_digits := map(x -> StringTools:-Ord(x) - 48, StringTools:-Explode(convert(n, string)));

end proc;

 

{{out}}

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

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

 

for i in 1..<5000:

number = number div 10

if sum == i:

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

<?php

 

echo $i . PHP_EOL;

}

{{out}}

<pre>

1

3435</pre>

 

=={{header|PicoLisp}}==

(and

(=

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

(mapcar format (chop N)) ) )

{{out}}

<pre>

1

3435</pre>

 

=={{header|Plain English}}==

Start up.

Show the Munchausen numbers up to 5000.

If the number is 0, break.

Repeat.

{{out}}

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

 

=={{header|Quackery}}==

[ dup 0 != while

10 /mod dup **

5000 times

[ i^ 1+ munchausen if

 

{{out}}

 

=={{header|Racket}}==

 

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

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

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

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

constant @powers = 0, |map { $_ ** $_ }, 1..9;

$n == @powers[$n.comb].sum;

}

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

 

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

@.= 0; do i=1 for 9; @.i= i**i; end /*precompute powers for non-zero digits*/

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

parse var x _ +1 x; $= $ + @._ /*add the next power*/

end /*while*/ /* [↑] get a digit.*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

===version 3===

It is about &nbsp; '''3''' &nbsp; times faster than REXX version 1.

@.= 0; do i=1 for 9; @.i= i**i; end /*precompute powers for non-zero digits*/

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

parse var x _ +1 x; $= $ + @._ /*sum 6th & up digs*/

end /*while*/

{{out|output|text=&nbsp; is the same as the 2^nd REXX version.}} <br><br>

 

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

 

=={{header|Symsyn}}==

x : 10 1

endif

 

{{out}}

<pre>1

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

{{trans|BASIC}}

This takes advantage of the fact that N^N > 9999 for any single digit natural number N where N > 6. It also uses a look up table for powers to allow the assumption that 0^0 = 1.

For(A,0,5,1)

For(B,0,5,1)

End

End

{{out}}

<pre>

 

=={{header|VBA}}==

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

 

=={{header|Wren}}==

for (i in 1..9) powers[i] = i.pow(i).round // cache powers

 

}

 

System.print("The Munchausen numbers <= 5000 are:")

for (i in 1..5000) {

if (munchausen.call(i)) System.print(i)

 

{{out}}

<pre>

The Munchausen numbers <= 5000 are:

1

3435

 

=={{header|zkl}}==

{{out}}

<pre>