Given an integer n, return the largest palindromic integer that can be represented as the product of two n-digits integers. Since the answer can be very large, return it modulo1337.
The largest palindrome made from the product of two n-digit numbers must be close to the square of the largest n-digit number. Instead of checking all products, we can generate palindromes in descending order and check if they can be factored into two n-digit numbers.
classSolution {
public:int largestPalindrome(int n) {
if (n ==1) return9;
int upper = pow(10, n) -1, lower = pow(10, n-1);
for (long left = upper; left >= lower; --left) {
string p = to_string(left);
reverse(p.begin(), p.end());
long pal = stol(to_string(left) + p);
for (long x = upper; x * x >= pal; --x) {
if (pal % x ==0) {
long y = pal / x;
if (y >= lower && y <= upper) return pal %1337;
}
}
}
return-1;
}
};
classSolution {
publicintlargestPalindrome(int n) {
if (n == 1) return 9;
int upper = (int)Math.pow(10, n) - 1, lower = (int)Math.pow(10, n-1);
for (long left = upper; left >= lower; --left) {
StringBuilder sb =new StringBuilder();
sb.append(left);
sb.reverse();
long pal = Long.parseLong(left + sb.toString());
for (long x = upper; x * x >= pal; --x) {
if (pal % x == 0) {
long y = pal / x;
if (y >= lower && y <= upper) return (int)(pal % 1337);
}
}
}
return-1;
}
}
classSolution {
funlargestPalindrome(n: Int): Int {
if (n ==1) return9val upper = Math.pow(10.0, n.toDouble()).toInt() - 1val lower = Math.pow(10.0, (n-1).toDouble()).toInt()
for (left in upper downTo lower) {
val s = left.toString()
val pal = (s + s.reversed()).toLong()
var x = upper
while (x.toLong() * x >= pal) {
if (pal % x ==0L) {
val y = pal / x
if (y >= lower && y <= upper) return (pal % 1337).toInt()
}
x-- }
}
return -1 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
classSolution:
deflargestPalindrome(self, n: int) -> int:
if n ==1:
return9 upper =10**n -1 lower =10**(n-1)
for left in range(upper, lower-1, -1):
s = str(left)
pal = int(s + s[::-1])
for x in range(upper, int(pal**0.5)-1, -1):
if pal % x ==0:
y = pal // x
if lower <= y <= upper:
return pal %1337return-1
impl Solution {
pubfnlargest_palindrome(n: i32) -> i32 {
if n ==1 { return9; }
let upper =10_i64.pow(n asu32) -1;
let lower =10_i64.pow((n-1) asu32);
for left in (lower..=upper).rev() {
let s = left.to_string();
let pal =format!("{}{}", s, s.chars().rev().collect::<String>()).parse::<i64>().unwrap();
letmut x = upper;
while x * x >= pal {
if pal % x ==0 {
let y = pal / x;
if y >= lower && y <= upper {
return (pal %1337) asi32;
}
}
x -=1;
}
}
-1 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
classSolution {
largestPalindrome(n: number):number {
if (n===1) return9;
constupper= Math.pow(10, n) -1, lower= Math.pow(10, n-1);
for (letleft=upper; left>=lower; --left) {
consts=left.toString();
constpal= parseInt(s+s.split('').reverse().join(''));
for (letx=upper; x*x>=pal; --x) {
if (pal%x===0) {
consty=pal/x;
if (y>=lower&&y<=upper) returnpal%1337;
}
}
}
return-1;
}
}
⏰ Time complexity: O(10^n * n), since we generate O(10^n) palindromes and for each, check up to O(10^n) factors, but in practice, it is much faster due to early breaks.
🧺 Space complexity: O(1), only a constant amount of extra space is used.