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

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]

`with Ada.Text_Io;with Ada.Containers.Vectors; procedure Common is    package Integer_Vectors is     new Ada.Containers.Vectors (Index_Type   => Positive,                                 Element_Type => Integer);   use Integer_Vectors;    function Common_Elements (Left, Right : Vector) return Vector is      Res : Vector;   begin      for E of Left loop         if Has_Element (Right.Find (E)) then            Res.Append (E);         end if;      end loop;      return Res;   end Common_Elements;    procedure Put (Vec : Vector) is      use Ada.Text_Io;   begin      Put ("[");      for E of Vec loop         Put (E'Image);  Put (" ");      end loop;      Put ("]");      New_Line;   end Put;    A : constant Vector := 2 & 5 & 1 & 3 & 8 & 9 & 4 & 6;   B : constant Vector := 3 & 5 & 6 & 2 & 9 & 8 & 4;   C : constant Vector := 1 & 3 & 7 & 6 & 9;   R : Vector;begin   R := Common_Elements (A, B);   R := Common_Elements (R, C);   Put (R);end Common;`
Output:
`[ 3  9  6 ]`

## APL

APL has the built-in intersection function `∩`

`      ∩/ (2 5 1 3 8 9 4 6) (3 5 6 2 9 8 4) (1 3 7 9 6) 3 9 6 `

## AppleScript

### AppleScriptObjC

`use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or lateruse framework "Foundation"use sorter : script "Insertion Sort" -- <https://www.rosettacode.org/wiki/Sorting_algorithms/Insertion_sort#AppleScript> on commonListElements(listOfLists)    set mutableSet to current application's class "NSMutableSet"'s setWithArray:(beginning of listOfLists)    repeat with i from 2 to (count listOfLists)        tell mutableSet to intersectSet:(current application's class "NSSet"'s setWithArray:(item i of listOfLists))    end repeat     return (mutableSet's allObjects()) as listend commonListElements set commonElements to commonListElements({{2, 5, 1, 3, 8, 9, 4, 6}, {3, 5, 6, 2, 9, 8, 4}, {1, 3, 7, 6, 9}})tell sorter to sort(commonElements, 1, -1)return commonElements`
Output:
`{3, 6, 9}`

### Core language only

The requirement for AppleScript 2.3.1 is only for the 'use' command which loads the "Insertion Sort" script. If the sort's instead loaded with the older 'load script' command or copied into the code, this will work on systems as far back as Mac OS X 10.5 (Leopard) or earlier. Same output as above.

`use AppleScript version "2.3.1" -- Mac OS X 10.9 (Mavericks) or later.use sorter : script "Insertion Sort" -- <https://www.rosettacode.org/wiki/Sorting_algorithms/Insertion_sort#AppleScript> on commonListElements(listOfLIsts)    script o        property list1 : beginning of listOfLIsts    end script     set common to {}    set listCount to (count listOfLIsts)    repeat with i from 1 to (count o's list1)        set thisElement to {item i of o's list1}        if (thisElement is not in common) then            repeat with j from 2 to listCount                set OK to (item j of listOfLIsts contains thisElement)                if (not OK) then exit repeat            end repeat            if (OK) then set end of common to beginning of thisElement        end if    end repeat     return commonend commonListElements set commonElements to commonListElements({{2, 5, 1, 3, 8, 9, 4, 6}, {3, 5, 6, 2, 9, 8, 4}, {1, 3, 7, 6, 9}})tell sorter to sort(commonElements, 1, -1)return commonElements`

## AutoHotkey

`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

` # syntax: GAWK -f COMMON_LIST_ELEMENTS.AWKBEGIN {    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
```

## Excel

### LAMBDA

Binding the names INTERSECT and INTERSECTCOLS to a pair of lambda expressions in the Excel WorkBook Name Manager:

`INTERSECT=LAMBDA(xs,    LAMBDA(ys,        FILTERP(            LAMBDA(x,                ELEM(x)(ys)            )        )(xs)    ))  INTERSECTCOLS=LAMBDA(xs,    IF(1 < COLUMNS(xs),        INTERSECT(            FIRSTCOL(xs)        )(            INTERSECTCOLS(                TAILCOLS(xs)            )        ),        xs    ))`

and also assuming the following generic bindings in Name Manager:

`ELEM=LAMBDA(x,    LAMBDA(xs,        ISNUMBER(MATCH(x, xs, 0))    ))  FILTERP=LAMBDA(p,    LAMBDA(xs,        FILTER(xs, p(xs))    ))  FIRSTCOL=LAMBDA(xs,    INDEX(        xs,        SEQUENCE(ROWS(xs), 1, 1, 1),        1    ))  TAILCOLS=LAMBDA(xs,    LET(        n, COLUMNS(xs) - 1,         IF(0 < n,            INDEX(                xs,                SEQUENCE(ROWS(xs), 1, 1, 1),                SEQUENCE(1, n, 2, 1)            ),            NA()        )    ))`
Output:
 =INTERSECTCOLS(D2:F9) fx A B C D E F 1 Intersection of three columns 2 3 2 3 1 3 9 5 5 3 4 6 1 6 7 5 3 2 6 6 8 9 9 7 9 8 8 4 4 9 6

## F#

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

` // Common list elements. Nigel Galloway: February 25th., 2021let 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

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

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    }    res := common2(ll, ll)    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]
```

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

## jq

Works with: jq

Works with gojq, the Go implementation of jq

The following definition of `intersection` does not place any restrictions on the arrays whose intersection is sought. The helper function, `ios`, might be independently useful and so is defined as a top-level filter.

`# If a and b are sorted lists, and if all the elements respectively of a and b are distinct,# then [a,b] | ios will emit the stream of elements in the set-intersection of a and b.def ios:  . as \$a | . as \$b  | if 0 == (\$a|length) or 0 == (\$b|length) then empty    elif \$a == \$b then \$a, ([\$a[1:], \$b[1:]] | ios)    elif \$a  < \$b then [\$a[1:], \$b] | ios    else [\$a, \$b[1:]] | ios    end ; # input: an array of arbitrary JSON arrays# output: their intersection as setsdef intersection:  def go:    if length == 1 then (.|unique)    else [(.|unique), (.[1:] | go)] | [ios]    end;  if length == 0 then []  elif any(.[]; length == 0) then []  else sort_by(length) | go  end;`
`# The 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

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

## Mathematica/Wolfram Language

`Intersection[{2, 5, 1, 3, 8, 9, 4, 6}, {3, 5, 6, 2, 9, 8, 4}, {1, 3, 7, 6, 9}]`
Output:
`{3, 6, 9}`

## Nim

`import algorithm, sequtils proc commonElements(list: openArray[seq[int]]): seq[int] =  var list = sortedByIt(list, it.len)   # Start with the shortest array.  for val in list.deduplicate():     # Check values only once.    block checkVal:      for i in 1..list.high:        if val notin list[i]:          break checkVal      result.add val echo commonElements([@[2,5,1,3,8,9,4,6], @[3,5,6,2,9,8,4], @[1,3,7,6,9]])`
Output:
`@[3, 6, 9]`

## Perl

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

```function intersection(sequence s)
sequence res = {}
if length(s) then
for i=1 to length(s) do
integer candidate = s[i]
for j=2 to length(s) do
if not find(candidate,s[j]) then
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}})
```

Note that a (slightly more flexible) intersection() function is also defined in sets.e, so you could just include that instead, and use it the same way.

Output:
```{3,9,6}
{2,3,6}
```

## Python

### Without Duplicates

`"""Find distinct common list elements using set.intersection.""" def common_list_elements(*lists):    return list(set.intersection(*(set(list_) for list_ in lists)))  if __name__ == "__main__":    test_cases = [        ([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 case in test_cases:        result = common_list_elements(*case)        print(f"Intersection of {case} is {result}") `
Output:
```intersection of ([2, 5, 1, 3, 8, 9, 4, 6], [3, 5, 6, 2, 9, 8, 4], [1, 3, 7, 6, 9]) is [9, 3, 6]
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]
```

### With Duplicates

`"""Find common list elements using collections.Counter (multiset).""" from collections import Counterfrom functools import reducefrom itertools import chain  def common_list_elements(*lists):    counts = (Counter(list_) for list_ in lists)    intersection = reduce(lambda x, y: x & y, counts)    return list(chain.from_iterable([elem] * cnt for elem, cnt in intersection.items()))  if __name__ == "__main__":    test_cases = [        ([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 case in test_cases:        result = common_list_elements(*case)        print(f"Intersection of {case} is {result}") `
Output:
```intersection of ([2, 5, 1, 3, 8, 9, 4, 6], [3, 5, 6, 2, 9, 8, 4], [1, 3, 7, 6, 9]) is [9, 3, 6]
intersection of ([2, 2, 1, 3, 8, 9, 4, 6], [3, 5, 6, 2, 2, 2, 4], [2, 3, 7, 6, 2]) is [2, 2, 3, 6]
```

## Quackery

`  [ behead sort swap witheach    [ sort [] temp put      [ over [] !=         over [] != and while        over 0 peek        over 0 peek = iff          [ behead temp take             swap join temp put            swap behead drop ] again        over 0 peek        over 0 peek < if swap         behead drop again ]        2drop temp take ] ]          is common ( [ [ --> [ )   ' [ [ 2 5 1 3 8 9 4 6 ] [ 3 5 6 2 9 8 4 ] [ 1 3 7 6 9 ] ] common echo`
Output:
`[ 3 6 9 ]`

## Raku

`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

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

` 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])    nextnext sumNums = sort(sumNums)for n = len(sumNums) to 2 step -1    if sumNums[n] = sumNums[n-1]       del(sumNums,n)    oknext 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])    oknext 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]
```

## Ruby

`nums = [2,5,1,3,8,9,4,6], [3,5,6,2,9,8,4], [1,3,7,6,9]p nums.inject(&:intersection)  # or nums.inject(:&) `
Output:
```[3, 9, 6]
```

## Wren

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    var first2 = common2.call(ll, ll)    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]
```