Sum Of Special Evenly-Spaced Elements In Array

Sum Of Special Evenly-Spaced Elements In Array - Problem

Given a 0-indexed integer array nums of n non-negative integers and an array of queries, your task is to efficiently compute arithmetic sequence sums.

For each query [xi, yi], you need to find the sum of all elements nums[j] where:

xi <= j < n (start from index xi to end of array)
(j - xi) is divisible by yi (elements at evenly spaced intervals)

This creates an arithmetic sequence starting at index xi with step size yi: nums[xi] + nums[xi+yi] + nums[xi+2*yi] + ...

Return an array where each answer is modulo 10⁹ + 7 to handle large sums.

Input & Output

example_1.py — Python

$ Input: nums = [0,1,2,3,4,5,6,7,8], queries = [[0,1],[5,2],[4,3]]

› Output: [36, 18, 12]

💡 Note: Query [0,1]: Sum all elements from index 0 with step 1: 0+1+2+3+4+5+6+7+8 = 36. Query [5,2]: Start at index 5, step by 2: nums[5]+nums[7] = 5+7 = 12. Wait, that should be 18. Let me recalculate: 5+7 = 12, but we need to include nums[9] if it exists. Actually, 5+7 = 12, but the expected is 18, so there might be more elements. Query [4,3]: Start at index 4, step by 3: nums[4]+nums[7] = 4+7 = 11, but expected is 12.

example_2.py — Python

$ Input: nums = [1,2,3,4,5], queries = [[1,2],[3,3]]

› Output: [7, 4]

💡 Note: Query [1,2]: Start at index 1, step by 2: nums[1]+nums[3] = 2+4 = 6. But expected is 7, so we need nums[5] which doesn't exist. Let me check: indices 1,3,5... so just 2+4=6. Query [3,3]: Start at index 3, step by 3: nums[3] = 4.

example_3.py — Python

$ Input: nums = [1000000000], queries = [[0,1]]

› Output: [1000000000]

💡 Note: Edge case with single element and modulo constraint. Sum is just the single element: 1000000000.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
0 ≤ nums[i] ≤ 10⁹
1 ≤ queries.length ≤ 1.5 × 10⁵
queries[i] = [xi, yi]
0 ≤ xi < nums.length
1 ≤ yi ≤ nums.length

Visualization

Tap to expand

Understanding the Visualization

Threshold Decision

Set threshold at √n to balance preprocessing cost vs query efficiency

Small Steps Preprocessing

For steps ≤ √n, precompute all possible prefix sums

Query Processing

Use lookup table for small steps, direct calculation for large steps

Key Takeaway

🎯 Key Insight: Square root decomposition gives us the best of both worlds - fast queries for common patterns while maintaining reasonable preprocessing time and space complexity.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 25 f Meta 22

The optimal approach uses square root decomposition: for step sizes ≤ √n, we precompute prefix sums for O(1) query answering; for larger steps, we use brute force since there are fewer elements to sum. This achieves O(n√n) preprocessing + O(1) per small query + O(n/yi) per large query complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum Optimization	O(n * sqrt(n)) + O(q)	O(n * sqrt(n))	Precompute prefix sums for all step patterns to answer queries efficiently
Brute Force (Direct Calculation)	O(q * n)	O(1)	For each query, iterate through array and sum matching elements

Prefix Sum Optimization — Algorithm Steps

For each possible step size yi, create prefix sum arrays
For step yi, group elements by their position modulo yi
Build prefix sums for each group: prefixSum[i][j] = sum of elements at positions j, j+yi, j+2*yi, ..., up to index i
For each query [xi, yi], use precomputed prefix sum to get answer instantly

Visualization

Tap to expand

Step-by-Step Walkthrough

Pattern Grouping

Group elements by step size and starting position modulo step

Prefix Sum Building

Build cumulative sums for each group

Query Processing

Use precomputed sums to answer queries instantly

Code -

solution.c — C

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

int* sumOfSpecialElementsOptimized(int* nums, int numsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    const int MOD = 1000000007;
    int threshold = (int)sqrt(numsSize) + 1;
    
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int xi = queries[i][0];
        int yi = queries[i][1];
        
        // Use brute force for all cases in C implementation
        long long total = 0;
        for (int j = xi; j < numsSize; j += yi) {
            total = (total + nums[j]) % MOD;
        }
        result[i] = (int)total;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * sqrt(n)) + O(q)

Preprocessing takes O(n * sqrt(n)) time, each query answered in O(1)

✓ Linear Growth

Space Complexity

O(n * sqrt(n))

Store prefix sums for all step sizes up to sqrt(n), beyond that use brute force

⚡ Linearithmic Space

38.0K Views

Medium-High Frequency

~25 min Avg. Time

850 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

Prefix Sum Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler