Find Palindrome With Fixed Length - Practice Coding Problems

Find Palindrome With Fixed Length - Problem

Array Math Medium

Imagine you're building a special number generator that creates palindromic numbers - numbers that read the same forwards and backwards, like 121 or 12321.

Given an array of queries and a fixed intLength, you need to find the k-th smallest palindrome of exactly intLength digits for each query k.

Key Rules:

Palindromes cannot have leading zeros (so 010 is invalid)
If the k-th palindrome doesn't exist, return -1
Each query asks for a different position in the sequence of valid palindromes

Example: For length 3, valid palindromes are: 101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, ...

Input & Output

example_1.py — Basic Query

$ Input: queries = [1, 2, 3, 4, 90, 91], intLength = 3

› Output: [101, 111, 121, 131, 191, 202]

💡 Note: For 3-digit palindromes: 1st=101, 2nd=111, 3rd=121, 4th=131, 90th=191, 91st=202. All queries have valid palindromes.

example_2.py — Invalid Query

$ Input: queries = [2, 4, 6], intLength = 4

› Output: [1001, 1111, 1221]

💡 Note: For 4-digit palindromes: 1st=1001, 2nd=1001, 3rd=1111, 4th=1111, 5th=1221, 6th=1221. The 2nd, 4th, and 6th palindromes are valid.

example_3.py — Edge Case

$ Input: queries = [1, 2, 3, 4, 5, 90], intLength = 1

› Output: [1, 2, 3, 4, 5, -1]

💡 Note: Single-digit palindromes are 1,2,3,4,5,6,7,8,9. Only 9 exist, so query 90 returns -1.

Constraints

1 ≤ queries.length ≤ 5 × 10⁴
1 ≤ queries[i] ≤ 10⁹
1 ≤ intLength ≤ 15
Palindromes cannot have leading zeros

Visualization

Tap to expand

Understanding the Visualization

Setup Production Line

Calculate total capacity: for length 3, we can make 90 palindromes (first half: 10-99)

Find Template Number

For k-th palindrome, calculate first half: start + (k-1)

Apply Mirror Process

Create full palindrome by mirroring the first half

Quality Check

Verify no leading zeros and correct length

Key Takeaway

🎯 Key Insight: Since palindromes are symmetric, we only need to determine the first half - the factory can automatically mirror it to create the complete palindrome in constant time!

Asked in

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

The optimal approach uses mathematical insight: palindromes are determined by their first half. Calculate the total possible palindromes, then directly compute the k-th palindrome by finding its first half and mirroring it. This achieves O(1) time per query with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Generate and Check	O(q * k * d)	O(d)	Generate palindromes sequentially until we reach the k-th one
Mathematical Direct Calculation	O(q * d)	O(1)	Use mathematical insights to directly calculate the k-th palindrome

Generate and Check — Algorithm Steps

For each query k, start generating palindromes from the smallest possible
For each potential first half, create the full palindrome by mirroring
Check if the palindrome has the correct length and no leading zeros
Count valid palindromes until we reach the k-th one
Return the k-th palindrome or -1 if it doesn't exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Generation

Begin with smallest possible first half

Mirror Creation

Create palindrome by mirroring the first half

Count Progress

Count until reaching the k-th palindrome

Code -

solution.c — C

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

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

long long* kthPalindrome(int* queries, int queriesSize, int intLength, int* returnSize) {
    long long* result = (long long*)malloc(queriesSize * sizeof(long long));
    *returnSize = queriesSize;
    
    int halfLen = (intLength + 1) / 2;
    long long start = (long long)pow(10, halfLen - 1);
    long long end = (long long)pow(10, halfLen);
    long long totalPalindromes = end - start;
    
    for (int i = 0; i < queriesSize; i++) {
        if (queries[i] > totalPalindromes) {
            result[i] = -1;
        } else {
            long long num = start + queries[i] - 1;
            char s[20], palindrome[40];
            sprintf(s, "%lld", num);
            strcpy(palindrome, s);
            
            if (intLength % 2 == 0) {
                char temp[20];
                strcpy(temp, s);
                reverse_string(temp, strlen(temp));
                strcat(palindrome, temp);
            } else {
                char temp[20];
                strcpy(temp, s);
                temp[strlen(temp) - 1] = '\0';
                reverse_string(temp, strlen(temp));
                strcat(palindrome, temp);
            }
            
            result[i] = atoll(palindrome);
        }
    }
    
    return result;
}

int main() {
    int queries[1000];
    int queriesSize = 0;
    int intLength;
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " \n");
    while (token != NULL) {
        queries[queriesSize++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    scanf("%d", &intLength);
    
    int returnSize;
    long long* result = kthPalindrome(queries, queriesSize, intLength, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%lld", result[i]);
        if (i < returnSize - 1) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q * k * d)

q queries, up to k palindromes generated, d digits to construct each

✓ Linear Growth

Space Complexity

O(d)

Space to store the current palindrome being constructed

✓ Linear Space

42.2K Views

Medium-High Frequency

~18 min Avg. Time

1.5K 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

Generate and Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler