Distinct power numbers

Distinct power numbers is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Task

Compute all combinations of $a^{b}$ where a and b are integers between 2 and 5 inclusive.

Place them in numerical order, with any repeats removed.

You should get the following sequence of 15 distinct terms:
4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125

11l

Translation of: Python

print(sorted(Array(Set(cart_product(2..5, 2..5).map((a, b) -> a ^ b)))))

Output:

[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]

Action!

Library: Action! Tool Kit

INCLUDE "D2:SORT.ACT" ;from the Action! Tool Kit

INT FUNC Power(INT a,b)
  INT res,i

  res=1
  FOR i=1 TO b
  DO
    res==*a
  OD
RETURN (res)

BYTE FUNC Contains(INT ARRAY a INT count,x)
  INT i

  FOR i=0 TO count-1
  DO
    IF a(i)=x THEN
      RETURN (1)
    FI
  OD
RETURN (0)

PROC Main()
  INT ARRAY a(100)
  INT i,j,x,count

  Put(125) PutE() ;clear the screen

  count=0
  FOR i=2 TO 5
  DO
    FOR j=2 TO 5
    DO
      x=Power(i,j)
      IF Contains(a,count,x)=0 THEN
        a(count)=x
        count==+1
      FI
    OD
  OD
  SortI(a,count,0)
  FOR i=0 TO count-1
  DO
    PrintI(a(i)) Put(32)
  OD
RETURN

Output:

Screenshot from Atari 8-bit computer

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

Ada

with Ada.Text_Io;
with Ada.Containers.Doubly_Linked_Lists;

procedure Power_Numbers is

   package Number_Lists   is new Ada.Containers.Doubly_Linked_Lists (Integer);
   package Number_Sorting is new Number_Lists.Generic_Sorting;
   use Number_Lists, Ada.Text_Io;

   List : Number_Lists.List;
begin
   for A in 2 .. 5 loop
      for B in 2 .. 5 loop
         declare
            R : constant Integer := A**B;
         begin
            if not List.Contains (R) then
               List.Append (R);
            end if;
         end;
      end loop;
   end loop;

   Number_Sorting.Sort (List);

   for E of List loop
      Put (Integer'Image (E));
      Put (" ");
   end loop;
   New_Line;

end Power_Numbers;

Output:

 4  8  9  16  25  27  32  64  81  125  243  256  625  1024  3125 

ALGOL 68

BEGIN # show in order, distinct values of a^b where 2 <= a <= b <= 5        #
    INT max number = 5;
    INT min number = 2;
    # construct a table of a ^ b                                            #
    INT length     = ( max number + 1 ) - min number;
    [ 1 : length * length ]INT a to b;
    INT pos := 0;
    FOR i FROM min number TO max number DO
        a to b[ pos +:= 1 ] := i * i;
        FOR j FROM min number + 1 TO max number DO
            INT prev = pos;
            a to b[ pos +:= 1 ] := a to b[ prev ] * i
        OD
    OD;
    # sort the table                                                        #
    # it is small and nearly sorted so a bubble sort should suffice         #
    FOR u FROM UPB a to b - 1 BY -1 TO LWB a to b
    WHILE BOOL sorted := TRUE;
          FOR p FROM LWB a to b BY 1 TO u DO
              IF a to b[ p ] > a to b[ p + 1 ] THEN
                  INT t            = a to b[ p     ];
                  a to b[ p     ] := a to b[ p + 1 ];
                  a to b[ p + 1 ] := t;
                  sorted := FALSE
              FI
          OD;
          NOT sorted
    DO SKIP OD;
    # print the table, excluding duplicates                                 #
    INT last := -1;
    FOR i TO UPB a to b DO
        INT next = a to b[ i ];
        IF next /= last THEN print( ( " ", whole( next, 0 ) ) ) FI;
        last := next
    OD;
    print( ( newline ) )
END

Output:

 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

APL

Works with: Dyalog APL

(⊂∘⍋⌷⊣)∪,∘.*⍨1+⍳4

Output:

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

AppleScript

Idiomatic

Uses an extravagantly long list, but gets the job done quickly and easily.

on task()
    script o
        property output : {}
    end script
    
    repeat (5 ^ 5) times
        set end of o's output to missing value
    end repeat
    
    repeat with a from 2 to 5
        repeat with b from 2 to 5
            tell (a ^ b as integer) to set item it of o's output to it
            tell (b ^ a as integer) to set item it of o's output to it
        end repeat
    end repeat
    
    return o's output's integers
end task

task()

Output:

{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}

---

Functional

Composing a solution from generic primitives, for speed of drafting, and ease of refactoring:

use framework "Foundation"
use scripting additions


------------------ DISTINCT POWER VALUES -----------------

-- distinctPowers :: [Int] -> [Int]
on distinctPowers(xs)
    script powers
        on |λ|(a, x)
            script integerPower
                on |λ|(b, y)
                    b's addObject:((x ^ y) as integer)
                    b
                end |λ|
            end script
            
            foldl(integerPower, a, xs)
        end |λ|
    end script
    
    sort(foldl(powers, ¬
        current application's NSMutableSet's alloc's init(), xs)'s ¬
        allObjects())
end distinctPowers


--------------------------- TEST -------------------------
on run
    distinctPowers(enumFromTo(2, 5))
end run


------------------------- GENERIC ------------------------

-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
    if m ≤ n then
        set lst to {}
        repeat with i from m to n
            set end of lst to i
        end repeat
        lst
    else
        {}
    end if
end enumFromTo


-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
    tell mReturn(f)
        set v to startValue
        set lng to length of xs
        repeat with i from 1 to lng
            set v to |λ|(v, item i of xs, i, xs)
        end repeat
        return v
    end tell
end foldl


-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
    -- 2nd class handler function lifted into 1st class script wrapper. 
    if script is class of f then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn


-- sort :: Ord a => [a] -> [a]
on sort(xs)
    ((current application's NSArray's arrayWithArray:xs)'s ¬
        sortedArrayUsingSelector:"compare:") as list
end sort

Output:

{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}

---

AppleScriptObjC

Throwing together a solution using the most appropriate methods for efficiency and legibility.

use AppleScript version "2.4" -- Mac OS X 10.10 (Yosemite) or later.
use framework "Foundation"

on task()
    set nums to {}
    repeat with a from 2 to 5
        repeat with b from 2 to 5
            set end of nums to (a ^ b) as integer
            set end of nums to (b ^ a) as integer
        end repeat
    end repeat
    
    set nums to current application's class "NSSet"'s setWithArray:(nums)
    set descriptor to current application's class "NSSortDescriptor"'s sortDescriptorWithKey:("self") ascending:(true)
    return (nums's sortedArrayUsingDescriptors:({descriptor})) as list
end task

task()

Output:

{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}

Arturo

print sort unique flatten map 2..5 'a [
    map 2..5 'b -> a^b
]

Output:

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

BCPL

get "libhdr"

let pow(n, p) = 
    p=0 -> 1, 
    n * pow(n, p-1)

let sort(v, length) be
    if length > 0
    $(  for i=0 to length-2
            if v!i > v!(i+1) 
            $(  let t = v!i
                v!i := v!(i+1)
                v!(i+1) := t
            $)
        sort(v, length-1)
    $)

let start() be 
$(  let v = vec 15
    let i = 0
    for a = 2 to 5 for b = 2 to 5
    $(  v!i := pow(a,b)
        i := i+1
    $)
    sort(v, 16)
    for i = 0 to 15
        if i=0 | v!i ~= v!(i-1) do writef("%N ", v!i)
    wrch('*N')
$)

Output:

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

BQN

∧⍷⥊⋆⌜˜ 2+↕4

Output:

⟨ 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 ⟩

C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int compare(const void *a, const void *b) {
    int ia = *(int*)a;
    int ib = *(int*)b;
    return (ia>ib) - (ia<ib);
}

int main() {
    int pows[16];
    int a, b, i=0;
    
    for (a=2; a<=5; a++)
        for (b=2; b<=5; b++)
            pows[i++] = pow(a, b);
    
    qsort(pows, 16, sizeof(int), compare);
    
    for (i=0; i<16; i++)
        if (i==0 || pows[i] != pows[i-1]) 
            printf("%d ", pows[i]);
    
    printf("\n");
    return 0;
}

Output:

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

C++

#include <iostream>
#include <set>
#include <cmath>

int main() {
    std::set<int> values;
    for (int a=2; a<=5; a++)
        for (int b=2; b<=5; b++)
            values.insert(std::pow(a, b));
    
    for (int i : values)
        std::cout << i << " ";
    
    std::cout << std::endl;
    return 0;
}

Output:

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

F#

set[for n in 2..5 do for g in 2..5->pown n g]|>Set.iter(printf "%d ")

Output:

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

Delphi

Works with: Delphi version 6.0

Library: Classes,SysUtils,StdCtrls,Math

Uses Delphi's standard StringList control to avoid duplicates and keep the list storted. It uses a trick to make the strings sorted numerically. The number strings are stored with leading zeros to make them sort numericall and the actual number is stored as an object so it can be retrieved without the leading zeros.

procedure FindDistinctPowers(Memo: TMemo);
{Display list of numbers a^b sort and exclude duplicates}
{tricks Delphi TStringGrid into sorting numerically}
var A,B,I,P: integer;
var SL: TStringList;
begin
SL:=TStringList.Create;
try
SL.Duplicates:=dupIgnore;
SL.Sorted:=True;
for A:=2 to 5 do
 for B:=2 to 5 do
	begin
	P:=Trunc(Power(A,B));
	{Add leading zeros to number so it sorts numerically}
	SL.AddObject(FormatFloat('00000',P),Pointer(P));
	end;
Memo.Text:=IntToStr(integer(SL.Objects[0]));
for I:=1 to SL.Count-1 do Memo.Text:=Memo.Text+','+IntToStr(integer(SL.Objects[I]));
finally SL.Free; end;
end;

Output:

4,8,9,16,25,27,32,64,81,125,243,256,625,1024,3125

Factor

Works with: Factor version 0.99 2021-06-02

USING: kernel math.functions math.ranges prettyprint sequences
sets sorting ;

2 5 [a,b] dup [ ^ ] cartesian-map concat members natural-sort .

Output:

{ 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 }

FreeBASIC

redim arr(-1) as uinteger
dim as uinteger i
for a as uinteger = 2 to 5
    for b as uinteger = 2 to 5
        redim preserve arr(0 to ubound(arr)+1)
        i = ubound(arr)
        arr(i) = a^b
        while arr(i-1)>arr(i) and i > 0
            swap arr(i-1), arr(i)
            i -= 1
        wend
    next b
next a

for i = 0 to ubound(arr)
    if arr(i)<>arr(i-1) then print arr(i),
next i

Go

Translation of: Wren

Library: Go-rcu

package main

import (
    "fmt"
    "rcu"
    "sort"
)

func main() {
    var pows []int
    for a := 2; a <= 5; a++ {
        pow := a
        for b := 2; b <= 5; b++ {
            pow *= a
            pows = append(pows, pow)
        }
    }
    set := make(map[int]bool)
    for _, e := range pows {
        set[e] = true
    }
    pows = pows[:0]
    for k := range set {
        pows = append(pows, k)
    }
    sort.Ints(pows)
    fmt.Println("Ordered distinct values of a ^ b for a in [2..5] and b in [2..5]:")
    for i, pow := range pows {
        fmt.Printf("%5s ", rcu.Commatize(pow))
        if (i+1)%5 == 0 {
            fmt.Println()
        }
    }
    fmt.Println("\nFound", len(pows), "such numbers.")
}

Output:

Ordered distinct values of a ^ b for a in [2..5] and b in [2..5]:
    4     8     9    16    25 
   27    32    64    81   125 
  243   256   625 1,024 3,125 

Found 15 such numbers.

Haskell

import qualified Data.Set as S


------------------ DISTINCT POWER NUMBERS ----------------

distinctPowerNumbers :: Int -> Int -> [Int]
distinctPowerNumbers a b =
  (S.elems . S.fromList) $
    (fmap (^) >>= (<*>)) [a .. b]


--------------------------- TEST -------------------------
main :: IO ()
main =
  print $
    distinctPowerNumbers 2 5

Output:

[4,8,9,16,25,27,32,64,81,125,243,256,625,1024,3125]

or, as a one-off list comprehension:

import qualified Data.Set as S

main :: IO ()
main =
  (print . S.elems . S.fromList) $
    (\xs -> [x ^ y | x <- xs, y <- xs]) [2 .. 5]

or a liftA2 expression:

import Control.Applicative (liftA2)
import Control.Monad (join)
import qualified Data.Set as S

main :: IO ()
main =
  (print . S.elems . S.fromList) $
    join
      (liftA2 (^))
      [2 .. 5]

which can always be reduced (shedding imports) to the pattern:

import qualified Data.Set as S

main :: IO ()
main =
  (print . S.elems . S.fromList) $
      (\xs -> (^) <$> xs <*> xs)
      [2 .. 5]

Output:

[4,8,9,16,25,27,32,64,81,125,243,256,625,1024,3125]

J

~./:~;^/~2+i.4

Output:

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

jq

Works with: jq

Works with gojq, the Go implementation of jq

For relatively small integers, such as involved in the specified task, the built-in function `pow/2` does the job:

[range(2;6) as $a | range(2;6) as $b | pow($a; $b)] | unique

Output:

[4,8,9,16,25,27,32,64,81,125,243,256,625,1024,3125]

However, if using gojq, then for unbounded precision, a special-purpose "power" function is needed:

def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);

[range(2;6) as $a | range(2;6) as $b | $a|power($b)] | unique

Output:

As above.

Julia

println(sort(unique([a^b for a in 2:5, b in 2:5])))

Output:

[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]

Mathematica/Wolfram Language

Union @@ Table[a^b, {a, 2, 5}, {b, 2, 5}]

Output:

{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}

Nim

import algorithm, math, sequtils, strutils, sugar

let list = collect(newSeq):
             for a in 2..5:
               for b in 2..5: a^b

echo sorted(list).deduplicate(true).join(" ")

Output:

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

OCaml

module IntSet = Set.Make(Int)

let pow x =
  let rec aux acc b = function
    | 0 -> acc
    | y -> aux (if y land 1 = 0 then acc else acc * b) (b * b) (y lsr 1)
  in
  aux 1 x

let distinct_powers first count =
  let sq = Seq.(take count (ints first)) in
    IntSet.of_seq (Seq.map_product pow sq sq)

let () = distinct_powers 2 4
  (* output *)
  |> IntSet.to_seq |> Seq.map string_of_int
  |> List.of_seq |> String.concat " " |> print_endline

Output:

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

Phix

with javascript_semantics
function sqpn(integer n) return sq_power(n,{2,3,4,5}) end function
sequence res = apply(true,sprintf,{{"%,5d"},unique(join(apply({2,3,4,5},sqpn),""))})
printf(1,"%d found:\n%s\n",{length(res),join_by(res,1,5," ")})

Output:

15 found:
    4     8     9    16    25
   27    32    64    81   125
  243   256   625 1,024 3,125

Perl

#!/usr/bin/perl -l

use strict; # https://rosettacode.org/wiki/Distinct_power_numbers
use warnings;
use List::Util qw( uniq );

print join ', ', sort { $a <=> $b } uniq map { my $e = $_; map $_ ** $e, 2 .. 5} 2 .. 5;

Output:

4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125

Python

from itertools import product
print(sorted(set(a**b for (a,b) in product(range(2,6), range(2,6)))))

Output:

[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]

Or, for variation, generalizing a little in terms of starmap and pow:

'''Distinct power numbers'''

from itertools import product, starmap


# distinctPowerNumbers :: Int -> Int -> [Int]
def distinctPowerNumbers(a):
    '''Sorted values of x^y where x, y <- [a..b]
    '''
    def go(b):
        xs = range(a, 1 + b)

        return sorted(set(
            starmap(pow, product(xs, xs))
        ))

    return go


# ------------------------- TEST -------------------------
# main :: IO ()
def main():
    '''Distinct powers from integers [2..5]'''

    print(
        distinctPowerNumbers(2)(5)
    )


# MAIN ---
if __name__ == '__main__':
    main()

Output:

[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]

R

This only takes one line.

unique(sort(rep(2:5, each = 4)^rep(2:5, times = 4)))

Output:

 [1]    4    8    9   16   25   27   32   64   81  125  243  256  625 1024 3125

Quackery

  [ [] swap
    behead swap
    witheach
      [ 2dup = iff
          drop done
        dip join ]
    join ]          is unique ( [ --> [ )

  []
  4 times
    [ i 2 +
      4 times
        [ dup i 2 + **
          rot join swap ]
      drop ]
  sort unique echo

Output:

[ 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 ]

Raku

put squish sort [X**] (2..5) xx 2;

Output:

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125

REXX

With this version of REXX,   there's no need to sort the found numbers,   or to eliminate duplicates.

/*REXX pgm finds and displays distinct power integers:  a^b,  where a and b are 2≤both≤5*/
parse arg lo hi cols .                           /*obtain optional arguments from the CL*/
if   lo=='' |   lo==","  then   lo=  2           /*Not specified?  Then use the default.*/
if   hi=='' |   hi==","  then   hi=  5           /* "      "         "   "   "     "    */
if cols=='' | cols==","  then cols= 10           /* "      "         "   "   "     "    */
w= 11                                            /*width of a number in any column.     */
title= ' distinct power integers, a^b, where  a  and  b  are: '    lo    "≤ both ≤"    hi
say ' index │'center(title,  1 + cols*(w+1)     )
say '───────┼'center(""   ,  1 + cols*(w+1), '─')
@.= .;                      $$=                  /*the default value for the  @.  array.*/
        do    a=lo  to  hi                       /*traipse through  A  values (LO──►HI).*/
           do b=lo  to  hi                       /*   "       "     B     "     "    "  */
           x= a ** b;   if @.x\==.  then iterate /*Has it been found before?  Then skip.*/
           @.x= x;      $$= $$  x                /*assign power product; append to  $$  */
           end   /*b*/
        end      /*a*/
$=;                             idx= 1           /*$$: a list of distinct power integers*/
    do j=1  while words($$)>0;  call getMin $$   /*obtain smallest number in the $$ list*/
    $= $  right(commas(z), max(w, length(z) ) )  /*add a distinct power number ──► list.*/
    if j//cols\==0  then iterate                 /*have we populated a line of output?  */
    say center(idx, 7)'│'  substr($, 2);   $=    /*display what we have so far  (cols). */
    idx= idx + cols                              /*bump the  index  count for the output*/
    end   /*j*/

if $\==''  then say center(idx, 7)"│"  substr($, 2)  /*possible display residual output.*/
say '───────┴'center(""   ,  1 + cols*(w+1), '─')
say
say 'Found '       commas(j-1)         title
exit 0                                           /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg ?;  do jc=length(?)-3  to 1  by -3; ?=insert(',', ?, jc); end;  return ?
/*──────────────────────────────────────────────────────────────────────────────────────*/
getMin: parse arg z .;  p= 1;   #= words($$)               /*assume min;  # words in $$.*/
          do m=2  for #-1;    a= word($$, m);    if a>=z  then iterate;     z= a;     p= m
          end   /*m*/;    $$= delword($$, p, 1);    return /*delete the smallest number.*/

output   when using the default inputs:

 index │                            distinct power integers, a^b, where  a  and  b  are:  2 ≤ both ≤ 5
───────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │           4           8           9          16          25          27          32          64          81         125
  11   │         243         256         625       1,024       3,125
───────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Found  15  distinct power integers, a^b, where  a  and  b  are:  2 ≤ both ≤ 5

output   when using the inputs of:     0   5

 index │                            distinct power integers, a^b, where  a  and  b  are:  0 ≤ both ≤ 5
───────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │           0           1           2           3           4           5           8           9          16          25
  11   │          27          32          64          81         125         243         256         625       1,024       3,125
───────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

output   when using the inputs of:     0   9

 index │                            distinct power integers, a^b, where  a  and  b  are:  0 ≤ both ≤ 9
───────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │           0           1           2           3           4           5           6           7           8           9
  11   │          16          25          27          32          36          49          64          81         125         128
  21   │         216         243         256         343         512         625         729       1,024       1,296       2,187
  31   │       2,401       3,125       4,096       6,561       7,776      15,625      16,384      16,807      19,683      32,768
  41   │      46,656      59,049      65,536      78,125     117,649     262,144     279,936     390,625     531,441     823,543
  51   │   1,679,616   1,953,125   2,097,152   4,782,969   5,764,801  10,077,696  16,777,216  40,353,607  43,046,721 134,217,728
  61   │ 387,420,489
───────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Found  61  distinct power integers, a^b, where  a  and  b  are:  0 ≤ both ≤ 9

Ring

load "stdlib.ring"

see "working..." + nl
see "Distinct powers are:" + nl
row = 0
distPow = []

for n = 2 to 5
    for m = 2 to 5
        sum = pow(n,m)
        add(distPow,sum)
    next
next

distPow = sort(distPow)

for n = len(distPow) to 2 step -1
    if distPow[n] = distPow[n-1]
       del(distPow,n-1)
    ok
next

for n = 1 to len(distPow)
    row++
    see "" + distPow[n] + " "
    if row%5 = 0
       see nl
    ok
next
 
see "Found " + row + " numbers" + nl
see "done..." + nl

Output:

working...
Distinct powers are:
4 8 9 16 25 
27 32 64 81 125 
243 256 625 1024 3125 
Found 15 numbers
done...

RPL

≪ { }
   2 5 FOR a 
     2 5 FOR b 
       a b ^ 
       IF DUP2 POS THEN DROP ELSE + END
   NEXT NEXT SORT
≫ 'DPOWR' STO

Output:

1: { 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 }

Ruby

a = (2..5).to_a
p a.product(a).map{_1 ** _2}.sort.uniq

Output:

[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]

Sidef

[2..5]*2 -> cartesian.map_2d {|a,b| a**b }.sort.uniq.say

Alternative solution:

2..5 ~X** 2..5 -> sort.uniq.say

Output:

[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]

Wren

Library: Wren-seq

Library: Wren-fmt

import "./seq" for Lst
import "./fmt" for Fmt

var pows = []
for (a in 2..5) {
    var pow = a
    for (b in 2..5) {
        pow = pow * a
        pows.add(pow)
    }
}
pows = Lst.distinct(pows).sort()
System.print("Ordered distinct values of a ^ b for a in [2..5] and b in [2..5]:")
Fmt.tprint("$,5d", pows, 5)
System.print("\nFound %(pows.count) such numbers.")

Output:

Ordered distinct values of a ^ b for a in [2..5] and b in [2..5]:
    4     8     9    16    25
   27    32    64    81   125
  243   256   625 1,024 3,125

Found 15 such numbers.

XPL0

int A, B, N, Last, Next;
[Last:= 0;
loop    [Next:= -1>>1;          \infinity
        for A:= 2 to 5 do       \find smallest Next
            for B:= 2 to 5 do   \ that's > Last
                [N:= fix(Pow(float(A), float(B)));
                if N>Last & N<Next then Next:= N;
                ];
        if Next = -1>>1 then quit;
        IntOut(0, Next);  ChOut(0, ^ );
        Last:= Next;
        ];
]

Output:

4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125