Prime Palindrome - Practice Coding Problems

Prime Palindrome - Problem

Find the Prime Palindrome

Your mission is to find the smallest number that satisfies both special properties: being a prime number and reading the same forwards and backwards (a palindrome).

Given an integer n, return the smallest prime palindrome that is greater than or equal to n.

What makes a number prime?
A prime number has exactly two divisors: 1 and itself. Examples: 2, 3, 5, 7, 11, 13

What makes a number a palindrome?
It reads the same from left to right as from right to left. Examples: 101, 121, 12321

Example: If n = 6, the answer is 7 because 7 is both prime and a palindrome (single digits are palindromes).
If n = 8, the answer is 11 because it's the next number that's both prime and palindromic.

Input & Output

example_1.py — Basic Case

$ Input: n = 6

› Output: 7

💡 Note: Starting from 6: 6 is a palindrome but not prime (divisible by 1, 2, 3, 6). 7 is both a palindrome (single digit) and prime, so we return 7.

example_2.py — Skip Non-Primes

$ Input: n = 8

› Output: 11

💡 Note: 8 is a palindrome but not prime (even number). 9 is a palindrome but not prime (3×3). 10 is not a palindrome. 11 is both palindrome and prime.

example_3.py — Larger Number

$ Input: n = 987654321

› Output: 1003001001

💡 Note: For very large inputs, we need to find palindromes with more digits. 1003001001 is the next prime palindrome after 987654321.

Constraints

1 ≤ n ≤ 2 × 10⁸
The answer always exists and is within the given range
n is a positive integer

Visualization

Tap to expand

Understanding the Visualization

Smart Generation

Instead of checking every book, create palindromes by writing the first half and mirroring it

Prime Testing

For each palindrome generated, test if the catalog number is prime

Length Progression

If no palindrome of current length works, move to next length systematically

Key Takeaway

🎯 Key Insight: Instead of checking every number sequentially, generate palindromes systematically by mirroring their first half. This reduces the search space from potentially millions of numbers to just a few hundred palindromes per digit length!

Asked in

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

The optimal approach involves generating palindromes systematically instead of checking every number. By creating palindromes from their first half and mirroring, we reduce the search space dramatically. For a k-digit palindrome, we only need to generate O(10^(k/2)) candidates instead of checking all numbers. Key insight: most even-length palindromes are divisible by 11, so focusing on odd-length palindromes can provide additional optimization.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Palindrome Generation	O(10^(k/2) * √n)	O(log n)	Generate palindromes systematically and test only those for primality
Brute Force (Check Every Number)	O(n * √n)	O(log n)	Check each number starting from n to see if it's both prime and palindromic

Optimized Palindrome Generation — Algorithm Steps

Determine the length of palindromes to generate starting from n
Generate palindromes by taking the first half and mirroring it
For each generated palindrome >= n, test if it's prime
Return the first palindrome that is also prime
If no palindrome of current length works, try next length

Visualization

Tap to expand

Step-by-Step Walkthrough

Determine Length

Find the digit length we need to search

Generate Half

Create first half of palindrome systematically

Mirror to Palindrome

Reflect first half to create full palindrome

Test Primality

Check if the generated palindrome is prime

Code -

solution.c — C

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

int isPrime(long long num) {
    if (num < 2) return 0;
    if (num == 2) return 1;
    if (num % 2 == 0) return 0;
    for (long long i = 3; i * i <= num; i += 2) {
        if (num % i == 0) return 0;
    }
    return 1;
}

long long getPalindrome(long long half, int isOddLength) {
    char s[20], result[40];
    sprintf(s, "%lld", half);
    strcpy(result, s);
    
    int len = strlen(s);
    int start = isOddLength ? len - 2 : len - 1;
    
    for (int i = start; i >= 0; i--) {
        strncat(result, &s[i], 1);
    }
    
    return atoll(result);
}

long long findPrimePalindromeOfLength(int length, long long minVal) {
    int isOdd = length % 2;
    int halfLen = (length + 1) / 2;
    long long startHalf = (long long)pow(10, halfLen - 1);
    long long endHalf = (long long)pow(10, halfLen);
    
    for (long long half = startHalf; half < endHalf; half++) {
        long long palindrome = getPalindrome(half, isOdd);
        if (palindrome >= minVal && isPrime(palindrome)) {
            return palindrome;
        }
    }
    return -1;
}

long long solution(long long n) {
    if (n <= 2) return 2;
    if (n <= 3) return 3;
    if (n <= 5) return 5;
    if (n <= 7) return 7;
    if (n <= 11) return 11;
    
    char temp[20];
    sprintf(temp, "%lld", n);
    int length = strlen(temp);
    
    long long result = findPrimePalindromeOfLength(length, n);
    if (result != -1) return result;
    
    length++;
    while (1) {
        result = findPrimePalindromeOfLength(length, n);
        if (result != -1) return result;
        length++;
    }
}

int main() {
    long long n;
    scanf("%lld", &n);
    printf("%lld\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10^(k/2) * √n)

Generate O(10^(k/2)) palindromes of length k, each taking O(√n) for prime check

✓ Linear Growth

Space Complexity

O(log n)

Space for number conversion and palindrome construction

⚡ Linearithmic Space

23.1K Views

Medium Frequency

~25 min Avg. Time

890 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

Optimized Palindrome Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler