Number of Pairs of Interchangeable Rectangles - Problem

Array Hash Table Math Counting Number Theory Medium

You are given n rectangles represented by a 0-indexed 2D integer array rectangles, where rectangles[i] = [width_i, height_i] denotes the width and height of the i^th rectangle.

Two rectangles i and j (where i < j) are considered interchangeable if they have the same width-to-height ratio. More formally, two rectangles are interchangeable if width_i/height_i == width_j/height_j (using decimal division, not integer division).

Return the number of pairs of interchangeable rectangles in rectangles.

Input & Output

Example 1 — Basic Case

$ Input: rectangles = [[4,6],[8,10],[4,8],[2,4]]

› Output: 1

💡 Note: Rectangles [4,8] and [2,4] have the same ratio 1:2 (4/8 = 2/4 = 0.5), forming 1 interchangeable pair

Example 2 — Multiple Groups

$ Input: rectangles = [[4,8],[3,6],[10,20],[12,16]]

› Output: 3

💡 Note: Rectangles [4,8], [3,6], and [10,20] all have ratio 1/2, while [12,16] has ratio 3/4. The 3 rectangles with ratio 1/2 form C(3,2) = 3 pairs

Example 3 — No Matches

$ Input: rectangles = [[1,2],[2,3],[3,4]]

› Output: 0

💡 Note: All rectangles have different ratios: 1/2, 2/3, 3/4. No pairs are interchangeable

Constraints

n == rectangles.length
1 ≤ n ≤ 10⁵
rectangles[i].length == 2
1 ≤ width_i, height_i ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is to group rectangles by their simplified width-to-height ratios. Use GCD to avoid floating point precision issues and count pairs using combination formula. Best approach is hash map grouping with Time: O(n × log(min(w,h))), Space: O(n).

Common Approaches

✓ Brute Force

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

Compare each rectangle with every other rectangle to calculate their width-to-height ratios and count matching pairs. For each pair (i,j) where i < j, check if width[i]/height[i] equals width[j]/height[j].

Hash Map with Ratio Counting

⏱️ Time: O(n × log(min(w,h))) Space: O(n)

Calculate the simplified ratio (using GCD) for each rectangle and count how many rectangles share the same ratio. For each group of k rectangles with the same ratio, the number of pairs is k*(k-1)/2.

Brute Force — Algorithm Steps

Step 1: Iterate through all pairs (i,j) where i < j
Step 2: Calculate ratios for both rectangles
Step 3: Count pairs with equal ratios

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Rectangles

Array of [width, height] pairs

Compare Pairs

Check each pair using cross multiplication

Count Matches

Increment counter for equal ratios

Code -

solution.c — C

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

long long solution(int rectangles[][2], int n) {
    long long count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // Use cross multiplication to avoid floating point precision issues
            if ((long long)rectangles[i][0] * rectangles[j][1] == (long long)rectangles[i][1] * rectangles[j][0]) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for 2D array
    int rectangles[1000][2];
    int n = 0;
    char* ptr = line + 1; // Skip first '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            rectangles[n][0] = atoi(ptr);
            while (*ptr != ',') ptr++;
            ptr++;
            rectangles[n][1] = atoi(ptr);
            while (*ptr != ']') ptr++;
            ptr++;
            n++;
        } else {
            ptr++;
        }
    }
    
    printf("%lld\n", solution(rectangles, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops check all n×(n-1)/2 pairs of rectangles

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra variables for counting

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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 Pairs of Interchangeable Rectangles - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler