Count Equal and Divisible Pairs in an Array

Count Equal and Divisible Pairs in an Array - Problem

Array Easy

You are given a 0-indexed integer array nums of length n and an integer k. Your task is to find all special pairs in the array.

A pair (i, j) is considered special if it satisfies both of these conditions:

0 ≤ i < j < n (valid pair indices with i before j)
nums[i] == nums[j] (elements at these positions are equal)
(i * j) is divisible by k (product of indices is divisible by k)

Goal: Return the count of all such special pairs.

Example: If nums = [3,1,2,2,2,1,3] and k = 2, we need to find pairs where elements are equal AND the product of their indices is divisible by 2.

Input & Output

example_1.py — Basic Case

$ Input: nums = [3,1,2,2,2,1,3], k = 2

› Output: 4

💡 Note: Valid pairs: (0,6) since nums[0]==nums[6]=3 and (0*6)%2=0, (2,3) since nums[2]==nums[3]=2 and (2*3)%2=0, (2,4) since nums[2]==nums[4]=2 and (2*4)%2=0, (3,4) since nums[3]==nums[4]=2 and (3*4)%2=0

example_2.py — All Equal Elements

$ Input: nums = [1,2,3,4], k = 1

› Output: 0

💡 Note: No pairs have equal elements, so the count is 0. The divisibility condition doesn't matter if elements aren't equal.

example_3.py — Edge Case Small Array

$ Input: nums = [1,1], k = 3

› Output: 0

💡 Note: Only one pair (0,1) with nums[0]==nums[1]=1, but (0*1)%3=0, so this should count as 1. Wait, actually 0%3=0, so the answer should be 1.

Visualization

Tap to expand

Understanding the Visualization

Find Equal Elements

Identify pairs of elements with the same value (matching outfits)

Check Index Product

For equal pairs, verify if the product of their indices is divisible by k

Count Valid Pairs

Sum up all pairs that satisfy both conditions

Return Result

Return the total count of special pairs found

Key Takeaway

🎯 Key Insight: We must check both equality and divisibility conditions for each pair, making the brute force O(n²) approach unavoidable but acceptable given the constraints.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Worst case when all elements are equal, we still check all pairs. Best case O(n) when all elements are unique.

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map stores up to n indices across all value groups

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i], k ≤ 100
Note: The constraint on array length makes brute force acceptable

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

This problem requires finding pairs where elements are equal and index product is divisible by k. The brute force approach checking all O(n²) pairs is actually optimal here since we must verify the divisibility condition individually for each potential pair. Hash map grouping can organize the solution better but doesn't improve the worst-case complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map Grouping	O(n²)	O(n)	Group elements by value, then check divisibility within groups
Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible pairs (i,j) where i < j for both conditions

Hash Map Grouping — Algorithm Steps

Create a hash map to group indices by their values
First pass: for each index i, add i to the list for nums[i]
Second pass: for each value group with 2+ indices
Check all pairs within the group for divisibility condition
Count pairs where (i * j) % k == 0
Return total count across all groups

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by Values

Create hash map with value as key and list of indices as value

Process Groups

For each group with 2+ elements, check all pairs

Check Divisibility

Within each group, verify if index products are divisible by k

Count Results

Sum up valid pairs from all groups

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int countPairs(int* nums, int numsSize, int k) {
    // Simple approach without hash map in C
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[i] == nums[j] && (i * j) % k == 0) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[] = {3,1,2,2,2,1,3};
    int k = 2;
    printf("%d\n", countPairs(nums, 7, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Worst case when all elements are equal, we still check all pairs. Best case O(n) when all elements are unique.

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map stores up to n indices across all value groups

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i], k ≤ 100
Note: The constraint on array length makes brute force acceptable

28.4K Views

Medium Frequency

~12 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Map Grouping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler