Maximum Split of Positive Even Integers

Maximum Split of Positive Even Integers - Problem

You are given an integer finalSum. Split it into a sum of a maximum number of unique positive even integers.

For example, given finalSum = 12, the following splits are valid (unique positive even integers summing up to finalSum): (12), (2 + 10), (2 + 4 + 6), and (4 + 8). Among them, (2 + 4 + 6) contains the maximum number of integers. Note that finalSum cannot be split into (2 + 2 + 4 + 4) as all the numbers should be unique.

Return a list of integers that represent a valid split containing a maximum number of integers. If no valid split exists for finalSum, return an empty list. You may return the integers in any order.

Input & Output

Example 1 — Basic Case

$ Input: finalSum = 12

› Output: [2,4,6]

💡 Note: We can split 12 into 2+4+6=12. This gives us 3 unique even integers, which is maximum possible. Other valid splits like (12) or (2,10) have fewer integers.

Example 2 — Small Sum

$ Input: finalSum = 7

› Output: []

💡 Note: Since 7 is odd, it cannot be expressed as a sum of even integers. Return empty array.

Example 3 — Single Number

$ Input: finalSum = 28

› Output: [2,4,6,16]

💡 Note: Start with 2,4,6,8,10... but 2+4+6+8+10=30>28. So we use [2,4,6] and remaining 28-12=16, giving [2,4,6,16].

Constraints

1 ≤ finalSum ≤ 10¹⁰

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use a greedy approach starting with the smallest even numbers (2, 4, 6, 8...) to maximize the count. The optimal approach is the greedy method with O(√n) time complexity and O(√n) space.

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^n) Space: O(2^n)

Try every possible subset of even numbers up to finalSum and find the one with maximum length that sums to the target. This involves checking exponentially many combinations.

Greedy - Sequential Even Numbers

⏱️ Time: O(√n) Space: O(√n)

Use a greedy approach by taking consecutive even numbers starting from 2. If we overshoot, adjust the last number to make the sum exact. This maximizes the count since we use the smallest possible numbers first.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible even numbers up to finalSum
Try all subsets of these numbers
Check which subsets sum to finalSum
Return the longest valid subset

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Evens

Create all even numbers up to finalSum

Try Subsets

Check all 2^n possible combinations

Find Maximum

Return the longest valid combination

Code -

solution.c — C

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

int contains(int* arr, int size, int item) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == item) {
            return 1;
        }
    }
    return 0;
}

void removeItem(int* arr, int* size, int item) {
    for (int i = 0; i < *size; i++) {
        if (arr[i] == item) {
            for (int j = i; j < *size - 1; j++) {
                arr[j] = arr[j + 1];
            }
            (*size)--;
            break;
        }
    }
}

int* solution(int finalSum, int* returnSize) {
    *returnSize = 0;
    if (finalSum % 2 == 1) {
        return NULL;
    }
    
    // Greedy approach: start with consecutive even numbers
    int* result = (int*)malloc(1000 * sizeof(int));
    int current_sum = 0;
    int current_even = 2;
    
    // Keep adding consecutive even numbers while we can
    while (current_sum + current_even < finalSum) {
        result[*returnSize] = current_even;
        (*returnSize)++;
        current_sum += current_even;
        current_even += 2;
    }
    
    // Add the remaining amount as the last number
    int remaining = finalSum - current_sum;
    if (remaining > 0 && remaining % 2 == 0 && !contains(result, *returnSize, remaining)) {
        result[*returnSize] = remaining;
        (*returnSize)++;
        return result;
    }
    
    // If remaining is already in result, we need to adjust
    if (remaining > 0 && contains(result, *returnSize, remaining)) {
        // Remove the conflicting number and add it to remaining
        removeItem(result, returnSize, remaining);
        remaining += remaining;
        result[*returnSize] = remaining;
        (*returnSize)++;
        return result;
    }
    
    free(result);
    return NULL;
}

int main() {
    int finalSum;
    scanf("%d", &finalSum);
    
    int returnSize;
    int* result = solution(finalSum, &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(2^n)

Need to check all 2^n subsets where n is finalSum/2 (number of even integers)

⚠ Quadratic Growth

Space Complexity

O(2^n)

Store all possible subsets during generation

⚠ Quadratic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

842 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler