Проверка наличия палиндрома в слове в строке

const words = new Set(["hello", "sannas", "smith", "give", "me", "food"]);

function SearchingChallenge(str) {
  const n = str.length;
  if (n === 0) return "none";

  let res = "";
  const dp = Array.from({ length: n }, () => Array(n).fill(false));

  for (let len = 1; len <= n; len++) {
    for (let i = 0; i <= n - len; i++) {
      const j = i + len - 1;
      if (len === 1) {
        dp[i][j] = true;
      } else if (len === 2) {
        dp[i][j] = str[i] === str[j];
      } else {
        dp[i][j] = str[i] === str[j] && dp[i + 1][j - 1];
      }
      if (dp[i][j] && len > res.length) {
        res = str.slice(i, j + 1);
      }
    }
  }

  return words.has(res) ? res : "none";
}

console.info(SearchingChallenge("hellosannasmith"));
console.info(SearchingChallenge("givemefood"));

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

function SearchingChallenge(str) {

  if (str.length <= 1) return 'none';
  
  for(let i=0;i<str.length-3;i++) {
    for(let j=str.length-1; j>i+2; j--) {
        
        const substr = str.substring(i, j);
        if (isPalindrome(substr)) return substr;
    }
  }

  return 'none';
}

console.info(SearchingChallenge('hellosannasmith'));
console.info(SearchingChallenge('givemefood'));
console.info(SearchingChallenge('abcdef'));
console.info(SearchingChallenge('someawesomeemosik'));

function findLongestPalindromeSubstring(str) {
  const pOdd = Array(str.length).fill(0), pEven = Array(str.length).fill(0);
  let lOdd = 0, rOdd = 0, lEven = 0, rEven = 0, maxLen = 0, start = 0;
  for (let i = 0; i < str.length; i++) {
    if (rOdd > i) pOdd[i] = Math.min(rOdd - i, pOdd[lOdd + rOdd - i]);
    while (i - pOdd[i] >= 0 && i + pOdd[i] < str.length &&
      str[i - pOdd[i]] === str[i + pOdd[i]]) ++pOdd[i];
    if (i + pOdd[i] > rOdd) lOdd = i - pOdd[i], rOdd = i + pOdd[i];
    if (2 * pOdd[i] - 1 > maxLen) {
      maxLen = 2 * pOdd[i] - 1;
      start = i - pOdd[i] + 1;
    }
    if (rEven > i) pEven[i] = Math.min(rEven - i, pEven[lEven + rEven - i + 1]);
    while (i - 1 - pEven[i] >= 0 && i + pEven[i] < str.length
      && str[i - 1 - pEven[i]] === str[i + pEven[i]]) ++pEven[i];
    if (i + pEven[i] > rEven) lEven = i - 1 - pEven[i], rEven = i + pEven[i];
    if (2 * pEven[i] > maxLen) {
      maxLen = 2 * pEven[i];
      start = i - pEven[i];
    }
  }
  return maxLen > 1 ? str.slice(start, start + maxLen) : 'none';
}
console.info(findLongestPalindromeSubstring('hellosannasmith'));
console.info(findLongestPalindromeSubstring('givemefood'));
console.info(findLongestPalindromeSubstring('abc'));

const strings = JSON.parse(document.querySelector(`#strings`)
  .content.textContent);
const result = document.querySelector(`#result`);

// just check for palindrome existence
strings.forEach(string => {
  const found = getPalindromesInString({str2Check: string, single: true});
  result.innerHTML += `<b>Are there palindromes in</b>\n<i>${
    JSON.stringify(string)}</i>?<span>${
      found.error 
      ? ` => ${found.error}` : found ? ` => SURE` : ` => NOPE`}
    </span>\n`;
});

result.innerHTML += `<hr>`;

// retrieve all palindromes
strings.forEach(string => {
  const found = getPalindromesInString({str2Check: string});
  result.innerHTML += [
    `<b>All palindromes in</b>\n<i>${JSON.stringify(string)}</i>`,
    `${JSON.stringify(found, null, 2)}`]
    .join(`\n`) + `\n\n`;
});

function getPalindromesInString({ 
    str2Check, 
    caseSensitive = false, 
    single = false, 
    isPalindrome = stringIsPalindromeFactory() } = {}) {

  if ( str2Check?.constructor !== String || str2Check?.length <= 1 ) {
    return {error: `invalid input`};
  }
  
  str2Check = str2Check.replace(/[^a-z]/gi, ``);
  const result = [];
  
  
  for (let i = 0; i < str2Check.length; i += 1) {
    for (let j = str2Check.length; j > i + 2; j -= 1) {
        const substr = str2Check.substring(i, j);
        const palindromeFound = substr.length > 1
          && isPalindrome(substr, caseSensitive);
        palindromeFound && result.push(substr);
    }
  }
  
  return single ? result.length > 0 : result;
}

// Recursive palindrome determination
function stringIsPalindromeFactory() {
  return function maybePalindrome(string, cs = false) {
    const lc = cs ? string : string?.toLowerCase();
    return lc[0] !== lc.at(-1) ? false : tail(lc.slice(1, -1));
  };

  function tail(str) {
    return !str.length 
      ? true : str[0] !== str.slice(-1) 
        ? false : tail(str.slice(1, -1));
  };
}

b {color: green; }

i {
  display: inline-block; 
  margin-left: 1rem;
  color: blue; 
}

span {color: red; }

<template id = "strings">[
  "I don't think we'll find palindromes",
  "It's Anna I am talking about, or quod non so m eawe so meem sos and finally tattarrattat",
  "A man, a plan, a canal: Panama",
  "T. Eliot, top bard, notes putrid tang emanating, is sad; I'd assign it a name: gnat dirt upset on drab pot toilet.",
  {"invalid": "input"} ]
</template>

<pre id = "result"></pre>