Javascript中最大的回文产品

回文数字的两种读取方式相同。由两个两位数的乘积构成的最大回文是9009=91×99

查找由两个3位数字的乘积构成的最大回文

我编写此代码是为了找到解决方案，但Project Euler网站中的答案仍然不正确：

function Palindromic(x) {
    var pal = parseInt(x.toString().split('').reverse().join(''));

    if (pal === x)
        return true;
    else
        return false;
}

var x = 100,
    y = 100,
    product = x * y;

for (x; x <= 999; x++) {
    for (y = x; y <= 999; y++) {
        product = x * y;
        if (Palindromic(product)) {
            console.log(x + '*' + y + '=' + product);
        }
    }
}

函数回文（x）{
var pal=parseInt（x.toString（）.split（“”）.reverse（）.join（“”））；
如果（pal==x）
返回true；
其他的
返回false；
}
var x=100，
y=100，
乘积=x*y；
对于（x；x，我不认为您的代码存在真正的问题。您只是不筛选最大的产品，这不一定是您最后的输出。只需为最大的产品添加额外的检查，例如：

var x, y, product, max = 0;

for (x = 100; x <= 999; x++) {
    for (y = x; y <= 999; y++) {
        product = x * y;
        if (Palindromic(product)) {
          if( max < product ) { // this is new
            max = product;
            console.log(x + '*' + y + '=' + product);
          }
        }
    }
}

var x，y，乘积，max=0；
对于（x=100；x这是一个非常晚的答案，但是我提出了一个不同的方法，它是一个充分的解决方案，而不是完美的解决方案

我只检查了6位回文

1.仅从max生成回文6位数字（前三位，应倒转最后三位）

2.检查生成的回文数字是否有两个3位数字作为因子，如果是，则返回数字，即两个3位数字乘积可以生成的最大回文。在c#中编码示例

static void Main（字符串[]args）
{
Console.WriteLine（带除数（）的六位回文ToString（））；
Console.ReadLine（）；
}
公共静态整型六位回文带除数（）
{
对于（int i=999；i>100；i--）
{
//从max生成回文数
var palindromeInt=Int32.Parse（Convert.ToString（i）+ReverseString（Convert.ToString（i））；
//检查是否存在三位数字因子
if（选中ThreeDigitDivisorExists（回文））
{
返回回文；
}
}
返回0；
}
公共静态bool CheckThreeDigitDivisorExists（整数）
{
对于（int i=999；i>100；i--）
{
如果（编号%i==0）
{
如果（No/i很晚的答案，我的方法与Sirko类似。我发现我认为一个有趣的方式来获得戏剧性的性能提升，所以我想我应该分享：

function isPalindrome(num) {
  return parseInt(String(num).split('').reverse().join('')) === num;
}

function findLargestPalindromeProduct(numberOfDigits) {
  var start = Math.pow(10, numberOfDigits - 1);
  var end = Math.pow(10, numberOfDigits);
  var largestPalindrome = 0;
  var product;
  for (a = start; a < end; a++) {
    for (b = start; b < end; b++) {
      product = a * b;
      if (largestPalindrome < product) {
        if (isPalindrome(product)) {
          largestPalindrome = product;
        }
      }
    }
  }

  return largestPalindrome;
}
console.time('Function #1');
for (var i = 0; i < 100; i++) {
  findLargestPalindromeProduct(3);
};
console.timeEnd('Function #1')

函数isAlindrome（num）{
返回parseInt（字符串（num）.split（“”）.reverse（）.join（“”））==num；
}
函数FindArgestAlindromeProduct（数字位数）{
var start=数学功率（10，数字-1）；
var end=数学功率（10，数字）；
var最大回文数=0；
var乘积；
对于（a=开始；a<结束；a++）{
对于（b=开始；b<结束；b++）{
产品=a*b；
if（最大回文<乘积）{
if（isPalindrome（产品））{
最大回文数=乘积；
}
}
}
}
返回最大回文数；
}
console.time（'Function#1'）；
对于（变量i=0；i<100；i++）{
FindLargestalindrome产品（3）；
};
console.timeEnd（'函数#1'）

当我在Chrome控制台中运行时，每次迭代的平均速度大约为34毫秒

当我首先检查它是否是回文时，我的平均迭代时间约为500毫秒

之所以速度如此之快，是因为检查乘积是否大于最大回文非常快，可以快速检查并过滤出许多对，而不是先检查它是否是回文（当它甚至可能不大于最大回文时-即使它实际上是回文）.
也是一个迟来的答案，但是循环所有选项的速度非常慢。您可以循环批处理，对于n==2，您可以执行10批处理，对于n==3批处理，您可以执行100批处理，依此类推

这是一个JSPerf


export const isPalindrome=（arg:string | number）：布尔=>{
常量=`${arg}`；
const reverse=orig.split（“”）.reverse（）.join（“”）；
返回原点===反向；
};
/**
*这里的想法是分批搜索，以避免在所有可能性中循环。
*
*对于n==2，您将首先在90和99之间搜索，如果没有找到回文，您将移动到80和89等。
*如果找到回文，您将从批中选取最大值
*
*/
导出常量最大回文量=（num:number）：[number，[number，number]=>{
const min=编号（“1”）。padEnd（num，“0”）；
const max=Number（“9”）。padEnd（num，“9”）；
设stepperMax=max；
设res:number=0；
让位置：[编号，编号]=[min，min]；
同时（步进最大>=分钟）{
对于（设i=max；i>=stepperMax-min-1；i--）{
对于（设j=max；j>=stepperMax-min-1；j--）{
常数温度=i*j；
如果（isPalindrome（温度）和&temp>res）{
位置=[i，j]；
res=温度；
}
}
}
如果（res！==0）{
返回[res，position]；
}
步进最大=步进最大-最小-1；
}
返回[res，position]；
}；
让字符串=[]；
设mul=0；
设x=100；
而（x<1000）{
对于（y=100；y<1000；y++）{
mul=x*y；
设n=mul.toString（）；//将乘以的值转换为字符串
让stringSplit=n.split（“”；//在数组中拆分字符串
让reverseSplit=stringSplit.reverse（）；//反转字符串数组
让joinSplit=reverseSplit.join（“”；//将反转的数组连接到字符串中
如果（joinSplit==n）{//检查字符串是否等于乘以的值
string.push（joinSplit）；//因为有很多值，所以它将它们放入数组中
}
}
x++；
}
sort（函数（a，b）{return b-a}）；//按降序对数组排序，因为我们需要最高的值
console.log（字符串[0]）；
如果我们知道正确答案应该是什么，那会很有帮助。如果你在寻找最大回文数，为什么不反向循环呢？谢谢@Sirko，它非常有用，没有解释。这个答案的用途有限。请添加解释
function isPalindrome(num) {
  return parseInt(String(num).split('').reverse().join('')) === num;
}

function findLargestPalindromeProduct(numberOfDigits) {
  var start = Math.pow(10, numberOfDigits - 1);
  var end = Math.pow(10, numberOfDigits);
  var largestPalindrome = 0;
  var product;
  for (a = start; a < end; a++) {
    for (b = start; b < end; b++) {
      product = a * b;
      if (largestPalindrome < product) {
        if (isPalindrome(product)) {
          largestPalindrome = product;
        }
      }
    }
  }

  return largestPalindrome;
}
console.time('Function #1');
for (var i = 0; i < 100; i++) {
  findLargestPalindromeProduct(3);
};
console.timeEnd('Function #1')

let string = [];
let mul = 0;

let x = 100;
while(x < 1000){
    for(y = 100; y < 1000; y++){
        mul = x * y;
        let n = mul.toString();                   //to convert multiplied value to string 
        let stringSplit = n.split("");            //splits the string in array
        let reverseSplit = stringSplit.reverse(); //reverse the string array
        let joinSplit = reverseSplit.join("");    //join the reversed array into string
        if (joinSplit == n){          //check weather reversed string is equal to multiplied value
            string.push(joinSplit);  //as there are lots of value it puts them in array
        }
    }
  x++;
 }
 string.sort(function(a, b){return b-a}); // sort array in descending order as we want highest value 
 console.log(string[0]);