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

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.

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

## 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)`
Output:
```[4, 9, 16, 25, 36, 36, 49, 81, 121, 144, 169]
```

## ALGOL 68

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

`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^2square?: 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`

## AWK

` # syntax: GAWK -f COLLECT_AND_SORT_SQUARE_NUMBERS_IN_ASCENDING_ORDER_FROM_THREE_LISTS.AWKBEGIN {    list = "3,4,34,25,9,12,36,56,36"    list = "2,8,81,169,34,55,76,49,7"    list = "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#

` // Collect and sort square numbers in ascending order from three lists. Nigel Galloway: December 21st., 2021let 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

`function issquare( n as integer ) as boolean    if int(sqr(n))^2=n then return true else return falseend 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 lengthredim 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 againwend 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

`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

Works with: jq

Works with gojq, the Go implementation of jq

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

`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

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

`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

`Parse Version vSay vl.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=0Do li=1 To 3  Do e over l.li    If is_square(e) Then      Call store s    End  EndCall ShowExit is_square:Parse Arg xDo i=1 By 1 UNtil i**2>x  if i**2=x Then Return 1  EndReturn 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  Endst.i=eIf i>st.0 Then  st.0=iReturn show:ol='Ordered squares:'Do i=1 To st.0  ol=ol st.i  EndSay olExit`
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

Library: ntheory
`#!/usr/bin/perl use strict; # https://rosettacode.org/wiki/Add_and_sort_square_numbers_in_ascending_order_from_three_listsuse 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

```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)
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

` 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 1for 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

`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

`Parse Version vSay vl.=0Call mk_array 1,3,4,34,25,9,12,36,56,36Call mk_array 2,2,8,81,169,34,55,76,49,7Call mk_array 3,75,121,75,144,3,5,16,46,35st.0=0Do li=1 To 3  Do ii=1 To l.li.0    If is_square(l.li.ii) Then      Call store l.li.ii    End  EndCall ShowExit mk_array:an=arg(1)Do i=1 To arg()-1  l.an.i=arg(i+1)  Endl.an.0=arg()-1Return is_square:Parse Arg xDo i=1 By 1 Until i**2>x  if i**2=x Then Return 1  EndReturn 0 store:Parse Arg edo 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  Endst.i=eIf i>st.0 Then  st.0=iReturn show:ol='Ordered squares:'Do i=1 To st.0  ol=ol st.i  EndSay olExit`
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

` load "stdlib.ring" see "working..." + nllist = list(3)list = [3,4,34,25,9,12,36,56,36]list = [2,8,81,169,34,55,76,49,7]list = [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    nextnext 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

`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

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

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 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
```