Un nombre Munchausen dans la base $b$ , également connu sous le nom d' invariant parfait de chiffre à chiffre ou PDDI est un type particulier d'entier positif où la somme de ses chiffres de base $b$ élevés pour lui-même est égale au nombre lui-même. Ils portent le nom du fictif Baron Munchausen , qui s'est apparemment hissé par sa propre queue de cheval pour se sauver de la noyade. Un concept connexe est celui des nombres narcissiques .

Par exemple, $1$ est trivialement un nombre Munchausen dans chaque base car $1^1=1$ . De plus, chaque entier positif est par définition un nombre Munchausen de base 1.

Plus intéressant, $3435$ est un nombre Munchausen de base 10 car $3^3+4^4+3^3+5^5=3435$ , et en fait est le seul autre nombre Munchausen de base 10 .

Une liste partielle des numéros de Munchausen dans chaque base jusqu'à 35 peut être trouvée sur l'OEIS sous la séquence A166623 .

Étant donné un entier positif $n>0$ , déterminez s'il s'agit d'un nombre de Munchausen dans n'importe quelle base $b\geq2$ .

Règles

• Les règles d'E / S par défaut s'appliquent, donc:
  • Un programme complet ou des fonctions sont acceptables.
  • L'entrée peut provenir de STDIN, comme argument de fonction, et la sortie peut être vers STDOUT, comme valeur de retour de fonction, etc.
• Les failles par défaut s'appliquent.
• La sortie doit être l'un des deux résultats distincts et cohérents. Donc, TRUEc'est bien pour la vérité et FALSEc'est bien pour la fausseté, mais vous pouvez inverser cela ou revenir Nonepour la vérité et 1pour la fausseté ou autre chose. Veuillez spécifier les résultats sélectionnés dans votre réponse.
• Votre réponse doit fonctionner au moins théoriquement pour tout entier positif.
• Les nombres Munchausen utilisent la convention $0^0=1$ , donc $2$ est un nombre Munchausen de base 2 comme $1^1+0^0=2$ . Votre code doit suivre cette convention.
• Les explications sont fortement encouragées, même si les soumissions utiliseront très probablement la méthode de recherche par force brute.
• L'utilisation de langues ésotériques vous rapporte des points brownie car Munchausen était apparemment une personne étrange.

Cas de test

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

Il s'agit de code-golf , donc la réponse la plus courte dans chaque langue (en octets) l'emporte!

05AB1E , 7 octets

LвDmOQZ

Essayez-le en ligne!

Les cas de test plus importants expireront sur TIO.

Explication

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

Gelée , 8 octets

bŻ*`§ċ⁸Ị

Cède 0pour Munchausen et 1autrement.

Essayez-le en ligne!
Ou voyez les cinq cents premiers entiers positifs divisés en[[Munchausen], [non-Munchausen]].

Comment?

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 pour 1Munchausen et 0autre:

bŻ*`§ċ>1

J , ^{33 28} 27 octets

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

Essayez-le en ligne!

• e. est l'entrée un élément de ...
• 1#. la somme de chaque rangée de ...
• i.@>: ... ] 0..input et l'entrée elle-même, passés comme arguments gauche et droit à ...
• ^~@(#.inv)"0convertissez l'argument droit (entrée) en chaque base de l'argument gauche et augmentez chaque résultat élément par élément ^~@.
• ::1enfin, cela est nécessaire car vous ne pouvez pas convertir uniquement en base 1, donc il y a des erreurs. dans ce cas, nous renvoyons simplement 1, qui ne correspondra à aucun nombre sauf 1, ce que nous voulons

R , 72 69 octets

-1 octet grâce à digEmAll

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

Essayez-le en ligne!

Sorties TRUEpour numéros Munchausen et FALSEautres.

x%/%b^(0:log(x,b))%%b)convertit xen base b, et la boucle for fait le reste du travail (réaffectation F, qui est FALSEpar défaut).

Nous devons autoriser la base bà aller jusqu'au x+1lieu de xgérer le boîtier x=1.

Japt , 13 octets

õ@ìXÄ x_pZ
øN

Un octet enregistré grâce à @Shaggy

Essayez-le

Perl 6 , 51 octets

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

Essayez-le en ligne!

Explication:

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

Rubis , 50 octets

TIO a expiré le 591912. En quelque sorte, Perl dépasse d'un octet ... (au moment de la rédaction)

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

Essayez-le en ligne!

JavaScript (ES7), 60 octets

Renvoie une valeur booléenne.

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

Essayez-le en ligne!

Commenté

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 octets

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

Essayez-le en ligne!

Grâce à Adám, ngn et dzaima, nous avons réussi à réduire de 10 octets cette réponse en utilisant dzaima / APL.

Fonction tacite de préfixe. Les nombres Munchausen renvoient 1, sinon 0.

Comment

⊢∊⊂+.*⍨⍤⊤⍨¨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 octets

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

Essayez-le en ligne!

-4 octets de @attinat

Fusain , 17 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Ma tentative de 16 octets n'a pas fonctionné, mais cela pourrait être un bug dans Charcoal, alors surveillez cet espace. Sorties -sauf si le nombre est un nombre Munchausen. Explication:

Ｎθ                  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 octets

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;})

Essayez-le en ligne!

Haskell, 61 octets

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

Résultats True pour Munchausen et Falseautrement.

Essayez-le en ligne!

C (gcc) -lm , 79 75 octets

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

Essayez-le en ligne!

Renvoie les 0numéros Munchausen, et1 autrement.

également 75 octets

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

Essayez-le en ligne!

Python 2 , 83 81 octets

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)

Essayez-le en ligne!

Retourne 1pour véridique et 0pour falsey. En raison de la récursivité, ne peut pratiquement pas être traité 591912, mais cela fonctionne dans l'abstrait.

Perl 6 , 66 65 octets

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

Essayez-le en ligne!

JavaScript (ES6), 88 octets

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}

Icône , 109 octets

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

Essayez-le en ligne!

Temps mort pour 591912. Icon traite 0^0comme un débordement et c'est pourquoi j'ai besoin d'une vérification supplémentaire pour zéro.

Stax , 15 octets

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

Exécuter et déboguer

Prend très longtemps pour les plus grands cas de test.

Explication:

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