Largest Palindrome Product - Practice Coding Problems

Largest Palindrome Product - Problem

Math Enumeration Hard

You're tasked with finding the largest palindrome that can be formed by multiplying two n-digit numbers. A palindrome reads the same forwards and backwards (like 12321 or 9009).

Given an integer n, return the largest palindromic integer that is the product of two n-digit integers. For example, if n = 2, you need to find the largest palindrome formed by multiplying two 2-digit numbers (10-99).

Since the result can be extremely large, return it modulo 1337.

Key Challenge: The brute force approach of checking all possible products becomes computationally expensive for larger values of n. We need to work backwards from the largest possible palindrome!

Input & Output

example_1.py — Basic Case

$ Input: n = 2

› Output: 987

💡 Note: The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99. Since 9009 % 1337 = 987, we return 987.

example_2.py — Single Digit

$ Input: n = 1

› Output: 9

💡 Note: The largest product of two 1-digit numbers is 9 × 9 = 81, but we need a palindrome. The largest palindromic product is 9 × 1 = 9.

example_3.py — Three Digits

$ Input: n = 3

› Output: 181

💡 Note: The largest palindrome from two 3-digit numbers is 999999 = 999 × 1001. Since 999999 % 1337 = 181, we return 181.

Visualization

Tap to expand

Understanding the Visualization

Start with Perfect Mirror

Begin with the largest possible palindromic number

Test Production Units

Check if the mirror can be created by multiplying two n-digit numbers

Verify Constraints

Ensure both factors are exactly n digits long

Package Result

Apply modulo 1337 to handle large numbers

Key Takeaway

🎯 Key Insight: Instead of building up from small products, work backwards from the largest possible palindrome and check if it can be decomposed into exactly two n-digit factors!

Time & Space Complexity

Time Complexity

⏱️

O(10^n)

We generate palindromes by their first half, and for each palindrome we do factorization check

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations and variables

✓ Linear Space

Constraints

1 ≤ n ≤ 8
The result must be returned modulo 1337
Both factors must be exactly n-digit numbers

Asked in

G Google 15 ⊞ Microsoft 12 a Amazon 8 f Meta 5

The optimal approach works backwards from the largest possible palindrome instead of checking all products. We generate palindromes by mirroring the first half, then check if each can be factored into two n-digit numbers. This reduces complexity from O(10^(2n)) to O(10^n) and handles the modulo 1337 requirement efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Enumeration (Work Backwards)	O(10^n)	O(1)	Start from the largest possible palindrome and check if it can be factored
Brute Force (Check All Products)	O(10^(2n))	O(1)	Generate all products of n-digit numbers and find the largest palindrome

Optimized Enumeration (Work Backwards) — Algorithm Steps

Handle edge case: for n=1, return 9
Calculate the upper bound for n-digit number products
Generate palindromes in descending order by constructing the first half
For each palindrome, check if it can be factored into two n-digit numbers
Use modular arithmetic to handle large numbers efficiently
Return the first valid palindrome found modulo 1337

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Largest

Begin with the largest possible first half (999... for n digits)

Create Palindrome

Mirror the first half to create a palindrome (999 → 999999)

Check Factorization

Try to factor the palindrome into two n-digit numbers

Success or Continue

If factorization succeeds, return result; otherwise try next smaller first half

Code -

solution.c — C

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

void reverse_string(char* str) {
    int len = strlen(str);
    for (int i = 0; i < len/2; i++) {
        char temp = str[i];
        str[i] = str[len-1-i];
        str[len-1-i] = temp;
    }
}

int largestPalindrome(int n) {
    if (n == 1) return 9;
    
    long long lower = (long long)pow(10, n-1);
    long long upper = (long long)pow(10, n) - 1;
    
    for (long long firstHalf = upper; firstHalf >= lower; firstHalf--) {
        char firstStr[32], palinStr[64];
        sprintf(firstStr, "%lld", firstHalf);
        strcpy(palinStr, firstStr);
        
        reverse_string(firstStr);
        strcat(palinStr, firstStr);
        
        long long palindrome = atoll(palinStr);
        
        long long maxFactor = (long long)fmin(upper, sqrt(palindrome));
        for (long long i = maxFactor; i >= lower; i--) {
            if (palindrome % i == 0) {
                long long factor2 = palindrome / i;
                if (factor2 >= lower && factor2 <= upper) {
                    return palindrome % 1337;
                }
                if (factor2 < lower) break;
            }
        }
    }
    
    return 0;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", largestPalindrome(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10^n)

We generate palindromes by their first half, and for each palindrome we do factorization check

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations and variables

✓ Linear Space

Constraints

1 ≤ n ≤ 8
The result must be returned modulo 1337
Both factors must be exactly n-digit numbers

18.5K Views

Medium Frequency

~35 min Avg. Time

450 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Enumeration (Work Backwards) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler