Die minimale Potenziteration einer Zahl $n$ ist wie folgt definiert:

Das heißt, $n$ auf die niedrigste Stelle in $n$ angehoben . Zum Beispiel ist $\text{MPI}(32)=32^2=1024$ und $\text{MPI}(1234)=1234^1=1234$ .

Die minimale Potenzwurzel einer Zahl $n$ ist definiert als die Zahl, die durch wiederholtes Anwenden von $\text{MPI}$ bis ein fester Punkt gefunden wird. Hier ist eine Tabelle der minimalen Potenzwurzeln von Zahlen zwischen 1 und 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

Aufgabe: Erzeuge die Zahlen, deren minimale Potenzwurzel ungleich 1 ist.

Hier sind die ersten 50 Zahlen in dieser Reihenfolge:

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

Regeln

• Sie können die ersten nNummern dieser Sequenz generieren (0- oder 1-indiziert), generieren Sie dien dritten Term , einen Generator erstellen, der diese Terms berechnet, unendlich viele davon ausgeben usw.
• Sie können Eingaben nehmen und Ausgaben in jeder Basis geben, aber die Berechnungen für MPR müssen in Basis 10 sein. Sie können beispielsweise Eingaben ###(in Unary) und Ausgaben nehmen### ##### ###### (in Unary) nehmen.
• Sie müssen Zahlen ergeben. Sie dürfen (zB) nicht ausgeben "3", "5", "6", da es sich um Strings handelt. 3, 5, 6und 3 5 6sind jedoch beide gültig. Das Ausgeben von 2 3, "23"oder twenty-threealle werden als ungültige Darstellungen der Zahl betrachtet 23. (Auch hier können Sie eine beliebige Basis verwenden, um diese Zahlen darzustellen.)
• Dies ist ein Code-Golf , also gewinnt der kürzeste Code (in Bytes).

05AB1E , 8 Bytes

Erzeugt die n-te Nummer 1 -indiziert

µNÐΔWm}‹

Probieren Sie es online!

Erläuterung

µ          # 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

Optional als unendliche Liste bei gleicher Byteanzahl:

∞ʒDΔWm}‹

Probieren Sie es online!

Perl 6 , 49 Bytes

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

Probieren Sie es online!

Gibt eine unendliche Folge zurück. Ich nehme an, dass die folgende 45-Byte-Version auch funktioniert, aber ich kann nicht beweisen, dass der Fixpunkt immer nach n Iterationen gefunden wird.

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

J , _{41 39} 37 Bytes

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

Probieren Sie es online!

Dieses ist ein volles Programm, das die unendliche Folge druckt. Eine sehr seltene Gelegenheit, bei der ein volles Programm ein Verb in J schlägt.

Wie es funktioniert

(>:[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 , _41-39 Bytes

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

Probieren Sie es online!

Ein monadisches Verb. Bei einem auf 1 basierenden Index wird die Nummer an diesem Index zurückgegeben. Die Fußzeile überprüft, ob die ersten 20 Begriffe korrekt sind.

Als ich das Wort "Fixpoint" las, dachte ich sofort: "Oh ja, das ^:_wird großartige Arbeit leisten." Dann endete ich mit diesem Gräuel von wütenden und traurigen Gesichtern. Und es ist nicht einmal ein Zug, es ist ein einzelnes Verb .

Ungolfed & Wie es funktioniert

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

Die Ganzzahl mit willkürlicher Genauigkeit 0xwird benötigt, um den Fixpunkt genau zu berechnen, z. B. der Zahl 6.

Pyth , 10 Bytes

.f>u^GshS`

Probieren Sie es online!

Dies erzeugt eine Liste der ersten $n$ solcher Nummern. Das automatisch gefüllte Programm hat GZZQein Suffix. Dies findet einfach ( .f) die ersten QZahlen, die eine minimale Potenzwurzel haben, die u^GshS`Ggrößer ist als sie selbst Z.

Der Root-Code für die minimale Potenz ermittelt einen festen Punkt u, an dem die aktuelle Zahl Gauf die minimale Stelle hochgesetzt wird. Dies entspricht der ersten Ziffer ( h), die lexikografisch sortiert ( S) und anschließend in eine Ganzzahl ( s) zurückgewandelt wird.

Gelee , 10 Bytes

*DṂƊƬḊCȦµ#

Ein monadischer Link, der eine Ganzzahl Ivon STDIN annimmt, die die ersten IEinträge liefert .

Probieren Sie es online!

( *DṂƊƬṪ%@µ#funktioniert auch für 10)

Wie?

Es wird gezählt, n=0bis inputwahrheitsgemäße Ergebnisse einer monadischen Funktion angetroffen werden und diese ns ergeben.

Die Funktion wendet wiederholt eine andere monadische Funktion an, beginnend mit x=nund sammelt die Werte von, xbis die Ergebnisse nicht mehr eindeutig sind. (z. B .: 19Erträge [19]; 23Erträge [23,529,279841]; 24Erträge [24, 576, 63403380965376, 1]; usw.) und reiht das Ergebnis in die Warteschlange (entfernt den am weitesten links stehenden Wert), ergänzt alle Werte ( 1-x) und verwendet, um Ȧzu ergeben, 0wenn die Liste eine Null enthält oder leer ist.

Die innerste Funktion erhöht den Strom xauf alle Ziffern von xund hält dann das Minimum (dies ist eine Byte-Ersparnis gegenüber dem Finden der minimalen Ziffer zuerst).

*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 Bytes

^{-8 Bytes dank Mischa Lawrow .}

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

Funktion pur. Nimmt eine Zahl als Eingabe und gibt die Liste der Begriffe bis zu dieser Zahl als Ausgabe zurück. Nichts sehr kompliziertes hier.

Python 3 , ₉₀ 88 Bytes

-2 Bytes von @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

Probieren Sie es online!

printWenn ein Ausdruck zwei Bytes spart, berechnet using ifstatement in Python 2 Fden MPI-Fixpunkt. der Rest gibt STDOUT die unendliche Folge.

Haskell, 67 62 Bytes

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

Gibt eine unendliche Liste zurück.

Probieren Sie es online!

Ruby , 52 Bytes

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

Probieren Sie es online!

Gibt eine unendliche Folge aus

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 von @GBs Ruby-Antwort , druckt also auch auf unbestimmte Zeit.

Probieren Sie es online aus.

Erläuterung:

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 Byte

$n$

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

Probieren Sie es online!

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

-3 Bytes danke @Conor O'Brien

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

Probieren Sie es online!

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

Scheint, dass ein Generator kürzer ist, als ein Array von nZahlen zurückzugeben?

Oder unendlich drucken - 72 Bytes

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

Probieren Sie es online!

Jelly , 14 Bytes

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

Probieren Sie es 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)

Probieren Sie es online!

Port meiner eigenen Python 3-Lösung . Die neueste Version von Chrome unterstützt BigInt(auf meinem PC getestet). Probieren Sie diesen Code nicht so aus, wie er in Ihrem Browser ist.

Schläger , 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'()))))

Probieren Sie es online!

Dies ist meine erste Racket- Einsendung, daher kann man definitiv viel weiter Golf spielen. Trotzdem bin ich etwas zufrieden, zumindest damit, die Aufgabe zu lösen.

Besser lesbar:

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

Die zu verwendende Funktion ist z (); hier druckt es Zahlen, die die Entsprechung einer Zahl haben, nicht 1, nicht sich selbst und sind kleiner als sein 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 Byte (einschließlich Importe)

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

Probieren Sie es online!

Erfordert folgenden Import:

Imports B = System.Numerics.BigInteger

Dies verwendet eine Iteratorfunktion, um eine unendliche (verzögert geladene) Liste von Ganzzahlen zurückzugeben, die die Kriterien erfüllt. VerwendetBigInteger zur Vermeidung von Größenbeschränkungen, insbesondere bei Zwischenberechnungen.

Nicht golfen:

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

Probieren Sie es online!

APL (NARS), 96 Zeichen, 192 Byte

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 (Teilergebnis für Argument 22 scheint zu groß, also <21 Argumente, ich weiß nicht, ob es in Ordnung sein kann)

  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)

Probieren Sie es online!

Beschlossen, eine Python 3-Lösung zu verwenden, die direkt den n-ten Ausdruck in der Sequenz ausgibt.

C (clang) + -DL=long long -lm213 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--;}}

Probieren Sie es online!

Funktion g(j)druckt die ersten jTerme der Sequenz.

Schale , 16 12 10 Bytes

fS>ωṠ^o▼dN

6 Bytes gespart dank H.PWiz.
Probieren Sie es online!

Erläuterung

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Ä

Probieren Sie es online!

Erheblich anders als die andere Antwort von Japt.

Erläuterung:

                        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

Im Hinblick auf zukünftige Golfmöglichkeiten rufe ich häufig manuell eine Funktion für eine Nummer an, von der ich vermute, dass sie reduziert werden könnte, aber ich bin nicht sicher, wie.