A iteração mínima de energia de um número é definida da seguinte maneira:$n$

Ou seja, elevado ao dígito mais baixo em . Por exemplo, e .$n$$n$$\text{MPI}(32)=32^2=1024$$\text{MPI}(1234)=1234^1=1234$

A raiz de potência mínima de um número é definida como o número obtido pela aplicação repetida de até que um ponto fixo seja encontrado. Aqui está uma tabela das raízes mínimas de potência dos números entre 1 e 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

Desafio: Gere os números cuja raiz de energia mínima não seja igual a 1 ou a si mesma.

Aqui estão os primeiros 50 números nesta sequência:

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, 286, 287, 289, 296, 335, 338, 339, 342

Regras

• Você pode gerar os primeiros nnúmeros desta sequência (indexados em 0 ou 1), gerar o ntermo th, criar um gerador que calcule esses termos, produza infinitamente muitos deles, etc.
• Você pode receber e fornecer saída em qualquer base, mas os cálculos para MPR devem estar na base 10. Por exemplo, você pode receber entrada ###(em unário) e saída ### ##### ######(em unário)
• Você deve produzir números. Você não pode (por exemplo) produzir "3", "5", "6", pois essas são cadeias de caracteres. 3, 5, 6e 3 5 6são ambos válidos, no entanto. Produzindo 2 3, "23"ou twenty-threesão todas as representações inválidos considerados do número 23. (Novamente, você pode usar qualquer base para representar esses números.)
• Este é um código de golfe , portanto o código mais curto (em bytes) vence.

05AB1E , 8 bytes

Gera o enésimo número 1 - indexado

µNÐΔWm}‹

Experimente online!

Explicação

µ          # 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 uma lista infinita na mesma contagem de bytes:

∞ʒDΔWm}‹

Experimente online!

Perl 6 , 49 bytes

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

Experimente online!

Retorna uma sequência infinita. Suponho que a seguinte versão de 45 bytes também funcione, mas não posso provar que o ponto fixo é sempre encontrado após n iterações.

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

J , _{41 39} 37 bytes

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

Experimente online!

Este é um programa completo que imprime a sequência infinita. Uma ocasião muito rara em que um programa completo bate um verbo em J.

Como 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

Experimente online!

Um verbo monádico. Dado um índice baseado em 1, retorna o número nesse índice. O rodapé verifica se os primeiros 20 termos estão corretos.

Ao ler a palavra "ponto fixo", pensei imediatamente "Ah, sim, ^:_fará um ótimo trabalho". Então acabei com essa abominação de rostos zangados e tristes. E nem é um trem, é um único verbo .

Ungolfed & Como 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

O número inteiro de precisão arbitrária 0xé necessário para calcular o ponto de correção com precisão, por exemplo, do número 6.

Pitão , 10 bytes

.f>u^GshS`

Experimente online!

$n$GZZQ.fQu^GshS`GZ

O código raiz da energia mínima funciona encontrando um ponto fixo ude aumentar o número atual Gà potência do seu dígito mínimo, que é o mesmo que o primeiro dígito ( h) classificado lexicograficamente ( S) e depois convertido de volta para um número inteiro ( s).

Gelatina , 10 bytes

*DṂƊƬḊCȦµ#

Um link monádico usando um número inteiro I,, de STDIN, que gera as primeiras Ientradas.

Experimente online!

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

Quão?

Contagens até iniciar um n=0até inputresultados truthy de uma função monadic são encontrados e produz essas ns.

A função aplica repetidamente outra função monádica iniciando com x=ne coleta os valores de xaté que os resultados não sejam mais exclusivos. (por exemplo: 19rendimentos [19]; 23rendimentos [23,529,279841]; 24rendimentos [24, 576, 63403380965376, 1]; etc ...) e, em seguida, retira da fila o resultado (remove o valor mais à esquerda), complementa todos os valores ( 1-x) e utiliza-o Ȧpara produzir 0quando houver um zero na lista ou se estiver vazio.

A função mais interna eleva a corrente xpara todos os dígitos de xe depois mantém o mínimo (fazer isso é uma economia de bytes em encontrar o dígito mínimo primeiro).

*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 graças a Misha Lavrov .}

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

Função pura. Pega um número como entrada e retorna a lista de termos até esse número como saída. Nada muito complicado aqui.

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

Experimente online!

printcomo uma expressão economiza dois bytes sobre a ifinstrução using no Python 2. Fcalcula o ponto de correção MPI; o resto fornece a sequência infinita para STDOUT.

Haskell, 67 62 bytes

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

Retorna uma lista infinita.

Experimente online!

Ruby , 52 bytes

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

Experimente online!

Imprime sequência infinita

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

Porta da resposta Ruby do @GB , também é impressa indefinidamente.

Experimente online.

Explicação:

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

Experimente online!

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

-3 bytes obrigado @Conor O'Brien

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

Experimente online!

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

Parece que um gerador é mais curto do que retornar uma matriz de nnúmeros?

Ou imprimindo infinitamente - 72 bytes

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

Experimente online!

Gelatina , 14 bytes

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

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

Experimente online!

Porta da minha própria solução Python 3 . A versão mais recente do Chrome suporta BigInt(testada no meu PC). Não tente esse código como está no seu navegador.

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

Experimente online!

Esta é a minha primeira finalização de raquete , para que possa definitivamente ser jogada ainda mais. No entanto, estou um pouco contente, pelo menos por conseguir resolver a tarefa.

Mais legível:

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

A função para usá-lo é z (); aqui imprime números que têm a correlação um número, não 1, não ele próprio e são menores que seu 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 (inclui importações)

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

Experimente online!

Requer a seguinte importação:

Imports B = System.Numerics.BigInteger

Isso usa uma função iteradora para retornar uma lista infinita (carregada lenta) de números inteiros que atenda aos critérios. Utilizado BigIntegerpara evitar restrições de tamanho, principalmente em cálculos intermediários.

Sem golfe:

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

Experimente online!

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

teste (o resultado parcial do argumento 22 parece muito grande, então <21 argumentos não sei se pode estar 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)

Experimente online!

Decidiu tentar uma solução Python 3 que imprime diretamente o enésimo termo na sequência.

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

Experimente online!

Função g(j)imprime os primeiros jtermos da sequência.

Casca , 16 12 10 bytes

fS>ωṠ^o▼dN

Economizou 6 bytes graças a H.PWiz.
Experimente online!

Explicação

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.

Japonês , 44 bytes

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

Experimente online!

Substancialmente diferente da outra resposta japonesa.

Explicação:

                        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

Em termos de possibilidades futuras de golfe, chamo muitas funções manualmente para um número, o que, suspeito, pode ser reduzido, mas não sei como.