Largest Palindromic Number

Largest Palindromic Number - Problem

You are given a string num consisting of digits only.

Return the largest palindromic integer (in the form of a string) that can be formed using digits taken from num. It should not contain leading zeroes.

Notes:

You do not need to use all the digits of num, but you must use at least one digit.
The digits can be reordered.

Input & Output

Example 1 — Basic Case

$ Input: num = "432"

› Output: "4"

💡 Note: We can form palindromes: "4", "3", "2". The largest is "4".

Example 2 — Multiple Digits

$ Input: num = "432132"

› Output: "432234"

💡 Note: Count: 4×1, 3×2, 2×2, 1×1. Build first half with pairs: "43", middle: "2", result: "432" + "2" + "234" = "432234".

Example 3 — Leading Zero Edge Case

$ Input: num = "10"

› Output: "1"

💡 Note: Cannot form "101" due to no leading zeros rule. Best palindrome using available digits is "1".

Constraints

1 ≤ num.length ≤ 10⁵
num consists of digits only

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 15 M Microsoft 12

The key insight is that palindromes are symmetric, so we can build the largest one by greedily placing the biggest available digits on the outside. The optimal approach uses frequency counting with careful edge case handling for leading zeros. Time: O(n), Space: O(1).

Common Approaches

✓ Stack

⏱️ Time: N/A Space: N/A

Brute Force - Generate All Combinations

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

Try every possible way to arrange the available digits, check if each arrangement forms a palindrome, and return the largest valid one.

Frequency Count with Greedy Construction

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

Count how many times each digit appears, then build the palindrome by placing the largest digits on the outside working inward, with at most one odd-count digit in the middle.

Optimized Greedy with Edge Case Handling

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

Improved version that handles all edge cases efficiently, including the tricky scenario where using all digits would create leading zeros, requiring us to use only the middle digit.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

void replaceAll(char* str, const char* from, const char* to) {
    char* pos = str;
    int fromLen = strlen(from);
    int toLen = strlen(to);
    
    while ((pos = strstr(pos, from)) != NULL) {
        memmove(pos + toLen, pos + fromLen, strlen(pos + fromLen) + 1);
        memcpy(pos, to, toLen);
        pos += toLen;
    }
}

int solution(char* input) {
    if (strlen(input) == 0) return 0;
    
    // Convert escaped characters to actual characters
    replaceAll(input, "\\n", "\n");
    replaceAll(input, "\\t", "\t");
    
    char lines[100][256];
    int numLines = 0;
    int stack[50];
    int stackSize = 0;
    int maxLength = 0;
    
    char* token = strtok(input, "\n");
    while (token != NULL && numLines < 100) {
        strcpy(lines[numLines], token);
        numLines++;
        token = strtok(NULL, "\n");
    }
    
    for (int i = 0; i < numLines; i++) {
        char* line = lines[i];
        int depth = 0;
        while (depth < strlen(line) && line[depth] == '\t') {
            depth++;
        }
        
        char* name = line + depth;
        
        // Adjust stack size to current depth
        while (stackSize > depth) {
            stackSize--;
        }
        
        // Calculate current path length
        int currentLength = strlen(name) + stackSize;
        for (int j = 0; j < stackSize; j++) {
            currentLength += stack[j];
        }
        
        if (strstr(name, ".")) {
            if (currentLength > maxLength) {
                maxLength = currentLength;
            }
        } else {
            stack[stackSize] = strlen(name);
            stackSize++;
        }
    }
    
    return maxLength;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    // Remove quotes if present
    int len = strlen(input);
    if (len >= 2 && input[0] == '"' && input[len-1] == '"') {
        memmove(input, input + 1, len - 1);
        input[len - 2] = '\0';
    }
    
    printf("%d\n", solution(input));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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