Palindrome Number - Practice Coding Problems

Palindrome Number - Problem

Math Easy

Check if a Number Reads the Same Forwards and Backwards

A palindrome is a sequence that reads the same forwards and backwards - like the word "racecar" or the number 12321. Your task is to determine if a given integer x is a palindromic number.

Goal: Return true if the integer is a palindrome, false otherwise.

Examples:
• 121 → true (reads as 121 backwards)
• -123 → false (negative numbers aren't palindromes)
• 10 → false (reads as 01 backwards, which is just 1)

Challenge: Can you solve this without converting the number to a string?

Input & Output

example_1.py — Python

$ Input: x = 121

› Output: true

💡 Note: 121 reads as 121 from left to right and right to left, so it's a palindrome

example_2.py — Python

$ Input: x = -121

› Output: false

💡 Note: From left to right it reads -121, but from right to left it becomes 121-, which is not the same

example_3.py — Python

$ Input: x = 10

› Output: false

💡 Note: Reads 10 from left to right but 01 from right to left, which equals 1, so it's not a palindrome

Visualization

Tap to expand

Understanding the Visualization

Handle Edge Cases

Negative numbers and multiples of 10 (except 0) cannot be palindromes

Start Reversal Process

Initialize reversed_half = 0 and begin extracting digits from right

Extract and Build

Take last digit of x, add to reversed_half, remove from x

Continue Until Halfway

Stop when x ≤ reversed_half (we've processed half the digits)

Compare Results

Check if x equals reversed_half (even digits) or reversed_half/10 (odd digits)

Key Takeaway

🎯 Key Insight: We only need to reverse half the digits mathematically, avoiding string conversion and achieving optimal O(1) space complexity!

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We process half the digits of the number, which is still O(log n) where n is the input

⚡ Linearithmic

Space Complexity

O(1)

Only uses a constant amount of extra space for variables

✓ Linear Space

Constraints

-2³¹ ≤ x ≤ 2³¹ - 1
Follow-up: Can you solve it without converting the integer to a string?

Asked in

f Meta 45 a Amazon 38 G Google 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses mathematical digit manipulation to reverse only half the number, achieving O(1) space complexity without string conversion. The key insight is that we only need to check if the first half equals the reversed second half.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Reversal (Optimal)	O(log n)	O(1)	Reverse half the number mathematically and compare with the other half
String Conversion Approach	O(log n)	O(log n)	Convert number to string and compare characters from both ends

Mathematical Reversal (Optimal) — Algorithm Steps

Handle edge cases: negative numbers and multiples of 10 (except 0)
Initialize reversed = 0
While x > reversed, extract last digit and add to reversed
Remove last digit from x by dividing by 10
Check if x equals reversed (even digits) or x equals reversed/10 (odd digits)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

x = 12321, reversed = 0

First Iteration

reversed = 0*10 + 1 = 1, x = 1232

Second Iteration

reversed = 1*10 + 2 = 12, x = 123

Stop Condition

x (123) > reversed (12), continue

Final Check

x = 12, reversed = 123. Check x == reversed//10 → 12 == 12 ✓

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

bool isPalindrome(int x) {
    // Negative numbers and multiples of 10 (except 0) are not palindromes
    if (x < 0 || (x % 10 == 0 && x != 0)) {
        return false;
    }
    
    int reversedHalf = 0;
    while (x > reversedHalf) {
        // Extract last digit and add to reversedHalf
        reversedHalf = reversedHalf * 10 + x % 10;
        x /= 10;
    }
    
    // For even digits: x == reversedHalf
    // For odd digits: x == reversedHalf / 10
    return x == reversedHalf || x == reversedHalf / 10;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We process half the digits of the number, which is still O(log n) where n is the input

⚡ Linearithmic

Space Complexity

O(1)

Only uses a constant amount of extra space for variables

✓ Linear Space

Constraints

-2³¹ ≤ x ≤ 2³¹ - 1
Follow-up: Can you solve it without converting the integer to a string?

58.5K Views

Very High Frequency

~15 min Avg. Time

2.8K 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

Mathematical Reversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler