Distinct power numbers: Difference between revisions
m
→{{header|Wren}}: Minor tidy
(Ada version) |
m (→{{header|Wren}}: Minor tidy) |
||
(10 intermediate revisions by 9 users not shown) | |||
Line 7:
<br>4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">print(sorted(Array(Set(cart_product(2..5, 2..5).map((a, b) -> a ^ b)))))</syntaxhighlight>
{{out}}
<pre>
[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]
</pre>
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<
INT FUNC Power(INT a,b)
Line 56 ⟶ 66:
PrintI(a(i)) Put(32)
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Distinct_power_numbers.png Screenshot from Atari 8-bit computer]
Line 64 ⟶ 74:
=={{header|Ada}}==
<
with Ada.Containers.Doubly_Linked_Lists;
Line 95 ⟶ 105:
New_Line;
end Power_Numbers;</
{{out}}
<pre> 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 </pre>
=={{header|ALGOL 68}}==
<
INT max number = 5;
INT min number = 2;
Line 136 ⟶ 146:
OD;
print( ( newline ) )
END</
{{out}}
<pre>
Line 144 ⟶ 154:
=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
Line 151 ⟶ 161:
===Idiomatic===
Uses an extravagantly long list, but gets the job done quickly and easily.
<
script o
property output : {}
Line 170 ⟶ 180:
end task
task()</
{{output}}
<
----
Line 179 ⟶ 189:
Composing a solution from generic primitives, for speed of drafting, and ease of refactoring:
<
use scripting additions
Line 258 ⟶ 268:
((current application's NSArray's arrayWithArray:xs)'s ¬
sortedArrayUsingSelector:"compare:") as list
end sort</
{{Out}}
<pre>{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}</pre>
Line 264 ⟶ 274:
===AppleScriptObjC===
Throwing together a solution using the most appropriate methods for efficiency and legibility.
<
use framework "Foundation"
Line 281 ⟶ 291:
end task
task()</
{{output}}
<
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">print sort unique flatten map 2..5 'a [
map 2..5 'b -> a^b
]</syntaxhighlight>
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
=={{header|BCPL}}==
<
let pow(n, p) =
Line 315 ⟶ 335:
if i=0 | v!i ~= v!(i-1) do writef("%N ", v!i)
wrch('*N')
$)</
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
=={{header|BQN}}==
<syntaxhighlight lang
{{out}}
<pre>⟨ 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 ⟩</pre>
=={{header|C}}==
<
#include <stdlib.h>
#include <math.h>
Line 351 ⟶ 371:
printf("\n");
return 0;
}</
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
=={{header|C++}}==
<
#include <set>
#include <cmath>
Line 371 ⟶ 391:
std::cout << std::endl;
return 0;
}</
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
=={{header|F_Sharp|F#}}==
<
set[for n in 2..5 do for g in 2..5->pown n g]|>Set.iter(printf "%d ")
</syntaxhighlight>
{{out}}
<pre>
4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125
</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|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.
<syntaxhighlight lang="Delphi">
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;
</syntaxhighlight>
{{out}}
<pre>
4,8,9,16,25,27,32,64,81,125,243,256,625,1024,3125
</pre>
=={{header|Factor}}==
{{works with|Factor|0.99 2021-06-02}}
<
sets sorting ;
2 5 [a,b] dup [ ^ ] cartesian-map concat members natural-sort .</
{{out}}
<pre>
Line 396 ⟶ 454:
=={{header|FreeBASIC}}==
<
redim arr(-1) as uinteger
dim as uinteger i
Line 414 ⟶ 472:
if arr(i)<>arr(i-1) then print arr(i),
next i
</syntaxhighlight>
=={{header|Go}}==
{{trans|Wren}}
{{libheader|Go-rcu}}
<
import (
Line 453 ⟶ 511:
}
fmt.Println("\nFound", len(pows), "such numbers.")
}</
{{out}}
Line 466 ⟶ 524:
=={{header|Haskell}}==
<
Line 481 ⟶ 539:
main =
print $
distinctPowerNumbers 2 5</
{{Out}}
<pre>[4,8,9,16,25,27,32,64,81,125,243,256,625,1024,3125]</pre>
Line 488 ⟶ 546:
or, as a one-off list comprehension:
<
main :: IO ()
main =
(print . S.elems . S.fromList) $
(\xs -> [x ^ y | x <- xs, y <- xs]) [2 .. 5]</
or a liftA2 expression:
<
import Control.Monad (join)
import qualified Data.Set as S
Line 505 ⟶ 563:
join
(liftA2 (^))
[2 .. 5]</
which can always be reduced (shedding imports) to the pattern:
<
main :: IO ()
Line 514 ⟶ 572:
(print . S.elems . S.fromList) $
(\xs -> (^) <$> xs <*> xs)
[2 .. 5]</
{{Out}}
Line 520 ⟶ 578:
=={{header|J}}==
<
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
Line 529 ⟶ 587:
For relatively small integers, such as involved in the specified task, the built-in function `pow/2` does the job:
<
{{out}}
<pre>
[4,8,9,16,25,27,32,64,81,125,243,256,625,1024,3125]
</pre>
However, if using gojq, then for unbounded precision, a special-purpose "power" function is needed:<
[range(2;6) as $a | range(2;6) as $b | $a|power($b)] | unique</
{{out}}
As above.
=={{header|Julia}}==
<
<pre>[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
{{out}}
<pre>{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}</pre>
=={{header|Nim}}==
<
let list = collect(newSeq):
Line 555 ⟶ 613:
for b in 2..5: a^b
echo sorted(list).deduplicate(true).join(" ")</
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
=={{header|OCaml}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
=={{header|Phix}}==
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">sqpn</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">sq_power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">})</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">,{{</span><span style="color: #008000;">"%,5d"</span><span style="color: #0000FF;">},</span><span style="color: #7060A8;">unique</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">({</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">},</span><span style="color: #000000;">sqpn</span><span style="color: #0000FF;">),</span><span style="color: #008000;">""</span><span style="color: #0000FF;">))})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d found:\n%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">)})</span>
<!--</
{{out}}
<pre>
Line 576 ⟶ 655:
=={{header|Perl}}==
<
use strict; # https://rosettacode.org/wiki/Distinct_power_numbers
Line 582 ⟶ 661:
use List::Util qw( uniq );
print join ', ', sort { $a <=> $b } uniq map { my $e = $_; map $_ ** $e, 2 .. 5} 2 .. 5;</
{{out}}
<pre>
Line 589 ⟶ 668:
=={{header|Python}}==
<
print(sorted(set(a**b for (a,b) in product(range(2,6), range(2,6)))))</
{{out}}
<pre>[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]</pre>
Line 596 ⟶ 675:
Or, for variation, generalizing a little in terms of '''starmap''' and '''pow''':
<
from itertools import product, starmap
Line 627 ⟶ 706:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]</pre>
Line 633 ⟶ 712:
=={{header|R}}==
This only takes one line.
<
{{out}}
<pre> [1] 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre>[ 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 ]</pre>
=={{header|Raku}}==
<syntaxhighlight lang="raku"
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
Line 644 ⟶ 746:
=={{header|REXX}}==
With this version of REXX, there's no need to sort the found numbers, or to eliminate duplicates.
<
parse arg lo hi cols . /*obtain optional arguments from the CL*/
if lo=='' | lo=="," then lo= 2 /*Not specified? Then use the default.*/
Line 678 ⟶ 780:
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.*/</
{{out|output|text= when using the default inputs:}}
<pre>
Line 716 ⟶ 818:
=={{header|Ring}}==
<
load "stdlib.ring"
Line 749 ⟶ 851:
see "Found " + row + " numbers" + nl
see "done..." + nl
</syntaxhighlight>
{{out}}
<pre>
Line 759 ⟶ 861:
Found 15 numbers
done...
</pre>
=={{header|RPL}}==
≪ { }
2 5 '''FOR''' a
2 5 '''FOR''' b
a b ^
'''IF''' DUP2 POS '''THEN''' DROP '''ELSE''' + '''END'''
'''NEXT NEXT''' SORT
≫ '<span style="color:blue">DPOWR</span>' STO
{{out}}
<pre>
1: { 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 }
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">a = (2..5).to_a
p a.product(a).map{_1 ** _2}.sort.uniq</syntaxhighlight>
{{out}}
<pre>
[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]
</pre>
=={{header|Sidef}}==
<
Alternative solution:
<
{{out}}
<pre>
Line 774 ⟶ 896:
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<
import "./fmt" for Fmt
var pows = []
Line 787 ⟶ 909:
pows = Lst.distinct(pows).sort()
System.print("Ordered distinct values of a ^ b for a in [2..5] and b in [2..5]:")
System.print("\nFound %(pows.count) such numbers.")</
{{out}}
Line 801 ⟶ 923:
=={{header|XPL0}}==
<
[Last:= 0;
loop [Next:= -1>>1; \infinity
Line 813 ⟶ 935:
Last:= Next;
];
]</
{{out}}
|