Largest Palindromic Number - Practice Coding Problems

Largest Palindromic Number - Problem

Given a string num consisting of digits only, your task is to construct the largest possible palindromic integer using the available digits.

A palindrome reads the same forwards and backwards (like 121, 9339, or 7). You want to create the numerically largest palindrome possible.

Key Rules:

You can reorder the digits however you want
You don't need to use all digits, but must use at least one
No leading zeros allowed (except for the single digit "0")

Examples:

Input: "432" → Output: "343" (largest palindrome using available digits)
Input: "10" → Output: "1" (can't have leading zero, so just use "1")
Input: "00009" → Output: "9" (avoid leading zeros)

Input & Output

example_1.py — Basic Case

$ Input: num = "432"

› Output: "343"

💡 Note: We can form palindromes: "4", "3", "2", "343". The largest is "343" using digits 4, 3, 4 (we use 3 in center and 4s on sides).

example_2.py — Leading Zero Case

$ Input: num = "10"

› Output: "1"

💡 Note: Possible palindromes: "1", "0". We cannot form "10" or "01" as palindromes. The largest valid palindrome is "1".

example_3.py — Multiple Zeros

$ Input: num = "00009"

› Output: "9"

💡 Note: We could form "90009" but this has leading zeros. Valid options are "9", "0". The largest is "9".

Constraints

1 ≤ num.length ≤ 10⁵
num consists of only digits
Must use at least one digit
No leading zeros allowed (except single digit "0")

Visualization

Tap to expand

Understanding the Visualization

Count Your Tiles

Count how many of each digit tile you have available

Place Pairs Strategically

Start with largest digits, place pairs symmetrically from outside edges

Choose Center Piece

Pick the largest remaining digit for the center position

Handle Special Cases

Avoid leading zeros - if result would start with 0, return largest single digit

Key Takeaway

🎯 Key Insight: Palindromes have symmetric structure - we can build them greedily by placing the largest digit pairs first from outside-in, then handling the center and edge cases!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a greedy counting approach: count digit frequencies, build the palindrome by placing largest digits first in pairs from outside-in, handle the center digit, and manage edge cases like leading zeros. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Counting (Optimal)	O(n)	O(1)	Count digit frequencies and greedily build the largest palindrome
Brute Force (Generate All Combinations)	O(2^n * n! * n)	O(n)	Generate all possible digit combinations and find the largest valid palindrome

Greedy Counting (Optimal) — Algorithm Steps

Count frequency of each digit (0-9)
Build left half by placing largest digits first (9→0)
For each digit, use pairs and place half on the left side
Find the largest digit with odd count for the center
Handle leading zeros: if result would start with 0, return largest single digit
Construct final palindrome: left + center + reverse(left)

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count: 4→1, 3→1, 2→1. All digits appear once.

Build Left Half

Process 9→0: pairs of 4(0), 3(0), 2(0). Left half empty.

Choose Center

Pick largest odd-count digit: 4 (since all have count=1)

Handle Edge Case

Left empty, so return largest available single digit: "4"

Code -

solution.c — C

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

void reverseString(char* str) {
    int len = strlen(str);
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }
}

char* largestPalindrome(const char* num) {
    static char result[1000];
    
    // Count frequency of each digit
    int count[10] = {0};
    int len = strlen(num);
    
    for (int i = 0; i < len; i++) {
        count[num[i] - '0']++;
    }
    
    // Build the left half of palindrome (largest digits first)
    char left[500] = "";
    char center[2] = "";
    int leftPos = 0;
    
    // Process digits from 9 to 0 (largest first)
    for (int digit = 9; digit >= 0; digit--) {
        // Use pairs for the sides
        int pairs = count[digit] / 2;
        for (int i = 0; i < pairs; i++) {
            left[leftPos++] = '0' + digit;
        }
        
        // If we don't have a center digit and this digit has odd count
        if (center[0] == '\0' && count[digit] % 2 == 1) {
            center[0] = '0' + digit;
            center[1] = '\0';
        }
    }
    left[leftPos] = '\0';
    
    // Handle edge cases
    // If left part is empty or starts with 0
    if (strlen(left) == 0 || left[0] == '0') {
        // Return the largest single digit available
        for (int digit = 9; digit >= 0; digit--) {
            if (count[digit] > 0) {
                sprintf(result, "%d", digit);
                return result;
            }
        }
        strcpy(result, "0");
        return result;
    }
    
    // Build the palindrome
    strcpy(result, left);
    strcat(result, center);
    
    char rightHalf[500];
    strcpy(rightHalf, left);
    reverseString(rightHalf);
    strcat(result, rightHalf);
    
    return result;
}

int main() {
    char num[1000];
    fgets(num, sizeof(num), stdin);
    
    // Remove newline and quotes
    num[strcspn(num, "\n")] = '\0';
    if (num[0] == '"') {
        memmove(num, num + 1, strlen(num));
        if (num[strlen(num) - 1] == '"') {
            num[strlen(num) - 1] = '\0';
        }
    }
    
    printf("\"%s\"\n", largestPalindrome(num));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count digits + O(10) to build result = O(n)

✓ Linear Growth

Space Complexity

O(1)

Fixed-size array for digit counts (size 10) regardless of input

✓ Linear Space

23.4K Views

Medium Frequency

~18 min Avg. Time

892 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 Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler