Project Euler #4 - Largest Palindrome Product

twitter logo github logo ・1 min read

Project Euler (7 Part Series)

1) Project Euler #1 - Multiples of 3 and 5 2) Project Euler #2 - Even Fibonacci numbers 3 ... 5 3) Project Euler #3 - Largest Prime Factor 4) Project Euler #4 - Largest Palindrome Product 5) Project Euler #5 - Finding the Smallest Multiple 6) Project Euler #6 - Sum Square Difference 7) Project Euler #7 - 10001st prime

I'm bumping a "series" that I started last year, where we collectively work on problems from Project Euler.

This is Problem 4, finding the largest palindrome product.

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 Γ— 99.

Find the largest palindrome made from the product of two 3-digit numbers.

twitter logo DISCUSS (25)
markdown guide

Here's my Python solution!

def palindrome_number():
    _range = xrange(100, 1000)
    palindrome = None
    for i in _range:
        for j in _range:
            prod = i * j
            if str(prod) == str(prod)[::-1]:
                if prod > palindrome:
                    palindrome = prod
    return palindrome


How's the run time? I think yours is Python 2?

Here's mine in Python 3 :) It's a bit more complicated because I try to write them more flexible. Like how this problem shows 2 digit numbers as an example and 3 for the actual problem, so I wrote it to take the number of digits per number as an input

import time
def largestPalindromeProduct(digits):
  min, max, temp, pal = '1', '', 0, 0
  for _ in range (1,digits):
    min += '0'
  for _ in range (0,digits):
    max += '9'
  min = int(min)-1
  max = int(max)
  start = time.time()
  for num1 in range (max,min,-1):
    for num2 in range (num1,min,-1):
      temp = num1 * num2
      if temp < pal:
      if str(temp) == "".join(reversed(str(temp))):
        pal = temp
  end = time.time()
  print(pal, end=' ')

A naive F# implementation:

let reverse (s : string) = s |> Seq.toArray |> Array.rev |> System.String

let palindrome n = let s = string n in s = reverse s

let main _ =
    seq { for i = 100 to 999  do
              for j = 100 to 999 do
                  let p = i * j
                  if palindrome p then yield p }
    |> Seq.max
    |> printf "%d\n"

Runs reasonably fast with .NET Core on my Macbook Air:

$ time dotnet Euler4.dll
dotnet Euler4.dll  0.35s user 0.03s system 101% cpu 0.376 total

This is another solution that I consider working in this particolar case (3 digits) but not actually correct (granted I could understand F# πŸ˜…). I explained it here:


This code generates the sequence of all palindromes which are products of 3 digit numbers and then selects the largest with Seq.max, so it does indeed produce the correct solution (just verify it on the Project Euler website).

You were right though about the Ruby version in your other comment. On a side note though: maybe don't go around telling people their code might be wrong if you can't actually understand the language it's written in?

I'm sorry if that seemed rude, that wasn't my intention at all. I did add "granted I could understand F#" in case I was wrong.

But no, I will keep on trying to understand what's going on in other people's code even out of my comfort zone, because I'll have the chance to learn something new πŸ‘Œ

If your intention really is to learn then you'd be better of asking questions (e.g. "I don't know F#, would you mind explaining how this selects the biggest palindrome?") instead of making statements that need a qualifier of potentially being wrong.

Being wrong is nothing to be ashamed of, as long as you're ready to stand corrected.

My mistake in this case is that I commented while it was very late 😴 Took note on the approach, though.


My typescript solution:

function reverseInteger(n: number): number {
  return Number(String(n).split('').reverse().join(''));

function isPalindrome(num: number): boolean {
  if (num === reverseInteger(num)) {
    return true;
  return false;

// I had this in separate files sorry if its confusing X)
import { max } from 'mathjs';

let number = 0;
let a = 999;

const palindromes: number[] = [];

while (a > 1) {
  for (let i = 2; i <= 999; i += 1) {
    number = a * i;
    if (isPalindrome(number)) {
  a -= 1;
console.log(`Max palindrome ${max(...palindromes)}`);
if (condition) {
  return true;
return false;

Please don't do this πŸ˜• It's verbose for no reason. You can accomplish the same with just return condition;.


cool! yes so much simple

function isPalindrome(num: number): boolean {
  return num === reverseInteger(num);



Here is my code on C (Brute force), the result was out after 0.172s.

#include <stdio.h>
#include <stdlib.h>

int palindrome(long x)
    int i,j=0;
    char ch[7];

    char ch1[7]="";

        return 1;
    return 0;

int main()
    int i,j;
    long s,max=100*100;
            if (palindrome(s) && s>max)
    printf("Result = %ld",max);


/****** 0.128 s *******/
        if (palindrome(s))

Here's my Ruby solution. There's probably a much more clever way to do this. Probably a more Ruby way to do it for that matter.

# Find the largest palindrome number that is the product of two three digit factors.

def check_equality(num)
  num.to_s == num.to_s.reverse

def find_palindrome
  r1 = (999..1)
  r2 = r1

  (r1.first).downto(r1.last).each do |i|
    (r2.first).downto(r2.last).each do |j|
      if check_equality( i * j )
        puts "#{i} * #{j} = #{i*j}"


If I understand it correctly (correct me if I'm wrong, I don't know Ruby), this doesn't work in general, as it prints the first palindrome product you find. But you don't know if it's the largest.

Unless you can prove it is πŸ€·β€β™‚οΈ (I have no idea).


I'm working backwards through the range of numbers beginning with '999.' Hence the extra verbosity in the block with the call to the downto method. (999..1).each do doesn't work, and (1..999).each do really shouldn't work either because ranges are not defined by their content, just a beginning state and an end state. So counting backwards the first palindrome I find is the largest. And the outer block isn't necessary, but I include it just for the sake of being thorough I guess.

The problem here is that the products you're getting aren't ordered. Which means that if you get a palindrome, you cannot be sure it's the largest.

In fact, I run your code and I got 999 * 91 = 90909, which is not correct. Even if you limit your range to 999 to 100 (we're looking for 3-digit factors after all), you'd get 995 * 583 = 580085. But the largest palindrome is 993 * 913 = 906609, which comes after the others.


A quadratic solution in JavaScript. I'm curious if there's a way to do this in linear time:

const array = new Array(900).fill(0).map((e, i) => i + 100);

const isPalindrome = num => {
  return (
    String(num) ===

const maxProduct = range => {
  let palindrome = 0;
  for (let i = 0; i < range.length; i++) {
    for (let j = i + 1; j < range.length; j++) {
      const product = array[i] * array[j];
      if (isPalindrome(product) && product > palindrome) {
        palindrome = product;

  return palindrome;


Not linear... but I think (without any actual proof πŸ€·β€β™‚οΈ) (I'm a fraud πŸ€¦β€β™‚οΈ) that my solution does it in logarithmic time:

Edit: scratch that, no way it's not quadratic πŸ˜‚ But then again, it's faster than the extensive check.


Written in Java!

public class Problem4 {
    public static boolean isPalindrome(long val) {
            boolean isPalindrome = true;
            String str = Long.toString(val);
            int len = str.length();
            int i = 0;
            while (isPalindrome && i <= (len-1)/2){
                isPalindrome = str.charAt(i) == str.charAt(len-1-i);
            return isPalindrome;

        public static void main(String[] args) {
            int i = 999;
            long largest = 1;
            String str = "";
            long val = 1;
        while (i>=100)
            int j = i;
            while (j>=100)
                val = i * j;
                if(isPalindrome(val) && largest < val)
                    largest = val;
                    str = i + " x " + j;
                isPalindrome (val);
        System.out.println(str+ "= "+ largest);


Am still able to just copy and paste from my Euler GitHub repo. πŸ˜‚

PHP again

$largestThreeDig = 999;
$largestPalindrome = 0;
for($l = $largestThreeDig; $l > 0 && $l * $largestThreeDig > $largestPalindrome; $l--) {
    for($p = $l * $largestThreeDig; $p > $largestPalindrome; $p -= $l) {
        if((string)$p === strrev((string)$p)) {
            $largestPalindrome = $p;
 echo "Largest Palindrome: $largestPalindrome\n";

This is another solution that I consider working in this particular case (3 digits) but not actually correct in the general case. I explained it here:


Sooo... there are so many good solutions, but they all kind of look the same, so I wanted a different approach 😁

What if, instead of starting with the factors and checking if their product is a palindrome, we start with palindromes and find two 3-digit factors?

We'd start with 999999, then 998899, then 997799... You get the point. So we can start with a 3-digit number (e.g. 356)... and get a palindrome out of it (e.g. 356653), and look for factors.

My solution in JavaScript:

const digits = 3;
const upper = 10 ** digits - 1;   // 999
const lower = 10 ** (digits - 1); // 100
function palindromize(num) {
  const padded = String(num).padStart(digits,'0');
  return +(padded + padded .split('').reverse().join(''));

let p, b;
out: for (let a = upper; a >= lower; a--) {
  p = palindromize(a);
  for (b = Math.floor(p ** .5); p/b <= upper; b--) {
    if (p % b === 0) break out;
console.log(p / b, b);

I've tested it with up to 7 digits and it's still basically instantaneous. Over that limit you go over Number.MAX_SAFE_INTEGER and it becomes unreliable. I didn't bother using BigInts, also because you can't get the square root out of them (you can approximate it, but it's a bother).

P.S.: yes, I've used a label in JavaScript. Sue me πŸ˜‚ (also useful if you have to break out of more than one cycle... which is usually rare).


Love to work on the challenges, please keep this series running.
Here's my Rust Solution: Playground

fn main() {
    let max = max_palindrome();
    println!("Max palindrome is {}, product of {} * {}", max.1, (max.0).0, (max.0).1);

fn max_palindrome() -> ((i32, i32), i32) {
    let range = 100..1000;
    let mut ans = ((0, 0), 0);
    for a in range.clone() {
        for b in range.clone() {
            let p = a * b;
            if is_palindrome(p) && p > ans.1 {
                ans.1 = p;
                ans.0 = (a ,b);

fn is_palindrome(num: i32) -> bool {
    let str_num = num.to_string();
        .all(|(c1, c2)| c1 == c2)


Just did this super quick in JS.

function isPalindrome(num) {
  const stringifiedNum = num.toString();

  return (
    Array.from(stringifiedNum).toString() ===

function findLargestPalindrome() {
  const start = 100;
  const end = 999;

  let largestPalindrome = 0;

  for (let i = start; i <= end; i += 1) {
    for (let j = start; j <= end; j += 1) {
      const product = i * j;
      if (isPalindrome(product) && product > largestPalindrome) {
        largestPalindrome = product;

  return largestPalindrome;


Did you try hackerrank's version? They have broader ranges for input values and pretty tight time/memory limitations. That sometimes makes even trivial project euler tasks challenging. :)

Classic DEV Post from Apr 30 '18

How to Use Git Merge [the CorrectΒ Way]

Whenever you try to do a three-way merge there is a chance for conflicts to happen. This article explains how to deal with them and how merging actually works.

Peter Kim Frank profile image

Do you prefer sans serif over serif?

You can change your font preferences in the "misc" section of your settings. ❀️