Question

Write a function commonElements(a1, a2) that takes in 2 tuples as arguments and returns a sorted tuple containing elements that are found in both tuples.

My task is :

    >>> commonElements((1, 2, 3), (2, 5, 1))
    (1, 2)
    >>> commonElements((1, 2, 3, 'p', 'n'), (2, 5 ,1, 'p'))
    (1, 2, 'p')
    >>> commonElements((1, 3, 'p', 'n'), ('a', 2 , 5, 1, 'p'))
    (1, 'p')

I tried to do it like this.

def commonElements(a1, a2):
    return tuple(set(a1).intersection( set(a2) ))

Anyone know what my mistake is with the requirement?
I can not pass.

Answer 1

Set is not ordered. So the order of the result may be arbitrary.
I would come up with something like that:

def commonElements(a1, a2):
    L = []
    for el in a1:
        if el in a2:
            L.append(el)
    return tuple(L)

Please, note, that this way of solving the problem would get the output elements ordered as in the tuple a1. So, as mentioned in the comments, the more correct way to call it is ‘ordering’, not ‘sorting’.
Also, it has a complexity of O(n*m), where n and m are the lengths of the lists a1 and a2 respectively.

O(n*log(m)) can be achieved in this case if bisect module is used to access the elements of the second tuple a2 (which should be sorted before the proceeding).

If sorting in common way is required, I would stick with your code, a bit altered:

def commonElements(a1, a2):
    return tuple(sorted(set(a1).intersection(set(a2))))

On the average it has a complexity of O(min(m+n)*log(min(n+m))) (because of sorting), and O(n*m) in the worst case because of intersection.

If the code needs to be implemented without using set (for example for the purposes of study), here is the code:

def commonElements(a1, a2):
    L = []
    for el in a1:
        if el in a2:
            L.append(el)
    L.sort()
    return tuple(L)

Complexity is O(n*m).

With using bisect the code would look this way:

from bisect import bisect_left
def commonElements(a1, a2):
   L = []
   a2.sort() #sort a2 to be able to use binary search in the internal loop thus changing the complexity from O(n^2) to O(n*log(n)) (assuming n and m are rather equal).
   a2_len = len(a2)
   for el in a1:
       i = bisect_left(a2, el)
       if i != a2_len and a2[i] == el:
           L.append(x)
   # L.sort() #uncomment this line if the list in sorted order is needed (not just ordered as the first lits; it's possible to sort a1 in the very beginning of the function, but that would be slower on the average since L is smaller on the average than a1 or a2 (since L is their intersection).
   return tuple(L)

Complexity is O(n*log(m)).