Collect and sort square numbers in ascending order from three lists

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

<lang 11l>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)</lang>

Output:

[4, 9, 16, 25, 36, 36, 49, 81, 121, 144, 169]

ALGOL 68

Library: ALGOL 68-rows

<lang algol68>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</lang>

Output:

 4 9 16 25 36 36 49 81 121 144 169

AWK

<lang AWK>

1. 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)

} </lang>

Output:

4 9 16 25 36 36 49 81 121 144 169

FreeBASIC

<lang freebasic>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</lang>

Output:

4   9   16   25   36   36   49   81   121   144   169

jq

Works with: jq

Works with gojq, the Go implementation of jq

<lang jq>def isSquare: sqrt | (. == floor);</lang>

The Task <lang>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))</lang>

Output:

[4,9,16,25,36,49,81,121,144,169]

Julia

vcat is list "addition" in Julia. <lang 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) </lang>

ooRexx

<lang oorexx>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</lang>

Output:

REXX-ooRexx_5.0.0(MT)_64-bit 6.05 8 Sep 2020
Ordered squares: 4 9 16 25 36 49 81 121 144 169

Perl

Library: ntheory

<lang perl>#!/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";</lang>

Output:

sum 690  -  4 9 16 25 36 36 49 81 121 144 169

Phix

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

<lang python> 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...") </lang>

Output:

working...
[4, 9, 16, 25, 36, 36, 49, 81, 121, 144, 169]
done...

Raku

<lang perl6>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;</lang>

Added - Sorted
 690  (4 9 16 25 36 36 49 81 121 144 169)

REXX

<lang rexx>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</lang>

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

<lang ring> 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 

</lang>

Output:

working...
[4,9,16,25,36,36,49,81,121,144,169]
done...

Wren

Library: Wren-math

<lang ecmascript>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)</lang>

Output:

[4, 9, 16, 25, 36, 36, 49, 81, 121, 144, 169]