Strictly Palindromic Number - Practice Coding Problems

Strictly Palindromic Number - Problem

A strictly palindromic number is a fascinating mathematical concept that challenges our understanding of number representations across different bases.

Given an integer n, we need to determine if it's strictly palindromic. This means that when we convert n to every possible base from 2 to n-2 (inclusive), the resulting string representation must be a palindrome in all of those bases.

What's a palindrome? A string that reads the same forwards and backwards, like "racecar" or "121".

Example: For n = 9, we'd check bases 2 through 7:
• Base 2: 9 = "1001" ✓ (palindrome)
• Base 3: 9 = "100" ✗ (not palindrome)
Since it fails in base 3, n = 9 is not strictly palindromic.

Goal: Return true if the number is strictly palindromic, false otherwise.

Input & Output

example_1.py — Python

$ Input: n = 9

› Output: false

💡 Note: In base 2: 9 = "1001" (palindrome), but in base 3: 9 = "100" (not palindrome). Since it fails in at least one base, return false.

example_2.py — Python

$ Input: n = 4

› Output: false

💡 Note: We only check base 2: 4 = "100" (not palindrome). Since the only base to check fails, return false.

example_3.py — Python

$ Input: n = 1

› Output: true

💡 Note: For n = 1, we need to check bases 2 to n-2 = -1. Since there are no valid bases to check, we return true by definition.

Visualization

Tap to expand

Understanding the Visualization

Base (n-1) Analysis

In base (n-1), number n is always "11" (palindromic)

Base (n-2) Analysis

In base (n-2), number n has a specific non-palindromic pattern

Mathematical Proof

Since base (n-2) always fails for n ≥ 4, the answer is always false

Key Takeaway

🎯 Key Insight: This is a mathematical brainteaser! For any n ≥ 4, the number will always fail the palindrome test in base (n-2), making the optimal solution simply `return false`.

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n) bases to check, each base conversion takes O(log n), palindrome check takes O(log n)

⚠ Quadratic Growth

Space Complexity

O(log n)

Space needed to store the string representation in each base

⚡ Linearithmic Space

Constraints

4 ≤ n ≤ 2 × 10⁹
The answer for all valid inputs will be false

Asked in

f Meta 25 G Google 20 ⊞ Microsoft 15 a Amazon 10

This is a mathematical brainteaser disguised as a coding problem. The key insight is that for any n ≥ 4, the answer is always false. In base (n-1), any number n is represented as "11", which is palindromic. However, in base (n-2), the representation will never be palindromic for n ≥ 4, making the optimal solution simply return false!

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Bases)	O(n² log n)	O(log n)	Convert to each base from 2 to n-2 and check if each representation is palindromic

Brute Force (Check All Bases) — Algorithm Steps

Iterate through each base b from 2 to n-2
Convert n to base b representation
Check if the base-b string is palindromic
If any base fails the palindrome test, return false
If all bases pass, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Base 2

9 → "1001" (palindrome ✓)

Convert to Base 3

9 → "100" (not palindrome ✗)

Early Exit

Since base 3 failed, return false

Code -

solution.c — C

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

char* toBase(int num, int base) {
    if (num == 0) {
        char* result = malloc(2);
        strcpy(result, "0");
        return result;
    }
    
    char* result = malloc(64);
    int index = 0;
    while (num > 0) {
        result[index++] = '0' + (num % base);
        num /= base;
    }
    
    // Reverse the string
    for (int i = 0; i < index / 2; i++) {
        char temp = result[i];
        result[i] = result[index - 1 - i];
        result[index - 1 - i] = temp;
    }
    
    result[index] = '\0';
    return result;
}

int isPalindrome(const 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 isStrictlyPalindromic(int n) {
    for (int base = 2; base < n - 1; base++) {
        char* representation = toBase(n, base);
        if (!isPalindrome(representation)) {
            free(representation);
            return 0;
        }
        free(representation);
    }
    return 1;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%s\n", isStrictlyPalindromic(n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n) bases to check, each base conversion takes O(log n), palindrome check takes O(log n)

⚠ Quadratic Growth

Space Complexity

O(log n)

Space needed to store the string representation in each base

⚡ Linearithmic Space

Constraints

4 ≤ n ≤ 2 × 10⁹
The answer for all valid inputs will be false

28.5K Views

Medium Frequency

~5 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Bases) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler