Maximum GCD-Sum of a Subarray - Practice Coding Problems

Maximum GCD-Sum of a Subarray - Problem

Maximum GCD-Sum of a Subarray

You are given an array of integers nums and an integer k. Your task is to find the maximum GCD-sum among all possible subarrays with at least k elements.

The GCD-sum of an array is calculated as:
• Let s be the sum of all elements in the array
• Let g be the greatest common divisor (GCD) of all elements
• The GCD-sum = s × g

Goal: Return the maximum GCD-sum possible from any subarray of nums that contains at least k elements.

Example: For array [6, 10, 3] with k = 2:
• Subarray [6, 10]: sum = 16, GCD = 2, GCD-sum = 32
• Subarray [10, 3]: sum = 13, GCD = 1, GCD-sum = 13
• Subarray [6, 10, 3]: sum = 19, GCD = 1, GCD-sum = 19
Maximum GCD-sum = 32

Input & Output

example_1.py — Basic case

$ Input: nums = [6, 10, 3], k = 2

› Output: 32

💡 Note: We need subarrays with at least 2 elements. Subarray [6,10] has sum=16 and GCD=2, so GCD-sum = 16×2 = 32. This is the maximum among all valid subarrays.

example_2.py — All elements have GCD 1

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

› Output: 18

💡 Note: The subarray [7,5,6] has sum=18 and GCD=1, giving GCD-sum=18. Even though other subarrays exist, this one has the maximum sum since all have GCD=1.

example_3.py — High GCD with smaller sum

$ Input: nums = [12, 16, 8], k = 2

› Output: 112

💡 Note: Subarray [12,16] has sum=28 and GCD=4, giving GCD-sum=112. Subarray [12,16,8] has sum=36 and GCD=4, giving GCD-sum=144. The maximum is 144.

Visualization

Tap to expand

Understanding the Visualization

Identify treasure groups

Group treasures by their common factors (potential multipliers)

Calculate collection values

For each group, find the best collection of k+ treasures

Apply magic multiplier

Multiply the treasure sum by the GCD multiplier

Choose the richest collection

Select the collection with maximum treasure × multiplier value

Key Takeaway

🎯 Key Insight: Elements with higher common factors can produce better results even with smaller sums, so we should prioritize subarrays where elements share meaningful divisors rather than just focusing on maximum sum.

Time & Space Complexity

Time Complexity

⏱️

O(n × d × log n)

Where d is the number of distinct divisors, n log n for sorting/searching within each group

⚡ Linearithmic

Space Complexity

O(n × d)

Space to store elements grouped by their divisors

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ k ≤ nums.length
-10⁹ ≤ nums[i] ≤ 10⁹
At least one valid subarray must exist

Asked in

G Google 42 ⊞ Microsoft 38 a Amazon 35 f Meta 28

The optimal approach uses GCD-based grouping where we group array elements by their possible GCD values and search within each group. For arrays with many common factors, this significantly reduces the search space compared to checking all subarrays. The key insight is that there are limited possible GCD values, and we can focus our search on subarrays where elements share meaningful common divisors.

Common Approaches

Approach	Time	Space	Notes
✓ GCD-Based Grouping with Binary Search	O(n × d × log n)	O(n × d)	Group elements by possible GCD values and use binary search to find optimal subarrays
Brute Force (Check All Subarrays)	O(n³ log(max))	O(1)	Check every possible subarray of length k or more and calculate GCD-sum for each

GCD-Based Grouping with Binary Search — Algorithm Steps

Find all possible GCD values by collecting divisors of array elements
For each possible GCD value, identify elements that are divisible by it
Use sliding window or binary search to find the best subarray of length ≥ k
Calculate GCD-sum for each candidate and track the maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Find all divisors

For each element, find all its divisors

Group by GCD

Group element indices by potential GCD values

Search within groups

For each GCD group, find optimal subarrays

Calculate results

Compute GCD-sum for promising candidates

Code -

solution.c — C

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

long long gcd(long long a, long long b) {
    while (b != 0) {
        long long temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

long long gcdOfArray(int* arr, int size) {
    long long result = abs(arr[0]);
    for (int i = 1; i < size; i++) {
        result = gcd(result, abs(arr[i]));
    }
    return result;
}

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

long long maxGcdSum(int* nums, int n, int k) {
    // Simplified version - using brute force approach
    // Full implementation would require dynamic data structures
    long long maxGcdSum = 0;
    
    for (int i = 0; i <= n - k; i++) {
        long long currentSum = 0;
        for (int j = i; j < n; j++) {
            currentSum += nums[j];
            if (j - i + 1 >= k) {
                long long currentGcd = gcdOfArray(nums + i, j - i + 1);
                long long gcdSum = currentSum * currentGcd;
                if (gcdSum > maxGcdSum) {
                    maxGcdSum = gcdSum;
                }
            }
        }
    }
    
    return maxGcdSum;
}

int main() {
    int nums[] = {6, 10, 3};
    int n = 3, k = 2;
    printf("%lld\n", maxGcdSum(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × d × log n)

Where d is the number of distinct divisors, n log n for sorting/searching within each group

⚡ Linearithmic

Space Complexity

O(n × d)

Space to store elements grouped by their divisors

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ k ≤ nums.length
-10⁹ ≤ nums[i] ≤ 10⁹
At least one valid subarray must exist

36.9K Views

Medium-High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

GCD-Based Grouping with Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler