的最小功率迭代若干定义如下：$n$

也就是说，提高到最低位。例如，和。$n$$n$$\text{MPI}(32)=32^2=1024$$\text{MPI}(1234)=1234^1=1234$

数字的最小幂根定义为重复应用直到找到固定点所获得的数字。下表列出了1到25之间的数字的最小幂根：$n$$\text{MPI}$

   n              MPR(n)
--------------------------
   1                   1
   2                   1
   3              531441
   4                   1
   5                3125
   6 4738381338321616896
   7                   1
   8            16777216
   9                   1
  10                   1
  11                  11
  12                  12
  13                  13
  14                  14
  15                  15
  16                  16
  17                  17
  18                  18
  19                  19
  20                   1
  21                  21
  22                   1
  23              279841
  24                   1
  25                   1

挑战：生成其最小幂根不等于1的数字或本身。

以下是此序列中的前50个数字：

3、5、6、8、23、26、27、29、35、36、39、42、47、53、59、64、72、76、78、82、83、84、92、222、223， 227、228、229、233、237、239、254、263、267、268、269、273、276、277、278、279、285、286、287、289、289、296、335、338、339、342

规则

• 您可以生成n该序列的第一个数字（索引为0或1），生成第nth项，创建一个生成器以计算这些项，无限次输出其中的许多项，依此类推。
• 您可以采用任意基数输入和给出输出，但是MPR的计算必须以10为基数。例如，您可以采用输入###（一元）和输出### ##### ######（一元）
• 您必须产生数字。您可能不会输出（例如）"3", "5", "6"，因为它们是字符串。3, 5, 6而且3 5 6都是有效的。输出2 3，"23"或者twenty-three是号码的全部视为无效表示23。（同样，您可以使用任何基数来表示这些数字。）
• 这是一个代码高尔夫球，因此最短的代码（以字节为单位）获胜。

05AB1E，8个字节

生成第n个编号1 -indexed

µNÐΔWm}‹

在线尝试！

说明

µ          # run until counter equals input
 NÐ        # push 3 copies of the current iteration index (1-based)
   Δ  }    # run this code until the result no longer changes     
    Wm     # raise the number to the power of its minimum digit
       ‹   # check if greater than the index

可以选择作为一个无限列表，且具有相同的字节数：

∞ʒDΔWm}‹

在线尝试！

Perl 6，49个字节

{grep {($_,{$_**.comb.min}...*==*).tail>$_},1..*}

在线尝试！

返回无限序列。我想以下45字节版本也适用，但是我无法证明在n次迭代后总能找到不动点。

{grep {($_,{$_**.comb.min}...*)[$_]>$_},3..*}

J，_{41 39} 37字节

(>:[echo^:(<(^0".@{/:~@":)^:_))^:_]1x

在线尝试！

这是一个打印无限序列的完整程序。很少有完整的程序在J中击败动词的情况。

怎么运行的

(>:[echo^:(<mpi_fix))^:_]1x    Using the mpi_fix below; it finds the MPI fixpoint
          (<mpi_fix)           Is mpi_fix greater than the input?
    echo^:                     If so, apply echo; do nothing otherwise
                               echo returns an empty array
 >:[                           Discard the above and return input+1
(                   )^:_       Repeat the above infinitely (increment has no fixpoint)
                        ]1x    starting from arbitrary-precision number 1

J，₄₁ 39字节

>:^:(>:(^0".@{/:~@":)^:_)^:_@>:@]^:[&0x

在线尝试！

一元动词。给定基于1的索引，返回该索引处的数字。页脚检查前20个字词是否正确。

读了“ fixpoint”一词，我立即想到“哦，是的，^:_将会做得很好。” 然后我结束了对这些愤怒和悲伤的面孔的憎恶。而且它甚至都不是火车，而是一个动词。

松散及其工作方式

nth_term =: >:^:(>:(^0".@{/:~@":)^:_)^:_@>:@]^:[&0x

mpi =: ^0".@{/:~@":    Find the MPI
             /:~@":    Sort the string representation
        0   {          Take first item
         ".@           Convert back to number
       ^               Raise the input to the power of above

mpi_fix =: mpi^:_      Find the MPI fixpoint

next_term =: >:^:(>:mpi_fix)^:_@>:    Given a number, find the next term
                               @>:    Increment once, and then...
                  >:mpi_fix           Is mpi_fix not greater than input?
             >:^:           ^:_       Increment while the above is true

nth_term =: next_term@]^:[&0x    Given one-based index, find the nth term
            next_term@]          Apply next_term monadically
                       ^:[       n times
                          &0x    to the starting value of zero

0x需要任意精度整数来精确计算定点，例如数字6。

Pyth，10个字节

.f>u^GshS`

在线尝试！

这将生成前$n$此类数字的列表。自动填充的程序具有GZZQ后缀。这简单地找到（.f）Q具有最小幂根u^GshS`G大于其自身的第一个数字Z。

最小幂根代码的工作原理是找到一个u将当前数字提高G到其最小数字的幂的固定点，该点与h按字典顺序排序的第一个数字（）相同S，然后转换回整数（s）。

果冻，10 字节

*DṂƊƬḊCȦµ#

I从STDIN 取整数的单子链接，产生第一个I条目。

在线尝试！

（也*DṂƊƬṪ%@µ#适用于10个）

怎么样？

开始计数n=0直到input遇到单调函数的真实结果并产生那些ns。

该函数反复应用另一个以开头的单子函数，x=n并收集的值，x直到结果不再唯一为止。（例如：19产率[19]; 23产率[23,529,279841]; 24产率[24, 576, 63403380965376, 1];等...），然后从队列中取出的结果（移除最左边的值）时，补充的所有值（1-x），并使用Ȧ以产生0当在列表中的零，或者如果它是空的。

最里面的函数将电流x增加到所有位数，x然后保持最小值（这样做是节省字节，而不是先找到最小值）。

*DṂƊƬḊCȦµ# - Link (call the input number I)
         # - count up from 0 and yield the first I for which this yields a truthy value:
        µ  -   a monadic chain:
    Ƭ      -     collect until results are not unique:
   Ɗ       -       last three links as a monad:
 D         -         convert to a list of decimal digits
*          -         exponentiate
  Ṃ        -         minimum
     Ḋ     -     dequeue
      C    -     compliment
       Ȧ   -     any-and-all?

Mathematica，59 51字节

^{-8个字节感谢Misha Lavrov。}

Select[Range@#,#<(#//.x_:>x^Min@IntegerDigits@x)&]&

纯功能。以数字作为输入，并返回直到该数字为止的术语列表作为输出。这里没什么复杂的。

Python 3中，₉₀ 88个字节

-2字节@mypetlion

def F(x):m=x**int(min(str(x)));return[int,F][m>x](m)
x=1
while 1:x<F(x)and print(x);x+=1

在线尝试！

print因为表达式if在Python 2中比using 语句节省了两个字节。F计算MPI固定点；其余的将无限序列赋予STDOUT。

Haskell，67 62字节

filter((<)<*>until((==)=<<g)g)[1..]
g a=a^read[minimum$show a]

返回无限列表。

在线尝试！

Ruby，52个字节

x=1;loop{b=x+=1;1while b<b**=b.digits.min;b>x&&p(x)}

在线尝试！

打印无限序列

Java的10，178个 173字节

v->{for(int x=1,m;;){var b=new java.math.BigInteger(++x+"");for(m=9;m>1;)b=b.pow(m=(b+"").chars().min().orElse(0)-48);if(b.compareTo(b.valueOf(x))>0)System.out.println(x);}}

@GB的Ruby answer的端口，因此也可以无限期打印。

在线尝试。

说明：

v->{             // Method with empty unused parameter and no return-type
  for(int x=1,   //  Start an integer `x` at 1
      m;         //  Temp integer for the smallest digit, starting uninitialized
      ;){        //  Loop indefinitely
    var b=new java.math.BigInteger(++x 
                 //   Increase `x` by 1 first
          +"");  //   And create a BigInteger `b` for the new `x`
    for(m=9;     //   Reset `m` to 9
        m>1;)    //   Loop as long as the smallest digit is not 0 nor 1
      b=b.pow(m=(b+"").chars().min().orElse(0)-48
                 //    Set `m` to the smallest digit in `b`
              ); //    Set `b` to `b` to the power of digit `m`
    if(b.compareTo(b.valueOf(x))>0)
                 //   If `b` is larger than `x`:
      System.out.println(x);}}
                 //    Print `x` with a trailing newline

JavaScript（Node.js），75字节

$n$

f=(i,x=n=1n)=>(N=x**BigInt(Math.min(...x+'')))>x?f(i,N):(i-=N>n)?f(i,++n):n

在线尝试！

JavaScript（Node.js），98 90 89 86字节

-3个字节，感谢@Conor O'Brien

function*(){for(n=0n;;x>n&&(yield n))for(x=++n;(b=Math.min(...""+x))-1;)x**=BigInt(b)}

在线尝试！

$MPR(n)>n$$MPR(n)\notin \{1,n\}$

似乎生成器比返回n数字数组短吗？

或无限打印-72个字节

for(n=0n;;x>n&&alert(n))for(x=++n;(b=Math.min(...""+x))-1;)x**=BigInt(b)

在线尝试！

果冻，14字节

3*DṂ$$ÐLḟ1,$Ɗ#

在线尝试！

JavaScript（Chrome），₇₈ 77字节

F=x=>(m=x**BigInt(Math.min(...''+x)))>x?F(m):m
for(x=0n;++x;)x<F(x)&&alert(x)

在线尝试！

我自己的Python 3解决方案的端口。Chrome支持最新版本BigInt（已在我的PC上测试）。不过，请勿在浏览器中按原样尝试此代码。

球拍，270，257个 233字节

(define(f n)(local((define(m x)(expt x(-(first(sort(map char->integer(string->list(~v x)))<))48)))(define(g y)(if(= y(m y))y(g(m y))))(define(k x l)(if(=(length l)n)l(if(< x(g x))(k(+ x 1)(cons x l))(k(+ x 1)l)))))(reverse(k 1'()))))

在线尝试！

这是我对球拍的首次投稿，因此肯定可以打得更远。尽管如此，我还是很满意的，至少对于设法解决任务很满意。

更具可读性：

(define (f n)
  (local ((define (m x)
           (expt x
                 (- (first (sort (map char->integer (string->list (~v x)))
                                 <))
                    48)))
         (define (g y)
           (if
             (= y (m y))
             y
             (g (m y))))
         (define (k x l)
           (if (= (length l) n)
               l
               (if (< x (g x))
                   (k (+ x 1) (cons x l))
                   (k (+ x 1) l))))
    (reverse (k 1 '()))))

公理，168字节

u(x)==(y:=x::String;x^reduce(min,[ord(y.i)-48 for i in 1..#y])::NNI)
q(a:PI):PI==(b:=a;repeat(c:=u(b);c=b=>break;b:=c);b)
z(x)==[i for i in 1..x|(m:=q(i))~=1 and m~=i]

使用它的函数是z（）; 在这里，它打印具有对应数字而不是1的数字，而不是本身，并且小于其自变量的数字。

(6) -> z 1000
 (6)
 [3, 5, 6, 8, 23, 26, 27, 29, 35, 36, 39, 42, 47, 53, 59, 64, 72, 76, 78, 82,
  83, 84, 92, 222, 223, 227, 228, 229, 233, 237, 239, 254, 263, 267, 268,
  269, 273, 276, 277, 278, 279, 285, 286, 287, 289, 296, 335, 338, 339, 342,
  346, 347, 348, 354, 358, 363, 365, 372, 373, 374, 376, 382, 383, 386, 392,
  394, 395, 399, 423, 424, 426, 427, 428, 432, 433, 435, 436, 442, 447, 459,
  462, 464, 466, 467, 468, 469, 476, 477, 479, 483, 487, 488, 489, 493, 494,
  523, 524, 527, 529, 533, 537, 542, 546, 553, 556, 557, 562, 563, 572, 573,
  577, 582, 583, 584, 594, 595, 598, 623, 626, 627, 629, 632, 633, 642, 646,
  647, 648, 663, 664, 669, 672, 676, 682, 683, 684, 693, 694, 695, 698, 722,
  724, 729, 736, 759, 763, 773, 775, 782, 786, 823, 829, 835, 846, 847, 856,
  873, 876, 885, 893, 894, 896, 923, 924, 928, 933, 953, 954, 962, 969, 973,
  974, 984, 993, 994, 995]
                                               Type: List PositiveInteger

Visual Basic .NET（.NET Core），290个字节（包括导入）

Iterator Function A()As System.Collections.IEnumerable
Dim i=B.One,q=i,p=i
While 1=1
q=i-1
p=i
While q<>p
For j=0To 9
If p.ToString.Contains(j)Then
q=p
p=B.Pow(p,j)
Exit For
End If
Next
End While
If p>1And p<>i Then Yield i
i+=1
End While
End Function

在线尝试！

需要以下导入：

Imports B = System.Numerics.BigInteger

这使用迭代器函数返回满足条件的整数的无限（延迟加载）列表。用于BigInteger避免任何大小限制，尤其是在进行中间计算时。

未打高尔夫球：

Iterator Function A() As System.Collections.IEnumerable
    Dim i As B = 1
    While True
        Dim prevProduct As B = 0
        Dim product As B = i
        While prevProduct <> product
            For j = 0 To 9
                If product.ToString.Contains(j) Then
                    prevProduct = product
                    product = B.Pow(product, j)
                    Exit For
                End If
            Next
        End While
        If product <> 1 And product <> i Then
            Yield i
        End If
        i += 1
    End While
End Function

普通Lisp，238个字节

(defun x(m n o p q)(setf i(sort(map 'list #'digit-char-p(prin1-to-string m))#'<))(setf j(expt m(first i)))(cond((= q p)nil)((and(= n j)(not(= n 1))(not(= n o)))(cons o(x(1+ o)0(1+ o)p(1+ q))))((= n j)(x(1+ o)0(1+ o)p q))(t(x j j o p q))))

在线尝试！

APL（NARS），96个字符，192个字节

r←f w;k;i;a
   r←⍬⋄k←1
A: i←k
B: →C×⍳i=a←i*⌊/⍎¨⍕i⋄i←a⋄→B
C: →D×⍳(a=k)∨a=1⋄r←r,k
D: k+←1⋄→A×⍳k≤w

测试（参数22的部分结果似乎很大，因此<21个我不知道是否可以的参数）

  f 21
3 5 6 8 

Python 3，102字节

x=int(input())
a=c=0
while x:
 a+=1;b=a
 while b-c:b,c=b**int(min(str(b))),b
 x-=b!=1and b!=a
print(a)

在线尝试！

决定尝试直接打印序列中第n个术语的Python 3解决方案。

C（clang） + -DL=long long -lm，213字节

q(char*a,char*b){return*a>*b;}L f(L a){char*c;asprintf(&c,"%lld",a);qsort(c,strlen(c),1,q);L b=pow(a,*c-48);return b>a?f(b):b;}i;g(j){for(i=0;j;i++){L x=f(i);x!=i&x!=1&x>0&&printf("%d\n",i)&&j--;}}

在线尝试！

函数g(j)打印j序列的第一项。

外壳，16 12 10字节

fS>ωṠ^o▼dN

由于H.PWiz，节省了6个字节。
在线尝试！

说明

fS>ωṠ^o▼dN
f        N       Filter the natural numbers where...
   ω             ... the fixed point...
    Ṡ^o▼d        ... of raising the number to its smallest digit...
 S>              ... is greater than the number.

Japt，44个字节

_ì ñ g
_gV ¥1?Z:ZpZgV)gW
@@[1X]øXgW}fXÄ}gUÄ

在线尝试！

与其他Japt答案完全不同。

说明：

                        Empty line preserves the input

_ì ñ g                Function V finds the smallest digit in a number Z
 ì                          Get the digits of Z
   ñ                        Sort the digits
     g                      Get the first (smallest) digit


_gV ¥1?Z:ZpZgV)gW     Function W finds the MPR of a number Z
 gV ¥1?Z                    If V(Z) is 1, then it's stable; return it
        :ZpZgV)             Otherwise get MPI of Z...
               gW           And call W on it ( MPR(Z) == MPR(MPI(Z)) )

@@[1X]øXgW}fXÄ}gUÄ    Main program
@             }gUÄ      Get the nth number by repeatedly applying...    
 @        }fXÄ              Find the next smallest number X which returns false to...
       XgW                    MPR(X)
      ø                       is either...
  [1X]                        1 or X

关于将来打高尔夫球的可能性，我做了很多手动调用某个数字的函数的事，我怀疑这可能会减少，但是我不确定如何做。