Python - Duplicate Element Indices in List

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.

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)

{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.

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)  

{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.

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)  

{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.

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)

{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]}.