L' itération de puissance minimale d'un nombre est définie comme suit:$n$

Autrement dit, élevé au chiffre le plus bas de . Par exemple, et .$n$$n$$\text{MPI}(32)=32^2=1024$$\text{MPI}(1234)=1234^1=1234$

La racine de puissance minimale d'un nombre est définie comme le nombre obtenu à partir de l'application répétée de jusqu'à ce qu'un point fixe soit trouvé. Voici un tableau des racines de puissance minimales des nombres compris entre 1 et 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

Défi: générer les nombres dont la racine de puissance minimale n'est pas égale à 1 ou elle-même.

Voici les 50 premiers chiffres de cette séquence:

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

Règles

• Vous pouvez générer les premiers nnombres de cette séquence (indexés 0 ou 1), générer le ne terme, créer un générateur qui calcule ces termes, en produire une infinité de nombres, etc.
• Vous pouvez prendre une entrée et donner une sortie dans n'importe quelle base, mais les calculs pour MPR doivent être en base 10. Par exemple, vous pouvez prendre une entrée ###(en unaire) et une sortie ### ##### ######(en unaire)
• Vous devez donner des chiffres. Vous ne pouvez pas (par exemple) sortir "3", "5", "6", car ce sont des chaînes. 3, 5, 6et 3 5 6sont tous deux valides, cependant. La sortie de 2 3, "23"ou twenty-threesont toutes considérées comme des représentations non valides du nombre 23. (Encore une fois, vous pouvez utiliser n'importe quelle base pour représenter ces nombres.)
• Il s'agit d'un code-golf , donc le code le plus court (en octets) l'emporte.

05AB1E , 8 octets

Génère le nième numéro 1 -indexé

µNÐΔWm}‹

Essayez-le en ligne!

Explication

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

En option sous forme de liste infinie avec le même nombre d'octets:

∞ʒDΔWm}‹

Essayez-le en ligne!

Perl 6 , 49 octets

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

Essayez-le en ligne!

Renvoie une séquence infinie. Je suppose que la version suivante de 45 octets fonctionne aussi, mais je ne peux pas prouver que le point fixe est toujours trouvé après n itérations.

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

J , _{41 39} 37 octets

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

Essayez-le en ligne!

Celui-ci est un programme complet imprimant la séquence infinie. Une occasion très rare où un programme complet bat un verbe en J.

Comment ça marche

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

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

Essayez-le en ligne!

Un verbe monadique. Étant donné un index basé sur 1, renvoie le nombre à cet index. Le pied de page vérifie que les 20 premiers termes sont corrects.

En lisant le mot "point fixe", j'ai immédiatement pensé "Oh ouais, ^:_fera du bon travail." Puis je me suis retrouvé avec cette abomination de visages en colère et tristes. Et ce n'est même pas un train, c'est un seul verbe .

Ungolfed & Comment ça marche

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'entier de précision arbitraire 0xest nécessaire pour calculer le point fixe avec précision, par exemple du nombre 6.

Pyth , 10 octets

.f>u^GshS`

Essayez-le en ligne!

$n$GZZQ.fQu^GshS`GZ

Le code racine de puissance minimale fonctionne en trouvant un point fixe upour élever le nombre actuel Gà la puissance de son chiffre minimal, qui est le même que le premier chiffre ( h) trié lexicographiquement ( S), puis reconverti en entier ( s).

Gelée , 10 octets

*DṂƊƬḊCȦµ#

Un lien monadique prenant un entier I,, de STDIN qui donne les premières Ientrées.

Essayez-le en ligne!

( *DṂƊƬṪ%@µ#fonctionne pour 10 aussi)

Comment?

Incrémentation à partir d' un n=0jusqu'à ce que les inputrésultats truthy d'une fonction monadique sont rencontrées et les rendements de ces ns.

La fonction applique à plusieurs reprises une autre fonction monadique en commençant par x=net collecte les valeurs de xjusqu'à ce que les résultats ne soient plus uniques. (par exemple: les 19rendements [19], les 23rendements [23,529,279841], les 24rendements [24, 576, 63403380965376, 1], etc ...) et dequeues le résultat (supprime la valeur extrême gauche), vient compléter toutes les valeurs ( 1-x) et les utilisations Ȧpour produire 0quand il y a un zéro dans la liste ou si elle est vide.

La fonction la plus intérieure élève le courant xà tous les chiffres de xpuis conserve le minimum (cela est une sauvegarde d'octets par rapport à la recherche du chiffre minimum en premier).

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

^{-8 octets grâce à Misha Lavrov .}

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

Fonction pure. Prend un nombre en entrée et renvoie la liste des termes jusqu'à ce nombre en sortie. Rien de bien compliqué ici.

Python 3 , ₉₀ 88 octets

-2 octets par @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

Essayez-le en ligne!

printen tant qu'expression enregistre deux octets par rapport à l'utilisation de l' ifinstruction en Python 2. Fcalcule le point fixe MPI; le reste donne la séquence infinie à STDOUT.

Haskell, 67 62 octets

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

Renvoie une liste infinie.

Essayez-le en ligne!

Rubis , 52 octets

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

Essayez-le en ligne!

Imprime une séquence infinie

Java 10, 178 173 octets

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 de la réponse Ruby de @GB , imprime donc également indéfiniment.

Essayez-le en ligne.

Explication:

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 octets

$n$

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

Essayez-le en ligne!

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

-3 octets merci @Conor O'Brien

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

Essayez-le en ligne!

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

Semble qu'un générateur est plus court que de renvoyer un tableau de nnombres?

Ou l'impression à l'infini - 72 octets

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

Essayez-le en ligne!

Gelée , 14 octets

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

Essayez-le en ligne!

JavaScript (Chrome), ₇₈ 77 octets

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

Essayez-le en ligne!

Port de ma propre solution Python 3 . La dernière version de Chrome est prise en charge BigInt(testée sur mon PC). N'essayez pas ce code tel quel sur votre navigateur.

Raquette , 270, 257 233 octets

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

Essayez-le en ligne!

Ceci est ma première soumission de Racket , donc il peut certainement être joué beaucoup plus loin. Néanmoins, je suis quelque peu satisfait, du moins pour avoir réussi à résoudre la tâche.

Plus lisible:

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

Axiome, 168 octets

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 fonction pour l'utiliser est z (); ici, il imprime des nombres qui ont la corrélation un nombre non 1, pas lui-même et sont inférieurs à son 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 octets (inclut les importations)

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

Essayez-le en ligne!

Nécessite l'importation suivante:

Imports B = System.Numerics.BigInteger

Cela utilise une fonction d'itérateur pour renvoyer une liste infinie (chargée paresseusement) d'entiers qui répond aux critères. Utilise BigIntegerpour éviter toute restriction de taille, en particulier avec des calculs intermédiaires.

Non-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 commun , 238 octets

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

Essayez-le en ligne!

APL (NARS), 96 caractères, 192 octets

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 (le résultat partiel de l'argument 22 semble beaucoup plus grand, donc <21 arguments, je ne sais pas si ça peut aller)

  f 21
3 5 6 8 

Python 3 , 102 octets

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)

Essayez-le en ligne!

Décidé d'essayer une solution Python 3 qui imprime directement le nième terme de la séquence.

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

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

Essayez-le en ligne!

La fonction g(j)imprime les premiers jtermes de la séquence.

Husk , 16 12 10 octets

fS>ωṠ^o▼dN

6 octets enregistrés grâce à H.PWiz.
Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Substantiellement différent de l'autre réponse Japt.

Explication:

                        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 termes de futures possibilités de golf, j'appelle beaucoup une fonction manuellement sur un numéro, ce qui pourrait être réduit, mais je ne sais pas comment.