Question

回文数字两种方式相同。由两个2位数字的乘积制成的最大回文是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);
        }
    }
}

我的代码有问题吗？！无论如何，我得到的答案是888888，来自924 * 962

Answer 1

我不认为，您的代码确实存在问题。您只是不过滤最大的产品，这不一定是您的最后一个输出。只需为最大的产品添加额外的支票，例如像这样：

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);
          }
        }
    }
}

返回

913 * 993 = 906609

是最大的结果。

Answer 2

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]);

Answer 3

这是一个非常晚的答案，但我提出了一个不同的方法，它是一个充分的解决方案，而不是完美的解决方案

我只检查过6位数的回文。

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

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

string data = "Example 2323 Second     This is a Phrase  2017-01-01 2019-01-03";
string firstword = new Regex(@"\b[A-Za-z]+\b").Matches(data )[0]

Answer 4

答案很晚，我的做法与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')

当我在Chrome控制台中运行该指令时，每次迭代平均获得约34毫秒的时间。

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

之所以如此之快，是因为检查产品是否大于最大的Palindrome可以非常快速地检查并快速过滤掉许多对，而不是首先检查它是否是回文（甚至可能不大于最大的回文图-即使它实际上是回文图）。

Answer 5

答案也很晚，但是循环遍历所有选项确实很慢。您可以遍历批处理，对于n === 2，可以进行10批处理，对于n ==== 3，可以进行100批处理，依此类推

这是一个JSPerf https://jsperf.com/largest-palindrome-product/1

export const isPalindrome = (arg: string | number): boolean => {
  const orig = `${arg}`;
  const reverse = orig.split("").reverse().join("");

  return orig === reverse;
};

/**
 * The idea here is to search in batches to avoid looping trough all of the possibilities.
 *
 * For n === 2 you will first search between 90 and 99 if no palindrome found you will move to 80 and 89 etc.
 * If a palindrome is found you will pick the max from the batch
 *
 */
export const largestPalindromeProduct = (num: number): [number, [number, number]] => {
  const min = Number("1".padEnd(num, "0"));
  const max = Number("9".padEnd(num, "9"));

  let stepperMax = max;
  let res: number = 0;

  let position: [number, number] = [min, min];

  while (stepperMax >= min) {
    for (let i = max; i >= stepperMax - min - 1; i--) {
      for (let j = max; j >= stepperMax - min - 1; j--) {
        const temp = i * j;
        if (isPalindrome(temp) && temp > res) {
          position = [i, j];
          res = temp;
        }
      }
    }

    if (res !== 0) {
      return [res, position];
    }

    stepperMax = stepperMax - min - 1;
  }

  return [res, position];
};

Javascript中最大的回文产品

5 个答案: