Largest Number - Practice Coding Problems

Largest Number - Problem

Imagine you have a collection of non-negative integers and you want to arrange them to form the largest possible number. This isn't as simple as sorting them in descending order! For example, given [3, 30, 34, 5, 9], the largest number isn't "93453430" but actually "9534330". The trick is determining which number should come first when two numbers could be concatenated in different orders. Your task is to arrange the numbers optimally and return the result as a string (since the number might be too large for standard integer types).

Input & Output

example_1.py — Standard Case

$ Input: [10, 2]

› Output: "210"

💡 Note: Comparing concatenations: '10'+'2'='102' vs '2'+'10'='210'. Since '210' > '102', we put '2' first, giving us '210'.

example_2.py — Multiple Digits

$ Input: [3, 30, 34, 5, 9]

› Output: "9534330"

💡 Note: Using our custom comparator: '9' comes first (largest), then '5' (5+34=534 > 34+5=345), then '34' (34+3=343 > 3+34=334), then '3' (3+30=330 > 30+3=303), finally '30'.

example_3.py — All Zeros

$ Input: [0, 0, 0]

› Output: "0"

💡 Note: Edge case: when all numbers are 0, the result should be '0' (not '000'). We handle this by checking if the first character of our result is '0'.

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 10⁹
The result may be very large, so return it as a string
All numbers are non-negative integers

Visualization

Tap to expand

Understanding the Visualization

Convert to Comparable Format

Transform all numbers to strings so we can easily concatenate and compare them

Define Team Chemistry

For any two numbers x and y, determine their order by checking if xy produces a larger number than yx

Sort Using Team Chemistry

Apply this comparison rule to sort all numbers, ensuring optimal positioning

Assemble the Final Team

Concatenate all sorted numbers to form the largest possible result

Key Takeaway

🎯 Key Insight: The custom comparator xy > yx ensures that each local decision (which of two numbers comes first) contributes to the globally optimal solution, eliminating the need to check all permutations.

Asked in

G Google 45 a Amazon 38 f Meta 22 ⊞ Microsoft 31

The optimal solution uses custom sorting with a clever comparator. Instead of trying all permutations, we sort the numbers using the rule: for any two numbers x and y, x should come before y if the concatenation xy is greater than yx. This greedy approach ensures the largest possible number in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Permutations)	O(n! × n)	O(n! × n)	Generate all possible arrangements and find the maximum
Custom Sorting (Optimal)	O(n log n)	O(n)	Sort numbers using custom comparator based on concatenation

Brute Force (All Permutations) — Algorithm Steps

Generate all possible permutations of the input array
For each permutation, concatenate numbers to form a string
Keep track of the maximum string found so far
Return the maximum string

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements: [3,30,34] → [3,30,34], [3,34,30], [30,3,34], etc.

Concatenate Each

Convert each permutation to string: [3,30,34] → '33034', [3,34,30] → '33430'

Find Maximum

Compare all strings lexicographically to find the largest

Code -

solution.c — C

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void permute(int* nums, int size, int start, char* maxResult) {
    if (start == size) {
        char current[1000] = "";
        for (int i = 0; i < size; i++) {
            char temp[20];
            sprintf(temp, "%d", nums[i]);
            strcat(current, temp);
        }
        if (strcmp(current, maxResult) > 0) {
            strcpy(maxResult, current);
        }
        return;
    }
    
    for (int i = start; i < size; i++) {
        swap(&nums[start], &nums[i]);
        permute(nums, size, start + 1, maxResult);
        swap(&nums[start], &nums[i]);
    }
}

char* largestNumber(int* nums, int numsSize) {
    if (numsSize == 0) {
        char* result = malloc(2);
        strcpy(result, "0");
        return result;
    }
    
    // Check if all zeros
    int allZero = 1;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] != 0) {
            allZero = 0;
            break;
        }
    }
    
    char* result = malloc(1000);
    if (allZero) {
        strcpy(result, "0");
        return result;
    }
    
    strcpy(result, "0");
    permute(nums, numsSize, 0, result);
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse input
    int nums[100];
    int count = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    char* result = largestNumber(nums, count);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to concatenate and compare

⚠ Quadratic Growth

Space Complexity

O(n! × n)

Storing all permutations, each of length n

⚠ Quadratic Space

89.0K Views

Medium-High Frequency

~25 min Avg. Time

2.9K 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 (All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler