Count Special Quadruplets - Practice Coding Problems

Count Special Quadruplets - Problem

Given a 0-indexed integer array nums, you need to find all special quadruplets that satisfy a unique mathematical relationship.

A quadruplet (a, b, c, d) is considered special if:

nums[a] + nums[b] + nums[c] == nums[d] (the sum of first three elements equals the fourth)
a < b < c < d (indices are in strictly increasing order)

Your task is to count how many distinct special quadruplets exist in the given array.

Example: In array [1,0,1,0,2], the quadruplet at indices (0,1,2,4) is special because nums[0] + nums[1] + nums[2] = 1 + 0 + 1 = 2 = nums[4].

Input & Output

example_1.py — Basic Case

$ Input: [1,0,1,0,2]

› Output: 1

💡 Note: The quadruplet (0,1,2,4) is special because nums[0] + nums[1] + nums[2] = 1 + 0 + 1 = 2 = nums[4]

example_2.py — Multiple Quadruplets

$ Input: [2,2,2,2]

› Output: 0

💡 Note: No special quadruplets exist because 2 + 2 + 2 = 6 ≠ 2

example_3.py — Edge Case

$ Input: [1,1,1,3,5]

› Output: 2

💡 Note: Two quadruplets: (0,1,2,3) where 1+1+1=3, and (0,1,3,4) where 1+1+3=5

Visualization

Tap to expand

Understanding the Visualization

Choose Team Leader

Pick the strongest member (rightmost position d) as team leader

Select Assistant

Choose an assistant (position c) from remaining candidates

Calculate Need

Determine what skill combination we need: target = leader_skill - assistant_skill

Count Valid Pairs

Use our database to quickly count how many pairs have the target skill sum

Key Takeaway

🎯 Key Insight: Instead of checking all combinations, fix the last two positions and use a hash table to efficiently count how many valid pairs exist for the first two positions.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, but inner operations are O(1) hash lookups

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash table stores pair sums, potentially O(n²) different sums

⚠ Quadratic Space

Constraints

4 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 100
Array must have at least 4 elements to form a quadruplet

Asked in

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

The optimal approach uses a hash table to efficiently count valid quadruplets by fixing the last two positions and counting valid pairs for the first two positions. This reduces complexity from O(n⁴) brute force to O(n³) with clever enumeration and hash table lookups.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Table Optimization (Optimal)	O(n³)	O(n²)	Fix d and c positions, use hash table to count valid (a,b) pairs efficiently
Brute Force (Four Nested Loops)	O(n⁴)	O(1)	Check all possible combinations of four indices with nested loops

Hash Table Optimization (Optimal) — Algorithm Steps

Iterate through all possible positions for d (from right to left)
For each d, iterate through all possible positions for c (right of current position)
Calculate target sum = nums[d] - nums[c]
Count pairs (a,b) where a < b < c and nums[a] + nums[b] = target
Update hash table with new pairs as we move c leftward

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix d position

Start from rightmost possible d position

Fix c position

For each d, iterate c from right to left

Calculate target

target = nums[d] - nums[c]

Count pairs

Add count of existing pairs that sum to target

Code -

solution.c — C

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

#define MAX_NUMS 50
#define HASH_SIZE 10007

typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

void insert(HashNode** table, int key, int value) {
    int idx = hash(key);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    node->key = key;
    node->value = value;
    node->next = table[idx];
    table[idx] = node;
}

int search(HashNode** table, int key) {
    int idx = hash(key);
    HashNode* node = table[idx];
    while (node) {
        if (node->key == key) return node->value;
        node = node->next;
    }
    return 0;
}

void clearHash(HashNode** table) {
    for (int i = 0; i < HASH_SIZE; i++) {
        HashNode* node = table[i];
        while (node) {
            HashNode* temp = node;
            node = node->next;
            free(temp);
        }
        table[i] = NULL;
    }
}

int countQuadruplets(int* nums, int n) {
    int count = 0;
    
    for (int d = n - 1; d >= 3; d--) {
        HashNode* pairSums[HASH_SIZE] = {0};
        
        for (int c = d - 1; c >= 2; c--) {
            int target = nums[d] - nums[c];
            count += search(pairSums, target);
            
            for (int a = 0; a < c - 1; a++) {
                int pairSum = nums[a] + nums[c - 1];
                int current = search(pairSums, pairSum);
                insert(pairSums, pairSum, current + 1);
            }
        }
        
        clearHash(pairSums);
    }
    
    return count;
}

int main() {
    int nums[MAX_NUMS];
    int n = 0;
    char c;
    scanf("%c", &c); // skip '['
    while (scanf("%d", &nums[n]) == 1) {
        n++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    printf("%d\n", countQuadruplets(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, but inner operations are O(1) hash lookups

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash table stores pair sums, potentially O(n²) different sums

⚠ Quadratic Space

Constraints

4 ≤ nums.length ≤ 50
1 ≤ nums[i] ≤ 100
Array must have at least 4 elements to form a quadruplet

28.5K Views

Medium Frequency

~18 min Avg. Time

892 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

Hash Table Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler