Working with Palindromes in JavaScript and Python

Another popular technical interview problem frequently asked by employers deals with palindromes. A palindrome is a number that is the same both forwards and backwards. For example:

101, 202, 9009, 51415…

Some interview questions deal with generating palindromes, or finding large palindromes that meet a certain criteria, i.e. ‘are divisible by 2’. Another popular variation of palindrome problems is palindromes derived from the product of other numbers. For example, the largest palindrome that can be generated by multiplying two -2 digit numbers is 9009, which is the product of 91 and 99. For this exercise, let’s look at how we might go about finding the largest palindrome that is the product of two -3 digit numbers.

Off the top of my head, I can think of two ways to go about doing this.

The second route seems to make the most sense to me, so that’s what I’ll do in both languages. Here goes:

JavaScript:

let threeD = [];
for (var i = 100; i <= 999; i++) {
    threeD.push(i);
}

I’m starting off here by creating an empty array, and then looping through the numbers 100–999, and pushing each integer into the array with the variable name threeD

I’ll use the same variable names in Python as well, so that it will be easier to keep track of. Next, I’m going to create a variable, and I’ll use y for this one. I’ll set the value of y to 0.

let y = 0;

I know that eventually I’ll be looping through an array, and at some point, I’ll want to save whatever the function returns, which will be our eventually answer to the problem. And I’ll set the value of y at that time, to whatever the solution is.

Next, I’m going to loop through the array threeD and get the product of each combination of integers in the array. In order to do this, I’ll need to do a nested for loop.

for (var i = 0; i < threeD.length; i++) {
  for (var k = 0; k < threeD.length; k++) {
    //----- Do stuff here ------//
      }
  }

Inside the for loop, I’ll need to do several things. First, I’ll need to multiply threeD[i] and threeD[k]. Then, I’m pretty sure that the eventual number we want is going to be 6 digits long. So, to make things faster, I’ll only want to check the 6 digit numbers, to see if they are palindromes. Then, if I find one, I’ll set the value of our variable y to the new value…so in each iteration, I’ll also need to check, and see if the current palindrome is greater than y , and only then will I reset the value of y to the new value.

for (var i = 0; i < threeD.length; i++) {
  for (var k = 0; k < threeD.length; k++) {
    let x = threeD[i] * threeD[k];
    let z = x.toString();
      if (x > y && x.toString().length == 6 && z[0] == z[5] && z[1] == z[4] && z[2] == z[3]){
        y = x;
      }
  }
}

Pretty cool! Now, we’ll do the same thing in Python. I’m fairly new to Python, but It’s simplicity is incredible!

Python:

threeD = range(100, 999)
threeF = range(100, 999)

In JavaScript, I created one array and did a nested loop of the same array. Python uses lists instead of arrays, and it seems easier to have two lists if you’re going to do a nested for loop, so that’s the only difference at this point. the range(100, 999) gives us a range of numbers between 100 and 999, basically the same as our initial for loop in JavaScript, but it requires quite a bit less code.

y = 0

This part will be the same for me, setting an empty variable to hold our eventual solution. In Python, variables don’t need to be defined with let, or var or const, but they are simply called explicitly, which is another one of the refreshingly simplistic things about Python.

Next, I’ll do my nested for loop in Python, but again, it will require far less code than our JavaScript alternative:

for i in threeD:
    for k in threeF:
        //---- do stuff ---//

If you remember in JavaScript, I determined if each integer was a palindrome by turning the number into a string and then testing the individual indices. z[0] needed to be equal to z[5], z[1] needed to be equal to z[4] and so on. Python has an easier method for testing palindromes, which we’ll implement inside our for loop, as well as checking to see if the current value is greater than y, like we did in JavaScript:

for i in threeD:
    for k in threeF:
x = i * k
        if str(x) == str(x)[::-1] and x > y:
            y = x
print y

In the above example, we’re converting it to a string and then testing to see if it’s a palindrome. Here’s how that works:

• We’re checking if the string representation of n equals the inverted string representation of n
• The [::-1] slice takes care of inverting the string
• After that, we compare for equality using ==

Pretty cool right?

Conclusion:

Both scenarios give us the same result, but already with my limited experience in Python, I’m in love with the language. It’s simple, and often requires far less code than JavaScript. It also seems to be easier to understand out of the gate.

✉️ Subscribe to CodeBurst’s once-weekly Email Blast, 🐦 Follow CodeBurst on Twitter, view 🗺️ The 2018 Web Developer Roadmap, and 🕸️ Learn Full Stack Web Development.