La iteración de potencia mínima de un número se define de la siguiente manera:$n$

Es decir, elevado al dígito más bajo en . Por ejemplo, y .$n$$n$$\text{MPI}(32)=32^2=1024$$\text{MPI}(1234)=1234^1=1234$

La raíz de potencia mínima de un número se define como el número obtenido al aplicar repetidamente hasta que se encuentre un punto fijo. Aquí hay una tabla de las raíces de potencia mínima de los números entre 1 y 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

Desafío: genere los números cuya raíz de potencia mínima no sea igual a 1 o en sí misma.

Aquí están los primeros 50 números en esta secuencia:

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

Reglas

• Puede generar los primeros nnúmeros de esta secuencia (indexados 0 o 1), generar el ntérmino th, crear un generador que calcule estos términos, generar infinitos de ellos, etc.
• Puede tomar entrada y dar salida en cualquier base, pero los cálculos para MPR deben estar en base 10. Por ejemplo, puede tomar entrada ###(en unario) y salida ### ##### ######(en unario)
• Usted debe dar números. No puede (p. Ej.) Salida "3", "5", "6", ya que son cadenas. 3, 5, 6y 3 5 6ambos son válidos, sin embargo. La salida 2 3, "23"o twenty-threetodos se consideran representaciones no válidas del número 23. (Nuevamente, puede usar cualquier base para representar estos números).
• Este es un código de golf , por lo que gana el código más corto (en bytes).

05AB1E , 8 bytes

Genera el enésimo número 1 -indexado

µNÐΔWm}‹

Pruébalo en línea!

Explicación

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

Opcionalmente como una lista infinita en el mismo conteo de bytes:

∞ʒDΔWm}‹

Pruébalo en línea!

Perl 6 , 49 bytes

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

Pruébalo en línea!

Devuelve una secuencia infinita. Supongo que la siguiente versión de 45 bytes también funciona, pero no puedo probar que el punto fijo siempre se encuentre después de n iteraciones.

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

J , _{41 39} 37 bytes

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

Pruébalo en línea!

Este es un programa completo que imprime la secuencia infinita. Una ocasión muy rara en la que un programa completo supera un verbo en J.

Cómo funciona

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

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

Pruébalo en línea!

Un verbo monádico. Dado un índice basado en 1, devuelve el número en ese índice. El pie de página verifica que los primeros 20 términos sean correctos.

Al leer la palabra "punto fijo", inmediatamente pensé "Oh, sí, ^:_hará el gran trabajo". Luego terminé con esta abominación de rostros enojados y tristes. Y ni siquiera es un tren, es un solo verbo .

Ungolfed y cómo funciona

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

El entero de precisión arbitraria 0xes necesario para calcular el punto fijo con precisión, por ejemplo, del número 6.

Pyth , 10 bytes

.f>u^GshS`

Pruébalo en línea!

$n$GZZQ.fQu^GshS`GZ

El código raíz de potencia mínima funciona al encontrar un punto fijo ude elevar el número actual Ga la potencia de su dígito mínimo, que es el mismo que el primer dígito ( h) ordenado lexicográficamente ( S), y luego convertido de nuevo a un entero ( s).

Jalea , 10 bytes

*DṂƊƬḊCȦµ#

Un enlace monádico que toma un número entero I, de STDIN, que produce las primeras Ientradas.

Pruébalo en línea!

( *DṂƊƬṪ%@µ#funciona para 10 también)

¿Cómo?

Cuenta comenzando n=0hasta que se inputencuentren resultados verdaderos de una función monádica y produzca esos ns.

La función aplica repetidamente otra función monádica que comienza x=ny recopila los valores de xhasta que los resultados ya no sean únicos. (por ejemplo: 19rendimientos [19]; 23rendimientos [23,529,279841]; 24rendimientos [24, 576, 63403380965376, 1]; etc.) y luego quita el resultado (elimina el valor situado más a la izquierda), complementa todos los valores ( 1-x) y utiliza Ȧpara producir 0cuando hay un cero en la lista o si está vacío.

La función más interna eleva la corriente xa todos los dígitos de xy luego mantiene el mínimo (hacer esto es un ahorro de bytes sobre la búsqueda del dígito mínimo primero).

*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 gracias a Misha Lavrov .}

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

Pura función. Toma un número como entrada y devuelve la lista de términos hasta ese número como salida. Nada muy complicado aquí.

Python 3 , ₉₀ 88 bytes

-2 bytes por @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

Pruébalo en línea!

printcomo una expresión ahorra dos bytes sobre el uso de la ifdeclaración en Python 2. Fcalcula el punto de fijación MPI; el resto le da la secuencia infinita a STDOUT.

Haskell, 67 62 bytes

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

Devuelve una lista infinita.

Pruébalo en línea!

Ruby , 52 bytes

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

Pruébalo en línea!

Imprime secuencia infinita

Java 10, 178173 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);}}

El puerto de la respuesta de Ruby de @GB , también se imprime indefinidamente.

Pruébalo en línea.

Explicación:

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

$n$

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

Pruébalo en línea!

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

-3 bytes gracias @Conor O'Brien

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

Pruébalo en línea!

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

¿Parece que un generador es más corto que devolver una matriz de nnúmeros?

O imprimiendo infinitamente - 72 bytes

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

Pruébalo en línea!

Jalea , 14 bytes

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

Pruébalo en línea!

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)

Pruébalo en línea!

Puerto de mi propia solución Python 3 . La última versión de Chrome es compatible BigInt(probado en mi PC). Sin embargo, no intente este código tal como está en su navegador.

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

Pruébalo en línea!

Esta es mi primera presentación de Racket , por lo que definitivamente se puede jugar mucho más. Sin embargo, estoy algo contento, al menos por lograr resolver la tarea.

Más legible:

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

Axioma, 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]

La función para usarlo es z (); aquí imprime números que tienen la correspondencia de un número no 1, no en sí mismo y son menores que su argumento.

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

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

Pruébalo en línea!

Requiere la siguiente importación:

Imports B = System.Numerics.BigInteger

Esto usa una función de iterador para devolver una lista infinita de enteros que cumple con los criterios. Se utiliza BigIntegerpara evitar restricciones de tamaño, particularmente con cálculos intermedios.

Sin 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 común , 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))))

Pruébalo en línea!

APL (NARS), 96 caracteres, 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

prueba (el resultado parcial para el argumento 22 parece demasiado grande, por lo que <21 argumentos no sé si puede estar bien)

  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)

Pruébalo en línea!

Decidí probar una solución de Python 3 que imprime directamente el enésimo término en la secuencia.

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

Pruébalo en línea!

La función g(j)imprime los primeros jtérminos de la secuencia.

Casco , 16 12 10 bytes

fS>ωṠ^o▼dN

Guardado 6 bytes gracias a H.PWiz.
Pruébalo en línea!

Explicación

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Ä

Pruébalo en línea!

Sustancialmente diferente de la otra respuesta de Japt.

Explicación:

                        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

En términos de posibilidades futuras de golf, hago muchas llamadas manuales a una función en un número, que sospecho que podría reducirse, pero no estoy seguro de cómo.