Determine whether an integer is a palindrome

Question

The task

Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward.

Example 1:

Input: 121 Output: true

Example 2:

Input: -121 Output: false Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.

Example 3:

Input: 10 Output: false Explanation: Reads 01 from right to left. Therefore it is not a palindrome. Follow up:

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

My solution with converting number to string

const isPalindrome = n => n >= 0 && Number([...`${n}`].reverse().join("")) === n;

console.log(isPalindrome(121));

My solution without converting number to string

const isPalindrome2 = n => {
  if (n < 0) { return false; }
  let num = Math.abs(n);
  const arr = [];
  let i = 1;
  while (num > 0) {
    const min = num % (10 ** i);
    num = num - min;
    i++;
    arr.push(min);
  }
  i = i - 2;
  let j = 0;
  return n === arr.reduce((res, x) => {
    const add = (x/ (10 ** j)) * (10 ** i);
    res += add;
    i--;
    j++;
    return res;
  }, 0);
};

console.log(isPalindrome2(121));

Answer 1

Count digits in positive integer

You can get the number of digits using log10

eg

Math.log10(13526); // is 4.131169383089324
const digits = Math.ceil(Math.log10(13526)); // 5

You can get the unit value eg 423 is 100 or 256378 is 100000 by raising 10 to the power of the number of digits minus one. Well not for powers of 10

eg

unit = 10 ** (Math.ceil(Math.log10(13526)) -1); // 10000
unit = 10 ** (Math.ceil(Math.log10(10000)) -1); // 1000 wrong for power of 10 number

To get the value we want we need to floor the log first

unit = 10 ** Math.floor(Math.log10(10000)); // 10000
unit = 10 ** Math.floor(Math.log10(13526)); // 10000 correct

or

unit = 10 ** (Math.log10(10000) | 0); // 10000
unit = 10 ** (Math.log10(13526) | 0); // 10000 

Get digit at position of positive integer

To get the digit at any position in a number divide it by 10 raised to the power of the digit position get the remainder of that divided by 10 and floor it.

const digitAt = (val, digit) => Math.floor(val / 10 ** digit % 10);

or

const digitAt = (val, digit) => val / 10 ** digit % 10 | 0;

// Note  brackets added only to clarify order and are not needed
// ((val / (10 ** digit)) % 10) | 0;

digitAt(567, 0);  // 7
digitAt(567, 1);  // 6
digitAt(567, 2);  // 5

Positive integer a palindrome in \$O(1)\$ space

With that info you can then build a function that does test in \$O(1)\$ space, as you do not need to store the digits in an array for later comparison.

To keep performance up we can avoid the slower versions of some operation. For floor we can | 0 (note that for large numbers > 2**31-1 you must use floor) and for ** use Math.pow

Rather than do the full calculation to get the digit we can store the unit value of the digit we want for the top and bottom and multiply by 10 to move up and divide by 10 to move down.

function isPalindrome(num) {
    var top = Math.pow(10, Math.log10(num) | 0), bot = 1;
    while (top >= bot) {
        if ((num / top % 10 | 0) !== (num / bot % 10 | 0)) { return false }
        top /= 10;
        bot *= 10;
    }
    return true;
}

• The function will returns false for negative numbers but is not optimized for them
• The function only works on integer values less than Number.MAX_SAFE_INTEGER which is 9007199254740991

In terms of performance the above function is 5 times faster for a 16 digit palindrome 2192123993212912 and 10-11 times faster for a non palindrome of 16 digits

Answer 2

Your second solution is awfully complicated for something simple.

You start out alright. No negative number can be a palindrome, so we can discount those. However, 0 is always a palindrome, so you're discounting that while you shouldn't.

You do a lot of complicated math and use an array. You could use either, but shouldn't use both. There are a couple of mathematical approaches to solve this, but you should be able to use those without iterating over the individual numbers or splitting it up at all. The most obvious solution however, is using an array and direct comparisons, without any math.

Say we got 1221. Split it up. [1, 2, 2, 1]. Iterate over the array, comparing every nth character to the last-nth character. 0th to 3rd. 1st to 2nd.

Say we got 92429. Split it up. [9, 2, 4, 2, 9]. Ignore the middle character. Handle the rest like it's an even-length number.

Based on those 2 cases, you should be able to figure out a much simpler algorithm.

Note: This answers the explicit question. Implicitly, you should wonder whether arrays should be allowed for this challenge. After all, iterating over a string or an array, it's not that different. I strongly suspect they want you to use the math-only approach.

Another approach, which is somewhat math-based and you should beware of overflows, is simply reversing the number. In pseudo-code, that would look something like this:

reverse = 0
while (number != 0) {
  reverse = reverse * 10 + number % 10;
  number /= 10;
}

Check the input versus its reversed number. If they are the same, it's a palindrome.

But this still uses extra memory to hold the additional integer we just created.

Can it be done without? Absolutely. But I'll leave that as an exercise for you.

Answer 3

Are you sure you should generate all those objects and arrays?
And the second code additionally looks quite complex.

Testing whether a number is palindromic is actually quite simple:

function isPalindrome(num) {
    if (num % 10 == 0) {
        return num == 0
    }
    var rev = 0
    while (rev < num) {
        rev = rev * 10 + num % 10
        num /= 10
    }
    return rev == num || rev / 10 == num
}