Super Palindromes - Practice Coding Problems

Super Palindromes - Problem

🎯 Super Palindromes Problem

A super-palindrome is a fascinating mathematical concept - it's a number that is both a palindrome and the square of another palindrome!

Given two positive integers left and right represented as strings, your task is to count how many super-palindromes exist in the inclusive range [left, right].

What makes a super-palindrome?

The number must be a palindrome (reads the same forwards and backwards)
It must be the perfect square of another palindrome

Example: The number 9 is a super-palindrome because:

9 is a palindrome ✅
9 = 3² and 3 is also a palindrome ✅

Your goal is to efficiently count all such numbers in the given range without checking every possible number!

Input & Output

example_1.py — Basic Range

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

› Output: 1

💡 Note: Only 1 is a super-palindrome in range [1,2]. 1 is a palindrome and 1 = 1², where 1 is also a palindrome.

example_2.py — Larger Range

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

› Output: 4

💡 Note: Super-palindromes in [4,1000] are: 9 (3²), 121 (11²), 484 (22²), and 10201 would be next but exceeds 1000.

example_3.py — Edge Case

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

› Output: 1

💡 Note: Range contains only 1, which is a super-palindrome (1 = 1² and both 1 and 1 are palindromes).

Visualization

Tap to expand

Understanding the Visualization

Plant Seeds

Generate palindromic 'seeds' (potential square roots) from 1 to √(right)

Square Formation

Arrange each seed in a perfect square pattern (calculate root²)

Check Bloom

See if the square arrangement also creates a palindromic pattern

Count Garden

Count how many beautiful super-palindromic flowers grew in our range

Key Takeaway

🎯 Key Insight: Super-palindromes are rare gems! Instead of searching through potentially 10¹⁸ numbers, we smartly generate only the palindromic 'seeds' (square roots) and test if their squares bloom into palindromic flowers. This reduces our search space dramatically from O(right) to O(√right)!

Time & Space Complexity

Time Complexity

⏱️

O(√(right) * L)

We generate palindromes up to √(right), and for each palindrome we perform string operations taking O(L) time where L is the number of digits

✓ Linear Growth

Space Complexity

O(L)

Space for storing string representations of numbers, where L is the maximum number of digits

✓ Linear Space

Constraints

1 ≤ left ≤ right ≤ 10¹⁸
left and right are represented as strings
The range can be extremely large, making brute force impractical
Super-palindromes are relatively rare, especially for large numbers

Asked in

G Google 15 f Facebook 8 ⊞ Microsoft 5

The optimal approach is to generate palindromic square roots up to √(right) and test if their squares are also palindromic. This reduces the search space from potentially 10¹⁸ numbers to around 10⁹ candidates, making the solution efficient even for very large ranges. The key insight is that instead of checking every number in the range, we only need to examine the much smaller set of possible palindromic roots.

Common Approaches

Approach	Time	Space	Notes
✓ Smart Generation + Binary Search (Optimal)	O(√(right) * L)	O(L)	Generate palindromic square roots and check if their squares are also palindromic
Brute Force (Check Every Number)	O((right - left) * L)	O(1)	Check every number in range to see if it's a super-palindrome

Smart Generation + Binary Search (Optimal) — Algorithm Steps

Calculate the maximum possible square root: √(right)
Generate all palindromes from 1 to √(right)
For each palindromic root, calculate its square
Check if the square is also a palindrome
Check if the square falls within [left, right] range
Count valid super-palindromes

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate max root

Find √(right) to limit our search space

Generate palindromic roots

Create all palindromes from 1 to max root

Square each root

Calculate root² for each palindromic root

Validate result

Check if square is palindromic and in range

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.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 superpalindromesInRange(char* left, char* right) {
    long long leftNum = atoll(left);
    long long rightNum = atoll(right);
    int count = 0;
    char buffer[20];
    
    long long maxRoot = sqrt(rightNum) + 1;
    
    for (long long root = 1; root <= maxRoot; root++) {
        sprintf(buffer, "%lld", root);
        if (isPalindrome(buffer)) {
            long long square = root * root;
            if (square >= leftNum && square <= rightNum) {
                sprintf(buffer, "%lld", square);
                if (isPalindrome(buffer)) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char left[20], right[20];
    scanf("%s %s", left, right);
    printf("%d\n", superpalindromesInRange(left, right));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(√(right) * L)

We generate palindromes up to √(right), and for each palindrome we perform string operations taking O(L) time where L is the number of digits

✓ Linear Growth

Space Complexity

O(L)

Space for storing string representations of numbers, where L is the maximum number of digits

✓ Linear Space

Constraints

1 ≤ left ≤ right ≤ 10¹⁸
left and right are represented as strings
The range can be extremely large, making brute force impractical
Super-palindromes are relatively rare, especially for large numbers

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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

🎯 Super Palindromes Problem

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Smart Generation + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler