Number of Pairs of Interchangeable Rectangles

Number of Pairs of Interchangeable Rectangles - Problem

Array Hash Table Math Counting Number Theory Medium

Imagine you're organizing a collection of rectangular frames and need to find pairs that have the same proportions. Two rectangles are considered interchangeable if they have identical width-to-height ratios - meaning one can be scaled to match the other perfectly!

Given an array rectangles where rectangles[i] = [width_i, height_i], your task is to count how many pairs of rectangles (i, j) where i < j are interchangeable.

Key insight: Two rectangles are interchangeable when width_i / height_i == width_j / height_j. For example, a 4×2 rectangle and a 6×3 rectangle are interchangeable because both have a ratio of 2:1.

Goal: Return the total number of interchangeable rectangle pairs.

Input & Output

example_1.py — Basic Case

$ Input: rectangles = [[4,6],[6,9],[3,4.5]]

› Output: 3

💡 Note: All three rectangles have the same ratio of 2:3 (4/6 = 6/9 = 3/4.5 = 2/3), so we have 3 pairs: (0,1), (0,2), and (1,2)

example_2.py — Mixed Ratios

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

› Output: 3

💡 Note: Rectangles at indices 0,2,3 have ratio 1:2 (4/8 = 2/4 = 1/2), giving us 3 pairs: (0,2), (0,3), (2,3). Rectangle 1 has ratio 1:1 and forms no pairs.

example_3.py — No Pairs

$ Input: rectangles = [[4,5],[7,8]]

› Output: 0

💡 Note: The two rectangles have different ratios (4:5 vs 7:8), so no pairs can be formed.

Visualization

Tap to expand

Understanding the Visualization

Normalize Each Rectangle

Calculate GCD and reduce each rectangle to its simplest ratio form

Group by Ratio

Use hash map to count how many rectangles share each normalized ratio

Count Combinations

For each group of size k, calculate C(k,2) = k×(k-1)/2 possible pairs

Key Takeaway

🎯 Key Insight: Instead of comparing all pairs directly (O(n²)), group rectangles by their normalized ratios using GCD, then use the combination formula to count pairs efficiently in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through rectangles, GCD calculation is O(log(min(w,h))) which is negligible

✓ Linear Growth

Space Complexity

O(n)

Hash map can store up to n different ratios in worst case

⚡ Linearithmic Space

Constraints

n == rectangles.length
1 ≤ n ≤ 10⁵
rectangles[i].length == 2
1 ≤ width_i, height_i ≤ 10⁵
All dimensions are positive integers

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a hash map with normalized ratios to achieve O(n) time complexity. By computing the GCD of each rectangle's dimensions, we create a canonical form that avoids floating-point precision issues. For each ratio appearing k times, we can form k×(k-1)/2 pairs, leading to an elegant and efficient solution.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Compare every rectangle with every other rectangle
One-Pass Hash Table (Optimal)	O(n)	O(n)	Use GCD to create normalized ratios and count pairs in one pass

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each rectangle i from 0 to n-2
For each rectangle i, iterate through rectangles j from i+1 to n-1
Check if width[i]/height[i] == width[j]/height[j]
If ratios match, increment the count
Return total count of matching pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first rectangle

Compare rectangle 0 with all following rectangles

Check ratio equality

Use cross multiplication: w1*h2 == w2*h1

Continue for all pairs

Move to next rectangle and repeat comparisons

Code -

solution.c — C

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

int interchangeableRectangles(int** rectangles, int rectanglesSize, int* rectanglesColSize) {
    int count = 0;
    
    for (int i = 0; i < rectanglesSize; i++) {
        for (int j = i + 1; j < rectanglesSize; j++) {
            // Compare ratios using cross multiplication
            if (rectangles[i][0] * rectangles[j][1] == rectangles[i][1] * rectangles[j][0]) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all possible pairs, which is n*(n-1)/2 comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting and iteration

✓ Linear Space

Constraints

n == rectangles.length
1 ≤ n ≤ 10⁵
rectangles[i].length == 2
1 ≤ width_i, height_i ≤ 10⁵
All dimensions are positive integers

32.0K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler