通过反转子串查找最长回文

Question

我正在尝试找到最长的回文。我有两个从字符串的第一个字母开始的指针。对于外循环中的每个字母，我遍历内循环中的所有其他字母并使用子字符串，即起始字母（外循环）和结束字母（内循环）之间的差异。我反转这个子字符串并检查反转的版本是否与原始版本相同。有了这个，我知道我找到了一个回文。这个算法适用于我的大多数测试用例，除了一个，我不知道为什么。

function longestPalindrome (str) {
  const string = str.toLowerCase();
  if (str.length < 2) return null;
  let palindrome = '';

  function stringReverser (start, end) {
    const reversed = string.substr(start, end).split('').reverse().join('');
    return reversed;
  }

  for (let i = 0; i <= string.length; i++) {
    for (let j = i; j <= string.length; j++) {
      if (string.substr(i, j) === stringReverser(i, j)) {
        if (string.substr(i,j).length > palindrome.length) {
          palindrome = string.substr(i,j);
        }
      }
    }
  }

  if (!palindrome) return null;
  return palindrome;
}

let result1 = longestPalindrome('My mom is called annnna')
let result2 = longestPalindrome('My dad is a racecar athelete')
let result3 = longestPalindrome('That trip with a kayak was quite an adventure!')

console.log(result1)
console.log(result2)
console.log(result3)// should return ' kayak ' but returns 't t' instead.

Answer 1

我建议抽象出选定的子字符串，并使用isPalendrome 函数：

function longestPalindrome (str) {
  const inputString = str.toLowerCase();
  if (str.length < 2) return null;
  let longestPalindrome = '';

  function isPalendrome(strParam) {
    return strParam === strParam.split('').reverse().join('');
  }

  for (let i = 0; i <= inputString.length; i++) {
    for (let j = i; j <= inputString.length; j++) {
      const thisStr = inputString.slice(i, j);
      if (!isPalendrome(thisStr)) continue;
      if (thisStr.length > longestPalindrome.length) longestPalindrome = thisStr;
    }
  }
  return longestPalindrome || null;
}

let result1 = longestPalindrome('My mom is called annnna')
let result2 = longestPalindrome('My dad is a racecar athelete')
let result3 = longestPalindrome('That trip with a kayak was quite an adventure!')

console.log(result1)
console.log(result2)
console.log(result3)

Answer 2

原始实现中的错误是substr 参数是(begin, length)，其中原始代码似乎对第二个参数的含义有错误的假设。见https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr

以下是您的示例代码的一个小改动，它的输出更正确：

function longestPalindrome (str) {
  const string = str.toLowerCase();
  if (str.length < 2) return null;
  let palindrome = '';

  function stringReverser (start, length) {
    const reversed = string.substr(start, length).split('').reverse().join('');
    return reversed;
  }

  for (let i = 0; i < string.length; i++) {
    for (let j = 1; j <= string.length - i; j++) {
      if (string.substr(i, j) === stringReverser(i, j)) {
        if (j > palindrome.length) {
          palindrome = string.substr(i,j);
        }
      }
    }
  }

  if (!palindrome) return null;
  return palindrome;
}

let result1 = longestPalindrome('My mom is called annnna')
let result2 = longestPalindrome('My dad is a racecar athelete')
let result3 = longestPalindrome('That trip with a kayak was quite an adventure!')

console.log(result1)
console.log(result2)
console.log(result3)// should return ' kayak ' but returns 't t' instead.

Answer 3

这是一个使用数组助手的解决方案。回文辅助函数检查给定单词是否为回文。过滤器查找返回 true 的那些，然后使用 reduce 找到最长的回文。

function findLongest(str) {
  let arr = str.split(' ').filter(word => palindrome(word));
  return arr.reduce((a,b) => a.length > b.length ? a : b);
}

function palindrome(str) {
    return str === str.split('').reverse().join('');
}

console.log(findLongest('That trip with a kayak was quite an adventure!'));

Answer 4

Java 代码

“findlongestPalindrome”函数将参数作为字符串返回最长回文字符串

"isPalindrome" 验证字符串是否为回文

公共类 findlongestPalindrome {

      public static void main(String[] args) {
          System.out.println("-->" + findlongestPalindrome("That trip with a kayak was quite an adventure!"));
      }
      public static String findlongestPalindrome(String s){
          StringBuffer sb = new StringBuffer();
          int len = 0;
          int maxlen = 0;
          String maxString = "";

          char[] arr = s.toCharArray();
          for(int i=0;i<=s.length();i++){
              for(int j=i;j<s.length();j++){
                  System.out.print(arr[j]);
                  sb.append(arr[j]);
                  if(isPalindrome(sb.toString())) {
                      len = sb.toString().length();
                      if(len > maxlen) {
                          maxlen = len;
                          maxString = sb.toString() + "";
                      }
                  }
              }
              sb = new StringBuffer();
              System.out.println();
          }
          return maxString;
      }
      public static boolean isPalindrome(String s){
          StringBuffer sb = new StringBuffer(s);
          return sb.reverse().toString().equals(s);
      }

}