easy
Palidrome Number
Link to algo
We can solve the palindrome check problem using two pointers. We can use the twopointer approach to compare digits from the left and right to check if they form a palindrome.
The idea is to extract the digits of the number from left to right and right to left, and then compare them. To extract the digits, we can use the modulo operator (%) to get the rightmost digit, and the integer division (Math.floor) to remove the rightmost digit.
Let's implement the solution using the twopointer approach in JavaScript:
/**
* @param {number} x
* @return {boolean}
*/
var isPalindrome = function (x) {
if (x < 0) {
return false; // Negative numbers cannot be palindromes
}
let originalX = x;
let reversedX = 0;
while (x > 0) {
const digit = x % 10;
reversedX = reversedX * 10 + digit;
x = Math.floor(x / 10);
}
return originalX === reversedX;
};
You can use the isPalindrome
function in the same way as mentioned earlier to check if a given integer x
is a palindrome. The function returns true
if the integer is a palindrome; otherwise, it returns false
.
Let's break down the code inside the while
loop and understand how it works to reverse the digits of the given integer x
.
while (x > 0) {
const digit = x % 10;
reversedX = reversedX * 10 + digit;
x = Math.floor(x / 10);
}

x % 10
: This operation extracts the rightmost digit of the numberx
. In JavaScript, the%
operator gives the remainder whenx
is divided by 10. For example,123 % 10
would give3
. 
reversedX * 10 + digit
: Here,reversedX
is used to build the reversed number. For each iteration of the loop, we multiplyreversedX
by 10 to shift its digits to the left, and then add the extracted digit to the rightmost position. This effectively places each digit extracted in reverse order. For example, ifreversedX
is0
anddigit
is3
, after this operation,reversedX
becomes3
. 
x = Math.floor(x / 10)
: This operation removes the rightmost digit fromx
by performing an integer division by 10. Integer division discards any decimal part, effectively removing the rightmost digit. For example, ifx
is123
, after this operation,x
becomes12
.
The loop continues to run until x
becomes 0. During each iteration, it extracts the rightmost digit from x
, places it in the reversed position in reversedX
, and then removes the rightmost digit from x
. After the loop, reversedX
will contain the reversed digits of the original x
.
For example, let's say x
is 123
:
1st iteration:
x
: 123digit
: 3reversedX
: 3 (sincereversedX
starts as 0, it becomes 0 * 10 + 3 = 3)x
: 12 (after performing Math.floor(123 / 10))
2nd iteration:
x
: 12digit
: 2reversedX
: 32 (sincereversedX
was 3, it becomes 3 * 10 + 2 = 32)x
: 1 (after performing Math.floor(12 / 10))
3rd iteration:
x
: 1digit
: 1reversedX
: 321 (sincereversedX
was 32, it becomes 32 * 10 + 1 = 321)x
: 0 (after performing Math.floor(1 / 10))
The loop ends since x
is now 0. The final value of reversedX
becomes 321
, which is the reversed digits of the original x
(123).
After the loop, we compare reversedX
with the original value of x
. If they are the same, it means x
is a palindrome. Otherwise, it's not.
This implementation has a time complexity of O(log10(x)), where x is the given integer, as we are extracting digits from the number. The space complexity is O(1), as we are not using any additional data structures that grow with the input size.