JavaScript Basics & Syntax Quiz

Check for Palindrome Number (JavaScript)

Check for Palindrome Number

A palindrome number is a number that reads the same forwards and backwards. For example, 121 is a palindrome, but 123 is not. This problem often involves reversing a number and then comparing it with the original.

Understanding the Concept

To check if a number is a palindrome, we need to compare its original form with its reversed form. If they are identical, the number is a palindrome.

Common Approaches

1. Reversing the Number (Iterative Method) and Comparing:

This approach involves the same logic as reversing a number and then directly comparing the reversed number with the original.

Copy to Clipboard

function isPalindromeNumberIterative(num) {
  // Negative numbers cannot be palindromes (unless defined otherwise, e.g., -121 is not -121 reversed)
  // Numbers ending in 0 (except 0 itself) cannot be palindromes
  if (num < 0 || (num % 10 === 0 && num !== 0)) {
    return false;
  }

let reversedNum = 0;
  let originalNumCopy = num; // Keep a copy for comparison

while (originalNumCopy > 0) {
    const lastDigit = originalNumCopy % 10;
    reversedNum = reversedNum * 10 + lastDigit;
    originalNumCopy = Math.floor(originalNumCopy / 10);
  }

// A number is a palindrome if it equals its reversed counterpart.
  // For even number of digits: num === reversedNum
  // For odd number of digits: num === Math.floor(reversedNum / 10) (e.g., 12321, 12 vs 12)
  // The second check is an optimization for odd-length palindromes to avoid full reversal if halfway match is found.
  // However, for simplicity, checking `num === reversedNum` is generally sufficient and clear.
  return num === reversedNum;
}

// Example usage:
// console.log(isPalindromeNumberIterative(121));   // Output: true
// console.log(isPalindromeNumberIterative(123));   // Output: false
// console.log(isPalindromeNumberIterative(1221));  // Output: true
// console.log(isPalindromeNumberIterative(-121));  // Output: false
// console.log(isPalindromeNumberIterative(10));    // Output: false

Explanation:

Initial checks handle negative numbers and numbers ending in 0 (unless it’s just 0), which cannot be palindromes.
The `while` loop logic is identical to reversing a number.
Finally, it compares the original `num` with the `reversedNum`.

2. Converting to String and Reversing (Simplified Method):

This is often the most concise and readable method in JavaScript, leveraging string manipulation.

Copy to Clipboard

Explanation:

The number is converted to a string.
The string is split into characters, reversed, and then joined back.
The original string representation is compared to the reversed string representation.

Key Takeaways

Reversal Logic: Understanding how to reverse a number (either numerically or via string conversion) is key.
Edge Cases: Always consider inputs like single-digit numbers, zero, and negative numbers.
Readability vs. Performance: For typical number sizes, the string-based method is often preferred for its simplicity and readability in JavaScript. For extremely large numbers that might exceed JavaScript's safe integer limits, the iterative numerical approach might be more robust, but such cases are rare for this problem.