I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

Collect and sort square numbers in ascending order from three lists

From Rosetta Code
Collect and sort square numbers in ascending order from three lists 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


Collect and sort square numbers in ascending order from three lists.
list[1] = [3,4,34,25,9,12,36,56,36]
list[2] = [2,8,81,169,34,55,76,49,7]
list[3] = [75,121,75,144,35,16,46,35]

11l[edit]

V lists = [[3, 4, 34, 25, 9, 12, 36, 56, 36], [2, 8, 81, 169, 34, 55, 76, 49, 7], [75, 121, 75, 144, 35, 16, 46, 35]]
[Int] squares
 
F is_square(x)
R Int(sqrt(x)) ^ 2 == x
 
L(l) lists
L(x) l
I is_square(x)
squares.append(x)
 
squares.sort()
print(squares)
Output:
[4, 9, 16, 25, 36, 36, 49, 81, 121, 144, 169]

ALGOL 68[edit]

Library: ALGOL 68-rows
BEGIN # construct a list of the squares from some other lists                 #
# lists are represented by arrays in this sample #
PR read "rows.incl.a68" PR # sorting and printing utilities #
 
# construct the lists of numbers required by the task #
[][]INT list = ( ( 3, 4, 34, 25, 9, 12, 36, 56, 36 )
, ( 2, 8, 81, 169, 34, 55, 76, 49, 7 )
, ( 75, 121, 75, 144, 35, 16, 46, 35 )
);
# find the elements of the lists that are squares #
INT r pos := 0;
REF[]INT squares := HEAP[ 1 : 0 ]INT; # start with an empty list #
FOR i FROM LWB list TO UPB list DO
FOR j FROM LWB list[ i ] TO UPB list[ i ] DO
IF INT n = list[ i ][ j ];
REAL root = sqrt( n );
root = ENTIER root
THEN # have a square #
r pos +:= 1;
IF r pos > UPB squares THEN
# the squares array isn't big enough - make a larger one #
REF[]INT new squares
:= HEAP[ 1 : UPB squares + 10 ]INT;
new squares[ 1 : UPB squares ] := squares;
squares := new squares
FI;
squares[ r pos ] := n
FI
OD
OD;
QUICKSORT squares FROMELEMENT 1 TOELEMENT r pos;
SHOW squares[ 1 : r pos ]
END
Output:
 4 9 16 25 36 36 49 81 121 144 169

Arturo[edit]

lists: [
[3,4,34,25,9,12,36,56,36]
[2,8,81,169,34,55,76,49,7]
[75,121,75,144,35,16,46,35]
]
 
squares: map 1..inc to :integer sqrt max flatten lists 'x -> x^2
square?: function [n]-> contains? squares n
 
print select sort fold.seed:[] lists [a,b][a++b] => square?
Output:
4 9 16 25 36 36 49 81 121 144 169

AutoHotkey[edit]

list := [], t := [], result := []
 
list[1] := [3,4,34,25,9,12,36,56,36]
list[2] := [2,8,81,169,34,55,76,49,7]
list[3] := [75,121,75,144,35,16,46,35]
 
for i, l in list
for j, n in l
if ((s:=Sqrt(n)) = Floor(s))
t[n, j] := true
 
for n, obj in t
for i, v in obj
result.push(n)
Output:
[4, 9, 16, 25, 36, 36, 49, 81, 121, 144, 169]

AWK[edit]

 
# syntax: GAWK -f COLLECT_AND_SORT_SQUARE_NUMBERS_IN_ASCENDING_ORDER_FROM_THREE_LISTS.AWK
BEGIN {
list[1] = "3,4,34,25,9,12,36,56,36"
list[2] = "2,8,81,169,34,55,76,49,7"
list[3] = "75,121,75,144,35,16,46,35"
for (i=1; i<=length(list); i++) {
n = split(list[i],list_arr,",")
for (j=1; j<=n; j++) {
if (is_square(list_arr[j])) {
sq_arr[i,j] = list_arr[j]
}
}
}
PROCINFO["sorted_in"] = "@val_num_asc"
for (i in sq_arr) {
printf("%d ",sq_arr[i])
}
printf("\n")
exit(0)
}
function is_square(n) {
return (int(sqrt(n))^2 == n)
}
 
Output:
4 9 16 25 36 36 49 81 121 144 169

F#[edit]

 
// Collect and sort square numbers in ascending order from three lists. Nigel Galloway: December 21st., 2021
let fN g=g*g in printfn "%A" (([3;4;34;25;9;12;36;56;36]@[2;8;81;169;34;55;76;49;7]@[75;121;75;144;35;16;46;35])|>List.filter(fun n->(float>>sqrt>>int>>fN)n=n)|>List.sort)
 
Output:
[4; 9; 16; 25; 36; 36; 49; 81; 121; 144; 169]

FreeBASIC[edit]

function issquare( n as integer ) as boolean
if int(sqr(n))^2=n then return true else return false
end function
 
dim as integer i, j, nums(1 to 3, 1 to 9) = {{3,4,34,25,9,12,36,56,36},_
{2,8,81,169,34,55,76,49,7}, {75,121,75,144,35,16,46,35,-1}}, c, d, ii, jj 'pad the last list to make it the same length
redim as integer squares(-1) 'we don't know beforehand how many squares we'll find, so set up a placeholder
 
while true 'keep going while there are still squares in the lists
c = 99999 'sentinel value
for i = 1 to 3 'loop through lists
for j = 1 to 9
d = nums(i, j)
if issquare(d) then 'have we found a square?
if d < c then 'is it the smallest so far?
c = d
ii = i
jj = j
end if
end if
next j
next i
if c = 99999 then exit while 'if we didn't find a square, stop looking
redim preserve squares(0 to ubound(squares)+1) 'update our list
squares(ubound(squares)) = c
nums(ii,jj) = 13 'mod the original lists so we don't find that same square again
wend
 
for i = 0 to ubound(squares) 'output data
print squares(i);" ";
next i
Output:
4   9   16   25   36   36   49   81   121   144   169

Go[edit]

package main
 
import (
"fmt"
"math"
"sort"
)
 
func isSquare(n int) bool {
s := int(math.Sqrt(float64(n)))
return s*s == n
}
 
func main() {
lists := [][]int{
{3, 4, 34, 25, 9, 12, 36, 56, 36},
{2, 8, 81, 169, 34, 55, 76, 49, 7},
{75, 121, 75, 144, 35, 16, 46, 35},
}
var squares []int
for _, list := range lists {
for _, e := range list {
if isSquare(e) {
squares = append(squares, e)
}
}
}
sort.Ints(squares)
fmt.Println(squares)
}
Output:
[4 9 16 25 36 36 49 81 121 144 169]

jq[edit]

Works with: jq

Works with gojq, the Go implementation of jq

def isSquare: sqrt | (. == floor);

The Task

def lists: [
[3,4,34,25,9,12,36,56,36],
[2,8,81,169,34,55,76,49,7],
[75,121,75,144,35,16,46,35]
];
 
[lists[][]] | unique | map(select(isSquare))
Output:
[4,9,16,25,36,49,81,121,144,169]

Julia[edit]

vcat is list "addition" in Julia.

lists = [
[3,4,34,25,9,12,36,56,36],
[2,8,81,169,34,55,76,49,7],
[75,121,75,144,35,16,46,35]
]
 
squares = reduce(vcat, [[s for s in list if isqrt(s)^2 == s] for list in lists])
sort!(squares)
println(squares)
 

Mathematica / Wolfram Language[edit]

list1 = {3, 4, 34, 25, 9, 12, 36, 56, 36};
list2 = {2, 8, 81, 169, 34, 55, 76, 49, 7};
list3 = {75, 121, 75, 144, 35, 16, 46, 35};
[email protected][Join[list1, list2, list3], IntegerQ[Sqrt[#]] &]
Output:

{4,9,16,25,36,36,49,81,121,144,169}

ooRexx[edit]

Parse Version v
Say v
l.1=.array~of(3,4,34,25,9,12,36,56,36)
l.2=.array~of(2,8,81,169,34,55,76,49,7)
l.3=.array~of(75,121,75,144,35,16,46,35)
st.0=0
Do li=1 To 3
Do e over l.li
If is_square(e) Then
Call store s
End
End
Call Show
Exit
 
is_square:
Parse Arg x
Do i=1 By 1 UNtil i**2>x
if i**2=x Then Return 1
End
Return 0
 
store:
do i=1 To st.0
/*
If st.i=e Then
Return
*/

If st.i>e Then Do
Do j=st.0 To i By -1
ja=j+1
st.ja=st.j
End
st.0=st.0+1
Leave i
End
End
st.i=e
If i>st.0 Then
st.0=i
Return
 
show:
ol='Ordered squares:'
Do i=1 To st.0
ol=ol st.i
End
Say ol
Exit
Output:
REXX-ooRexx_5.0.0(MT)_64-bit 6.05 8 Sep 2020
Ordered squares: 4 9 16 25 36 36 49 81 121 144 169

Perl[edit]

Library: ntheory
#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Add_and_sort_square_numbers_in_ascending_order_from_three_lists
use warnings;
use ntheory qw( is_square );
use List::Util qw( sum );
 
my @lists = (
[3,4,34,25,9,12,36,56,36],
[2,8,81,169,34,55,76,49,7],
[75,121,75,144,35,16,46,35]);
 
my $sum = sum my @squares = grep is_square($_), sort { $a <=> $b } map @$_, @lists;
print "sum $sum - @squares\n";
Output:
sum 690  -  4 9 16 25 36 36 49 81 121 144 169

Phix[edit]

with javascript_semantics
procedure squares(sequence lists)
    sequence res = sort(join(lists)), sq = {1}
    while res[$]>sq[$] do sq &= power(length(sq)+1,2) end while
    res = filter(res,"in",sq)
    printf(1,"Added:%,d, Sorted:%V\n",{sum(res),res})
end procedure

squares({{3,4,34,25,9,12,36,56,36},
         {2,8,81,169,34,55,76,49,7},
         {75,121,75,144,35,16,46,35}})

Alternatively, and a smidgen faster but not enough to be measurable here, you could replace that inner while loop with:

    integer m = res[$], s = 1, d = 1
    while m>s do d += 2; s += d; sq &= s; end while
Output:
Added:690, Sorted:{4,9,16,25,36,36,49,81,121,144,169}

You could also apply res:=unique(res), anywhere/8 ways: new line in 3 places, or inline (two ways each) on either existing assignment, or as a replacement for the sort(), which would reduce the length by 1 (the duplicate 36) and yield a total of 654.

Python[edit]

 
import math
 
print("working...")
list = [(3,4,34,25,9,12,36,56,36),(2,8,81,169,34,55,76,49,7),(75,121,75,144,35,16,46,35)]
Squares = []
 
def issquare(x):
for p in range(x):
if x == p*p:
return 1
for n in range(3):
for m in range(len(list[n])):
if issquare(list[n][m]):
Squares.append(list[n][m])
 
Squares.sort()
print(Squares)
print("done...")
 
Output:
working...
[4, 9, 16, 25, 36, 36, 49, 81, 121, 144, 169]
done...

Raku[edit]

my $s = cache sort ( my $l = ( cache flat
 
[3,4,34,25,9,12,36,56,36],
[2,8,81,169,34,55,76,49,7],
[75,121,75,144,35,16,46,35]
 
)).grep: * ∈ cache {$++²}*>$l.max;
 
put 'Added - Sorted';
put ' ' ~ $s.sum ~ ' ' ~ $s.gist;
Added - Sorted
 690  (4 9 16 25 36 36 49 81 121 144 169)

REXX[edit]

Parse Version v
Say v
l.=0
Call mk_array 1,3,4,34,25,9,12,36,56,36
Call mk_array 2,2,8,81,169,34,55,76,49,7
Call mk_array 3,75,121,75,144,3,5,16,46,35
st.0=0
Do li=1 To 3
Do ii=1 To l.li.0
If is_square(l.li.ii) Then
Call store l.li.ii
End
End
Call Show
Exit
 
mk_array:
an=arg(1)
Do i=1 To arg()-1
l.an.i=arg(i+1)
End
l.an.0=arg()-1
Return
 
is_square:
Parse Arg x
Do i=1 By 1 Until i**2>x
if i**2=x Then Return 1
End
Return 0
 
store:
Parse Arg e
do i=1 To st.0
If st.i>e Then Do
Do j=st.0 To i By -1
ja=j+1
st.ja=st.j
End
st.0=st.0+1
Leave i
End
End
st.i=e
If i>st.0 Then
st.0=i
Return
 
show:
ol='Ordered squares:'
Do i=1 To st.0
ol=ol st.i
End
Say ol
Exit
Output:
REXX-Regina_3.9.4(MT) 5.00 25 Oct 2021
Ordered squares: 4 9 16 25 36 36 49 81 121 144 169

Ring[edit]

 
load "stdlib.ring"
 
see "working..." + nl
list = list(3)
list[1] = [3,4,34,25,9,12,36,56,36]
list[2] = [2,8,81,169,34,55,76,49,7]
list[3] = [75,121,75,144,35,16,46,35]
Primes = []
 
for n = 1 to 3
for m = 1 to len(list[n])
if issquare(list[n][m])
add(Primes,list[n][m])
ok
next
next
 
Primes = sort(Primes)
showArray(Primes)
 
see nl + "done..." + nl
 
func issquare(x)
for n = 1 to sqrt(x)
if x = pow(n,2)
return 1
ok
next
return 0
 
func showArray(array)
txt = ""
see "["
for n = 1 to len(array)
txt = txt + array[n] + ","
next
txt = left(txt,len(txt)-1)
txt = txt + "]"
see txt
 
Output:
working...
[4,9,16,25,36,36,49,81,121,144,169]
done...

Sidef[edit]

var lists = [
[3,4,34,25,9,12,36,56,36],
[2,8,81,169,34,55,76,49,7],
[75,121,75,144,35,16,46,35],
]
 
say lists.flat.grep{.is_square}.sort
Output:
[4, 9, 16, 25, 36, 36, 49, 81, 121, 144, 169]

Wren[edit]

Library: Wren-math
import "./math" for Int
 
var lists = [
[3,4,34,25,9,12,36,56,36],
[2,8,81,169,34,55,76,49,7],
[75,121,75,144,35,16,46,35]
]
 
var squares = []
for (list in lists) {
for (e in list) if (Int.isSquare(e)) squares.add(e)
}
squares.sort()
System.print(squares)
Output:
[4, 9, 16, 25, 36, 36, 49, 81, 121, 144, 169]

XPL0[edit]

The task description seems to dictate how a program is supposed to solve this, rather than merely provide a procedure that determines the solution. XPL0 doesn't have a built-in list capability like Python. A simple substitute is to treat the lists as arrays. A complication is that list[3] is shorter than the others, which is adjusted here. XPL0 also doesn't have a built-in sort routine (although one is provided in its library). Displaying a small number of sorted items is easily done with a few lines of code.

int List(3+1), Min, I, J, S, MI, MJ;
def Inf = -1>>1;
[List(1):= [3,4,34,25,9,12,36,56,36];
List(2):= [2,8,81,169,34,55,76,49,7];
List(3):= [75,121,75,144,35,16,46,35,Inf];
loop [Min:= Inf;
for I:= 1 to 3 do
for J:= 0 to 8 do
[S:= sqrt(List(I,J));
if S*S = List(I,J) then
if List(I,J) <= Min then
[Min:= List(I,J); MI:= I; MJ:= J];
];
if Min = Inf then quit;
IntOut(0, Min); ChOut(0, ^ );
List(MI, MJ):= Inf;
];
]
Output:
4 9 16 25 36 36 49 81 121 144 169