Eine Münchhausen-Zahl in der Basis $b$ , die auch als perfekte Ziffer-zu-Ziffer-Invariante oder PDDI bezeichnet wird, ist ein besonderer Typ einer positiven Ganzzahl, bei der die Summe ihrer zur Basis $b$ erhobenen Ziffern der Zahl selbst entspricht. Sie sind nach dem fiktiven Baron Münchhausen benannt , der sich anscheinend mit seinem eigenen Pferdeschwanz aufgerichtet hat, um sich vor dem Ertrinken zu retten. Ein verwandtes Konzept sind narzisstische Zahlen .

Zum Beispiel ist $1$ trivial eine Münchhausen-Zahl in jeder Basis, weil $1^1=1$ . Außerdem ist jede positive ganze Zahl per Definition eine Zahl zur Basis 1 Münchhausen.

Interessanterweise ist $3435$ eine Basis-10-Münchhausen-Zahl, weil $3^3+4^4+3^3+5^5=3435$ , und tatsächlich ist es die einzige andere Basis-10-Münchhausen-Zahl .

Eine unvollständige Liste der Münchhausen-Nummern in jeder Basis bis zu 35 ist im OEIS als Sequenz A166623 zu finden .

Bestimmen Sie bei einer positiven ganzen Zahl $n>0$ , ob es sich um eine Münchhausen-Zahl in einer beliebigen Basis $b\geq2$ .

Regeln

• Es gelten die Standard-E / A-Regeln.
  • Vollständiges Programm oder Funktionen sind akzeptabel.
  • Die Eingabe kann von STDIN als Funktionsargument und die Ausgabe von STDOUT als Funktionsrückgabewert usw. erfolgen.
• Es gelten Standardlücken.
• Die Ausgabe muss eines von zwei unterschiedlichen, konsistenten Ergebnissen sein. Also TRUEist es in Ordnung für Wahres und FALSEist es in Ordnung für Falsches, aber Sie können dies umkehren oder Nonefür Wahres und 1Falsches oder was auch immer zurückkehren. Bitte geben Sie die ausgewählten Ergebnisse in Ihrer Antwort an.
• Ihre Antwort muss zumindest theoretisch für eine positive ganze Zahl funktionieren.
• Münchhausen-Zahlen verwenden die Konvention $0^0=1$ , also ist $2$ eine Basis-2-Münchhausen-Zahl als $1^1+0^0=2$ . Ihr Code muss dieser Konvention entsprechen.
• Erklärungen werden nachdrücklich empfohlen, auch wenn bei Einsendungen höchstwahrscheinlich die Brute-Force-Suchmethode verwendet wird.
• Die Verwendung von esoterischen Sprachen bringt Ihnen Brownie-Punkte, da Münchhausen anscheinend eine seltsame Person war.

Testfälle

Truthy
1 (all bases)
2 (base 2)
5 (base 3)
28 (base 9 and base 25)
29 (base 4)
55 (base 4)
3435 (base 10)
923362 (base 9)
260 (base 128)
257 (base 64 and base 253)

Falsy
3
4
591912
3163
17

Das ist Code-Golf , also gewinnt die kürzeste Antwort in jeder Sprache (in Bytes)!

05AB1E , 7 Bytes

LвDmOQZ

Probieren Sie es online!

Bei den größeren Testfällen tritt bei TIO eine Zeitüberschreitung auf.

Erläuterung

L         # push range [1 ... input]
 в        # convert input to a digit list in each of these bases
  Dm      # raise each digit to the power of itself
    O     # sum each
     Q    # check each for equality with input
      Z   # max

Gelee , 8 Bytes

bŻ*`§ċ⁸Ị

Erträge 0für Münchhausen und 1sonst.

Probieren Sie es online!
Oder sehen Sie die ersten fünfhundert positiven ganzen Zahlen aufgeteilt als[[Munchausen], [non-Munchausen]] .

Wie?

bŻ*`§ċ⁸Ị - Link: integer, n
 Ż       - zero-range -> [0,1,2,3,4,...,n]
b        - (n) to base (vectorises)
   `     - with left as both arguments:
  *      -   exponentiation (vectorises)
    §    - sums
     ċ   - count occurrences of:
      ⁸  -   n
       Ị - is insignificant (abs(x) <= 1)

Alternative für 1für Münchhausen und 0sonst:

bŻ*`§ċ>1

J , ^{33 28} 27 Bytes

e.1#.i.@>:^~@(#.inv ::1)"0]

Probieren Sie es online!

• e. ist der Eingang ein Element von ...
• 1#. die Summe jeder Reihe von ...
• i.@>: ... ] 0..input und die Eingabe selbst, übergeben als linkes und rechtes Argument an ...
• ^~@(#.inv)"0 Wandle das rechte Argument (Eingabe) in jede Basis im linken Argument und erhöhe jedes Ergebnis elementweise auf sich ^~@ .
• ::1Schließlich ist dies erforderlich, weil Sie nicht eindeutig zur Basis 1 konvertieren können, so dass es Fehler gibt. In diesem Fall geben wir einfach 1 zurück, die für keine Zahl außer 1 passt , was wir wollen

R , 72 69 Bytes

-1 Byte dank digEmAll

function(x){for(b in 1+1:x)F=F|!sum((a=x%/%b^(0:log(x,b))%%b)^a)-x;F}

Probieren Sie es online!

Ausgänge TRUEfür Münchhausen-Nummern und FALSEsonstiges.

x%/%b^(0:log(x,b))%%b)konvertiert xin base bund die for-Schleife erledigt den Rest der Arbeit (Neuzuweisung F, die FALSEstandardmäßig ist).

Wir müssen zulassen, dass die Basis bden gesamten Weg zurücklegt, x+1anstatt xden Fall zu behandeln x=1.

Japt , 13 Bytes

õ@ìXÄ x_pZ
øN

Dank @Shaggy ein Byte gespeichert

Versuch es

Perl 6 , 51 Bytes

{?grep {$_==sum [Z**] .polymod($^a xx*)xx 2},^$_+2}

Probieren Sie es online!

Erläuterung:

{                                                 } # Anonymous code block
 ?grep {                                  }         # Do any
                                           ,^$_+2   # Of the bases from 2 to n+1
            sum                              # Have the sum of
                      .polymod($^a xx*)      # The digits of n in that base
                [Z**]                  xx 2  # Raised to the power of themselves
        $_==                                 # Equal to the original number?

Ruby , 50 Bytes

TIO hat ein Zeitlimit von 591912 überschritten. Perl wird irgendwie um 1 Byte verdrängt ... (zum Zeitpunkt des Schreibens)

->n{(2..n+1).any?{|b|n.digits(b).sum{|d|d**d}==n}}

Probieren Sie es online!

JavaScript (ES7), 60 Byte

Gibt einen Booleschen Wert zurück.

n=>(F=b=>(g=n=>n&&g(n/b|0)+(n%=b)**n)(n)==n||b<n&&F(b+1))(2)

Probieren Sie es online!

Kommentiert

n =>                   // n = input
  ( F = b =>           // F = recursive function taking a base b
    ( g = n =>         //   g = recursive function taking an integer n
      n &&             //     if n is not equal to 0:
        g(n / b | 0) + //       do a recursive call with floor(n / b)
        (n %= b) ** n  //       and add (n mod b) ** (n mod b)
    )(n)               //   initial call to g with the original value of n
    == n ||            //   return true if the result is equal to n
    b < n &&           //   otherwise, if b is less than n:
      F(b + 1)         //     try with b + 1
  )(2)                 // initial call to F with b = 2

APL (dzaima / APL) , 23 13 Bytes

⊢∊⊂+.*⍨⍤⊤⍨¨2…

Probieren Sie es online!

Dank Adám, ngn und dzaima konnten wir mit dzaima / APL 10 Byte dieser Antwort einsparen.

Präfix implizite Funktion. Münchhausen-Zahlen geben 1 zurück, sonst 0.

Wie

⊢∊⊂+.*⍨⍤⊤⍨¨2… ⍝ Prefix tacit function, argument will be called ⍵

             2… ⍝ Generate the integer sequence [2..⍵]
          ⊤⍨¨  ⍝ Convert ⍵ to each base in the vector
     +.*⍨⍤      ⍝ Raise each digit of each element in the vector to itself, then sum
⊢∊⊂            ⍝ Check if ⍵ is in the resulting vector.

Wolfram Language (Mathematica) , 65 Byte

#<2||!Tr[Check[#^#,1]&/@#~IntegerDigits~i]~Table~{i,2,#}~FreeQ~#&

Probieren Sie es online!

-4 Bytes von @attinat

Kohle , 17 Bytes

Ｎθ¬Φθ⁼θΣＥ↨θ⁺²ιＸλλ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Mein 16-Byte-Versuch hat nicht funktioniert, aber das könnte ein Fehler in Charcoal sein. Wird ausgegeben, -sofern die Nummer keine Münchhausen-Nummer ist. Erläuterung:

Ｎθ                  Input `n` as a number
   Φθ               Try bases `2` .. `n+1`
       Σ            Sum of
         ↨θ         `n` converted to base
           ⁺²ι      Next trial base
        Ｅ           Each digit
              Ｘλλ   Raised to its own power
     ⁼              Equals
      θ             `n`
  ¬                 Logical Not

C # (Visual C # Interactive Compiler) , 99 Byte

n=>Enumerable.Range(2,n).Any(x=>{int g=0,t=n;for(;t>0;t/=x)g+=(int)Math.Pow(t%x,t%x);return g==n;})

Probieren Sie es online!

Haskell, 61 Bytes

_#0=0
b#n|m<-mod n b=m^m+b#div n b
f n=elem n$1:map(#n)[2..n]

Rückgabe Truefür Münchhausen und Falseansonsten.

Probieren Sie es online!

C (GCC) -lm , 79 75 Bytes

f(n,b,i,g,c){for(g=b=1;b+++~n;g*=!!c)for(c=i=n;c-=pow(i%b,i%b),i/=b;);n=g;}

Probieren Sie es online!

Rückgabe 0für Münchhausen-Nummern und 1sonst.

auch 75 Bytes

a,b;f(n){for(a=b=1;b+++~n;a*=g(n)!=n);n=a;}g(n){n=n?g(n/b)+pow(n%b,n%b):0;}

Probieren Sie es online!

Python 2 , 83-81 Bytes

def f(n,b=2):
 s=0;m=n
 while m:k=m%b;s+=k**k;m/=b
 return s==n or b<n>0<f(n,b+1)

Probieren Sie es online!

Returns 1für truthy und 0für Falsey. Wegen der Rekursion kann praktisch nicht damit umgehen 591912, aber es funktioniert abstrakt.

Perl 6 , 66 65 Bytes

{$^a==1||[+] map {$a==[+] map {$_**$_},$a.polymod($_ xx*)},2..$a}

Probieren Sie es online!

JavaScript (ES6), 88 Byte

f=n=>{for(b=2;n-b++;){for(c=0,r=n;r;r=(r-a)/b)c+=(a=(r%b))**a;if(n==c)return 1}return 0}

Icon , 109 Bytes

procedure m(n)
every k:=2to n&{i:=n;s:=0
while{a:=i%k;a<:=1;s+:=a^a;0<(i/:=k)}
n=s&return 1}
return n=1|0
end

Probieren Sie es online!

Mal raus für 591912. Icon wird0^0 als Überlauf behandelt und deshalb brauche ich eine zusätzliche Prüfung auf Null.

Stax , 15 Bytes

╡!←!║╝âñoêû►╦ä▓

Führen Sie es aus und debuggen Sie es

Dauert sehr lange für die größeren Testfälle.

Erläuterung:

{^xs|E{c|*m|+x=m|a Full program, unpacked
                   Implicitly input x
{              m   Map over bases [1 .. x]
 ^                   Increment base (effectively mapping over [2 .. x+1])
  xs                 Tuck x below base
    |E               Get digits of x in base
      {   m          Map over digits:
       c|*             copy and power
           |+        Sum
             x=      sum = x?
                |a Check if any element in array is true
                   Implicit output