Number of Equivalent Domino Pairs - Problem

Given a list of dominoes, dominoes[i] = [a, b] is equivalent to dominoes[j] = [c, d] if and only if either:

(a == c and b == d), or
(a == d and b == c)

That is, one domino can be rotated to be equal to another domino.

Return the number of pairs (i, j) for which 0 <= i < j < dominoes.length, and dominoes[i] is equivalent to dominoes[j].

Input & Output

Example 1 — Basic Case

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

› Output: 1

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

Example 2 — Multiple Pairs

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

› Output: 3

💡 Note: Three [1,2] dominoes form 3 pairs: (0,1), (0,3), (1,3). Other dominoes don't have matches.

Example 3 — No Equivalent Pairs

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

› Output: 0

💡 Note: No two dominoes are equivalent, so there are 0 pairs

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to normalize dominoes by sorting their values to handle rotation, then count frequencies. The optimal approach uses a hash map to count equivalent dominoes in O(n) time. For n identical dominoes, there are n*(n-1)/2 pairs. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(1)

Check each domino against all subsequent dominoes to see if they're equivalent. Two dominoes are equivalent if they match exactly or when one is rotated.

Hash Map Frequency Count

⏱️ Time: O(n) Space: O(n)

Convert each domino to a normalized form where the smaller value comes first, then use a hash map to count frequencies. The number of pairs for n identical dominoes is n*(n-1)/2.

Brute Force — Algorithm Steps

Step 1: For each domino i, compare with all dominoes j where j > i
Step 2: Check if dominoes[i] equals dominoes[j] or dominoes[j] rotated
Step 3: Count all equivalent pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Pairs

Check each domino with all dominoes after it

Check Equivalence

See if dominoes match exactly or when rotated

Count Matches

Increment counter for each equivalent pair found

Code -

solution.c — C

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

int solution(int dominoes[][2], int n) {
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int a = dominoes[i][0], b = dominoes[i][1];
            int c = dominoes[j][0], d = dominoes[j][1];
            if ((a == c && b == d) || (a == d && b == c)) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int dominoes[1000][2];
    int n = 0;
    
    char *ptr = line + 1;
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            dominoes[n][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            dominoes[n][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            n++;
        }
        ptr++;
    }
    
    int result = solution(dominoes, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops compare each domino with all subsequent dominoes

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

25.0K 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

Number of Equivalent Domino Pairs - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler