Python - Duplicate Element Indices in List

Last Updated : 01 Feb, 2025

We are having a list we need to find the duplicate element indices. For example, we are given a list a = [10, 20, 30, 20, 40, 30, 50] we need to find indices of the duplicate items so that output should be {20: [1, 3], 30: [2, 5]}.

Using a loop and a dictionary

We iterate through the list using enumerate() and store indices of each element in a dictionary appending new indices if element appears again.

Python

a = [10, 20, 30, 20, 40, 30, 50]
d = {}
for i, num in enumerate(a):
    if num in d:
        d[num].append(i)
    else:
        d[num] = [i]

# Filter to keep only the numbers with more than one occurrence
ans = {key: value for key, value in d.items() if len(value) > 1}
print(ans)

Output

{20: [1, 3], 30: [2, 5]}

Explanation:

Loop iterates through list using enumerate() storing indices of each element in a dictionary d appending indices if element appears more than once.
Final dictionary comprehension filters d to retain only elements with multiple occurrences.

Using collections.Counter

We use Counter to count occurrences of each element in the list and then create a dictionary that maps duplicate elements to their indices using list comprehension.

Python

from collections import Counter  

a = [10, 20, 30, 20, 40, 30, 50]  

# Count occurrences of each element in the list  
c = Counter(a)  

# Create a dictionary mapping duplicate elements to their indices  
ans = {num: [i for i, x in enumerate(a) if x == num] for num, cnt in c.items() if cnt > 1}  
 
print(ans)

Output

{20: [1, 3], 30: [2, 5]}

Explanation:

Counter(a) counts the occurrences of each element and then a dictionary comprehension extracts indices of elements appearing more than once using enumerate().
Final dictionary stores duplicate elements as keys and their corresponding indices as values.

Using list comprehension

We use list comprehension to create a dictionary where each duplicate element maps to a list of its indices filtering elements that appear more than once. This is achieved by iterating over unique elements and using enumerate() to collect indices of duplicates.

Python

a = [10, 20, 30, 20, 40, 30, 50]  
seen = set()  

# Create a dictionary mapping duplicate elements to their indices  
ans = {num: [i for i, x in enumerate(a) if x == num] for num in set(a) if a.count(num) > 1}  
print(ans)

Output

{20: [1, 3], 30: [2, 5]}

Explanation:

We use a dictionary comprehension to iterate over unique elements in a (using set(a)) and check if each element appears more than once (a.count(num) > 1).
For each duplicate element we use enumerate(a) to collect all its indices creating a dictionary where keys are duplicate elements and values are lists of their indices.

Using a loop and list.count()

We iterate through list and use list.count() to check if an element appears more than once then store its indices in a dictionary if it's not already processed. This ensures we collect indices of duplicate elements while avoiding redundant checks.

Python

a = [10, 20, 30, 20, 40, 30, 50]  
d = {}  

for i, num in enumerate(a):  
    if a.count(num) > 1 and num not in d:  
        # Add the element to the dictionary with a list of its indices
        d[num] = [j for j, x in enumerate(a) if x == num]  

print(d)

Output

{20: [1, 3], 30: [2, 5]}

Explanation:

Loop iterates through list checking if each element appears more than once (a.count(num) > 1) and ensures that it is added only once to dictionary d.
For each duplicate element a list comprehension collects all indices where element occurs storing them in d as {element: [indices]}.