[Question]
  [
The *minimal power iteration* of a number \$n\$ is defined as follows:
$$\text{MPI}(n):=n^{\text{min}(\text{digits}(n))}$$
That is, \$n\$ raised to the lowest digit in \$n\$. For example, \$\text{MPI}(32)=32^2=1024\$ and \$\text{MPI}(1234)=1234^1=1234\$.
The *minimal power root* of a number \$n\$ is defined as the number obtained from repeatedly applying \$\text{MPI}\$ until a fixed point is found. Here is a table of the minimal power roots of numbers between 1 and 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
```
**Challenge:** Generate the numbers whose minimal power root is not equal to 1 or itself.
Here are the first 50 numbers in this sequence:
> 
> 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
> 
> 
> 
## Rules
* You may generate the first `n` numbers of this sequence (0- or 1-indexed), generate the `n`th term, create a generator which calculates these terms, output infinitely many of them, etc.
* You may take input and give output in any base, but the calculations for MPR must be in base 10. E.g., you may take input `###` (in unary) and output `### ##### ######` (in unary)
* You **must** yield numbers. You may not (e.g.) output `"3", "5", "6"`, since those are strings. `3, 5, 6` and `3 5 6` are both valid, however. Outputting `2 3`, `"23"`, or `twenty-three` are all considered invalid representations of the number `23`. (Again, you may use any base to represent these numbers.)
* This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code (in bytes) wins.
  
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 49 bytes
```
{grep {($_,{$_**.comb.min}...*==*).tail>$_},1..*}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/Or0otUChWkMlXqdaJV5LSy85PzdJLzczr1ZPT0/L1lZLU68kMTPHTiW@VscQKFL7vzixUiFNQzM6ztQg9j8A "Perl 6 – Try It Online")
Returns an infinite sequence. I suppose that the following 45 byte version works, too, but I can't prove that the fixed point is always found after n iterations.
```
{grep {($_,{$_**.comb.min}...*)[$_]>$_},3..*}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
Generates the **nth** number **1**-indexed
```
µNÐΔWm}‹
```
[Try it online!](https://tio.run/##yy9OTMpM/f//0Fa/wxPOTQnPrX3UsPP/f0MjAA "05AB1E – Try It Online")
**Explanation**
```
µ          # 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
```
Optionally as an infinite list at the same byte count:
```
∞ʒDΔWm}‹
```
[Try it online!](https://tio.run/##yy9OTMpM/f//Uce8U5Nczk0Jz6191LDz/39DIwA "05AB1E – Try It Online")
[Answer]
# [J](http://jsoftware.com/), ~~41~~ ~~39~~ 37 bytes
```
(>:[echo^:(<(^0".@{/:~@":)^:_))^:_]1x
```
[Try it online!](https://tio.run/##y/r/X8POKjo1OSM/zkrDRiPOQEnPoVrfqs5ByUozzipeE0TEGlb8/w8A "J – Try It Online")
This one is a full program printing the infinite sequence. A very rare occasion where a full program beats a verb in J.
### How it works
```
(>:[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](http://jsoftware.com/), ~~41~~ 39 bytes
```
>:^:(>:(^0".@{/:~@":)^:_)^:_@>:@]^:[&0x
```
[Try it online!](https://tio.run/##y/qvpKegnqZga6WuoKNQa6VgoADE/@2s4qw07Kw04gyU9Byq9a3qHJSsNOOs4kHYwc7KITbOKlrNoOK/Jldqcka@QpqStoKdlUKmnpHBfwA "J – Try It Online")
A monadic verb. Given a 1-based index, returns the number at that index. The footer checks that first 20 terms are correct.
Reading the word "fixpoint", I immediately thought "Oh yeah, `^:_` will do the great job." Then I ended up with this abomination of angry and sad faces. And it's not even a train, it's a *single verb*.
### Ungolfed & How it works
```
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
```
The arbitrary-precision integer `0x` is needed to compute the fixpoint accurately, e.g. of the number 6.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 10 bytes
```
.f>u^GshS`
```
[Try it online!](https://tio.run/##K6gsyfj/Xy/NrjTOvTgjOOH/f1MDAA "Pyth – Try It Online")
This generates a list of the first \$ n \$ such numbers. The auto-filled program has `GZZQ` as a suffix. This simply finds (`.f`) the first `Q` numbers that have a minimal power root `u^GshS`G` greater than itself `Z`.
The minimal power root code works by finding a fixed point `u` of raising the current number `G` to the power of it's minimal digit, which is the same as the first digit (`h`) sorted lexicographically (`S`), then converted back to an integer (`s`).
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
*DṂƊƬḊCȦµ#
```
A monadic Link taking an integer, `I`, from STDIN which yields the first `I` entries.
**[Try it online!](https://tio.run/##AR0A4v9qZWxsef//KkThuYLGisas4biKQ8imwrUj//81MA "Jelly – Try It Online")**
(`*DṂƊƬṪ%@µ#` works for 10 too)
### How?
Counts up starting a `n=0` until `input` truthy results of a monadic function are encountered and yields those `n`s.
The function repeatedly applies another monadic function starting with `x=n` and collects the values of `x` until the results are no longer unique. (e.g.: `19` yields `[19]`; `23` yields `[23,529,279841]`; `24` yields `[24, 576, 63403380965376, 1]`; etc...) and then dequeues the result (removes the leftmost value), complements all the values (`1-x`) and uses `Ȧ` to yield `0` when there is a zero in the list or if it's empty.
The innermost function raises the current `x` to *all* the digits of `x` and then keeps the minimum (doing this is a byte save over finding the minimum digit first).
```
*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?
```
[Answer]
# Mathematica, ~~59~~ 51 bytes
*-8 bytes thanks to [Misha Lavrov](https://codegolf.stackexchange.com/users/74672).*
```
Select[Range@#,#<(#//.x_:>x^Min@IntegerDigits@x)&]&
```
Pure function. Takes a number as input, and returns the list of terms up to that number as output. Nothing very complicated here.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~90~~ 88 bytes
-2 bytes by @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
```
[Try it online!](https://tio.run/##FcuxCoAgEADQ3a9w9KxF2iwb@4loCDQU8hIzur7ean3w0lP8gV2t1m18EgQ6GpIyYBExoDhL/gygz65cGefP22mZ40iLiMDIKHb7sDuuNA1/X9HylP9O0FNjVK0v "Python 3 – Try It Online")
`print` as an expression saves two bytes over using `if` statement in Python 2. `F` computes the MPI fixpoint; the rest gives the infinite sequence to STDOUT.
[Answer]
## Haskell, ~~67~~ 62 bytes
```
filter((<)<*>until((==)=<<g)g)[1..]
g a=a^read[minimum$show a]
```
Returns an infinite list.
[Try it online!](https://tio.run/##DcbBDsIgDADQu1/Rww5g4qIHb9Qf2WbSTGDNChJg8e@tvtPbqO1eRAPOGli6r8Y4686PI3cWYxAtOhdttNNtHJdTBEJ6Vk@vKXHmdKShbe8P0KKJOANCqZw7DNBp93C//hf0uwah2PSylvID "Haskell – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 52 bytes
```
x=1;loop{b=x+=1;1while b<b**=b.digits.min;b>x&&p(x)}
```
[Try it online!](https://tio.run/##KypNqvz/v8LW0DonP7@gOsm2QhvINizPyMxJVUiySdLSsk3SS8lMzywp1svNzLNOsqtQUyvQqNCs/f8fAA "Ruby – Try It Online")
Prints infinite sequence
[Answer]
# 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 of [*@GB*'s Ruby answer](https://codegolf.stackexchange.com/a/174029/52210), so also prints indefinitely.
[Try it online.](https://tio.run/##LZA9T8MwEIb3/opTJ1slVisxgKxkQGJgoAxFLIjBdp3UwR@R47hBUX57uECX@35191wrsija8/eirOh7eBXGTxsA45OOtVAajmsKkIM5gyIfq8uUY23eoOmTSEbBETyUsOSimuoQCaphLA93jnM6ZRFBll5focVdzIl0YU@mecENjY5ktxt32y3lq86Vj9xVB05lKVkXrlggcu0ydRGxJ5Q549GG@Gx7Tfa0uH@g3NREMhVcJ6J@DxhnYQf9VpOR0mpPTz990o6FIbEu4mXWY4PP88JXgG6QFgFuHH@UDn9ATglnm88vEPT/AZ4p4gdrb@zz8gs)
**Explanation:**
```
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
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 75 bytes
Returns the \$n\$th term, 1-indexed.
```
f=(i,x=n=1n)=>(N=x**BigInt(Math.min(...x+'')))>x?f(i,N):(i-=N>n)?f(i,++n):n
```
[Try it online!](https://tio.run/##HYvBCoJAEEB/ZQ6BM24ueehijUG3DvkNLqY2YbOhEgvRt29Lt/fgvYd7u6Wb5bUW6m99jAOjbAMrl0pcY8Mhz88yXnTFq1vv9imK1tpgsoyI6nAaUt9QhVJwUyv93RilSuPgZxRgKA8gcGTY7xIYQ9B5XfzU28mP2DrcfORLqWvBQNqJ4g8 "JavaScript (Node.js) – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~98~~ ~~90~~ ~~89~~ 86 bytes
-3 bytes thanks @Conor O'Brien
```
function*(){for(n=0n;;x>n&&(yield n))for(x=++n;(b=Math.min(...""+x))-1;)x**=BigInt(b)}
```
[Try it online!](https://tio.run/##FcuxDoIwEIDh3ae4MJA7GhocnGod3Bx8iAIFa@BqSiU1xmevMH3Dn/9pVrN0wb1izb632WjMw5u76DxXSN/BB2TdsFLpwmWJH2enHphoD0kLwQpbfTfxIWfHKKUsCpGI6qOiVFX66sYbR2zplwlJHbYNcDUBHGho1MYZTrtCEHSeFz9ZOfkRjWSbIhLlPw "JavaScript (Node.js) – Try It Online")
Using the fact that \$MPR(n)>n\$ if \$MPR(n)\notin \{1,n\}\$
Seems that a generator is shorter than returning an array of `n` numbers?
Or printing infinitely - 72 bytes
```
for(n=0n;;x>n&&alert(n))for(x=++n;(b=Math.min(...""+x))-1;)x**=BigInt(b)
```
[Try it online!](https://tio.run/##HcoxDsIwDAXQu3So7Ea1YI7MwMbAIdISSlD4RmmEcvsgWJ/eM3zCvpb0rjPsFnvIsVRdDbvlKNm2frdC0AO8byeM4z8QmH/e1Dl4WvQa6kNeCSQiw@Aa83z03KZJz2m7oNLCvX8B "JavaScript (Node.js) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~171~~ ~~153~~ 138 bytes
```
__int128 m,a,t,h,s;r(){for(a=10,h=s;a=fmin(h%10,a),h/=10;);a=pow(s,a);a-s&&r(s=a);}f(n){for(;t-n;a-1&&a-m&&printf("%lu ",m,t++))r(s=++m);}
```
Outputs the first `n` terms whose MPRs are representable within the largest "integer" type.
Brute-forces the solution but still works surprisingly fast.
Some things may be able to be inlined (such as `r`, which is only called once), but it may require a decent amount of effort.
See previous revision for solution without `-lm`.
*-18 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!*
*-15 bytes and ultra-precision thanks to [rtpax](https://codegolf.stackexchange.com/users/85545/rtpax)!*
[Try it online!](https://tio.run/##JY3BCsMgEETv@QoJRBRXmhQKBfFbwmIxBmIS1LaHkF@v3dI57cxjdpyenKt1HOe1DNc7i4BQIEA2ScjDb0mgHXoINhu0Ps6rCB15lBAuBIykeN/eIlNkUGfOk8iW7tOL9f/AFL0SGjhHHTnfE0150XbLk7UQoSgl5a@kVKRaJcoi0tBrmx@yORpG8uLWS9Oc9eP8glOueolf "C (gcc) – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 6 bytes
```
λfge;Ẋ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%CE%BBfge%3B%E1%BA%8A&inputs=9&header=&footer=)
```
λ   ;Ẋ # While result changes...
 f     # Convert to digitlist
  g    # Take minimum
   e   # Number to power of that
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 14 bytes
```
3*DṂ$$ÐLḟ1,$Ɗ#
```
[Try it online!](https://tio.run/##y0rNyan8/99Yy@XhziYVlcMTfB7umG@oo3KsS/n///@mBgA "Jelly – Try It Online")
[Answer]
# JavaScript (Chrome), ~~78~~ 77 bytes
```
F=x=>(m=x**BigInt(Math.min(...''+x)))>x?F(m):m
for(x=0n;++x;)x<F(x)&&alert(x)
```
[Try it online!](https://tio.run/##HczBCsIwDADQux@yJSsGz85M8FDYwY8os85K20hXRv6@ird3em@3u20p4VOPWR6@uehL5UXyJtFTlLVZVp4gsQ7DLaxzrnB39UUpZCCivjeKiJNeLSQ8p8NTCiif8miMjqgXC4pd929/au0L "JavaScript (Node.js) – Try It Online")
Port of [my own Python 3 solution](https://codegolf.stackexchange.com/a/174023/78410). The latest version of Chrome supports `BigInt` (tested on my PC). Don't try this code as-is on your browser though.
[Answer]
# [Racket](https://racket-lang.org/), 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'()))))
```
[Try it online!](https://tio.run/##RY9BasNADEWvIuiiXxRDDV10keYugytPBitjoxmCZ5OrJ7JNyErS4@shWRgmqY8PDTmSHQP@ZUxZMFJm6DwExQtdaWXIulRa0WFMVirKbBXXsNBwCdadU64SxVCqpRy7sybP3G@@yHxi/vn1@tJFaow04o@aqxtzQzyad2ailfRIQSXHevExs27k5GfEzYwJX57rGcOcy77xZsq7z@QmVjZh/4kd@aepLBoa@a/9t4Mn "Racket – Try It Online")
This is my first [Racket](https://racket-lang.org/) submission, so it can definitely be golfed much further. Nevertheless I'm somewhat content, at least for managing to solve the task.
## More readable:
```
(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 '()))))
```
[Answer]
# 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]
```
The function to use it is z(); here it print numbers that has the corrispondence
one number not 1, not itself and are less than its 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
```
[Answer]
# [Visual Basic .NET (.NET Core)](https://www.microsoft.com/net/core/platform), 290 bytes (includes imports)
```
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
```
[Try it online!](https://tio.run/##VVFNb8IwDL3nV/i2VkBFDztMokh0K1KlwSaBNO3YD0ON0qS06VZ@feeG8eVLnBf7@T3nJ51kusY@LitdmwZCCGBzagyW3rotsaas8ULax8rgHmt4AlKZbHMEU1ADkhQyAunJIGS6VUasdN5KhFUfG6wTo2tYtiozpBUsHHfRXNhftZRo8caLIzXMSlKJ4o1KoCD0PhSOjwGNq4DEV0FM6Qe@YGTiixt2nM0rseQhh2C61fAi4h1U3lZvTE1qz0OUSUg1zsHdFqi4veLm0PvUv041Prgi6sgA94tI5RDvxBo7Y3NLb9nm/oLv1WxOMHDAN6HMgQSNWM@tdMguTvtNm8KKBzuuEPAf1hhv178ig@4oyQroIObtXPEhWHmjJXpfNRl85zU7nftQwNIGtuepVfXwNMTV2AN4NnkPEYzuJVn/1gtbsOf5P/s/ "Visual Basic .NET (.NET Core) – Try It Online")
Requires the following import:
```
Imports B = System.Numerics.BigInteger
```
This uses an iterator function to return an infinite (lazy loaded) list of integers that meets the criteria. Uses `BigInteger` to avoid any size restrictions, particularly with intermediate calculations.
Un-golfed:
```
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
```
[Answer]
# [Common Lisp](http://www.clisp.org/), 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))))
```
[Try it online!](https://tio.run/##XU/LCoMwEPyVgR6cpQh66K39GPHViCbRbMG/t6u2FLph2WEem6QeXYrbxqbtXh4rJ3gERMzC1GoHxxQW5VRFZGZVXLLG9U7z@lkteWRcnC9zDXlSQz0mkUt2l096YLtGxcTOLZZ1YkIdfEM@MCOKd6OQlREPu3cQ@qAHLOWHwyeVELiyvBpRnCPuY5Zd/y74M@wqlSsGO@e/rLbj2QrjSxTWtwKF0W8 "Common Lisp – Try It Online")
[Answer]
# APL(NARS), 96 chars, 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
```
test (partial result for argument 22 seems to much big so <21 arguments I don't know if can be ok)
```
  f 21
3 5 6 8 
```
[Answer]
# [Python 3](https://docs.python.org/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)
```
[Try it online!](https://tio.run/##JYvLCoMwEADv@xXrLesDKsWLZT9mNwoG2jXYlMavj4qngWEm7mlZ7VlK5mDJBYu/5IhA2PMD/kt4z5hHQGm4fykL4O2086O2nrWur@8TzH3T5pSIWgXMHWvFvdiEJwXidlVCpQwH "Python 3 – Try It Online")
Decided to try a Python 3 solution that directly prints the nth term in the sequence.
[Answer]
# [C (clang)](http://clang.llvm.org/) + `-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--;}}
```
[Try it online!](https://tio.run/##LY3BboMwEER/xUWKtUtsCaQeqqwglx75hF4WJ6ZGjgmGqEiIX69L017eSDPSPKON59ClNIL55JizekaLa7zOjxhyrvOWtkZYaATj@lwN8XSPLswWpFHZwftLphhpnIY4g1HTHP01gEFVqhGpEW11H76AVW706xvS37Voaz5baPG0Cxx10ONqhwiuKqgndzzi2oilsuCQlpfKyR2lXOpCyn95drh8hEw5lLLXmrYt7bW4sQuAawdlgbSlb2M9d1PS703lh9CJXyTtbz8 "C (clang) – Try It Online")
Function `g(j)` prints the first `j` terms of the sequence.
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~16~~ ~~12~~ 10 bytes
```
fS>ωṠ^o▼dN
```
Saved 6 bytes thanks to H.PWiz.  
[Try it online!](https://tio.run/##yygtzv7/Py3Y7nznw50L4vIfTduT4vf/PwA "Husk – Try It Online")
### Explanation
```
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.
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 44 bytes
```
_ì ñ g
_gV ¥1?Z:ZpZgV)gW
@@[1X]øXgW}fXÄ}gUÄ
```
[Try it online!](https://ethproductions.github.io/japt/?v=1.4.6&code=Cl/sIPEgZwpfZ1YgpTE/WjpacFpnVilnVwpAQFsxWF34WGdXfWZYxH1nVcQ=&input=NQ==)
Substantially different from the other Japt answer.
Explanation:
```
                        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 terms of future golfing possibilities, I do a lot of manually calling a function on a number, which I suspect could be reduced but I'm not sure how.
[Answer]
# [Python 3](https://docs.python.org/3/), 54 bytes
```
lambda n,x=0:n!=x and f(n**min(map(int,str(n))),n)or n
```
[Try it online!](https://tio.run/##Dco9DsIwDAbQGU7hdrKrIPGzoErhJCxGJWCJfI3SDEVVz552edNL//IdcauBPD3rT@NrUIKb/blH42dSDBQYXRcNHDWxobipZIaIOMiYCTXsGhkoKz5vvrjrXfrjIeU9c2gXW@n0oCWwydpK3QA "Python 3 – Try It Online")
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 35 bytes
```
r0f{J{J<]**}{J<]1!=}w!J1!=x/x/!=&&}
```
[Try it online!](https://tio.run/##SyotykktLixN/f@/yCCt2qvayyZWS6sWRBkq2taWK3oBqQr9Cn1FWzW12v//DQ0A "Burlesque – Try It Online")
"Produces" the infinite list of MPRs (i.e. never finishes, never prints). For a finite list use:
# [Burlesque](https://github.com/FMNSSun/Burlesque), 36 bytes
```
ri{J{J<]**}{J<]1!=}w!J1!=x/x/!=&&}FO
```
[Try it online!](https://tio.run/##SyotykktLixN/f@/KLPaq9rLJlZLqxZEGSra1pYregGpCv0KfUVbNbVaN////w0NAA "Burlesque – Try It Online")
Takes an integer input `N` and tests the first `N` values
```
r0      # All integers starting from 0
f{      # Filter for
 J      # Duplicate original value (for later)
 {
  J     # Duplicate current value
  <]    # Minimum digit
  **    # Raise current value to power of min digit
 }
 {
  J<]   # Find minimum digit (non-destructive)
  1!=   # Not equal to 1
 }w!    # While current value does not contain 0 or 1
 J      # Duplicate output
 1!=    # Not equal to 1
 x/x/   # Reorganise stack
 !=     # Output is not equal to original
 &&     # AND not equal to 1
}
```
[Answer]
# [Dash](https://wiki.debian.org/Shell) (or other generic Bourne shell) + [bc](https://www.gnu.org/software/bc/manual/html_mono/bc.html), 190 bytes
```
a=0
while :
do
a=`echo $a+1|bc`
b=$a
while :
do
for m in `seq 0 9`
do
case "$b" in
*$m*)break;;
esac
done
case $m in
0)break;;
1)[ $a = $b ]||echo $a;break;;
esac
b=`echo $b^$m|bc`
done
done
```
[Try it online!](https://tio.run/##VY69DsIwDIR3P4VVeWlZ2hGiPAkCxU6NUkFb0QwsefeQlh/B4uHuO9/1HEPObFt4hOGmeIB@BrZOfZiReNcl8Q7EEv8Cl3nBEYcJXdQ7trh3q@o5KlYkVXGgobGpZVG@GgMa2Rdi0hdDaxbar93Vx9KFFknwlNK72/yl5bNJzjRuo7Z/68n5CQ "Dash  Try It Online")
This implementation prints the infinite sequence -- as far as it is allowed. 
I specifically did not use bash arithmetic because I didn't want the limit of bash's number system. If you change the line `a=0` to `a=$1`, you can start looking at any number (though subtract 1 if you want the first number considered). Passing in 9922289264447635429194, I found part of the sequence is:
> 
> 9922289264447635429236  
> 
>  9922289264447635429254  
> 
>  9922289264447635429323  
> 
>  9922289264447635429328  
> 
>  9922289264447635429335 
> 
> 
> 
]