# 5 Best Ways to Find Common Elements in Two Python Arrays

5/5 - (1 vote)
π‘ Problem Formulation:

Finding common elements between two arrays is a fundamental problem in computer science. The problem involves identifying the set of elements that appear in both arrays. For example, given two arrays `arr1 = [1, 2, 3, 4]` and `arr2 = [2, 4, 6, 8]`, the desired output would be `[2, 4]`, since those are the elements common to both arrays.

## Method 1: Using a Loop and Membership Test

This method involves iterating over each element in the first array and checking if it exists in the second array. This is the most straightforward approach and does not require any additional libraries.

Here’s an example:

```arr1 = [1, 2, 3, 4]
arr2 = [2, 4, 6, 8]
common_elements = []

for element in arr1:
if element in arr2:
common_elements.append(element)

print(common_elements)```

Output: `[2, 4]`

This loop checks each element of `arr1` for membership in `arr2`. If it’s found, it’s added to the `common_elements` list. This method is simple but not the most efficient for large arrays.

## Method 2: Using Sets Intersection

The Python Set data structure provides a fast way to compute common elements using the intersection method. This method is significantly more efficient than the first, especially for large arrays.

Here’s an example:

```arr1 = [1, 2, 3, 4]
arr2 = [2, 4, 6, 8]
common_elements = list(set(arr1) & set(arr2))

print(common_elements)```

Output: `[2, 4]`

This snippet converts the arrays into sets and uses the `&` operator to find the intersection. The result is then converted back into a list. This method is quick and concise.

## Method 3: Using the filter Function

The `filter` function can be used to keep only the elements from the first array that are found in the second array. It’s a more functional programming approach to solving this problem.

Here’s an example:

```arr1 = [1, 2, 3, 4]
arr2 = [2, 4, 6, 8]
common_elements = list(filter(lambda x: x in arr2, arr1))

print(common_elements)```

Output: `[2, 4]`

This code uses a lambda function inside the `filter` function to choose which elements of `arr1` appear in `arr2`. It’s a succinct and expressive solution.

## Method 4: List Comprehensions

List comprehensions provide a concise way to create lists based on existing lists. You can use a list comprehension to create a list of common elements in a single readable line.

Here’s an example:

```arr1 = [1, 2, 3, 4]
arr2 = [2, 4, 6, 8]
common_elements = [element for element in arr1 if element in arr2]

print(common_elements)```

Output: `[2, 4]`

This list comprehension goes through all elements in `arr1` and adds an element to `common_elements` iff (if and only if) it’s also in `arr2`. This is a compact and Pythonic way of solving the problem.

## Bonus One-Liner Method 5: Using NumPy Libraries

If you’re working with numerical data and already using NumPy, you can leverage its built-in functionality to find common elements.

Here’s an example:

```import numpy as np

arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([2, 4, 6, 8])
common_elements = np.intersect1d(arr1, arr2)

print(common_elements)```

Output: `[2 4]`

This code uses NumPy’s `intersect1d` function, which returns the sorted, unique values that are in both of the input arrays. This method is efficient and returns a NumPy array.

## Summary/Discussion

• Method 1: Loop and Membership Test. Good for clarity. Inefficient for large lists.
• Method 2: Sets Intersection. Fast and efficient. Loses order and duplicates of original lists.
• Method 3: Using the filter Function. Functional and clean. May be less intuitive for those unfamiliar with functional programming concepts.
• Method 4: List Comprehensions. Pythonic and readable. Efficiency similar to Method 1 for large lists.
• Method 5: Using NumPy Libraries. Highly efficient for numerical data and large arrays. Requires NumPy installation.