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 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
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]
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
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
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;
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
(⊂∘⍋⌷⊣)∪,∘.*⍨1+⍳4
- Output:
4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125
Idiomatic
gets the job done quickly and easily.
on task()
script o
property output : {}
end script
repeat with a from 2 to 5
repeat with b from 2 to 5
set n to a ^ b as integer
if n is not in o's output then
set flag to false -- is n less than some item in output?
repeat with i from 1 to count o's output
if n < item i of o's output then
set flag to true -- n is less than some item already in output
exit repeat
end if
end repeat
if flag then
if i = 1 then
set beginning of o's output to n
else
set o's output to items 1 thru (i - 1) of o's output & {n} & items i thru -1 of o's output
end if
else -- put n at end of list
set end of o's output to n
end if
end if
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}
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
import ballerina/io;
function commatize(int n) returns string {
string s = n.toString();
if n < 0 { s = s.substring(1); }
int le = s.length();
foreach int i in int:range(le - 3, 0, -3) {
s = s.substring(0, i) + "," + s.substring(i);
}
if n >= 0 { return s; }
return "-" + s;
}
public function main() {
int[] pows = [];
foreach int a in 2...5 {
int pow = a;
foreach int b in 2...5 {
pow *= a;
pows.push(pow);
}
}
pows = pows.sort();
foreach int i in int:range(pows.length() - 2 , -1, -1) {
if pows[i + 1] == pows[i] {
_ = pows.remove(i + 1);
}
}
io:println("Ordered distinct values of a ^ b for a in [2, 5] and b in [2, 5]:");
foreach int i in 0 ..< pows.length() {
io:print(commatize(pows[i]).padStart(6));
if (i + 1) % 5 == 0 { io:println(); }
}
io:println("\nFound ", pows.length(), " 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.
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
∧⍷⥊⋆⌜˜ 2+↕4
- Output:
⟨ 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 ⟩
#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
#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
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
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
select DISTINCT power(a, b)::INTEGER as "a^b"
from range(2,6) t(a), range(2,6) as u(b)
order by "a^b";
- Output:
┌───────┐ │ a^b │ │ int32 │ ├───────┤ │ 4 │ │ 8 │ │ 9 │ │ 16 │ │ 25 │ │ 27 │ │ 32 │ │ 64 │ │ 81 │ │ 125 │ │ 243 │ │ 256 │ │ 625 │ │ 1024 │ │ 3125 │ └───────┘
To convert to a DuckDB list, one could use array_agg().
proc sortuniq &d[] .
i = 1
while i < len d[]
for j = i + 1 to len d[]
if d[j] < d[i] : swap d[j] d[i]
.
if i > 1 and d[i] = d[i - 1]
swap d[$] d[i]
len d[] -1
else
i += 1
.
.
.
for a = 2 to 5 : for b = 2 to 5
pows[] &= pow a b
.
sortuniq pows[]
print pows[]- Output:
[ 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 ]
%% Note: math:pow/2 returns floating-point numbers.
%% if you want integer powers, you’ll need to write a custom power function
-module(distinct_power_numbers).
-export([main/0]).
main() ->
Terms = [math:pow(A, B) || A <- lists:seq(2, 5), B <- lists:seq(2, 5)],
UniqueTerms = lists:usort(Terms),
io:format("The List: ~p~n", [UniqueTerms]),
io:format("The number of items in the list: ~p~n", [length(UniqueTerms)]).
- Output:
The List: [4.0,8.0,9.0,16.0,25.0,27.0,32.0,64.0,81.0,125.0,243.0,256.0,625.0,1024.0,3125.0] The number of items in the list: 15
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 }
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
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.
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]
~./:~;^/~2+i.4
- Output:
4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125
import java.util.Set;
import java.util.TreeSet;
public final class DistinctPowerNumbers {
public static void main(String[] args) {
Set<Integer> values = new TreeSet<Integer>();
for ( int a = 2; a <= 5; a++ ) {
for ( int b = 2; b <= 5; b++ ) {
values.add((int) Math.pow(a, b));
}
}
System.out.println(values);
}
}
- Output:
[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]
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.
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]
function notIn (t, n)
for _, v in pairs(t) do
if v == n then return false end
end
return true
end
local distinctPowers, result = {}
for a = 2, 5 do
for b = 2, 5 do
result = a ^ b
if notIn(distinctPowers, result) then
table.insert(distinctPowers, result)
end
end
end
table.sort(distinctPowers)
print(table.concat(distinctPowers, ", "))
- Output:
4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125
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}
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
class DistinctPowerNumbers {
function : Main(args : String[]) ~ Nil {
values := Collection.Set->New()<IntRef>;
for ( a := 2; a <= 5; a++ ) {
for ( b := 2; b <= 5; b++ ) {
values->Insert( Int->Pow(a, b));
};
};
values->ToString()->PrintLine();
}
}- Output:
[4,8,9,16,25,27,32,64,81,125,243,256,625,1024,3125]
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
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
#!/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
local pows = {}
for a = 2, 5 do
local pow = a
for b = 2, 5 do
pow *= a
if !pows:contains(pow) do
pows:insert(pow)
end
end
end
pows:sort()
print("Ordered distinct values of a ^ b for a in [2, 5] and b in [2, 5]:")
for i = 1, #pows do
io.write(string.format("%5s ", string.formatint(pows[i])))
if i % 5 == 0 do print() end
end
print($"\nFound {#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.
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]
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
[ [] 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 ]
put squish sort [X**] (2..5) xx 2;
- Output:
4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125
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
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...
≪ { }
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 }
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]
fn main() {
let mut v = (2u32..=5)
.flat_map(|a| (2u32..=5).map(move |b| a.pow(b)))
.collect::<Vec<_>>();
v.sort();
v.dedup();
println!("{v:?}");
}
- Output:
[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]
[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]
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.
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
Categories:
- Draft Programming Tasks
- 11l
- Action!
- Action! Tool Kit
- Ada
- ALGOL 68
- APL
- AppleScript
- Arturo
- Ballerina
- BCPL
- BQN
- C
- C++
- F Sharp
- Delphi
- Classes,SysUtils,StdCtrls,Math
- DuckDB
- EasyLang
- Erlang
- Factor
- FreeBASIC
- Go
- Go-rcu
- Haskell
- J
- Java
- Jq
- Julia
- Lua
- Mathematica
- Wolfram Language
- Nim
- Objeck
- OCaml
- Phix
- Perl
- Pluto
- Python
- R
- Quackery
- Raku
- REXX
- Ring
- RPL
- Ruby
- Rust
- Sidef
- Wren
- Wren-seq
- Wren-fmt
- XPL0