Find Palindrome With Fixed Length

Find Palindrome With Fixed Length - Problem

Array Math Medium

Given an integer array queries and a positive integer intLength, return an array answer where answer[i] is either the queries[i]th smallest positive palindrome of length intLength or -1 if no such palindrome exists.

A palindrome is a number that reads the same backwards and forwards. Palindromes cannot have leading zeros.

Input & Output

Example 1 — Basic Case

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

› Output: [101,111,121,131,141,999]

💡 Note: For length 3: 1st palindrome is 101, 2nd is 111, 3rd is 121, etc. The 90th palindrome is 999.

Example 2 — Out of Range

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

› Output: [1001,1111,1221]

💡 Note: For length 4: palindromes are 1001, 1111, 1221, 1331, etc.

Example 3 — Single Digit

$ Input: queries = [1,2,3,4,5,6,7,8,9,10], intLength = 1

› Output: [1,2,3,4,5,6,7,8,9,-1]

💡 Note: For length 1: only 9 palindromes exist (1-9), so query 10 returns -1

Constraints

1 ≤ queries.length ≤ 5 × 10⁴
1 ≤ queries[i] ≤ 10⁹
1 ≤ intLength ≤ 15

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 M Microsoft 8

The key insight is that palindromes follow a mathematical pattern - we only need to generate the first half and mirror it. The optimal approach directly calculates the nth palindrome using: total_palindromes = 9 × 10^((length-1)/2), then find first_half = start + position - 1, and mirror appropriately. Time: O(q × L), Space: O(L)

Common Approaches

✓ Dp 2d

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

Optimized

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

Brute Force Generation

⏱️ Time: O(q × 10^(L/2)) Space: O(1)

For each query, generate palindromes in order starting from the smallest until we reach the queries[i]th palindrome. This involves checking each number to see if it forms a valid palindrome.

Mathematical Direct Calculation

⏱️ Time: O(q × L) Space: O(L)

Instead of generating palindromes one by one, we use the mathematical structure of palindromes. For a palindrome of length L, we only need to determine the first half, then mirror it to create the full palindrome.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

long long power10(int exp) {
    long long result = 1;
    for (int i = 0; i < exp; i++) {
        result *= 10;
    }
    return result;
}

long long kthPalindrome(int k, int intLength) {
    int halfLen = (intLength + 1) / 2;
    
    long long start, end;
    if (halfLen == 1) {
        start = 1;
        end = 9;
    } else {
        start = power10(halfLen - 1);
        end = power10(halfLen) - 1;
    }
    
    long long totalPalindromes = end - start + 1;
    if ((long long)k > totalPalindromes) {
        return -1;
    }
    
    long long firstHalf = start + k - 1;
    
    // Build palindrome
    char firstHalfStr[20];
    sprintf(firstHalfStr, "%lld", firstHalf);
    
    char palindrome[40];
    strcpy(palindrome, firstHalfStr);
    
    int len = strlen(firstHalfStr);
    if (intLength % 2 == 0) {
        // Even length: mirror the entire first half
        for (int i = len - 1; i >= 0; i--) {
            palindrome[len + (len - 1 - i)] = firstHalfStr[i];
        }
        palindrome[len * 2] = '\0';
    } else {
        // Odd length: mirror all but the last digit
        for (int i = len - 2; i >= 0; i--) {
            palindrome[len + (len - 2 - i)] = firstHalfStr[i];
        }
        palindrome[len + len - 1] = '\0';
    }
    
    return strtoll(palindrome, NULL, 10);
}

int main() {
    char line[10000];
    
    // Read queries array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int queries[1000];
    int queryCount = 0;
    char* ptr = line;
    
    // Skip '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    // Parse numbers
    while (*ptr && *ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            queries[queryCount++] = strtol(ptr, &ptr, 10);
        } else {
            ptr++;
        }
    }
    
    // Read intLength
    fgets(line, sizeof(line), stdin);
    int intLength = atoi(line);
    
    // Process queries and output results
    printf("[");
    for (int i = 0; i < queryCount; i++) {
        if (i > 0) printf(",");
        long long result = kthPalindrome(queries[i], intLength);
        printf("%lld", result);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~25 min Avg. Time

485 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