L' iterazione di potenza minima di un numero è definita come segue:$n$

Cioè, elevato alla cifra più bassa in . Ad esempio, e .$n$$n$$\text{MPI}(32)=32^2=1024$$\text{MPI}(1234)=1234^1=1234$

La radice di potenza minima di un numero $n$ è definita come il numero ottenuto dall'applicazione ripetuta di $\text{MPI}$ fino a quando non viene trovato un punto fisso. Ecco una tabella delle radici di potenza minima di numeri tra 1 e 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

Sfida: genera i numeri la cui radice minima di potenza non è uguale a 1 o a se stessa.

Ecco i primi 50 numeri in questa sequenza:

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

Regole

• È possibile generare i primi nnumeri di questa sequenza (0 o 1 indicizzati), generare il ntermine th, creare un generatore che calcola questi termini, emetterne infiniti molti, ecc.
• Puoi prendere input e dare output in qualsiasi base, ma i calcoli per MPR devono essere in base 10. Ad esempio, puoi prendere input ###(in unario) e output ### ##### ######(in unario)
• È necessario dare i numeri. Non è possibile (ad es.) Produrre "3", "5", "6", poiché si tratta di stringhe. 3, 5, 6e 3 5 6sono entrambi validi, tuttavia. L'output 2 3, "23"o twenty-threesono tutti considerati rappresentazioni non valide del numero 23. (Ancora una volta, è possibile utilizzare qualsiasi base per rappresentare questi numeri.)
• Questo è un code-golf , quindi vince il codice più breve (in byte).

05AB1E , 8 byte

Genera l' ennesimo numero 1 -indexed

µNÐΔWm}‹

Provalo online!

Spiegazione

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

Facoltativamente come un elenco infinito con lo stesso numero di byte:

∞ʒDΔWm}‹

Provalo online!

Perl 6 , 49 byte

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

Provalo online!

Restituisce una sequenza infinita. Suppongo che anche la seguente versione a 45 byte funzioni, ma non posso dimostrare che il punto fisso si trova sempre dopo n iterazioni.

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

J , _{41 39} 37 byte

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

Provalo online!

Questo è un programma completo che stampa la sequenza infinita. Un'occasione molto rara in cui un programma completo batte un verbo in J.

Come funziona

(>:[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 byte

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

Provalo online!

Un verbo monadico. Dato un indice basato su 1, restituisce il numero in quell'indice. Il piè di pagina verifica che i primi 20 termini siano corretti.

Leggendo la parola "fixpoint", ho subito pensato "Oh sì, ^:_farà un ottimo lavoro". Poi ho finito con questo abominio di facce arrabbiate e tristi. E non è nemmeno un treno, è un singolo verbo .

Ungolfed e come funziona

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

L'intero di precisione arbitraria 0xè necessario per calcolare accuratamente il punto fisso, ad es. Del numero 6.

Pyth , 10 byte

.f>u^GshS`

Provalo online!

$n$GZZQ.fQu^GshS`GZ

Il codice root di potenza minima funziona trovando un punto fisso uper elevare il numero corrente Galla potenza della sua cifra minima, che è la stessa della prima cifra ( h) ordinata lessicograficamente ( S), quindi riconvertita in un numero intero ( s).

Gelatina , 10 byte

*DṂƊƬḊCȦµ#

Un collegamento monadico che prende un numero intero I, da STDIN che produce le prime Ivoci.

Provalo online!

( *DṂƊƬṪ%@µ#funziona anche per 10)

Come?

Conta fino a n=0quando non si inputincontrano risultati veritieri di una funzione monadica e produce quelli ns.

La funzione applica ripetutamente un'altra funzione monadica che inizia con x=ne raccoglie i valori xfino a quando i risultati non sono più univoci. (ad esempio: 19rese [19]; 23rese [23,529,279841]; 24rese [24, 576, 63403380965376, 1]; ecc ...) e quindi dequeues il risultato (rimuove il valore più a sinistra), integra tutti i valori ( 1-x) e usa Ȧper produrre 0quando c'è uno zero nell'elenco o se è vuoto.

La funzione più interna aumenta la corrente xa tutte le cifre di xe quindi mantiene il minimo (facendo ciò si risparmia un byte nel trovare prima la cifra minima).

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

^{-8 byte grazie a Misha Lavrov .}

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

Funzione pura. Accetta un numero come input e restituisce l'elenco di termini fino a quel numero come output. Niente di molto complicato qui.

Python 3 , ₉₀ 88 byte

-2 byte di @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

Provalo online!

printpoiché un'espressione salva due byte usando l' ifistruzione in Python 2. Fcalcola il fixpoint MPI; il resto dà la sequenza infinita a STDOUT.

Haskell, 67 62 byte

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

Restituisce un elenco infinito.

Provalo online!

Rubino , 52 byte

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

Provalo online!

Stampa una sequenza infinita

Java 10, 178 173 byte

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

Porta della risposta Ruby di @GB , quindi stampa anche a tempo indeterminato.

Provalo online.

Spiegazione:

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

Restituisce il $n$^esimo termine, 1-indicizzato.

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

Provalo online!

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

-3 byte grazie @Conor O'Brien

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

Provalo online!

Usando il fatto che $MPR(n)>n$ Se $MPR(n)\notin \{1,n\}$

Sembra che un generatore sia più corto rispetto alla restituzione di una matrice di n numeri?

O stampa all'infinito - 72 byte

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

Provalo online!

Gelatina , 14 byte

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

Provalo online!

JavaScript (Chrome), ₇₈ 77 byte

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

Provalo online!

Porta della mia soluzione Python 3 . L'ultima versione di Chrome supporta BigInt(testata sul mio PC). Non provare questo codice così com'è sul tuo browser.

Racchetta , 270, 257 233 byte

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

Provalo online!

Questa è la mia prima presentazione per la racchetta , quindi può sicuramente essere giocata a golf molto di più. Tuttavia sono in qualche modo contento, almeno per riuscire a risolvere il compito.

Più leggibile:

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

Assioma, 168 byte

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]

La funzione per usarlo è z (); qui stampa numeri che hanno la corrispondenza un numero non 1, non se stesso e sono inferiori al suo argomento.

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

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

Provalo online!

Richiede la seguente importazione:

Imports B = System.Numerics.BigInteger

Questo utilizza una funzione iteratore per restituire un elenco infinito di numeri interi caricati in modo pigro che soddisfa i criteri. Utilizza BigIntegerper evitare qualsiasi limitazione dimensionale, in particolare con calcoli intermedi.

Un-giocato a golf:

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 comune , 238 byte

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

Provalo online!

APL (NARS), 96 caratteri, 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 (il risultato parziale per l'argomento 22 sembra molto grande, quindi <21 argomenti non so se può essere ok)

  f 21
3 5 6 8 

Python 3 , 102 byte

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)

Provalo online!

Ha deciso di provare una soluzione Python 3 che stampa direttamente l'ennesimo termine nella sequenza.

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

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

Provalo online!

La funzione g(j)stampa i primi jtermini della sequenza.

Husk , 16 12 10 byte

fS>ωṠ^o▼dN

6 byte salvati grazie a H.PWiz.
Provalo online!

Spiegazione

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 byte

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

Provalo online!

Sostanzialmente diverso dall'altra risposta di Japt.

Spiegazione:

                        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 termini di future possibilità di golf, faccio molte chiamate manualmente a una funzione su un numero, che sospetto possa essere ridotto, ma non sono sicuro di come.