Greatest Sum Divisible by Three - Practice Coding Problems

Greatest Sum Divisible by Three - Problem

You're given an array of integers and need to find the maximum possible sum of elements that is divisible by 3.

The key insight is that you don't need to use all elements - you want to select a subset that gives you the largest sum while ensuring the total is divisible by 3.

Example: For array [3,6,5,1,8], you could take 3+6+5+1 = 15 (divisible by 3) or 3+6 = 9 (also divisible by 3). The maximum is 15.

Remember: A number is divisible by 3 if the sum of its digits is divisible by 3. This property extends to sums of numbers too!

Input & Output

example_1.py — Basic Case

$ Input: [3,6,5,1,8]

› Output: 18

💡 Note: We can select elements [3,6,8,1] to get sum = 18, which is divisible by 3. This is the maximum possible.

example_2.py — All Divisible

$ Input: [4]

› Output: 0

💡 Note: Since 4 % 3 = 1, we cannot form any sum divisible by 3 using this element, so we return 0.

example_3.py — Multiple Options

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

› Output: 12

💡 Note: We can select [3,4,4,1] to get sum = 12, which is divisible by 3. Other combinations like [3] give smaller sums.

Constraints

1 ≤ nums.length ≤ 4 × 10⁴
0 ≤ nums[i] ≤ 10⁴
The array can contain zeros
At minimum, we can always return 0 (empty subset)

Visualization

Tap to expand

Understanding the Visualization

Initialize Buckets

Bucket 0 starts with 0 (empty sum), others start empty

Process Numbers

For each number, see which bucket it would land in when added to existing sums

Update Buckets

Update each bucket with the maximum possible sum for that remainder

Get Result

The answer is the value in bucket 0

Key Takeaway

🎯 Key Insight: By tracking the maximum sum for each remainder (0, 1, 2), we can efficiently build the optimal solution without generating all possible subsets.

Asked in

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

The optimal approach uses dynamic programming with modular arithmetic. We track the maximum sum for each possible remainder (0, 1, 2) when divided by 3. For each number, we update our DP states by considering what happens when we add this number to existing sums. The answer is stored in dp[0] - the maximum sum with remainder 0.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Track maximum sums for each remainder (0, 1, 2) modulo 3
Brute Force (Generate All Subsets)	O(2^n)	O(1)	Generate all possible subsets and find the maximum sum divisible by 3

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP array: dp[0]=0, dp[1]=-infinity, dp[2]=-infinity
For each number, calculate what happens when we add it to each remainder state
Update DP array with the maximum sums for each remainder
Return dp[0] which contains the maximum sum with remainder 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

dp[0]=0, dp[1]=-∞, dp[2]=-∞

Process Each Number

For each number, update all possible remainder states

State Transition

new_remainder = (old_sum + num) % 3

Update Maximum

Keep the maximum sum for each remainder

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int maxSumDivThree(int* nums, int numsSize) {
    // dp[i] represents the maximum sum with remainder i when divided by 3
    int dp[3] = {0, INT_MIN, INT_MIN};
    
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i];
        // Create a copy to avoid modifying during iteration
        int temp[3];
        for (int j = 0; j < 3; j++) {
            temp[j] = dp[j];
        }
        
        for (int remainder = 0; remainder < 3; remainder++) {
            if (dp[remainder] != INT_MIN) {
                int newRemainder = (dp[remainder] + num) % 3;
                temp[newRemainder] = max(temp[newRemainder], dp[remainder] + num);
            }
        }
        
        for (int j = 0; j < 3; j++) {
            dp[j] = temp[j];
        }
    }
    
    return dp[0];
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input [1,2,3] format
    int nums[100];
    int size = 0;
    char* token = strtok(input, "[,]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", maxSumDivThree(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the array once, doing constant work for each element

✓ Linear Growth

Space Complexity

O(1)

Only using a constant-size DP array of length 3

✓ Linear Space

42.4K Views

Medium-High Frequency

~18 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler