Rosetta Code

Distinct power numbers: Difference between revisions

Page Discussion

Distinct power numbers (view source)

Revision as of 11:33, 26 November 2023

3,803 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Minor tidy
(Added Arturo implementation)
m (→‎{{header|Wren}}: Minor tidy)
 
(7 intermediate revisions by 7 users not shown)
Line 11:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">print(sorted(Array(Set(cart_product(2..5, 2..5).map((a, b) -> a ^ b)))))</langsyntaxhighlight>
 
{{out}}
Line 20:
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<langsyntaxhighlight Actionlang="action!">INCLUDE "D2:SORT.ACT" ;from the Action! Tool Kit
 
INT FUNC Power(INT a,b)
Line 66:
PrintI(a(i)) Put(32)
OD
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Distinct_power_numbers.png Screenshot from Atari 8-bit computer]
Line 74:
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_Io;
with Ada.Containers.Doubly_Linked_Lists;
 
Line 105:
New_Line;
 
end Power_Numbers;</langsyntaxhighlight>
{{out}}
<pre> 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 </pre>
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68">BEGIN # show in order, distinct values of a^b where 2 <= a <= b <= 5 #
INT max number = 5;
INT min number = 2;
Line 146:
OD;
print( ( newline ) )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 154:
=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang APL="apl">(⊂∘⍋⌷⊣)∪,∘.*⍨1+⍳4</langsyntaxhighlight>
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
Line 161:
===Idiomatic===
Uses an extravagantly long list, but gets the job done quickly and easily.
<langsyntaxhighlight lang="applescript">on task()
script o
property output : {}
Line 180:
end task
 
task()</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}</langsyntaxhighlight>
----
 
Line 189:
Composing a solution from generic primitives, for speed of drafting, and ease of refactoring:
 
<langsyntaxhighlight lang="applescript">use framework "Foundation"
use scripting additions
 
Line 268:
((current application's NSArray's arrayWithArray:xs)'s ¬
sortedArrayUsingSelector:"compare:") as list
end sort</langsyntaxhighlight>
{{Out}}
<pre>{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}</pre>
Line 274:
===AppleScriptObjC===
Throwing together a solution using the most appropriate methods for efficiency and legibility.
<langsyntaxhighlight lang="applescript">use AppleScript version "2.4" -- Mac OS X 10.10 (Yosemite) or later.
use framework "Foundation"
 
Line 291:
end task
 
task()</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}</langsyntaxhighlight>
 
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">powers:print sort unique flatten map 2..5 'a [
map 2..5 'b -> a^b
]</syntaxhighlight>
]
 
print powers</lang>
 
{{out}}
Line 309 ⟶ 307:
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
 
let pow(n, p) =
Line 337 ⟶ 335:
if i=0 | v!i ~= v!(i-1) do writef("%N ", v!i)
wrch('*N')
$)</langsyntaxhighlight>
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
 
=={{header|BQN}}==
<syntaxhighlight lang ="bqn">∧⍷⥊⋆⌜˜ 2+↕4</langsyntaxhighlight>
{{out}}
<pre>⟨ 4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125 ⟩</pre>
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <math.h>
Line 373 ⟶ 371:
printf("\n");
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <set>
#include <cmath>
Line 393 ⟶ 391:
std::cout << std::endl;
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
set[for n in 2..5 do for g in 2..5->pown n g]|>Set.iter(printf "%d ")
</syntaxhighlight>
</lang>
{{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}}
<langsyntaxhighlight lang="factor">USING: kernel math.functions math.ranges prettyprint sequences
sets sorting ;
 
2 5 [a,b] dup [ ^ ] cartesian-map concat members natural-sort .</langsyntaxhighlight>
{{out}}
<pre>
Line 418 ⟶ 454:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">
redim arr(-1) as uinteger
dim as uinteger i
Line 436 ⟶ 472:
if arr(i)<>arr(i-1) then print arr(i),
next i
</syntaxhighlight>
</lang>
 
=={{header|Go}}==
{{trans|Wren}}
{{libheader|Go-rcu}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 475 ⟶ 511:
}
fmt.Println("\nFound", len(pows), "such numbers.")
}</langsyntaxhighlight>
 
{{out}}
Line 488 ⟶ 524:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import qualified Data.Set as S
 
 
Line 503 ⟶ 539:
main =
print $
distinctPowerNumbers 2 5</langsyntaxhighlight>
{{Out}}
<pre>[4,8,9,16,25,27,32,64,81,125,243,256,625,1024,3125]</pre>
Line 510 ⟶ 546:
or, as a one-off list comprehension:
 
<langsyntaxhighlight lang="haskell">import qualified Data.Set as S
 
main :: IO ()
main =
(print . S.elems . S.fromList) $
(\xs -> [x ^ y | x <- xs, y <- xs]) [2 .. 5]</langsyntaxhighlight>
 
or a liftA2 expression:
<langsyntaxhighlight lang="haskell">import Control.Applicative (liftA2)
import Control.Monad (join)
import qualified Data.Set as S
Line 527 ⟶ 563:
join
(liftA2 (^))
[2 .. 5]</langsyntaxhighlight>
 
which can always be reduced (shedding imports) to the pattern:
<langsyntaxhighlight lang="haskell">import qualified Data.Set as S
 
main :: IO ()
Line 536 ⟶ 572:
(print . S.elems . S.fromList) $
(\xs -> (^) <$> xs <*> xs)
[2 .. 5]</langsyntaxhighlight>
 
{{Out}}
Line 542 ⟶ 578:
 
=={{header|J}}==
<langsyntaxhighlight lang="j">~./:~;^/~2+i.4</langsyntaxhighlight>
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
Line 551 ⟶ 587:
 
For relatively small integers, such as involved in the specified task, the built-in function `pow/2` does the job:
<langsyntaxhighlight lang="jq">[range(2;6) as $a | range(2;6) as $b | pow($a; $b)] | unique</langsyntaxhighlight>
{{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:<langsyntaxhighlight lang="jq">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</langsyntaxhighlight>
{{out}}
As above.
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">println(sort(unique([a^b for a in 2:5, b in 2:5])))</langsyntaxhighlight>{{out}}
<pre>[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">Union @@ Table[a^b, {a, 2, 5}, {b, 2, 5}]</langsyntaxhighlight>
{{out}}
<pre>{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import algorithm, math, sequtils, strutils, sugar
 
let list = collect(newSeq):
Line 577 ⟶ 613:
for b in 2..5: a^b
 
echo sorted(list).deduplicate(true).join(" ")</langsyntaxhighlight>
 
{{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}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 598 ⟶ 655:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl -l
 
use strict; # https://rosettacode.org/wiki/Distinct_power_numbers
Line 604 ⟶ 661:
use List::Util qw( uniq );
 
print join ', ', sort { $a <=> $b } uniq map { my $e = $_; map $_ ** $e, 2 .. 5} 2 .. 5;</langsyntaxhighlight>
{{out}}
<pre>
Line 611 ⟶ 668:
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">from itertools import product
print(sorted(set(a**b for (a,b) in product(range(2,6), range(2,6)))))</langsyntaxhighlight>
{{out}}
<pre>[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]</pre>
Line 618 ⟶ 675:
 
Or, for variation, generalizing a little in terms of '''starmap''' and '''pow''':
<langsyntaxhighlight lang="python">'''Distinct power numbers'''
 
from itertools import product, starmap
Line 649 ⟶ 706:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>[4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125]</pre>
Line 655 ⟶ 712:
=={{header|R}}==
This only takes one line.
<langsyntaxhighlight lang="rsplus">unique(sort(rep(2:5, each = 4)^rep(2:5, times = 4)))</langsyntaxhighlight>
{{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" perl6line>put squish sort [X**] (2..5) xx 2;</langsyntaxhighlight>
{{out}}
<pre>4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125</pre>
Line 666 ⟶ 746:
=={{header|REXX}}==
With this version of REXX, &nbsp; there's no need to sort the found numbers, &nbsp; or to eliminate duplicates.
<langsyntaxhighlight lang="rexx">/*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.*/
Line 700 ⟶ 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.*/</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 738 ⟶ 818:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 771 ⟶ 851:
see "Found " + row + " numbers" + nl
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 781 ⟶ 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}}==
<langsyntaxhighlight lang="ruby">[2..5]*2 -> cartesian.map_2d {|a,b| a**b }.sort.uniq.say</langsyntaxhighlight>
 
Alternative solution:
<langsyntaxhighlight lang="ruby">2..5 ~X** 2..5 -> sort.uniq.say</langsyntaxhighlight>
{{out}}
<pre>
Line 796 ⟶ 896:
{{libheader|Wren-seq}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./seq" for Lst
import "./fmt" for Fmt
 
var pows = []
Line 809 ⟶ 909:
pows = Lst.distinct(pows).sort()
System.print("Ordered distinct values of a ^ b for a in [2..5] and b in [2..5]:")
for (chunk in Lst.chunks(pows, 5)) Fmt.printtprint("$,5d", chunkpows, 5)
System.print("\nFound %(pows.count) such numbers.")</langsyntaxhighlight>
 
{{out}}
Line 823 ⟶ 923:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">int A, B, N, Last, Next;
[Last:= 0;
loop [Next:= -1>>1; \infinity
Line 835 ⟶ 935:
Last:= Next;
];
]</langsyntaxhighlight>
 
{{out}}
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/315100...355010"