Find the Closest Palindrome - Practice Coding Problems

Find the Closest Palindrome - Problem

Math String Hard

You're given a string n representing a positive integer, and your task is to find the closest palindromic number to it (excluding the number itself).

A palindrome reads the same forwards and backwards, like 121, 1331, or 9. The "closest" palindrome is the one with the minimum absolute difference from the original number.

Special case: If there are two palindromes with the same distance (a tie), return the smaller one.

Examples:

n = "123" → return "121" (difference of 2)
n = "1" → return "0" (closest smaller palindrome)
n = "99" → return "101" (next palindrome is closer than 88)

Input & Output

example_1.py — Basic Case

$ Input: n = "123"

› Output: "121"

💡 Note: The closest palindromes are 121 (difference of 2) and 131 (difference of 8). Since 121 is closer, we return "121".

example_2.py — Single Digit

$ Input: n = "1"

› Output: "0"

💡 Note: For single digit numbers, the closest smaller palindrome is n-1. So for "1", the answer is "0".

example_3.py — Edge Case

$ Input: n = "99"

› Output: "101"

💡 Note: The candidates are: 88 (diff=11) and 101 (diff=2). Since 101 is much closer, we return "101".

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Palindromes are symmetric - we only need to focus on the left half

Generate Smart Candidates

Create 5 strategic candidates based on mathematical properties

Handle Edge Cases

Special patterns like 999→1001 and 100→99 need special handling

Choose Optimal

Select the candidate with minimum difference (prefer smaller if tied)

Key Takeaway

🎯 Key Insight: Instead of checking every number, generate only 5 mathematically optimal candidates based on palindrome structure properties.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the length of the number string. We generate at most 5 candidates.

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for candidate generation

✓ Linear Space

Constraints

1 ≤ n.length ≤ 18
n consists of only digits
n does not have leading zeros
n is representing an integer in the range [1, 10¹⁸ - 1]

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 23

The optimal solution uses mathematical construction to generate only 5 candidate palindromes: mirror the left half, mirror left half ±1, and two edge cases (999...9 and 100...01). This avoids checking every possible number and achieves O(n) time complexity where n is the string length.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Construction (Optimal)	O(n)	O(1)	Generate only the 5 most promising palindrome candidates using mathematical properties

Mathematical Construction (Optimal) — Algorithm Steps

Handle single digit edge case (return n-1 or n+1)
Split number into left and right halves
Generate candidate 1: mirror left half to right
Generate candidate 2: increment left half, then mirror
Generate candidate 3: decrement left half, then mirror
Add edge case candidates: 999...9 and 100...01
Filter out the original number and return closest

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Input

Divide number into left and right halves

Mirror Current

Create palindrome by mirroring left half

Mirror +1

Increment left half, then mirror

Mirror -1

Decrement left half, then mirror

Edge Cases

Add 999...9 and 100...01 patterns

Code -

solution.c — C

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

char* createPalindrome(char* prefix, int isOdd, char* result) {
    strcpy(result, prefix);
    int len = strlen(prefix);
    int start = isOdd ? len - 2 : len - 1;
    int pos = len;
    for (int i = start; i >= 0; i--) {
        result[pos++] = prefix[i];
    }
    result[pos] = '\0';
    return result;
}

char* nearestPalindromic(char* n) {
    int length = strlen(n);
    long long num = atoll(n);
    
    // Edge case: single digit
    if (length == 1) {
        char* result = malloc(20);
        sprintf(result, "%lld", num - 1);
        return result;
    }
    
    char candidates[5][20];
    int candidateCount = 0;
    
    // Candidate 1: smaller palindrome (999...9)
    for (int i = 0; i < length - 1; i++) {
        candidates[candidateCount][i] = '9';
    }
    candidates[candidateCount][length - 1] = '\0';
    candidateCount++;
    
    // Candidate 2: larger palindrome (100...001)
    candidates[candidateCount][0] = '1';
    for (int i = 1; i < length; i++) {
        candidates[candidateCount][i] = '0';
    }
    candidates[candidateCount][length] = '1';
    candidates[candidateCount][length + 1] = '\0';
    candidateCount++;
    
    // Get the first half of the number
    int isOdd = length % 2;
    int mid = (length + 1) / 2;
    char prefix[20];
    strncpy(prefix, n, mid);
    prefix[mid] = '\0';
    
    // Candidate 3: mirror the current prefix
    createPalindrome(prefix, isOdd, candidates[candidateCount]);
    candidateCount++;
    
    // Candidate 4: increment prefix and mirror
    long long prefixNum = atoll(prefix);
    sprintf(prefix, "%lld", prefixNum + 1);
    if (strlen(prefix) == mid) {
        createPalindrome(prefix, isOdd, candidates[candidateCount]);
        candidateCount++;
    }
    
    // Candidate 5: decrement prefix and mirror
    sprintf(prefix, "%lld", prefixNum - 1);
    if (strlen(prefix) == mid) {
        createPalindrome(prefix, isOdd, candidates[candidateCount]);
        candidateCount++;
    }
    
    // Find the closest palindrome
    char* result = malloc(20);
    long long minDiff = LLONG_MAX;
    
    for (int i = 0; i < candidateCount; i++) {
        if (strcmp(candidates[i], n) == 0) continue;
        
        long long candidateNum = atoll(candidates[i]);
        long long diff = llabs(candidateNum - num);
        
        if (diff < minDiff || (diff == minDiff && candidateNum < atoll(result))) {
            minDiff = diff;
            strcpy(result, candidates[i]);
        }
    }
    
    return result;
}

int main() {
    char n[20];
    scanf("%s", n);
    if (n[0] == '"') {
        int len = strlen(n);
        memmove(n, n + 1, len - 2);
        n[len - 2] = '\0';
    }
    printf("%s\n", nearestPalindromic(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Where n is the length of the number string. We generate at most 5 candidates.

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for candidate generation

✓ Linear Space

Constraints

1 ≤ n.length ≤ 18
n consists of only digits
n does not have leading zeros
n is representing an integer in the range [1, 10¹⁸ - 1]

28.4K Views

Medium Frequency

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Mathematical Construction (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler