以b为底的Munchausen数（也称为完美数对数不变式或PDDI）是一种特殊类型的正整数，其中，将其b数的底位数加起来等于其自身。他们以虚构的男爵Munchausen的名字命名，男爵显然是通过自己的马尾辫将自己抬起的，以免溺水。一个相关的概念是自恋数字$b$$b$。

例如，$1$是平凡在每个基地Munchausen号码，因为$1^1=1$。另外，根据定义，每个正整数都是以1为底的Munchausen数。

更有趣的是，$3435$是一个以10为底的Munchausen数，因为$3^3+4^4+3^3+5^5=3435$，实际上是唯一的另一个以10为底的Munchausen数。

在OEIS上可以找到序列号为A166623的Munchausen数字的部分列表，最多35个基数。

给定一个正整数$n>0$，确定它是否是任何一个基Munchausen数$b\geq2$。

规则

• 默认的I / O规则适用，因此：
  • 完整的程序或功能是可以接受的。
  • 输入可以来自STDIN，作为函数参数，输出可以到STDOUT，作为函数返回值，等等。
• 默认漏洞适用。
• 输出必须是两个不同的，一致的结果之一。因此TRUE，对真理有好处，FALSE对虚假也可以，但您可以颠倒它，也可以None为真理和1虚假之类返回。请在答案中指定所选结果。
• 您的答案必须至少在理论上适用于任何正整数。
• Munchausen数字使用约定$0^0=1$，因此$2$是2的Munchausen数字以$1^1+0^0=2$为基数。您的代码必须遵循此约定。
• 即使提交内容很可能使用蛮力搜索方法，也强烈建议您进行解释。
• 由于蒙克豪森显然是一个陌生的人，所以使用深奥的语言可以使您获得布朗尼积分。

测试用例

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

这是代码高尔夫球，因此每种语言（以字节为单位）中最短的答案将获胜！

05AB1E，7个字节

LвDmOQZ

在线尝试！

较大的测试用例将在TIO上超时。

说明

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

果冻，8 字节

bŻ*`§ċ⁸Ị

0对于Munchausen和1其他地区，收益率较高。

在线尝试！
或将前五百个正整数拆分为[[Munchausen], [non-Munchausen]]。

怎么样？

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)

1Munchausen的替代品，0否则：

bŻ*`§ċ>1

J，^{33 28} 27字节

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

在线尝试！

• e. 输入是...的元素
• 1#. 每行...的总和
• i.@>: ... ] 0..input和输入本身，作为左右参数传递给...
• ^~@(#.inv)"0将右arg（输入）转换为左arg中的每个基数，并将每个结果逐元素提高到自身^~@。
• ::1最后，这是必需的，因为您不能唯一地转换为基数1，因此会出错。在这种情况下，我们只返回1，该数字与除 1 以外的任何数字都不匹配，这就是我们想要的

R，72 69字节

-1字节归功于digEmAll

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

在线尝试！

输出TRUEMunchausen编号，FALSE否则输出。

x%/%b^(0:log(x,b))%%b)转换x为base b，并且for循环完成其余工作（重新分配F，即FALSE默认情况下）。

我们需要让基地b一路走来x+1而不是x处理案件x=1。

Japt，13个字节

õ@ìXÄ x_pZ
øN

@Shaggy节省了一个字节

试试吧

Perl 6，51个字节

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

在线尝试！

说明：

{                                                 } # 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个字节

TIO在591912上超时。以某种方式使Perl减少了1个字节...（在撰写本文时）

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

在线尝试！

JavaScript（ES7），60个字节

返回一个布尔值。

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

在线尝试！

已评论

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

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

在线尝试！

多亏了Adám，ngn和dzaima，我们使用dzaima / APL设法将答案减少了10个字节。

前缀默认功能。Munchausen数字返回1，否则返回0。

怎么样

⊢∊⊂+.*⍨⍤⊤⍨¨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语言（Mathematica），65个字节

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

在线尝试！

@attinat的-4个字节

木炭，17字节

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

在线尝试！链接是详细版本的代码。我的16字节尝试没有奏效，但这可能是Charcoal中的错误，因此请注意此空间。-除非数字是Munchausen数字，否则输出。说明：

Ｎθ                  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＃交互式编译器），99字节

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

在线尝试！

Haskell，61个字节

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

返回True蒙克豪森和False否则。

在线尝试！

C（gcc） -lm，79 75字节

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

在线尝试！

返回0Munchausen编号，1否则返回。

也是75个字节

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

在线尝试！

Python 2中，83 81个字节

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)

在线尝试！

退货 1的truthy和0对falsey。由于存在递归，因此实际上无法处理591912，但它抽象地起作用。

Perl 6的，66 65个字节

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

在线尝试！

JavaScript（ES6），88个字节

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}

图标，109字节

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

在线尝试！

超时了591912。图标被视为0^0溢出，这就是为什么我需要额外检查零的原因。

Stax，15 个字节

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

运行并调试

较大的测试用例需要很长时间。

说明：

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