Super Palindromes

Super Palindromes - Problem

A super-palindrome is a positive integer that satisfies two conditions:

It is a palindrome (reads the same forwards and backwards)
It is the square of a palindrome

Given two positive integers left and right represented as strings, return the number of super-palindromes in the inclusive range [left, right].

Example: If we have a palindrome like 11, its square is 121, which is also a palindrome. Therefore, 121 is a super-palindrome.

Input & Output

Example 1 — Small Range

$ Input: left = "1", right = "10"

› Output: 3

💡 Note: Super-palindromes in [1,10]: 1 (1² and both 1,1 are palindromes), 4 (2² and both 4,2 are palindromes) and 9 (3² and both 9,3 are palindromes)

Example 2 — Larger Range

$ Input: left = "1", right = "1000"

› Output: 4

💡 Note: Super-palindromes: 1 (1²), 4 (2²), 9 (3²), and 121 (11²). All are palindromes and squares of palindromes.

Example 3 — High Range

$ Input: left = "100", right = "200"

› Output: 1

💡 Note: Only 121 (11²) is a super-palindrome in range [100,200]. 121 is palindrome and 11 is palindrome.

Constraints

1 ≤ int(left) ≤ int(right) ≤ 10¹⁸
left and right consist of only digits
left and right will not have leading zeros

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8

The key insight is to generate palindromes first instead of checking every number in the range. Generate palindromes up to sqrt(right), square them, and check if results are palindromes within range. Best approach uses palindrome generation with Time: O(sqrt(R) × log(R)), Space: O(1)

Common Approaches

✓ Brute Force Check Every Number

⏱️ Time: O(n × m) Space: O(1)

For each number in the range, check if it's a palindrome, then check if its square root is an integer and also a palindrome. This is extremely slow for large ranges.

Generate Palindromes First

⏱️ Time: O(sqrt(R) × log(R)) Space: O(1)

Instead of checking every number, generate palindromes up to sqrt of the right bound, square them, and check if the result is a palindrome within range. This reduces candidates significantly.

Brute Force Check Every Number — Algorithm Steps

Step 1: Iterate through every number from left to right
Step 2: For each number, check if it's a palindrome
Step 3: Check if square root is integer and palindrome
Step 4: Count valid super-palindromes

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Range

Iterate through every number from left to right

Test Palindrome

Check if number is palindrome and square of palindrome

Count Valid

Count numbers that satisfy both conditions

Code -

solution.c — C

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

int isPalindrome(char* s) {
    int len = strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) {
            return 0;
        }
    }
    return 1;
}

int solution(char* left, char* right) {
    int count = 0;
    long long leftNum = atoll(left);
    long long rightNum = atoll(right);
    
    // Find max root we need to check
    long long maxRoot = (long long) sqrt(rightNum);
    
    // Check single digit palindromes (1-9)
    for (long long i = 1; i <= 9 && i <= maxRoot; i++) {
        long long square = i * i;
        if (square > rightNum) {
            break;
        }
        if (square >= leftNum) {
            char squareStr[20];
            sprintf(squareStr, "%lld", square);
            if (isPalindrome(squareStr)) {
                count++;
            }
        }
    }
    
    // Check multi-digit palindromes
    int length = 2;
    while (length <= 10) {
        int halfLen = (length + 1) / 2;
        long long start = 1;
        for (int k = 1; k < halfLen; k++) {
            start *= 10;
        }
        long long end = start * 10;
        if (end > maxRoot + 1) {
            end = maxRoot + 1;
        }
        
        if (start > maxRoot) {
            break;
        }
        
        int foundAny = 0;
        for (long long i = start; i < end; i++) {
            char s[20];
            sprintf(s, "%lld", i);
            
            char palindromeStr[40];
            strcpy(palindromeStr, s);
            
            if (length % 2 == 0) {
                // Even length: s + reverse(s)
                int sLen = strlen(s);
                for (int j = sLen - 1; j >= 0; j--) {
                    palindromeStr[sLen + (sLen - 1 - j)] = s[j];
                }
                palindromeStr[sLen * 2] = '\0';
            } else {
                // Odd length: s + reverse(s[:-1])
                int sLen = strlen(s);
                for (int j = sLen - 2; j >= 0; j--) {
                    palindromeStr[sLen + (sLen - 2 - j)] = s[j];
                }
                palindromeStr[sLen * 2 - 1] = '\0';
            }
            
            long long palNum = atoll(palindromeStr);
            if (palNum > maxRoot) {
                break;
            }
            
            long long square = palNum * palNum;
            if (square > rightNum) {
                break;
            }
            
            if (square >= leftNum) {
                char squareStr[40];
                sprintf(squareStr, "%lld", square);
                if (isPalindrome(squareStr)) {
                    count++;
                    foundAny = 1;
                }
            }
        }
        
        if (!foundAny && start > maxRoot) {
            break;
        }
        
        length++;
    }
    
    return count;
}

int main() {
    char left[20], right[20];
    fgets(left, sizeof(left), stdin);
    fgets(right, sizeof(right), stdin);
    left[strcspn(left, "\n")] = 0;
    right[strcspn(right, "\n")] = 0;
    
    int result = solution(left, right);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n is range size, m is average digits per number for palindrome checking

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

18.5K Views

Medium Frequency

~45 min Avg. Time

432 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

Brute Force Check Every Number — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler