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)

Common list elements

From Rosetta Code
Common list elements 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.

Given an integer array nums, find the common list elements.


Example

nums = [2,5,1,3,8,9,4,6], [3,5,6,2,9,8,4], [1,3,7,6,9]

output = [3,6,9]

AutoHotkey[edit]

Common_list_elements(nums){
counter := [], output := []
for i, num in nums
for j, d in num
if ((counter[d] := counter[d] ? counter[d]+1 : 1) = nums.count())
output.Push(d)
return output
}
 
Examples:
nums := [[2,5,1,3,8,9,4,6], [3,5,6,2,9,8,4], [1,3,7,6,9]]
output := Common_list_elements(nums)
return
Output:
[3, 6, 9]

AWK[edit]

 
# syntax: GAWK -f COMMON_LIST_ELEMENTS.AWK
BEGIN {
PROCINFO["sorted_in"] = "@ind_num_asc"
nums = "[2,5,1,3,8,9,4,6],[3,5,6,2,9,8,4],[1,3,7,6,9]"
printf("%s : ",nums)
n = split(nums,arr1,"],?") - 1
for (i=1; i<=n; i++) {
gsub(/[\[\]]/,"",arr1[i])
split(arr1[i],arr2,",")
for (j in arr2) {
arr3[arr2[j]]++
}
}
for (j in arr3) {
if (arr3[j] == n) {
printf("%s ",j)
}
}
printf("\n")
exit(0)
}
 
Output:
[2,5,1,3,8,9,4,6],[3,5,6,2,9,8,4],[1,3,7,6,9] : 3 6 9

F#[edit]

Of course it is possible to use sets but I thought the idea was not to?

 
// Common list elements. Nigel Galloway: February 25th., 2021
let nums=[|[2;5;1;3;8;9;4;6];[3;5;6;2;9;8;4];[1;3;7;6;9]|]
printfn "%A" (nums|>Array.reduce(fun n g->[email protected])|>List.distinct|>List.filter(fun n->nums|>Array.forall(fun g->List.contains n g)));;
 
Output:
[3; 9; 6]

Factor[edit]

Note: in older versions of Factor, intersect-all was called intersection.

Works with: Factor version 0.99 2021-02-05
USING: prettyprint sets ;
 
{ { 2 5 1 3 8 9 4 6 } { 3 5 6 2 9 8 4 } { 1 3 7 6 9 } } intersect-all .
Output:
{ 3 6 9 }

Go[edit]

Translation of: Wren
package main
 
import "fmt"
 
func indexOf(l []int, n int) int {
for i := 0; i < len(l); i++ {
if l[i] == n {
return i
}
}
return -1
}
 
func common2(l1, l2 []int) []int {
// minimize number of lookups
c1, c2 := len(l1), len(l2)
shortest, longest := l1, l2
if c1 > c2 {
shortest, longest = l2, l1
}
longest2 := make([]int, len(longest))
copy(longest2, longest) // matching duplicates will be destructive
var res []int
for _, e := range shortest {
ix := indexOf(longest2, e)
if ix >= 0 {
res = append(res, e)
longest2 = append(longest2[:ix], longest2[ix+1:]...)
}
}
return res
}
 
func commonN(ll [][]int) []int {
n := len(ll)
if n == 0 {
return []int{}
}
if n == 1 {
return ll[0]
}
res := common2(ll[0], ll[1])
if n == 2 {
return res
}
for _, l := range ll[2:] {
res = common2(res, l)
}
return res
}
 
func main() {
lls := [][][]int{
{{2, 5, 1, 3, 8, 9, 4, 6}, {3, 5, 6, 2, 9, 8, 4}, {1, 3, 7, 6, 9}},
{{2, 2, 1, 3, 8, 9, 4, 6}, {3, 5, 6, 2, 2, 2, 4}, {2, 3, 7, 6, 2}},
}
for _, ll := range lls {
fmt.Println("Intersection of", ll, "is:")
fmt.Println(commonN(ll))
fmt.Println()
}
}
Output:
Intersection of [[2 5 1 3 8 9 4 6] [3 5 6 2 9 8 4] [1 3 7 6 9]] is:
[3 6 9]

Intersection of [[2 2 1 3 8 9 4 6] [3 5 6 2 2 2 4] [2 3 7 6 2]] is:
[3 6 2 2]

Haskell[edit]

import qualified Data.Set as Set
 
task :: Ord a => [[a]] -> [a]
task [] = []
task xs = Set.toAscList . foldl1 Set.intersection . map Set.fromList $ xs
 
main = print $ task [[2,5,1,3,8,9,4,6], [3,5,6,2,9,8,4], [1,3,7,6,9]]
Output:
[3,6,9]

Julia[edit]

 
julia> intersect([2,5,1,3,8,9,4,6], [3,5,6,2,9,8,4], [1,3,7,6,9])
3-element Array{Int64,1}:
3
9
6
 

Perl[edit]

@nums = ([2,5,1,3,8,9,4,6], [3,5,6,2,9,8,4], [1,3,7,6,9]);
map { print "$_ " if @nums == ++$c{$_} } @$_ for @nums;
Output:
3 6 9

Phix[edit]

function intersection(sequence s)
sequence res = {}
if length(s) then
for i=1 to length(s[1]) do
integer candidate = s[1][i]
bool bAdd = not find(candidate,res)
for j=2 to length(s) do
if not find(candidate,s[j]) then
bAdd = false
exit
end if
end for
if bAdd then res &= candidate end if
end for
end if
return res
end function
?intersection({{2,5,1,3,8,9,4,6},{3,5,6,2,9,8,4},{1,3,7,6,9}})
?intersection({{2,2,1,3,8,9,4,6},{3,5,6,2,2,2,4},{2,3,7,6,2}})
Output:
{3,9,6}
{2,3,6}

Raku[edit]

put [] [2,5,1,3,8,9,4,6], [3,5,6,2,9,8,4], [1,3,7,6,9,3];
Output:
6 9 3

REXX[edit]

This REXX version properly handles the case of duplicate entries in a list   (which shouldn't happen in a true list).

/*REXX program finds and displays the  common list elements  from a collection of sets. */
parse arg a /*obtain optional arguments from the CL*/
if a='' | a="," then a= '[2,5,1,3,8,9,4,6] [3,5,6,2,9,8,4] [1,3,7,6,9]' /*defaults.*/
#= words(a) /*the number of sets that are specified*/
do j=1 for # /*process each set in a list of sets.*/
@.j= translate( word(a, j), ,'],[') /*extract a " from " " " " */
end /*j*/
$= /*the list of common elements (so far).*/
do k=1 for #-1 /*use the last set as the base compare.*/
do c=1 for words(@.#); x= word(@.#, c) /*obtain an element from a set. */
do f=1 for #-1 /*verify that the element is in the set*/
if wordpos(x, @.f)==0 then iterate c /*Is in the set? No, then skip element*/
end /*f*/
if wordpos(x, $)==0 then $= $ x /*Not already in the set? Add common. */
end /*c*/
end /*k*/
/*stick a fork in it, we're all done. */
say 'the list of common elements in all sets: ' "["translate(space($), ',', " ")']'
output   when using the default inputs:
the list of common elements in all sets:  [3,6,9]

Ring[edit]

 
nums = [[2,5,1,3,8,9,4,6],[3,5,6,2,9,8,4],[1,3,7,6,9]]
sumNums = []
result = []
 
for n = 1 to len(nums)
for m = 1 to len(nums[n])
add(sumNums,nums[n][m])
next
next
 
sumNums = sort(sumNums)
for n = len(sumNums) to 2 step -1
if sumNums[n] = sumNums[n-1]
del(sumNums,n)
ok
next
 
for n = 1 to len(sumNums)
flag = list(len(nums))
for m = 1 to len(nums)
flag[m] = 1
ind = find(nums[m],sumNums[n])
if ind < 1
flag[m] = 0
ok
next
flagn = 1
for p = 1 to len(nums)
if flag[p] = 1
flagn = 1
else
flagn = 0
exit
ok
next
if flagn = 1
add(result,sumNums[n])
ok
next
 
see "common list elements are: "
showArray(result)
 
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:
common list elements are: [3,6,9]

Wren[edit]

Library: Wren-seq

As we're dealing here with lists rather than sets, some guidance is needed on how to deal with duplicates in each list in the general case. A drastic solution would be to remove all duplicates from the result. Instead, the following matches duplicates - so if List A contains 2 'a's and List B contains 3 'a's, there would be 2 'a's in the result.

import "/seq" for Lst
 
var common2 = Fn.new { |l1, l2|
// minimize number of lookups
var c1 = l1.count
var c2 = l2.count
var shortest = (c1 < c2) ? l1 : l2
var longest = (l1 == shortest) ? l2 : l1
longest = longest.toList // matching duplicates will be destructive
var res = []
for (e in shortest) {
var ix = Lst.indexOf(longest, e)
if (ix >= 0) {
res.add(e)
longest.removeAt(ix)
}
}
return res
}
 
var commonN = Fn.new { |ll|
var n = ll.count
if (n == 0) return ll
if (n == 1) return ll[0]
var first2 = common2.call(ll[0], ll[1])
if (n == 2) return first2
return ll.skip(2).reduce(first2) { |acc, l| common2.call(acc, l) }
}
 
var lls = [
[[2, 5, 1, 3, 8, 9, 4, 6], [3, 5, 6, 2, 9, 8, 4], [1, 3, 7, 6, 9]],
[[2, 2, 1, 3, 8, 9, 4, 6], [3, 5, 6, 2, 2, 2, 4], [2, 3, 7, 6, 2]]
]
 
for (ll in lls) {
System.print("Intersection of %(ll) is:")
System.print(commonN.call(ll))
System.print()
}
Output:
Intersection of [[2, 5, 1, 3, 8, 9, 4, 6], [3, 5, 6, 2, 9, 8, 4], [1, 3, 7, 6, 9]] is:
[3, 6, 9]

Intersection of [[2, 2, 1, 3, 8, 9, 4, 6], [3, 5, 6, 2, 2, 2, 4], [2, 3, 7, 6, 2]] is:
[2, 3, 6, 2]