Tuple with Same Product - Practice Coding Problems

Tuple with Same Product - Problem

Find Tuples with Equal Products

Given an array of distinct positive integers, your task is to count how many unique 4-tuples (a, b, c, d) exist such that:

• a × b = c × d (products are equal)
• All four numbers are different from each other
• All four numbers come from the input array

For example, if nums = [2, 3, 4, 6], then (2, 6, 3, 4) is a valid tuple because 2 × 6 = 3 × 4 = 12.

Goal: Return the total count of such valid tuples.

Note: Different orderings of the same four numbers count as separate tuples. So if (a, b, c, d) is valid, then (b, a, c, d), (a, b, d, c), etc. are also counted separately.

Input & Output

example_1.py — Python

$ Input: [2, 3, 4, 6]

› Output: 8

💡 Note: We have 8 valid tuples: (2,6,3,4), (2,6,4,3), (6,2,3,4), (6,2,4,3), (3,4,2,6), (3,4,6,2), (4,3,2,6), (4,3,6,2). All satisfy the condition 2×6 = 3×4 = 12.

example_2.py — Python

$ Input: [1, 2, 4, 5, 10]

› Output: 16

💡 Note: Two groups: (1,10,2,5) since 1×10 = 2×5 = 10, and (2,10,4,5) since 2×10 = 4×5 = 20. Each group contributes 8 tuples, total = 16.

example_3.py — Python

$ Input: [2, 3, 5, 7]

› Output: 0

💡 Note: All numbers are prime, so no two pairs can have the same product. No valid tuples exist.

Visualization

Tap to expand

Understanding the Visualization

As each couple registers, calculate their chemistry score (product)

Find matches

If another couple already has this score, they can compete!

Count competitions

Each match allows 8 different dance-off arrangements

Running total

Keep adding to our total count as we process each couple

Key Takeaway

🎯 Key Insight: Instead of checking all possible combinations later, we count matches immediately as we discover them, leading to an elegant O(n²) solution that's both time and space optimal!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Single pass through all O(n²) pairs, hash operations are O(1) average case

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash map stores at most O(n²) unique products

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁴
All elements of nums are distinct
Important: Products can be as large as 10⁸

Asked in

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

The optimal solution uses a one-pass hash table approach with O(n²) time complexity. As we generate each pair's product, we immediately check how many existing pairs share the same product and calculate valid tuples on the spot. The key insight is that for k pairs with the same product, we can form k×(k-1)×8 tuples (8 orderings per combination).

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n²)	O(n²)	First pass: build product frequency map, second pass: count combinations
Brute Force (Four Nested Loops)	O(n⁴)	O(1)	Check all possible combinations of 4 different elements
One-Pass Hash Table (Optimal)	O(n²)	O(n²)	Build hash map and count combinations simultaneously for optimal efficiency

Two-Pass Hash Table — Algorithm Steps

Generate all possible pairs and calculate their products
Store products in a hash map with their frequency counts
For each product with frequency > 1, calculate combinations
Each group of k pairs with same product contributes k*(k-1)*8 tuples
Sum up all contributions and return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate all pairs

Calculate products of all possible pairs

Count frequencies

Store product frequencies in hash map

Calculate combinations

For each product with count > 1, calculate valid tuples

Code -

solution.c — C

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

#define MAX_PRODUCTS 10000

struct ProductCount {
    int product;
    int count;
};

int tupleSameProduct(int* nums, int numsSize) {
    struct ProductCount products[MAX_PRODUCTS];
    int productIndex = 0;
    
    // First pass: count frequency of each product
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            int product = nums[i] * nums[j];
            
            // Find if product already exists
            int found = -1;
            for (int k = 0; k < productIndex; k++) {
                if (products[k].product == product) {
                    found = k;
                    break;
                }
            }
            
            if (found != -1) {
                products[found].count++;
            } else {
                products[productIndex].product = product;
                products[productIndex].count = 1;
                productIndex++;
            }
        }
    }
    
    // Second pass: count valid tuples
    int result = 0;
    for (int i = 0; i < productIndex; i++) {
        int count = products[i].count;
        if (count > 1) {
            // For k pairs with same product, we can form k*(k-1) combinations
            // Each combination has 8 different orderings
            result += count * (count - 1) * 8;
        }
    }
    
    return result;
}

int main() {
    int nums[1000];
    int size = 0;
    char ch;
    int num = 0;
    int reading = 0;
    
    while ((ch = getchar()) != '\n') {
        if (ch >= '0' && ch <= '9') {
            num = num * 10 + (ch - '0');
            reading = 1;
        } else if (reading) {
            nums[size++] = num;
            num = 0;
            reading = 0;
        }
    }
    if (reading) nums[size++] = num;
    
    printf("%d\n", tupleSameProduct(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

First pass O(n²) to generate all pairs, second pass O(unique products) which is at most O(n²)

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash map can store up to O(n²) unique products in worst case

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁴
All elements of nums are distinct
Important: Products can be as large as 10⁸

67.2K Views

Medium Frequency

~18 min Avg. Time

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

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler