The minimal power iteration of a number $n$ is defined as follows:

$$textMPI(n):=n^textmin(textdigits(n))$$

That is, $n$ raised to the lowest digit in $n$. For example, $textMPI(32)=32^2=1024$ and $textMPI(1234)=1234^1=1234$.

The minimal power root of a number $n$ is defined as the number obtained from repeatedly applying $textMPI$ 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 nth 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, so the shortest code (in bytes) wins.

Jelly, 14 bytes

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

Try it online!

Mathematica, 59 bytes

Select[Range@#,1<FixedPoint[#^Min@IntegerDigits@#&,#]!=#&]&

Pure function. Takes a number as input, and returns the list of terms up to that number as output. Nothing very complicated here.

Pyth, 10 bytes

.f>u^GshS`

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

Perl 6, 24 bytes

$_,$_**.comb.min...*

Try it online!

Returns an infinite sequence.

Jelly, 10 bytes

*DṂƊƬḊCȦµ#

A monadic Link taking an integer, I, from STDIN which yields the first I entries.

Try it online!

How?

Counts up starting a n=1 until input truthy results of a monadic function are encountered and yields those ns.

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 1 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?