Distinct power numbers: Difference between revisions

Line 11:

<~~lang~~ 11l>print(sorted(Array(Set(cart_product(2..5, 2..5).map((a, b) -> a ^ b)))))</~~lang~~>

<syntaxhighlight lang="11l">print(sorted(Array(Set(cart_product(2..5, 2..5).map((a, b) -> a ^ b)))))</syntaxhighlight>

Line 20:

=={{header|Action!}}==

<~~lang~~ ~~Action~~!>INCLUDE "D2:SORT.ACT" ;from the Action! Tool Kit

<syntaxhighlight lang="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</~~lang~~>

RETURN</syntaxhighlight>

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Distinct_power_numbers.png Screenshot from Atari 8-bit computer]

Line 74:

=={{header|Ada}}==

<~~lang~~ ~~Ada~~>with Ada.Text_Io;

<syntaxhighlight lang="ada">with Ada.Text_Io;

with Ada.Containers.Doubly_Linked_Lists;

Line 105:

New_Line;

end Power_Numbers;</~~lang~~>

end Power_Numbers;</syntaxhighlight>

=={{header|ALGOL 68}}==

<~~lang~~ algol68>BEGIN # show in order, distinct values of a^b where 2 <= a <= b <= 5 #

<syntaxhighlight 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</~~lang~~>

END</syntaxhighlight>

<pre>

Line 154:

=={{header|APL}}==

Line 161:

===Idiomatic===

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

<~~lang~~ applescript>on task()

<syntaxhighlight lang="applescript">on task()

script o

property output : {}

Line 180:

end task

task()</~~lang~~>

task()</syntaxhighlight>

<~~lang~~ applescript>{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}</~~lang~~>

----

Line 189:

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

<~~lang~~ applescript>use framework "Foundation"

<syntaxhighlight lang="applescript">use framework "Foundation"

use scripting additions

Line 268:

((current application's NSArray's arrayWithArray:xs)'s ¬

sortedArrayUsingSelector:"compare:") as list

end sort</~~lang~~>

end sort</syntaxhighlight>

Line 274:

===AppleScriptObjC===

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

<~~lang~~ applescript>use AppleScript version "2.4" -- Mac OS X 10.10 (Yosemite) or later.

<syntaxhighlight lang="applescript">use AppleScript version "2.4" -- Mac OS X 10.10 (Yosemite) or later.

use framework "Foundation"

Line 291:

end task

task()</~~lang~~>

task()</syntaxhighlight>

<~~lang~~ applescript>{4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125}</~~lang~~>

=={{header|Arturo}}==

<~~lang~~ rebol>print sort unique flatten map 2..5 'a [

<syntaxhighlight lang="rebol">print sort unique flatten map 2..5 'a [

map 2..5 'b -> a^b

]</~~lang~~>

]</syntaxhighlight>

Line 307:

=={{header|BCPL}}==

<~~lang~~ bcpl>get "libhdr"

<syntaxhighlight lang="bcpl">get "libhdr"

let pow(n, p) =

Line 335:

if i=0 | v!i ~= v!(i-1) do writef("%N ", v!i)

wrch('*N')

$)</~~lang~~>

$)</syntaxhighlight>

=={{header|BQN}}==

=={{header|C}}==

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

#include <stdlib.h>

#include <math.h>

Line 371:

printf("\n");

return 0;

}</~~lang~~>

}</syntaxhighlight>

=={{header|C++}}==

<~~lang~~ cpp>#include <iostream>

<syntaxhighlight lang="cpp">#include <iostream>

#include <set>

#include <cmath>

Line 391:

std::cout << std::endl;

return 0;

}</~~lang~~>

}</syntaxhighlight>

=={{header|F_Sharp|F#}}==

<~~lang~~ fsharp>

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

</syntaxhighlight>

</lang>

<pre>

Line 406:

=={{header|Factor}}==

<~~lang~~ factor>USING: kernel math.functions math.ranges prettyprint sequences

<syntaxhighlight lang="factor">USING: kernel math.functions math.ranges prettyprint sequences

sets sorting ;

2 5 [a,b] dup [ ^ ] cartesian-map concat members natural-sort .</~~lang~~>

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

<pre>

Line 416:

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>

redim arr(-1) as uinteger

dim as uinteger i

Line 434:

if arr(i)<>arr(i-1) then print arr(i),

next i

</syntaxhighlight>

</lang>

=={{header|Go}}==

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 473:

}

fmt.Println("\nFound", len(pows), "such numbers.")

}</~~lang~~>

}</syntaxhighlight>

Line 486:

=={{header|Haskell}}==

<~~lang~~ haskell>import qualified Data.Set as S

<syntaxhighlight lang="haskell">import qualified Data.Set as S

Line 501:

main =

print $

distinctPowerNumbers 2 5</~~lang~~>

distinctPowerNumbers 2 5</syntaxhighlight>

Line 508:

or, as a one-off list comprehension:

<~~lang~~ haskell>import qualified Data.Set as S

<syntaxhighlight 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]</~~lang~~>

(\xs -> [x ^ y | x <- xs, y <- xs]) [2 .. 5]</syntaxhighlight>

or a liftA2 expression:

<~~lang~~ haskell>import Control.Applicative (liftA2)

<syntaxhighlight lang="haskell">import Control.Applicative (liftA2)

import Control.Monad (join)

import qualified Data.Set as S

Line 525:

join

(liftA2 (^))

[2 .. 5]</~~lang~~>

[2 .. 5]</syntaxhighlight>

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

<~~lang~~ haskell>import qualified Data.Set as S

<syntaxhighlight lang="haskell">import qualified Data.Set as S

main :: IO ()

Line 534:

(print . S.elems . S.fromList) $

(\xs -> (^) <$> xs <*> xs)

[2 .. 5]</~~lang~~>

[2 .. 5]</syntaxhighlight>

Line 540:

=={{header|J}}==

<~~lang~~ j>~./:~;^/~2+i.4</~~lang~~>

Line 549:

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

<~~lang~~ jq>[range(2;6) as $a | range(2;6) as $b | pow($a; $b)] | unique</~~lang~~>

<syntaxhighlight lang="jq">[range(2;6) as $a | range(2;6) as $b | pow($a; $b)] | unique</syntaxhighlight>

<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:<~~lang~~ jq>def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);

However, if using gojq, then for unbounded precision, a special-purpose "power" function is needed:<syntaxhighlight 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</~~lang~~>

[range(2;6) as $a | range(2;6) as $b | $a|power($b)] | unique</syntaxhighlight>

As above.

=={{header|Julia}}==

<~~lang~~ julia>println(sort(unique([a^b for a in 2:5, b in 2:5])))</~~lang~~>{{out}}

<syntaxhighlight lang="julia">println(sort(unique([a^b for a in 2:5, b in 2:5])))</syntaxhighlight>{{out}}

=={{header|Mathematica}}/{{header|Wolfram Language}}==

<~~lang~~ ~~Mathematica~~>Union @@ Table[a^b, {a, 2, 5}, {b, 2, 5}]</~~lang~~>

<syntaxhighlight lang="mathematica">Union @@ Table[a^b, {a, 2, 5}, {b, 2, 5}]</syntaxhighlight>

=={{header|Nim}}==

<~~lang~~ ~~Nim~~>import algorithm, math, sequtils, strutils, sugar

<syntaxhighlight lang="nim">import algorithm, math, sequtils, strutils, sugar

let list = collect(newSeq):

Line 575:

for b in 2..5: a^b

echo sorted(list).deduplicate(true).join(" ")</~~lang~~>

echo sorted(list).deduplicate(true).join(" ")</syntaxhighlight>

Line 581:

=={{header|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," ")})

<pre>

Line 596:

=={{header|Perl}}==

<~~lang~~ perl>#!/usr/bin/perl -l

<syntaxhighlight lang="perl">#!/usr/bin/perl -l

use strict; # https://rosettacode.org/wiki/Distinct_power_numbers

Line 602:

use List::Util qw( uniq );

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

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

<pre>

Line 609:

=={{header|Python}}==

<~~lang~~ python>from itertools import product

<syntaxhighlight lang="python">from itertools import product

print(sorted(set(a**b for (a,b) in product(range(2,6), range(2,6)))))</~~lang~~>

print(sorted(set(a**b for (a,b) in product(range(2,6), range(2,6)))))</syntaxhighlight>

Line 616:

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

<~~lang~~ python>'''Distinct power numbers'''

<syntaxhighlight lang="python">'''Distinct power numbers'''

from itertools import product, starmap

Line 647:

# MAIN ---

if __name__ == '__main__':

main()</~~lang~~>

main()</syntaxhighlight>

Line 653:

=={{header|R}}==

This only takes one line.

<~~lang~~ rsplus>unique(sort(rep(2:5, each = 4)^rep(2:5, times = 4)))</~~lang~~>

<syntaxhighlight lang="rsplus">unique(sort(rep(2:5, each = 4)^rep(2:5, times = 4)))</syntaxhighlight>

=={{header|Raku}}==

<lang ~~perl6~~>put squish sort [X**] (2..5) xx 2;</~~lang~~>

<syntaxhighlight lang="raku" line>put squish sort [X**] (2..5) xx 2;</syntaxhighlight>

Line 664:

=={{header|REXX}}==

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

<~~lang~~ rexx>/*REXX pgm finds and displays distinct power integers: a^b, where a and b are 2≤both≤5*/

<syntaxhighlight 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 698:

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.*/</~~lang~~>

end /*m*/; $$= delword($$, p, 1); return /*delete the smallest number.*/</syntaxhighlight>

<pre>

Line 736:

=={{header|Ring}}==

<~~lang~~ ring>

load "stdlib.ring"

Line 769:

see "Found " + row + " numbers" + nl

see "done..." + nl

</syntaxhighlight>

</lang>

<pre>

Line 782:

=={{header|Sidef}}==

<~~lang~~ ruby>[2..5]*2 -> cartesian.map_2d {|a,b| a**b }.sort.uniq.say</~~lang~~>

<syntaxhighlight lang="ruby">[2..5]*2 -> cartesian.map_2d {|a,b| a**b }.sort.uniq.say</syntaxhighlight>

Alternative solution:

<~~lang~~ ruby>2..5 ~X** 2..5 -> sort.uniq.say</~~lang~~>

<pre>

Line 794:

<~~lang~~ ecmascript>import "/seq" for Lst

<syntaxhighlight lang="ecmascript">import "/seq" for Lst

import "/fmt" for Fmt

Line 808:

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.print("$,5d", chunk)

System.print("\nFound %(pows.count) such numbers.")</~~lang~~>

System.print("\nFound %(pows.count) such numbers.")</syntaxhighlight>

Line 821:

=={{header|XPL0}}==

<~~lang~~ ~~XPL0~~>int A, B, N, Last, Next;

<syntaxhighlight lang="xpl0">int A, B, N, Last, Next;

[Last:= 0;

loop [Next:= -1>>1; \infinity

Line 833:

Last:= Next;

];

]</~~lang~~>

]</syntaxhighlight>