Мінімальна потужність ітерації з числа $n$ визначається таким чином :

Тобто $n$ піднято до найнижчої цифри в $n$ . Наприклад, $\text{MPI}(32)=32^2=1024$ і $\text{MPI}(1234)=1234^1=1234$ .

Мінімальний корінь потужності з числа $n$ визначається як число , отримане від багаторазового застосування $\text{MPI}$ , поки фіксована крапка не буде знайдена. Ось таблиця мінімальних коренів потужності чисел між 1 і 25:

   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, 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 байт

Генерує п - й номер 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

Спробуйте в Інтернеті!

Цей - це повна програма, що друкує нескінченну послідовність. Дуже рідкісний випадок, коли повна програма б’є дієслово в Дж.

Як це працює

(>:[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", я одразу подумав: "Так, ^:_ зробить чудову роботу". Тоді я закінчився цією гидотою розлючених і сумних облич. І це навіть не поїзд, це одне дієслово .

Ungolfed & Як це працює

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.fQu^GshS`GZ .

Корінний код мінімальної потужності працює, знаходячи фіксовану точку uпідняття поточного числа Gдо потужності його мінімальної цифри, яка є такою ж, як перша цифра ( h), сортована лексикографічно ( S), потім перетворена назад у ціле число ( s).

Желе , 10 байт

*DṂƊƬḊCȦµ#

Монадічна Посилання, що приймає ціле число I, від STDIN, яке дає перші Iзаписи.

Спробуйте в Інтернеті!

(*DṂƊƬṪ%@µ# працює також для 10)

Як?

Підраховує, починаючи з n=0тих пір, поки не inputвиявляться тридійні результати монадичної функції, і вони дають ці результатиn s.

Функція неодноразово застосовує іншу монадичну функцію, починаючи з 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?

Математика, 59 51 байт

^{-8 байтів завдяки Міші Лаврову .}

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

Чиста функція. Приймає число як вхідне і повертає список термінів до цього числа як вихід. Тут нічого дуже складного.

Пітон 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. Fобчислює точку MPI; решта надає нескінченну послідовність STDOUT.

Haskell, 67 62 байт

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

Повертає нескінченний список.

Спробуйте в Інтернеті!

Рубін , 52 байти

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

Спробуйте в Інтернеті!

Друкує нескінченну послідовність

Java 10, 178 173 bytes

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

Port of @GB's Ruby answer, so also prints indefinitely.

Try it online.

Explanation:

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 bytes

Returns the $n$^th term, 1-indexed.

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

Try it online!

JavaScript (Node.js), 98 90 89 86 bytes

-3 bytes thanks @Conor O'Brien

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

Try it online!

Using the fact that $MPR(n)>n$ if $MPR(n)\notin \{1,n\}$

Seems that a generator is shorter than returning an array of n numbers?

Or printing infinitely - 72 bytes

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

Try it online!

Jelly, 14 bytes

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

Try it online!

JavaScript (Chrome), ₇₈ 77 bytes

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

Try it online!

Port of my own Python 3 solution. The latest version of Chrome supports BigInt (tested on my PC). Don't try this code as-is on your browser though.

Racket, 270, 257 233 bytes

(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'()))))

Try it online!

This is my first Racket submission, so it can definitely be golfed much further. Nevertheless I'm somewhat content, at least for managing to solve the task.

More readable:

(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 '()))))

Axiom, 168 bytes

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]

The function to use it is z(); here it print numbers that has the corrispondence one number not 1, not itself and are less than its argument.

(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 bytes (includes imports)

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

Try it online!

Requires the following import:

Imports B = System.Numerics.BigInteger

This uses an iterator function to return an infinite (lazy loaded) list of integers that meets the criteria. Uses BigInteger to avoid any size restrictions, particularly with intermediate calculations.

Un-golfed:

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

Common Lisp, 238 bytes

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

Try it online!

APL(NARS), 96 chars, 192 bytes

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

test (partial result for argument 22 seems to much big so <21 arguments I don't know if can be ok)

  f 21
3 5 6 8 

Python 3, 102 bytes

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)

Try it online!

Decided to try a Python 3 solution that directly prints the nth term in the sequence.

C (clang) + -DL=long long -lm, 213 bytes

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

Try it online!

Function g(j) prints the first j terms of the sequence.

Husk, 16 12 10 bytes

fS>ωṠ^o▼dN

Saved 6 bytes thanks to H.PWiz.
Try it online!

Explanation

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 bytes

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

Try it online!

Substantially different from the other Japt answer.

Explanation:

                        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

In terms of future golfing possibilities, I do a lot of manually calling a function on a number, which I suspect could be reduced but I'm not sure how.