How to Determine if an Integer is a Palindrome on LeetCode

Ganthier Didier — Fri, 17 May 2024 22:07:55 +0000

Introduction

In this article, we will explore a straightforward method to determine if a given integer is a palindrome. This problem is a common algorithmic challenge that you might encounter on platforms like LeetCode. We will use JavaScript to implement our solution.

Thought Process

A palindrome is a number that reads the same backward as forward. For example, 121 is a palindrome, while 123 is not. To solve this problem, we can leverage the properties of strings to reverse the digits of the number and then compare the reversed version with the original.

Approach

Our approach can be broken down into the following steps:

Handle Negative Numbers: Negative numbers cannot be palindromes due to the presence of the negative sign. Thus, if the input number is negative, we can immediately return false.
Convert to String and Reverse:
- Convert the number to a string using the toString() method.
- Split the string into an array of characters.
- Reverse the array using the reverse() method.
- Join the reversed array back into a string.
Comparison: Convert the reversed string back to an integer using parseInt() and compare it with the original number. If they are equal, the number is a palindrome; otherwise, it is not.

Complexity

Time Complexity: The time complexity is ( O(n) ), where ( n ) is the number of digits in the number. This is because converting the number to a string, reversing the string, and joining the string all require linear time relative to the number of digits.
Space Complexity: The space complexity is ( O(n) ), because we create a new string (and an intermediate array) that is proportional in size to the number of digits in the number.

Code

Here is the implementation of the above approach in JavaScript:

/**
 * @param {number} x
 * @return {boolean}
 */
var isPalindrome = function(x) {
    if (x < 0) {
        return false;
    }
    // Convert the number to a string, reverse it, and compare with the original
    return parseInt(x.toString().split("").reverse().join("")) === x;
};

Conclusion

This solution is a simple and effective way to check if an integer is a palindrome. By leveraging JavaScript's string manipulation methods, we can achieve this in a few lines of code. This method ensures clarity and efficiency, making it a great approach for solving this problem on coding platforms like LeetCode.

Feel free to experiment with this code and try solving other similar problems to enhance your understanding of palindromes and string manipulations. Happy coding!