Largest Multiple of Three

Largest Multiple of Three - Problem

Given an array of digits digits, return the largest multiple of three that can be formed by concatenating some of the given digits in any order.

If there is no answer, return an empty string.

Note: The answer may not fit in an integer data type, so return the answer as a string. The returning answer must not contain unnecessary leading zeros.

Input & Output

Example 1 — Basic Case

$ Input: digits = [8,1,9]

› Output: 981

💡 Note: Sum = 8+1+9 = 18, which is divisible by 3. Use all digits arranged in descending order to get the largest number: 981.

Example 2 — Need to Remove Digits

$ Input: digits = [8,6,7,1,0]

› Output: 8760

💡 Note: Sum = 22, remainder = 1. Remove the smallest digit with remainder 1 (which is 1). Remaining digits [8,6,7,0] sum to 21, divisible by 3. Result: 8760.

Example 3 — All Zeros Case

$ Input: digits = [0,0,0]

› Output: 0

💡 Note: Sum = 0, divisible by 3. All digits are zero, so return single '0' to avoid leading zeros.

Constraints

1 ≤ digits.length ≤ 10⁴
0 ≤ digits[i] ≤ 9

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 Apple 25

The key insight is that a number is divisible by 3 if and only if the sum of its digits is divisible by 3. The optimal greedy approach counts digit frequencies, strategically removes minimal digits to achieve divisibility by 3, then arranges remaining digits in descending order. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ × n! × n) Space: O(2ⁿ × n)

Generate all possible subsets of digits, form numbers from each subset, check divisibility by 3, and keep track of the maximum. This approach considers every possible combination but is extremely inefficient for larger inputs.

Greedy - Mathematical Approach

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

Use the mathematical property that a number is divisible by 3 if the sum of its digits is divisible by 3. Count digit frequencies, calculate total sum, and strategically remove minimal digits to make sum divisible by 3, then arrange remaining digits in descending order.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible subsets of digits
For each subset, try all permutations to form numbers
Check if each number is divisible by 3
Track the maximum valid number

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all possible subsets of digits

Try Permutations

For each subset, try all arrangements

Check Divisibility

Test if sum of digits is divisible by 3

Track Maximum

Keep the largest valid number found

Code -

solution.c — C

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

char* solution(int* digits, int digitsSize) {
    if (digitsSize == 0) {
        char* result = (char*)malloc(1);
        result[0] = '\0';
        return result;
    }
    
    char* maxResult = (char*)malloc(1000);
    maxResult[0] = '\0';
    
    // Try all possible subsets (simplified version)
    for (int mask = 1; mask < (1 << digitsSize); mask++) {
        int subset[20];
        int subsetSize = 0;
        int sum = 0;
        
        for (int i = 0; i < digitsSize; i++) {
            if (mask & (1 << i)) {
                subset[subsetSize++] = digits[i];
                sum += digits[i];
            }
        }
        
        if (sum % 3 == 0) {
            // Sort in descending order for largest number
            for (int i = 0; i < subsetSize - 1; i++) {
                for (int j = i + 1; j < subsetSize; j++) {
                    if (subset[i] < subset[j]) {
                        int temp = subset[i];
                        subset[i] = subset[j];
                        subset[j] = temp;
                    }
                }
            }
            
            char numStr[1000] = "";
            for (int i = 0; i < subsetSize; i++) {
                char digit[2];
                sprintf(digit, "%d", subset[i]);
                strcat(numStr, digit);
            }
            
            // Skip if leading zeros (except "0")
            if (strlen(numStr) > 1 && numStr[0] == '0') continue;
            
            if (strlen(maxResult) == 0 || strlen(numStr) > strlen(maxResult) ||
                (strlen(numStr) == strlen(maxResult) && strcmp(numStr, maxResult) > 0)) {
                strcpy(maxResult, numStr);
            }
        }
    }
    
    return maxResult;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [1,2,3] format
    int digits[100];
    int digitsSize = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token) {
            digits[digitsSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    char* result = solution(digits, digitsSize);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n! × n)

2^n subsets, each with n! permutations, n digits to process

⚠ Quadratic Growth

Space Complexity

O(2ⁿ × n)

Store all possible number combinations

⚡ Linearithmic Space

42.0K Views

Medium Frequency

~25 min Avg. Time

894 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