https://leetcode.com/problems/longest-palindromic-substring/

longestPalindrome.js

/*
author Oleg Kornilov 
[email protected]

Runtime: 2025 ms, faster than 11.72% of JavaScript online submissions for Longest Palindromic Substring.
Memory Usage: 52 MB, less than 12.11% of JavaScript online submissions for Longest Palindromic Substring.
*/

var longestPalindrome = function(s) {

    function isPalindrome(str) {
        for (var i = 0; i < str.length; i++) {
            var start = str.charAt(i)
            var end = str.charAt(str.length - 1 - i)

            if (start !== end) {
                return false
            }
        }
        return s 
    }

    // if palindrome is in the beginning
    function isPalindromeAtBeginning(str) {
        var longest = ""
        this.isPalindrome = longestPalindrome.isPalindrome

        for (var i = 0; i < str.length; i++) {
            if ((i > 0) && (i < str.length)) {
                // s minus last i chars
                stringToCheck = str.slice(0, Number(-i))
               
                if ((stringToCheck.length > 1) && (isPalindrome(stringToCheck))) {
                    if (stringToCheck.length > longest.length) {
                        longest = stringToCheck
                        // console.log("isPalindromeAtBeginning", stringToCheck, longest)
                    } 
                } 
            }
        }
        return longest
    }

    // if palindrome is in the middle
    function isPalindromeAtMiddle(str) {
        var longest = ""
        this.isPalindrome = longestPalindrome.isPalindrome
        this.isPalindromeAtEnd = longestPalindrome.isPalindromeAtEnd
        this.isPalindromeAtBeginning = longestPalindrome.isPalindromeAtBeginning

        for (var i = 0; i < str.length; i++) {
            if (i > 0) {
                var stringToCheck = str.substr(i).slice(0, Number(-i))

                if (stringToCheck.length === 0) {
                    break
                }
                            
                if (stringToCheck && stringToCheck.length > 1) {
                    if (isPalindrome(stringToCheck)) {
                        if (stringToCheck.length > longest.length) {
                            longest = stringToCheck
                            // console.log("isPalindromeAtMiddle", stringToCheck, longest)
                        }
                    }

                    if (isPalindromeAtEnd(stringToCheck)) {
                        if (isPalindromeAtEnd(stringToCheck).length > longest.length) {
                            longest = isPalindromeAtEnd(stringToCheck)
                            // console.log(isPalindromeAtEnd(stringToCheck), longest)
                        }
                    }
                    
                    if (isPalindromeAtBeginning(stringToCheck)) {
                        if (isPalindromeAtBeginning(stringToCheck).length > longest.length) {
                            longest = isPalindromeAtBeginning(stringToCheck)
                            // console.log(isPalindromeAtBeginning(stringToCheck), longest)
                        }
                    }
                }
            }
        }
        return longest
    }

    // if palindrome is in the end
    function isPalindromeAtEnd(str) {
        var longest = ""
        this.isPalindrome = longestPalindrome.isPalindrome

        for (var i = str.length - 1; i > -1; i--) {
            if (i > 0) {
                stringToCheck = str.substr(str.length - i)

                if ((stringToCheck.length > 1) && (isPalindrome(stringToCheck))) {
                    if (stringToCheck.length > longest.length) {
                        longest = stringToCheck
                        // console.log(stringToCheck, longest)
                    }
                } 
            } 
        }
        return longest
    }

    longestPalindrome.isPalindrome = isPalindrome
    longestPalindrome.isPalindromeAtBeginning = isPalindromeAtBeginning
    longestPalindrome.isPalindromeAtMiddle = isPalindromeAtMiddle
    longestPalindrome.isPalindromeAtEnd = isPalindromeAtEnd

    var isPal = longestPalindrome.isPalindrome(s)
    if (isPal) {
        return isPal
    } 

    if (s.length === 1) {
        return s
    }

    if (s.length === 2) {
        return s[0]
    }

    else {
        var e = longestPalindrome.isPalindromeAtEnd(s)
        var m = longestPalindrome.isPalindromeAtMiddle(s)
        var b = longestPalindrome.isPalindromeAtBeginning(s)

        // console.log(m, e, b)

        if (!m && !e && !b) {
            return s[0]
        }

        if (m && e && b) {
            if (m.length > e.length && m.length > b.length) {
                return m
            }

            if (e.length > m.length && e.length > b.length) {
                return e
            }

            if (b.length > e.length && b.length > m.length) {
                return b
            }
        }

        else {
            if (m && e && !b) {
                if (m.length > e.length) {
                    return m
                }
                else {
                    return e
                }
            }

            if (m && !e && b) {
                if (m.length > b.length) {
                    return m
                }
                else {
                    return b
                }
            }

            if (!m && e && b) {
                if (e.length > b.length) {
                    return e
                }
                else {
                    return b
                }
            }

            if (m && !e && !b) {
                return m
            }

            if (!m && e && !b) {
                return e
            }

            if (!m && !e && b) {
                return b
            }
        }
    }
}


// console.log(longestPalindrome("babaddtattarrattatddetartrateedredividerb")) //O: redivider      E: ddtattarrattatdd
console.log(longestPalindrome("babaddtattarrattatddetartrateedredividerb"))