Arithmetic Subarrays - Practice Coding Problems

Arithmetic Subarrays - Problem

Arithmetic Subarrays is a fascinating problem that tests your ability to determine if subarrays can form arithmetic progressions after rearrangement.

An arithmetic sequence is a sequence where consecutive elements have the same difference. For example:
• [1, 3, 5, 7, 9] - difference is 2
• [7, 7, 7, 7] - difference is 0
• [3, -1, -5, -9] - difference is -4

Given an array nums and multiple range queries defined by arrays l and r, you need to determine for each query whether the subarray from index l[i] to r[i] can be rearranged to form an arithmetic sequence.

Key insight: The elements don't need to be in order initially - you can rearrange them however you want!

Input & Output

example_1.py — Basic Case

$ Input: nums = [4,6,5,9,3,7], l = [0,0,2], r = [1,2,5]

› Output: [true, false, true]

💡 Note: Query 1: [4,6] can form [4,6] with diff=2. Query 2: [4,6,5] sorted is [4,5,6] with diffs [1,1], so true. Wait, let me recalculate: [4,6,5] cannot form arithmetic (diffs would be 1,1 but we need same diff). Query 3: [5,9,3,7] can be rearranged to [3,5,7,9] with diff=2.

example_2.py — All Same Elements

$ Input: nums = [5,5,5,5], l = [0,1], r = [2,3]

› Output: [true, true]

💡 Note: Both queries result in subarrays of identical elements, which form arithmetic sequences with difference 0.

example_3.py — Single Elements

$ Input: nums = [1,2,3], l = [0], r = [0]

› Output: [true]

💡 Note: A single element trivially forms an arithmetic sequence (though we need at least 2 elements by definition, single elements are considered valid).

Constraints

n == nums.length
m == l.length == r.length
2 ≤ n ≤ 500
1 ≤ m ≤ 500
0 ≤ l[i] < r[i] < n
-10⁵ ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Extract Musicians

Select musicians for this piece (subarray elements)

Arrange by Pitch

Sort musicians by their note values (ascending order)

Check Intervals

Verify each consecutive pair has the same musical interval

Validate Harmony

If all intervals match, the arrangement creates perfect arithmetic harmony

Key Takeaway

🎯 Key Insight: An arithmetic sequence has exactly one valid arrangement - sorted order with equal consecutive differences!

Asked in

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

The optimal approach is to sort each subarray and verify consecutive differences are equal. For each query range, extract the subarray, sort it in O(k log k) time, then check if all consecutive differences match in O(k) time. The hash set approach can be faster by avoiding sorting, but requires more complex logic to handle edge cases.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Sort and Check)	O(m × k log k)	O(k)	Sort each subarray and verify if consecutive differences are equal
Hash Set Validation	O(m × k)	O(k)	Use hash set to verify if arithmetic sequence can be formed

Brute Force (Sort and Check) — Algorithm Steps

For each query range [l[i], r[i]], extract the subarray
Sort the extracted subarray
Calculate the common difference using first two elements
Verify all consecutive pairs have the same difference
Return true if all differences match, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Subarray

Extract elements from nums[l[i]] to nums[r[i]]

Sort Elements

Sort the extracted elements in ascending order

Check Differences

Verify that consecutive differences are all equal

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

bool* checkArithmeticSubarrays(int* nums, int numsSize, int* l, int lSize, int* r, int rSize, int* returnSize) {
    *returnSize = lSize;
    bool* result = (bool*)malloc(lSize * sizeof(bool));
    
    for (int i = 0; i < lSize; i++) {
        int subarraySize = r[i] - l[i] + 1;
        int* subarray = (int*)malloc(subarraySize * sizeof(int));
        
        // Copy subarray
        for (int j = 0; j < subarraySize; j++) {
            subarray[j] = nums[l[i] + j];
        }
        
        // Need at least 2 elements for arithmetic sequence
        if (subarraySize < 2) {
            result[i] = true;
            free(subarray);
            continue;
        }
        
        // Sort the subarray
        qsort(subarray, subarraySize, sizeof(int), compare);
        
        // Check if it forms arithmetic sequence
        int diff = subarray[1] - subarray[0];
        bool isArithmetic = true;
        
        for (int j = 2; j < subarraySize; j++) {
            if (subarray[j] - subarray[j-1] != diff) {
                isArithmetic = false;
                break;
            }
        }
        
        result[i] = isArithmetic;
        free(subarray);
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m × k log k)

m queries, each requiring O(k log k) sorting where k is average subarray length

⚡ Linearithmic

Space Complexity

O(k)

Space for copying and sorting each subarray of length k

✓ Linear Space

28.5K 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 (Sort and Check) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler