Add Longest Palindrom in a String

Author: marttp

kotlin/Dynamic Programming/LongestPalindromInAString.kt

@@ -0,0 +1,38 @@
+fun longestPalindromInAString(s: String): String {
+    val n = s.length
+    if (n == 0) {
+        return ""
+    }
+    val dp = Array(n) { BooleanArray(n) }
+    var maxLen = 1
+    var startIndex = 0
+    // Base case: a single character is always a palindrome.
+    for (i in 0 until n) {
+        dp[i][i] = true
+    }
+    // Base case: a substring of length two is a palindrome if both
+    // characters are the same.
+    for (i in 0 until n - 1) {
+        if (s[i] == s[i + 1]) {
+            dp[i][i + 1] = true
+            maxLen = 2
+            startIndex = i
+        }
+    }
+    // Find palindromic substrings of length 3 or greater.
+    for (substringLen in 3..n) {
+        // Iterate through each substring of length 'substringLen'.
+        for (i in 0 until n - substringLen + 1) {
+            val j = i + substringLen - 1
+            // If the first and last characters are the same, and the
+            // inner substring is a palindrome, then the current
+            // substring is a palindrome.
+            if (s[i] == s[j] && dp[i + 1][j - 1]) {
+                dp[i][j] = true
+                maxLen = substringLen
+                startIndex = i
+            }
+        }
+    }
+    return s.substring(startIndex, startIndex + maxLen)
+}

kotlin/Dynamic Programming/LongestPalindromInAStringExpanding.kt

@@ -0,0 +1,35 @@
+fun longestPalindromeInAStringExpanding(s: String): String {
+    val n = s.length
+    var start = 0
+    var maxLen = 0
+    for (center in 0 until n) {
+        // Check for odd-length palindromes.
+        val (oddStart, oddLength) = expandPalindrome(center, center, s)
+        if (oddLength > maxLen) {
+            start = oddStart
+            maxLen = oddLength
+        }
+        // Check for even-length palindromes.
+        if (center < n - 1 && s[center] == s[center + 1]) {
+            val (evenStart, evenLength) = expandPalindrome(center, center + 1, s)
+            if (evenLength > maxLen) {
+                start = evenStart
+                maxLen = evenLength
+            }
+        }
+    }
+    return s.substring(start, start + maxLen)
+}
+
+// Expands outward from the center of a base case to identify the start
+// index and length of the longest palindrome that extends from this
+// base case.
+fun expandPalindrome(left: Int, right: Int, s: String): Pair<Int, Int> {
+    var l = left
+    var r = right
+    while (l > 0 && r < s.length - 1 && s[l - 1] == s[r + 1]) {
+        l--
+        r++
+    }
+    return l to r - l + 1
+}