Largest Multiple of Three - Practice Coding Problems

Largest Multiple of Three - Problem

The Challenge: Building the Largest Multiple of Three

You're given an array of single digits (0-9) and need to construct the largest possible number that is divisible by 3 using any subset of these digits.

🎯 Goal: Form the largest multiple of 3 by concatenating digits in any order
📥 Input: Array of digits [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
📤 Output: String representing the largest multiple of 3 (or empty string if impossible)

Key Rules:
• Use any subset of the given digits
• Arrange them to form the largest possible number
• Result must be divisible by 3
• No leading zeros (except for "0")
• Return as string to handle large numbers

Example: For digits [8, 1, 9], you can form "981" (9+8+1=18, divisible by 3)

Input & Output

example_1.py — Basic Case

$ Input: [8,1,9]

› Output: "981"

💡 Note: The sum 8+1+9=18 is divisible by 3. Arranging in descending order gives us 981, which is the largest possible multiple of 3.

example_2.py — Need to Remove Digits

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

› Output: "8760"

💡 Note: Sum is 22, remainder is 1. We remove the smallest digit with remainder 1 (which is 1), leaving [8,6,7,0]. Arranging gives 8760.

example_3.py — All Zeros Case

$ Input: [0,0,0,0]

› Output: "0"

💡 Note: All digits are zero, so the largest (and only) multiple of 3 we can form is "0" (not "0000" to avoid leading zeros).

Constraints

1 ≤ digits.length ≤ 10⁴
0 ≤ digits[i] ≤ 9
The answer may not fit in a 32-bit integer, so return it as a string
No leading zeros in the result (except for the result "0")

Visualization

Tap to expand

Understanding the Visualization

Sort Coins by Type

Group your digit-coins by their remainder when divided by 3 (types 0, 1, and 2)

Check Total Value

Add up all coin values and see if the sum is divisible by 3

Remove Minimal Coins

If not divisible, remove the fewest, lowest-value coins to make it work

Arrange for Maximum

Sort remaining coins from highest to lowest value to maximize the final amount

Key Takeaway

🎯 Key Insight: Use the divisibility rule for 3 (sum of digits) combined with modular arithmetic to efficiently determine which digits to keep, then arrange them for maximum value.

Asked in

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

The optimal solution uses modular arithmetic and the divisibility rule for 3. Group digits by their remainder when divided by 3, then strategically remove the minimum number of smallest digits to make the sum divisible by 3. Finally, sort remaining digits in descending order to form the largest possible number. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Modular Arithmetic (Optimal)	O(n log n)	O(n)	Use divisibility rule for 3 and greedy selection based on digit remainders
Brute Force (Generate All Subsets)	O(2^n × n! × n)	O(2^n × n!)	Generate all possible subsets and arrangements, check divisibility by 3

Greedy with Modular Arithmetic (Optimal) — Algorithm Steps

Count digits by their remainder when divided by 3 (mod 0, 1, 2)
Calculate total sum of all digits
Determine what to remove based on sum % 3 to make it divisible by 3
Remove the minimum digits needed (prioritize smaller digits)
Sort remaining digits in descending order
Handle edge cases (all zeros, empty result)

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by Remainder

Separate digits by remainder when divided by 3

Calculate Total Sum

Find sum of all digits and its remainder mod 3

Remove Minimal Digits

Remove smallest digits to make sum divisible by 3

Sort Descending

Arrange remaining digits to form largest number

Code -

solution.c — C

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

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

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

char* largestMultipleOfThree(int* digits, int digitsSize) {
    // Count digits by their remainder when divided by 3
    int groups[3][1000];
    int groupSizes[3] = {0};
    int totalSum = 0;
    
    for (int i = 0; i < digitsSize; i++) {
        int remainder = digits[i] % 3;
        groups[remainder][groupSizes[remainder]++] = digits[i];
        totalSum += digits[i];
    }
    
    // Sort each group in ascending order
    for (int i = 0; i < 3; i++) {
        qsort(groups[i], groupSizes[i], sizeof(int), compare_asc);
    }
    
    int remainder = totalSum % 3;
    
    if (remainder == 1) {
        if (groupSizes[1] > 0) {
            for (int i = 0; i < groupSizes[1] - 1; i++) {
                groups[1][i] = groups[1][i + 1];
            }
            groupSizes[1]--;
        } else if (groupSizes[2] >= 2) {
            for (int i = 0; i < groupSizes[2] - 2; i++) {
                groups[2][i] = groups[2][i + 2];
            }
            groupSizes[2] -= 2;
        } else {
            char* empty = malloc(1);
            empty[0] = '\0';
            return empty;
        }
    } else if (remainder == 2) {
        if (groupSizes[2] > 0) {
            for (int i = 0; i < groupSizes[2] - 1; i++) {
                groups[2][i] = groups[2][i + 1];
            }
            groupSizes[2]--;
        } else if (groupSizes[1] >= 2) {
            for (int i = 0; i < groupSizes[1] - 2; i++) {
                groups[1][i] = groups[1][i + 2];
            }
            groupSizes[1] -= 2;
        } else {
            char* empty = malloc(1);
            empty[0] = '\0';
            return empty;
        }
    }
    
    // Collect all remaining digits
    int result[1000];
    int resultSize = 0;
    
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < groupSizes[i]; j++) {
            result[resultSize++] = groups[i][j];
        }
    }
    
    if (resultSize == 0) {
        char* empty = malloc(1);
        empty[0] = '\0';
        return empty;
    }
    
    // Sort in descending order
    qsort(result, resultSize, sizeof(int), compare_desc);
    
    // Handle all zeros case
    if (result[0] == 0) {
        char* zero = malloc(2);
        strcpy(zero, "0");
        return zero;
    }
    
    char* answer = malloc(resultSize + 1);
    answer[0] = '\0';
    
    for (int i = 0; i < resultSize; i++) {
        char digit[2];
        sprintf(digit, "%d", result[i]);
        strcat(answer, digit);
    }
    
    return answer;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int digits[1000];
    int count = 0;
    
    char* token = strtok(input, "[],\n ");
    while (token != NULL && count < 1000) {
        digits[count++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    char* result = largestMultipleOfThree(digits, count);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to group digits and calculate sums, O(n log n) for final sorting

⚡ Linearithmic

Space Complexity

O(n)

Storage for digit groups and result array

⚡ Linearithmic Space

68.2K Views

Medium-High Frequency

~25 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

Greedy with Modular Arithmetic (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler