Codestin Search App

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

Constraints

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

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.

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
✓ Brute Force (Four Nested Loops)	O(n⁴)	O(1)	Check all possible combinations of four indices with nested loops
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) — Algorithm Steps

Use four nested loops for indices a, b, c, d
Ensure a < b < c < d constraint
Check if nums[a] + nums[b] + nums[c] == nums[d]
Increment counter for each valid quadruplet

Visualization

Tap to expand

Step-by-Step Walkthrough

Outer Loop (a)

Start with first index a = 0

Second Loop (b)

For each a, try all valid b where b > a

Third Loop (c)

For each (a,b), try all valid c where c > b

Inner Loop (d)

For each (a,b,c), try all valid d where d > c

Code -

solution.c — C

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

int countQuadruplets(int* nums, int n) {
    int count = 0;
    
    for (int a = 0; a < n; a++) {
        for (int b = a + 1; b < n; b++) {
            for (int c = b + 1; c < n; c++) {
                for (int d = c + 1; d < n; d++) {
                    if (nums[a] + nums[b] + nums[c] == nums[d]) {
                        count++;
                    }
                }
            }
        }
    }
    
    return count;
}

int main() {
    int nums[50];
    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⁴)

Four nested loops, each potentially iterating through most of the array

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting and loop indices

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Four Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler