Rosetta Code

Common sorted list: Difference between revisions

Page Discussion

Common sorted list (view source)

Revision as of 16:40, 3 April 2024

15,975 bytes added ,  1 month ago
→‎{{header|Free Pascal}}
(Ada version)
 
(32 intermediate revisions by 24 users not shown)
Line 11:
'''output''' = [1,3,4,5,7,8,9]
<br><br>
 
=={{header|11l}}==
<syntaxhighlight lang="11l">F csl(nums)
Set[Int] r
L(num) nums
r.update(num)
R sorted(Array(r))
 
print(csl([[5, 1, 3, 8, 9, 4, 8, 7], [3, 5, 9, 8, 4], [1, 3, 7, 9]]))</syntaxhighlight>
 
{{out}}
<pre>
[1, 3, 4, 5, 7, 8, 9]
</pre>
 
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">INCLUDE "D2:SORT.ACT" ;from the Action! Tool Kit
 
DEFINE PTR="CARD"
 
PROC PrintArray(BYTE ARRAY a BYTE len)
BYTE i
 
Print(" [")
IF len>0 THEN
FOR i=0 TO len-1
DO
PrintB(a(i))
IF i<len-1 THEN Put(' ) FI
OD
FI
PrintE("]")
RETURN
 
BYTE FUNC Contains(BYTE ARRAY a BYTE len,value)
BYTE i
 
IF len>0 THEN
FOR i=0 TO len-1
DO
IF a(i)=value THEN RETURN(1) FI
OD
FI
RETURN (0)
 
PROC CommonListElements(PTR ARRAY arrays
BYTE ARRAY lengths BYTE count
BYTE ARRAY res BYTE POINTER resLen)
BYTE ARRAY a
BYTE i,j,len,value,cnt,maxcnt
 
resLen^=0
IF count=0 THEN
RETURN
ELSEIF count=1 THEN
MoveBlock(res,a,len) RETURN
FI
 
FOR i=0 TO count-1
DO
a=arrays(i) len=lengths(i)
IF len>0 THEN
FOR j=0 TO len-1
DO
value=a(j)
IF Contains(res,resLen^,value)=0 THEN
res(resLen^)=value resLen^==+1
FI
OD
FI
OD
SortB(res,resLen^,0)
RETURN
 
PROC Test(PTR ARRAY arrays BYTE ARRAY lengths BYTE count)
BYTE ARRAY res(100)
BYTE len,i
 
CommonListElements(arrays,lengths,count,res,@len)
PrintE("Input:")
FOR i=0 TO count-1
DO
PrintArray(arrays(i),lengths(i))
OD
PrintE("Output:")
PrintArray(res,len) PutE()
RETURN
 
PROC Main()
PTR ARRAY arrays(3)
BYTE ARRAY
lengths(3)=[8 5 4],
a1(8)=[5 1 3 8 9 4 8 7],
a2(5)=[3 5 9 8 4],
a3(4)=[1 3 7 9],
a4(8)=[5 1 1 1 9 9 8 7],
a5(5)=[5 5 9 9 9],
a6(4)=[1 7 7 9]
BYTE len
 
Put(125) PutE() ;clear the screen
arrays(0)=a1 arrays(1)=a2 arrays(2)=a3
Test(arrays,lengths,3)
 
arrays(0)=a4 arrays(1)=a5 arrays(2)=a6
Test(arrays,lengths,3)
 
lengths(0)=0
Test(arrays,lengths,3)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Common_sorted_list.png Screenshot from Atari 8-bit computer]
<pre>
Input:
[5 1 3 8 9 4 8 7]
[3 5 9 8 4]
[1 3 7 9]
Output:
[1 3 4 5 7 8 9]
 
Input:
[5 1 1 1 9 9 8 7]
[5 5 9 9 9]
[1 7 7 9]
Output:
[1 5 7 8 9]
 
Input:
[]
[5 5 9 9 9]
[1 7 7 9]
Output:
[1 5 7 9]
</pre>
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_Io;
with Ada.Containers.Vectors;
 
Line 49 ⟶ 186:
end Put;
 
A : constant Vector := Empty_Vector & 5 & 1 & 3 & 8 & 9 & 4 & 8 & 7;
B : constant Vector := Empty_Vector & 3 & 5 & 9 & 8 & 4;
C : constant Vector := Empty_Vector & 1 & 3 & 7 & 9;
R : Vector := A & B & C;
begin
Line 57 ⟶ 194:
Unique (R);
Put (R);
end Sorted;</langsyntaxhighlight>
{{out}}
<pre>[ 1 3 4 5 7 8 9 ]</pre>
Line 63 ⟶ 200:
=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang="text">csl ← (⊂∘⍋⌷⊢)∪∘∊</langsyntaxhighlight>
{{out}}
<pre> csl (5 1 3 8 9 4 8 7)(3 5 9 8 4)(1 3 7 9)
Line 70 ⟶ 207:
=={{header|AppleScript}}==
 
<langsyntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
use framework "Foundation"
 
Line 77 ⟶ 214:
set nums to current application's class "NSArray"'s arrayWithArray:({{5, 1, 3, 8, 9, 4, 8, 7}, {3, 5, 9, 8, 4}, {1, 3, 7, 9}})
set output to (nums's valueForKeyPath:("@distinctUnionOfArrays.self"))'s sortedArrayUsingSelector:("compare:")
return output as list</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">{1, 3, 4, 5, 7, 8, 9}</langsyntaxhighlight>
 
 
Line 87 ⟶ 224:
while ''concat/flatten'' and ''nub/distinct'' are more atomic, and more frequently reached for):
 
<langsyntaxhighlight lang="applescript">use AppleScript version "2.4"
use framework "Foundation"
 
Line 120 ⟶ 257:
((current application's NSArray's arrayWithArray:xs)'s ¬
sortedArrayUsingSelector:"compare:") as list
end sort</langsyntaxhighlight>
{{Out}}
<pre>{1, 3, 4, 5, 7, 8, 9}</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">print sort unique flatten [[5 1 3 8 9 4 8 7] [3 5 9 8 4] [1 3 7 9]]</syntaxhighlight>
 
{{out}}
 
<pre>1 3 4 5 7 8 9</pre>
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">Common_sorted_list(nums){
elements := [], output := []
for i, num in nums
Line 133 ⟶ 278:
output.push(val)
return output
}</langsyntaxhighlight>
Examples:<langsyntaxhighlight AutoHotkeylang="autohotkey">nums := [[5,1,3,8,9,4,8,7], [3,5,9,8,4], [1,3,7,9]]
output := Common_sorted_list(nums)
return</langsyntaxhighlight>
{{out}}
<pre>[1, 3, 4, 5, 6, 7, 9]</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f COMMON_SORTED_LIST.AWK
BEGIN {
Line 161 ⟶ 306:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
[5,1,3,8,9,4,8,7],[3,5,9,8,4],[1,3,7,9] : 1 3 4 5 7 8 9
</pre>
 
=={{header|BQN}}==
 
Joins all the arrays, deduplicate, sort.
 
<syntaxhighlight lang="bqn"> arr ← ⟨⟨5,1,3,8,9,4,8,7⟩, ⟨3,5,9,8,4⟩, ⟨1,3,7,9⟩⟩
⟨ ⟨ 5 1 3 8 9 4 8 7 ⟩ ⟨ 3 5 9 8 4 ⟩ ⟨ 1 3 7 9 ⟩ ⟩
CSL ← ∧·⍷∾
∧(⍷∾)
CSL arr
⟨ 1 3 4 5 7 8 9 ⟩</syntaxhighlight>
 
=={{header|C}}==
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define COUNTOF(a) (sizeof(a)/sizeof(a[0]))
 
void fatal(const char* message) {
fprintf(stderr, "%s\n", message);
exit(1);
}
 
void* xmalloc(size_t n) {
void* ptr = malloc(n);
if (ptr == NULL)
fatal("Out of memory");
return ptr;
}
 
int icompare(const void* p1, const void* p2) {
const int* ip1 = p1;
const int* ip2 = p2;
return (*ip1 < *ip2) ? -1 : ((*ip1 > *ip2) ? 1 : 0);
}
 
size_t unique(int* array, size_t len) {
size_t out_index = 0;
int prev;
for (size_t i = 0; i < len; ++i) {
if (i == 0 || prev != array[i])
array[out_index++] = array[i];
prev = array[i];
}
return out_index;
}
 
int* common_sorted_list(const int** arrays, const size_t* lengths, size_t count, size_t* size) {
size_t len = 0;
for (size_t i = 0; i < count; ++i)
len += lengths[i];
int* array = xmalloc(len * sizeof(int));
for (size_t i = 0, offset = 0; i < count; ++i) {
memcpy(array + offset, arrays[i], lengths[i] * sizeof(int));
offset += lengths[i];
}
qsort(array, len, sizeof(int), icompare);
*size = unique(array, len);
return array;
}
 
void print(const int* array, size_t len) {
printf("[");
for (size_t i = 0; i < len; ++i) {
if (i > 0)
printf(", ");
printf("%d", array[i]);
}
printf("]\n");
}
 
int main() {
const int a[] = {5, 1, 3, 8, 9, 4, 8, 7};
const int b[] = {3, 5, 9, 8, 4};
const int c[] = {1, 3, 7, 9};
size_t len = 0;
const int* arrays[] = {a, b, c};
size_t lengths[] = {COUNTOF(a), COUNTOF(b), COUNTOF(c)};
int* sorted = common_sorted_list(arrays, lengths, COUNTOF(arrays), &len);
print(sorted, len);
free(sorted);
return 0;
}</syntaxhighlight>
 
{{out}}
<pre>
[1, 3, 4, 5, 7, 8, 9]
</pre>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <vector>
#include <set>
Line 198 ⟶ 432:
return 0;
}</langsyntaxhighlight>
 
{{out}}
 
<pre>1 3 4 5 7 8 9</pre>
 
=={{header|Clojure}}==
===Efficient transducer & sorted-set version===
<syntaxhighlight lang="lisp">(defn common-sorted [& colls]
(into (sorted-set) cat colls))
 
(common-sorted [5 1 3 8 9 4 8 7] [3 5 9 8 4] [1 3 7 9])
;; => #{1 3 4 5 7 8 9}
</syntaxhighlight>
 
===Point-free, list-based version===
<syntaxhighlight lang="lisp">(def common-sorted (comp sort distinct concat))
 
(common-sorted [5 1 3 8 9 4 8 7] [3 5 9 8 4] [1 3 7 9])
;; => (1 3 4 5 7 8 9)
</syntaxhighlight>
 
=={{header|EasyLang}}==
<syntaxhighlight>
nums[][] = [ [ 2 5 1 3 8 9 4 6 ] [ 3 5 6 2 9 8 4 ] [ 1 3 7 6 9 ] ]
#
proc sort . d[] .
for i = 1 to len d[] - 1
for j = i + 1 to len d[]
if d[j] < d[i]
swap d[j] d[i]
.
.
.
.
#
for l to len nums[][]
for e in nums[l][]
h[] &= e
.
.
sort h[]
for e in h[]
if e <> last or len r[] = 0
r[] &= e
last = e
.
.
print r[]
</syntaxhighlight>
 
 
=={{header|Excel}}==
===LAMBDA===
 
Binding the name COMMONSORTED to the following lambda expression in the Name Manager of the Excel WorkBook:
 
(See [https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/ LAMBDA: The ultimate Excel worksheet function])
 
{{Works with|Office 365 betas 2021}}
<syntaxhighlight lang="lisp">COMMONSORTED
=LAMBDA(grid,
SORT(
UNIQUE(
CONCATCOLS(grid)
)
)
)</syntaxhighlight>
 
and also assuming the following generic bindings in the Name Manager for the WorkBook:
 
<syntaxhighlight lang="lisp">CONCATCOLS
=LAMBDA(cols,
LET(
nRows, ROWS(cols),
ixs, SEQUENCE(
COLUMNS(cols) * nRows, 1,
1, 1
),
 
FILTERP(
LAMBDA(x, 0 < LEN("" & x))
)(
INDEX(cols,
LET(
r, MOD(ixs, nRows),
 
IF(0 = r, nRows, r)
),
1 + QUOTIENT(ixs - 1, nRows)
)
)
)
)
 
 
FILTERP
=LAMBDA(p,
LAMBDA(xs,
FILTER(xs, p(xs))
)
)</syntaxhighlight>
 
The formula in cell B2 defines a dynamic array of values, additionally populating further cells in column B.
{{Out}}
{| class="wikitable"
|-
|||style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"|fx
! colspan="5" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"|=COMMONSORTED(C2:E9)
|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;"
|
| A
| B
| C
| D
| E
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1
|
| style="text-align:center; font-weight:bold" | Common sorted
|
| style="font-weight:bold" |
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2
|
| style="text-align:center; font-weight:bold; background-color:#cbcefb" | 1
| 5
| style="text-align:right" | 3
| style="text-align:right" | 1
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 3
|
| style="text-align:center; font-weight:bold" | 3
| 1
| style="text-align:right" | 5
| style="text-align:right" | 3
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 4
|
| style="text-align:center; font-weight:bold" | 4
| 3
| style="text-align:right" | 9
| style="text-align:right" | 7
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 5
|
| style="text-align:center; font-weight:bold" | 5
| 8
| style="text-align:right" | 8
| style="text-align:right" | 9
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 6
|
| style="text-align:center; font-weight:bold" | 7
| 9
| style="text-align:right" | 4
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 7
|
| style="text-align:center; font-weight:bold" | 8
| 4
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 8
|
| style="text-align:center; font-weight:bold" | 9
| 8
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 9
|
| style="font-style:italic" |
| 7
|
|
|}
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
// Common sorted list. Nigel Galloway: February 25th., 2021
let nums=[|[5;1;3;8;9;4;8;7];[3;5;9;8;4];[1;3;7;9]|]
printfn "%A" (nums|>Array.reduce(fun n g->n@g)|>List.distinct|>List.sort)
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 218 ⟶ 627:
Note: in older versions of Factor, <code>union-all</code> is called <code>combine</code>.
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: formatting kernel sets sorting ;
 
{ { 5 1 3 8 9 4 8 7 } { 3 5 9 8 4 } { 1 3 7 9 } }
dup union-all natural-sort
"Sorted union of %u is:\n%u\n" printf</langsyntaxhighlight>
{{out}}
<pre>
Line 228 ⟶ 637:
{ 1 3 4 5 7 8 9 }
</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="vbnet">Dim As Integer nums(2, 7) = {{5,1,3,8,9,4,8,7},{3,5,9,8,4},{1,3,7,9}}
Dim Shared As Integer sumNums()
 
Sub Sum(arr() As Integer, vals As Integer)
Redim Preserve arr(Ubound(arr) + 1)
arr(Ubound(arr)) = vals
End Sub
 
Sub Del(arr() As Integer, index As Integer)
For i As Integer = index To Ubound(arr) - 1
arr(i) = arr(i + 1)
Next i
Redim Preserve arr(Ubound(arr) - 1)
End Sub
 
Sub showArray(arr() As Integer)
Dim As String txt = ""
Print "[";
For n As Integer = 1 To Ubound(arr)
txt &= Str(arr(n)) & ","
Next n
txt = Left(txt, Len(txt) - 1)
txt &= "]"
Print txt
End Sub
 
Sub Sort(arr() As Integer)
Dim As Integer i, j
For i = 0 To Ubound(arr) - 1
For j = i + 1 To Ubound(arr)
If arr(i) > arr(j) Then Swap arr(i), arr(j)
Next j
Next i
End Sub
 
For n As Integer = 0 To Ubound(nums, 1)
For m As Integer = 0 To Ubound(nums, 2)
Sum(sumNums(), nums(n, m))
Next m
Next n
 
Sort(sumNums())
For n As Integer = Ubound(sumNums) To 1 Step -1
If sumNums(n) = sumNums(n - 1) Then
Del(sumNums(), n)
End If
Next n
 
Sort(sumNums())
 
Print "common sorted list elements are: ";
showArray(sumNums())
 
Sleep</syntaxhighlight>
{{out}}
<pre>common sorted list elements are: [1,3,4,5,7,8,9]</pre>
 
=={{header|Go}}==
{{trans|Wren}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 259 ⟶ 726:
fmt.Println("Distinct sorted union of", ll, "is:")
fmt.Println(distinctSortedUnion(ll))
}</langsyntaxhighlight>
 
{{out}}
Line 268 ⟶ 735:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List (nub, sort)
 
-------------------- COMMON SORTED LIST ------------------
Line 283 ⟶ 750:
[3, 5, 9, 8, 4],
[1, 3, 7, 9]
]</langsyntaxhighlight>
{{Out}}
<pre>[1,3,4,5,7,8,9]</pre>
 
=={{header|J}}==
<langsyntaxhighlight lang="j">csl =: /:~@~.@;</langsyntaxhighlight>
{{out}}
<pre> nums =: 5 1 3 8 9 4 8 7;3 5 9 8 4;1 3 7 9
Line 295 ⟶ 762:
 
=={{header|JavaScript}}==
<langsyntaxhighlight lang="javascript">(() => {
"use strict";
 
Line 317 ⟶ 784:
 
// concat :: [[a]] -> [a]
const concat = xs => [].concat(...xs);
xs.flat(1);
 
 
// nub :: Eq a => [a] -> [a]
const nub = xs => [...new Set(xs)];
 
Line 330 ⟶ 798:
 
return main();
})();</langsyntaxhighlight>
{{Out}}
<pre>[1, 3, 4, 5, 7, 8, 9]</pre>
 
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
 
Assuming the input is a single array of arrays, we can simply chain the `add` and `unique` filters:
<syntaxhighlight lang="jq">jq -nc '[[5,1,3,8,9,4,8,7], [3,5,9,8,4], [1,3,7,9]] | add | unique'</syntaxhighlight>
{{out}}
<pre>
[1,3,4,5,7,8,9]
</pre>
If the arrays are presented individually in an external stream, we could use the `-s` command-line option.
 
Alternatively, here's a stream-oriented version of `add` that could be used:
<syntaxhighlight lang="jq">def add(s): reduce s as $x (null; . + $x);</syntaxhighlight>
For example:
<syntaxhighlight lang="jq">jq -nc '
def add(s): reduce s as $x (null; . + $x);
add(inputs) | unique' <<< '[5,1,3,8,9,4,8,7] [3,5,9,8,4] [1,3,7,9]'</syntaxhighlight>
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">
julia> sort(union([5,1,3,8,9,4,8,7], [3,5,9,8,4], [1,3,7,9]))
7-element Array{Int64,1}:
Line 357 ⟶ 843:
"not"
 
</syntaxhighlight>
</lang>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Union[{5, 1, 3, 8, 9, 4, 8, 7}, {3, 5, 9, 8, 4}, {1, 3, 7, 9}]</syntaxhighlight>
{{out}}
<pre>{1, 3, 4, 5, 7, 8, 9}</pre>
 
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">
common_sorted(lst):=unique(flatten(lst))$
nums:[[5,1,3,8,9,4,8,7],[3,5,9,8,4],[1,3,7,9]]$
common_sorted(nums);
</syntaxhighlight>
{{out}}
<pre>
[1,3,4,5,7,8,9]
</pre>
 
=={{header|Nim}}==
We could use a <code>HashSet</code> or an <code>IntSet</code> to deduplicate. We have rather chosen to use the procedure <code>deduplicate</code> from module <code>sequtils</code> applied to the sorted list.
 
<syntaxhighlight lang="nim">import algorithm, sequtils
 
proc commonSortedList(list: openArray[seq[int]]): seq[int] =
sorted(concat(list)).deduplicate(true)
 
echo commonSortedList([@[5,1,3,8,9,4,8,7], @[3,5,9,8,4], @[1,3,7,9]])</syntaxhighlight>
 
{{out}}
<pre>@[1, 3, 4, 5, 7, 8, 9]</pre>
 
=={{header|Pascal}}==
==={{header|Free Pascal}}===
<syntaxhighlight lang="pascal">
Program CommonSortedList;
{$mode ObjFPC}{$H+}
 
Uses sysutils,fgl;
 
Type
tarr = array Of array Of integer;
 
Const List1: tarr = ((5,1,3,8,9,4,8,7), (3,5,9,8,4), (1,3,7,9));
 
Var list : specialize TFPGList<integer>;
 
Procedure addtolist(arr : tarr);
Var i : integer;
arr2 : array Of integer;
Begin
For arr2 In arr Do
For i In arr2 Do
If (list.indexof(i) = -1) {make sure number isn't in list already}
Then list.add(i);
End;
 
Function CompareInt(Const Item1,Item2: Integer): Integer;
Begin
result := item1 - item2;
End;
 
Var i : integer;
Begin
list := specialize TFPGList<integer>.create;
addtolist(list1);
List.Sort(@CompareInt); {quick sort the list}
For i In list Do
write(i:4);
list.destroy;
End.
</syntaxhighlight>
{{out}}
<pre>
1 3 4 5 7 8 9
</pre>
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">@c{@$_}++ for [5,1,3,8,9,4,8,7], [3,5,9,8,4], [1,3,7,9];
print join ' ', sort keys %c;
@c{@$_}++ for [qw<not all is integer ? is not ! 4.2>];
print join ' ', sort keys %c;</langsyntaxhighlight>
{{out}}
<pre>1 3 4 5 7 8 9
Line 370 ⟶ 930:
=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">},</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">},</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">},</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"not everything is an integer"</span><span style="color: #0000FF;">)},{}))</span>
<!--</langsyntaxhighlight>-->
Note the join(x,{}): the 2nd param is needed to prevent it putting 32 (ie the acsii code for a space) in the output.
{{out}}
Line 381 ⟶ 941:
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">'''Common sorted list'''
 
from itertools import chain
Line 421 ⟶ 981:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>[1, 3, 4, 5, 7, 8, 9]</pre>
 
=={{header|Quackery}}==
 
<code>uniquewith</code> is defined at [[Remove duplicate elements#Quackery]].
 
<syntaxhighlight lang="quackery"> ' [ [ 5 1 3 8 9 4 8 7 ]
[ 3 5 9 8 4 ]
[ 1 3 7 9 ] ]
[] swap witheach [ witheach join ]
uniquewith > echo</syntaxhighlight>
 
{{out}}
 
<pre>[ 1 3 4 5 7 8 9 ]</pre>
 
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>put sort keys [∪] [5,1,3,8,9,4,8,7], [3,5,9,8,4], [1,3,7,9];
put sort keys [∪] [5,1,3,8,9,4,8,7], [3,5,9,8,4], [1,3,7,9], [<not everything is an integer so why not avoid special cases # ~ 23 4.2>];</langsyntaxhighlight>
{{out}}
<pre>1 3 4 5 7 8 9
Line 433 ⟶ 1,009:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX pgm creates and displays a common sorted list of a specified collection of sets*/
parse arg a /*obtain optional arguments from the CL*/
if a='' | a="," then a= '[5,1,3,8,9,4,8,7] [3,5,9,8,4] [1,3,7,9]' /*default sets.*/
Line 454 ⟶ 1,030:
eSort: procedure expose @.; arg h 1 z; do while h>1; h= h%2; do i=1 for z-h; j= i; k= h+i
do while @.k<@.j; t=@.j; @.j=@.k; @.k=t; if h>=j then leave; j=j-h; k=k-h; end;end
end; return /*this sort was used 'cause of brevity.*/</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 461 ⟶ 1,037:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
nums = [[5,1,3,8,9,4,8,7],[3,5,9,8,4],[1,3,7,9]]
sumNums = []
Line 492 ⟶ 1,068:
txt = txt + "]"
see txt
</syntaxhighlight>
</lang>
{{out}}
<pre>
common sorted list elements are: [1,3,4,5,7,8,9]
</pre>
 
=={{header|RPL}}==
{{works with|HP|48G}}
≪ ∑LIST SORT → nums
≪ <span style="color:red">{ }</span>
<span style="color:red">1</span> nums SIZE '''FOR''' j
nums j GET
'''IF''' DUP2 POS '''THEN''' DROP '''ELSE''' + '''END'''
'''NEXT'''
≫ ≫ '<span style="color:blue">COMMON</span>' STO
 
<span style="color:red">{ { 5 1 3 8 9 4 8 7 } { 3 5 9 8 4 } { 1 3 7 9 } }</span> <span style="color:blue">COMMON</span>
{{out}}
<pre>
1: { 1 3 4 5 7 8 9 }
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">nums = [5,1,3,8,9,4,8,7], [3,5,9,8,4], [1,3,7,9]
p nums.inject(:+).sort.uniq
</syntaxhighlight>
{{out}}
<pre>[1, 3, 4, 5, 7, 8, 9]
</pre>
 
=={{header|Uiua}}==
<syntaxhighlight lang="Uiua">
F ← ⊏⍏.◴/◇⊂
</syntaxhighlight>
{{out}}
<pre>
F {[5 1 3 8 9 4 8 7] [3 5 9 8 4] [1 3 7 9]}
[1 3 4 5 7 8 9]
</pre>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">
fn main() {
nums := [[5,1,3,8,9,4,8,7], [3,5,9,8,4], [1,3,7,9]]
println("Distinct sorted union of $nums is:")
println(common_sorted_list(nums))
}
 
fn common_sorted_list(nums [][]int) []int {
mut elements, mut output := map[int]bool{}, []int{}
for num in nums {
for value in num {
elements[value] = true
}
}
 
for key, _ in elements {
output << key
}
output.sort()
return output
}
</syntaxhighlight>
{{out}}
<pre>
Distinct sorted union of [[5 1 3 8 9 4 8 7] [3 5 9 8 4] [1 3 7 9]] is:
[1 3 4 5 7 8 9]
</pre>
 
Line 501 ⟶ 1,141:
{{libheader|Wren-seq}}
{{libheader|Wren-sort}}
<langsyntaxhighlight ecmascriptlang="wren">import "./seq" for Lst
import "./sort" for Sort
 
var distinctSortedUnion = Fn.new { |ll|
Line 513 ⟶ 1,153:
var ll = [[5, 1, 3, 8, 9, 4, 8, 7], [3, 5, 9, 8, 4], [1, 3, 7, 9]]
System.print("Distinct sorted union of %(ll) is:")
System.print(distinctSortedUnion.call(ll))</langsyntaxhighlight>
 
{{out}}
Bvbesouw
43

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/308666...363220"