Palindrome Number

Palindrome Number - Problem

Math Easy

Given an integer x, return true if x is a palindrome, and false otherwise.

A palindrome number reads the same forward and backward. For example, 121 is a palindrome while 123 is not.

Follow up: Could you solve it without converting the integer to a string?

Input & Output

Example 1 — Positive Palindrome

$ Input: x = 121

› Output: true

💡 Note: 121 reads the same from left to right and right to left

Example 2 — Not a Palindrome

$ Input: x = -121

› Output: false

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

Example 3 — Single Digit

$ Input: x = 7

› Output: true

💡 Note: Single digit numbers are always palindromes

Constraints

-2³¹ ≤ x ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8 🍎 Apple 6

The key insight is that we can check palindromes mathematically without string conversion. The optimal approach reverses only half the digits to avoid overflow. Best approach: Half Reversal - Time: O(log n), Space: O(1)

Common Approaches

✓ Half Reversal (Optimal)

⏱️ Time: O(log n) Space: O(1)

Instead of reversing the entire number, we only reverse half of it. We compare the first half with the reversed second half, handling both even and odd length numbers.

Mathematical Reversal

⏱️ Time: O(log n) Space: O(1)

Use mathematical operations to reverse all digits of the number without string conversion. Extract digits from right to left and build the reversed number.

String Conversion

⏱️ Time: O(log n) Space: O(log n)

Convert the integer to a string and compare characters from both ends moving inward. If all corresponding characters match, it's a palindrome.

Half Reversal (Optimal) — Algorithm Steps

Handle negative numbers and edge cases
Reverse only half the digits
Compare first half with reversed second half

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Start with original number and empty reversed half

Process Half

Reverse digits until we reach the middle

Compare

Check if halves match (accounting for odd/even length)

Code -

solution.c — C

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

bool solution(int x) {
    // Negative numbers and numbers ending in 0 (except 0 itself) are not palindromes
    if (x < 0 || (x % 10 == 0 && x != 0)) {
        return false;
    }
    
    int reversedHalf = 0;
    while (x > 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);
    
    bool result = solution(x);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

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

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables, no extra data structures needed

✓ Linear Space

329.6K Views

High Frequency

~15 min Avg. Time

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

Half Reversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler