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]

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

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

## Haskell

`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

` 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

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

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

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