Find Subarrays With Equal Sum - Practice Coding Problems

Find Subarrays With Equal Sum - Problem

Find Subarrays With Equal Sum

You're given a 0-indexed integer array nums. Your task is to determine whether there exist two subarrays of length 2 with equal sum.

🎯 Key Points:
• Both subarrays must have exactly 2 elements
• They must begin at different indices
• A subarray is a contiguous sequence of elements

Goal: Return true if such subarrays exist, false otherwise.

Example: In array [4,2,4], we have subarrays [4,2] (sum=6) and [2,4] (sum=6), so return true.

Input & Output

example_1.py — Basic Case

$ Input: [4,2,4]

› Output: true

💡 Note: We have two subarrays: [4,2] starting at index 0 with sum 6, and [2,4] starting at index 1 with sum 6. Since both sums are equal and start at different indices, return true.

example_2.py — No Equal Sums

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

› Output: false

💡 Note: The subarrays are: [1,2]=3, [2,3]=5, [3,4]=7, [4,5]=9. All sums are different, so no two subarrays have equal sum. Return false.

example_3.py — Minimum Length

$ Input: [0,0,0]

› Output: true

💡 Note: We have subarrays [0,0] starting at index 0 with sum 0, and [0,0] starting at index 1 with sum 0. Both have equal sum, so return true.

Constraints

2 ≤ nums.length ≤ 1000
-10⁹ ≤ nums[i] ≤ 10⁹
Must have at least 2 elements to form length-2 subarrays

Visualization

Tap to expand

Understanding the Visualization

Scan Array

Move through array calculating adjacent pair sums

Check Memory

See if current sum was encountered before

Update Memory

Add new sum to memory if not seen

Early Exit

Return true immediately when duplicate found

Key Takeaway

🎯 Key Insight: Hash sets provide O(1) average lookup time, making duplicate detection extremely efficient. This transforms a quadratic comparison problem into a linear scanning problem with early termination.

Asked in

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

The optimal solution uses a hash set to track subarray sums in O(n) time. As we iterate through the array, we calculate each length-2 subarray sum and check if it already exists in our hash set. If found, we immediately return true. This approach provides early termination and is much more efficient than the O(n²) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Compare every subarray of length 2 with every other subarray of length 2
One-Pass Hash Set (Optimal)	O(n)	O(n)	Store subarray sums in a hash set and check for duplicates in one pass

Brute Force (Nested Loops) — Algorithm Steps

Generate all subarrays of length 2 (from index i to i+1)
For each subarray, compare it with all other subarrays
If two subarrays have equal sums and different starting indices, return true
If no matches found after checking all pairs, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Find all consecutive pairs in the array

Compare Pairs

Check each subarray against all others

Find Match

Return true when equal sums are found

Code -

solution.c — C

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

bool findSubarrays(int* nums, int numsSize) {
    // Check all pairs of length-2 subarrays
    for (int i = 0; i < numsSize - 1; i++) {
        for (int j = i + 1; j < numsSize - 1; j++) {
            // Compare sums of subarrays starting at i and j
            if (nums[i] + nums[i + 1] == nums[j] + nums[j + 1]) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    scanf("%c", &c); // skip '['
    while (scanf("%d", &nums[size]) == 1) {
        size++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    printf("%s\n", findSubarrays(nums, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check every pair of subarrays. With n-1 subarrays of length 2, we make (n-1)² comparisons in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store indices and sums, no additional data structures

✓ Linear Space

32.4K Views

Medium Frequency

~15 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler