Number of Equivalent Domino Pairs - Practice Coding Problems

Number of Equivalent Domino Pairs - Problem

Imagine you have a collection of dominoes scattered on a table. Each domino has two numbers on it, one on each end. The fascinating thing about dominoes is that you can rotate them - so a domino with [1, 2] is essentially the same as [2, 1]!

Given a list of dominoes where dominoes[i] = [a, b], your task is to find how many equivalent pairs exist. Two dominoes are equivalent if:

They have the same numbers in the same positions: (a == c and b == d)
OR they have the same numbers but rotated: (a == d and b == c)

Goal: Return the number of pairs (i, j) where 0 ≤ i < j < dominoes.length and dominoes[i] is equivalent to dominoes[j].

Example: If you have dominoes [[1,2], [2,1], [3,4], [5,6]], then [1,2] and [2,1] form one equivalent pair, so the answer is 1.

Input & Output

example_1.py — Basic Case

$ Input: dominoes = [[1,2],[2,1],[3,4],[5,6]]

› Output: 1

💡 Note: The dominoes [1,2] and [2,1] are equivalent (one can be rotated to match the other). All other dominoes are unique, so there's only 1 equivalent pair.

example_2.py — Multiple Pairs

$ Input: dominoes = [[1,2],[1,2],[1,1],[1,2],[2,2]]

› Output: 3

💡 Note: We have three [1,2] dominoes at indices 0, 1, 3. They form 3 pairs: (0,1), (0,3), and (1,3). The dominoes [1,1] and [2,2] are unique.

example_3.py — Edge Case

$ Input: dominoes = [[1,1],[2,2],[1,1]]

› Output: 1

💡 Note: Only the two [1,1] dominoes at indices 0 and 2 are equivalent, forming 1 pair. Note that [1,1] rotated is still [1,1].

Constraints

1 ≤ dominoes.length ≤ 4 × 10⁴
dominoes[i].length == 2
1 ≤ dominoes[i][j] ≤ 9

Visualization

Tap to expand

Understanding the Visualization

Normalize

Convert each domino to standard form [min, max]

Track

Use hash map to count each normalized domino type

Count Pairs

For each domino, add current count to result before incrementing

Result

Total pairs found across all equivalent domino groups

Key Takeaway

🎯 Key Insight: Normalize dominoes by sorting their values, then use a hash map to count equivalent pairs in O(n) time!

Asked in

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

The optimal solution uses a hash map with normalization technique. By converting each domino to a normalized form (smaller value first), we can treat [1,2] and [2,1] as the same key. In a single pass, we count how many equivalent dominoes we've seen before and accumulate the pairs. This achieves O(n) time complexity and is much more efficient than the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Compare every domino with every other domino using nested loops
One-Pass Hash Table (Optimal)	O(n)	O(n)	Normalize dominoes and use hash map to count equivalent pairs in one pass

Brute Force (Nested Loops) — Algorithm Steps

Use outer loop for domino i from 0 to n-2
Use inner loop for domino j from i+1 to n-1
Check if dominoes[i] and dominoes[j] are equivalent
Two dominoes are equivalent if (a==c && b==d) OR (a==d && b==c)
Count each equivalent pair found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first domino and compare with all others

Compare

Check if current pair is equivalent (same or rotated)

Count

Increment counter if equivalent pair found

Continue

Move to next domino and repeat process

Code -

solution.c — C

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

int numEquivDominoPairs(int** dominoes, int dominoesSize) {
    int count = 0;
    
    for (int i = 0; i < dominoesSize; i++) {
        for (int j = i + 1; j < dominoesSize; j++) {
            int a = dominoes[i][0], b = dominoes[i][1];
            int c = dominoes[j][0], d = dominoes[j][1];
            
            // Check if equivalent
            if ((a == c && b == d) || (a == d && b == c)) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int** dominoes = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dominoes[i] = (int*)malloc(2 * sizeof(int));
        scanf("%d %d", &dominoes[i][0], &dominoes[i][1]);
    }
    
    printf("%d\n", numEquivDominoPairs(dominoes, n));
    
    for (int i = 0; i < n; i++) {
        free(dominoes[i]);
    }
    free(dominoes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have nested loops where outer loop runs n-1 times and inner loop runs on average n/2 times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track indices and count, no additional data structures

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

850 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler