Find X-Sum of All K-Long Subarrays I - Practice Coding Problems

Find X-Sum of All K-Long Subarrays I - Problem

Find X-Sum of All K-Long Subarrays I

You're given an array nums of n integers and two important parameters: k (subarray length) and x (number of top frequent elements to consider).

Your task is to calculate the x-sum for every possible subarray of length k. The x-sum is a special calculation that focuses on the most frequent elements:

How to calculate x-sum:
1. Count frequency of all elements in the subarray
2. Select the top x most frequent elements
3. If frequencies are tied, prioritize the larger value
4. Sum all occurrences of these selected elements
5. If subarray has fewer than x distinct elements, just sum the entire subarray

Example: For subarray [3, 2, 2, 3, 3] with x=2:
• Element 3 appears 3 times, element 2 appears 2 times
• Top 2 most frequent: 3 (freq=3) and 2 (freq=2)
• X-sum = 3×3 + 2×2 = 9 + 4 = 13

Return an array where each element represents the x-sum of the corresponding k-length subarray.

Input & Output

example_1.py — Basic X-Sum Calculation

$ Input: nums = [1, 1, 2, 2, 3, 4, 2, 3], k = 6, x = 2

› Output: [6, 10, 12]

💡 Note: For subarray [1,1,2,2,3,4] with x=2: frequencies are {1:2, 2:2, 3:1, 4:1}. Top 2 most frequent (tie-break by larger value): 2 appears 2 times, 1 appears 2 times. X-sum = 2×2 + 1×2 = 6.

example_2.py — Tie-breaking by Value

$ Input: nums = [3, 8, 7, 8, 7, 5], k = 2, x = 2

› Output: [11, 15, 15, 15, 12]

💡 Note: For subarray [3,8]: both appear once, so we take both. X-sum = 3×1 + 8×1 = 11. For [8,7]: X-sum = 8×1 + 7×1 = 15.

example_3.py — Fewer than X Distinct Elements

$ Input: nums = [1, 1, 1], k = 3, x = 5

› Output: [3]

💡 Note: Subarray [1,1,1] has only 1 distinct element, which is less than x=5. So x-sum equals the total sum: 1+1+1 = 3.

Constraints

1 ≤ n ≤ 50
1 ≤ k ≤ n
1 ≤ x ≤ k
1 ≤ nums[i] ≤ 50
All elements fit in 32-bit integers

Visualization

Tap to expand

Understanding the Visualization

Count Frequencies

Build a frequency map for all elements in the current subarray

Sort by Priority

Sort elements first by frequency (descending), then by value (descending) for ties

Select Top X

Take the top x elements according to the priority order

Calculate Sum

Sum all occurrences of the selected top x elements

Key Takeaway

🎯 Key Insight: X-sum prioritizes frequent elements while using value-based tie-breaking, making it perfect for scenarios where you need to focus on the most significant contributors in a dataset.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses sliding window technique combined with frequency tracking. Instead of recalculating everything for each subarray, we maintain a frequency map and update it incrementally as we slide through the array. The key insight is that consecutive subarrays have significant overlap, so we can reuse computations by removing the leftmost element and adding the new rightmost element. While we still need to sort frequencies for each window, the incremental updates make this approach much faster in practice than the brute force method.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(nklog k)	O(k)	For each k-length subarray, count frequencies and calculate x-sum independently
Sliding Window with Hash Map (Optimal)	O(n×k×log k)	O(k)	Use sliding window technique to efficiently update frequency counts as we move through subarrays

Brute Force (Nested Loops) — Algorithm Steps

Iterate through all possible starting positions (0 to n-k)
For each position, extract k-length subarray
Count frequency of each element in the subarray
Sort elements by frequency (descending), then by value (descending) for ties
Take top x elements and calculate sum of their total occurrences
Store result in answer array

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Subarray

Take k consecutive elements starting at current position

Count Frequencies

Build frequency map for all elements in subarray

Sort by Priority

Sort by frequency desc, then value desc

Calculate X-Sum

Sum the top x elements

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* pairA = (int*)a;
    int* pairB = (int*)b;
    
    // Compare by frequency first (descending)
    if (pairA[0] != pairB[0]) {
        return pairB[0] - pairA[0];
    }
    // Then by value (descending)
    return pairB[1] - pairA[1];
}

int* findXSum(int* nums, int n, int k, int x, int* returnSize) {
    *returnSize = n - k + 1;
    int* result = (int*)malloc(*returnSize * sizeof(int));
    
    for (int i = 0; i <= n - k; i++) {
        int freqMap[1001] = {0}; // Assuming values are within reasonable range
        int uniqueVals[1001];
        int uniqueCount = 0;
        
        // Count frequencies and track unique values
        for (int j = i; j < i + k; j++) {
            if (freqMap[nums[j]] == 0) {
                uniqueVals[uniqueCount++] = nums[j];
            }
            freqMap[nums[j]]++;
        }
        
        // Create pairs of (frequency, value)
        int pairs[1001][2];
        for (int j = 0; j < uniqueCount; j++) {
            pairs[j][0] = freqMap[uniqueVals[j]]; // frequency
            pairs[j][1] = uniqueVals[j]; // value
        }
        
        // Sort pairs
        qsort(pairs, uniqueCount, sizeof(pairs[0]), compare);
        
        // Calculate x-sum
        int xSum = 0;
        int limit = (x < uniqueCount) ? x : uniqueCount;
        for (int j = 0; j < limit; j++) {
            xSum += pairs[j][0] * pairs[j][1];
        }
        
        result[i] = xSum;
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int input[1000];
    int count = 0;
    char* token = strtok(line, " \n");
    while (token != NULL) {
        input[count++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    int k = input[count - 2];
    int x = input[count - 1];
    int n = count - 2;
    
    int returnSize;
    int* result = findXSum(input, n, k, x, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k*log k)

O(n-k+1) subarrays, each requiring O(k) to count frequencies and O(k log k) to sort

⚡ Linearithmic

Space Complexity

O(k)

Hash map to store frequencies for each subarray, maximum k distinct elements

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

1.3K 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