Update longest palindromic substring

Author: sudheerj

README.md

@@ -92,7 +92,7 @@ List of Programs related to data structures and algorithms
 
    6. Valid palindrome: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/6.validPalindrome/validPalindrome.js)  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/6.validPalindrome/validPalindrome.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/6.validPalindrome/validPalindrome.md)
 
-   7. Longest palindromic substring: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/longestPalindromicSubstring.js)
+   7. Longest palindromic substring: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/7.longestPalindromicSubstring/longestPalindromicSubstring.js)  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/7.longestPalindromicSubstring/longestPalindromicSubstring.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/7.longestPalindromicSubstring/longestPalindromicSubstring.md)
 
    8. Palindromic substrings: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/palindromicStrings.js)
 

src/java1/algorithms/strings/LongestPalindromicSubstring.java

@@ -0,0 +1,73 @@
+//Expanding around center:- TC:O(n) SC:O(n)
+package java1.algorithms.strings.longestPalindromicSubstring;
+
+public class LongestPalindromicSubstring {
+
+    private static String longestPalindromicSubstring1(String str) {
+        if(str.length() <= 1) return str;
+
+        String maxPalindromicSubstr = str.substring(0, 1);
+
+        for (int i = 0; i < str.length(); i++) {
+            String maxOddPalindromicSubstr = expandAroundCenter(str, i, i);
+            String maxEvenPalindromicSubstr = expandAroundCenter(str, i, i+1);
+
+            if(maxOddPalindromicSubstr.length() > maxPalindromicSubstr.length()) {
+                maxPalindromicSubstr = maxOddPalindromicSubstr;
+            }
+            if(maxEvenPalindromicSubstr.length() > maxPalindromicSubstr.length()) {
+                maxPalindromicSubstr = maxEvenPalindromicSubstr;
+            }
+        }
+
+        return maxPalindromicSubstr;
+    }
+
+    private static String expandAroundCenter(String str, int left, int right) {
+        while(left >=0 && right < str.length() && str.charAt(left) == str.charAt(right)) {
+            left--;
+            right++;
+        }
+        return str.substring(left+1, right);
+    }
+
+    private static String longestPalindromicSubstring2(String str){
+        String longestSubstr = "";
+        int longestSubstrLen = 0;
+        int left =0, right = 0;
+
+        for(int i=0; i< str.length(); i++) {
+            // Odd length
+            left = i; right = i;
+            while(left >=0 && right < str.length() && str.charAt(left) == str.charAt(right)) {
+                if(right-left+1 > longestSubstrLen) {
+                    longestSubstr = str.substring(left, right+1);
+                    longestSubstrLen = right-left+1;
+                }
+                left--;
+                right++;
+            }
+            // Even length
+            left = i; right = i+1;
+            while(left >=0 && right < str.length() && str.charAt(left) == str.charAt(right)) {
+                if(right-left+1 > longestSubstrLen) {
+                    longestSubstr = str.substring(left, right+1);
+                    longestSubstrLen = right-left+1;
+                }
+                left--;
+                right++;
+            }
+        }
+        return longestSubstr;
+    }
+
+    public static void main(String[] args) {
+        String str1 = "ababd";
+        String str2 = "dbbc";
+        System.out.println(longestPalindromicSubstring1(str1));
+        System.out.println(longestPalindromicSubstring1(str2));
+        System.out.println(longestPalindromicSubstring2(str1));
+        System.out.println(longestPalindromicSubstring2(str2));
+    }
+    
+}

src/java1/algorithms/strings/longestPalindromicSubstring/LongestPalindromicSubstring.java

@@ -0,0 +1,37 @@
+**Description:**
+Given a string `str`, return the longest palindromic substring of `str`.
+
+**Note:**A palindrome is a string that reads the same backward as forward. If the characters includes non-alphanumerical letters, they needs to be removed and uppercase letters should be converted in a lowercase format. If there are multiple palindromic substrings that have the same length, return any one of them.
+
+### Examples
+Example 1:
+Input: s = "ababd"
+Output: "aba"
+
+Example 2:
+Input: s = "dbbc"
+Output: "bb"
+
+**Algorithmic Steps**
+This problem is solved with the help of **expanding around center** approach where we expand the input string at each position. The algorithmic approach can be summarized as follows:
+
+1. Add a preliminary check by returning `str` if the length of the string is less than or equal to 1.
+
+2. Initialize longest palindromic substring(`maxPalindromicSubstr`) to first character of given string.
+
+3. Iterate over an input string until the end of string.
+
+4. Create a method(`expandAroundCenter`) to expand the string from center for each character position. This function iterates over the string based on left and right pointers. The left pointer will be decremented and right pointer will be incremented when the characters are equals from both the ends and also both pointers exists with in the range of string boundaries.
+
+5. Invoke the method created in the previous step to find both odd(`left = right = i`) and even(`left = i`, `right = i+1`) longest palindromes.
+
+6. Update the longest palindrome by comparing the current longest palindrome with odd and even palindromes. 
+
+7. Repeat steps 4-6 until all the characters traversed within given input string.
+
+8. Return longest palindromic substring(`maxPalindromicSubstr`) from the main function.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n*2)` because expanding a palindrome around its center could take `O(n)` and it needs to repeated for each character(i.e, `n` times). 
+
+Also, it doesn't requires any additional data structure. So the space complexity is `O(1)`.

src/java1/algorithms/strings/longestPalindromicSubstring/LongestPalindromicSubstring.md

@@ -0,0 +1,68 @@
+//Expanding around center:- TC:O(n) SC:O(n)
+
+function longestPalindromicSubstring1(str) {
+    if(str.length <= 1) return str;
+
+    let maxPalindromicSubstr = str.substring(0, 1);
+
+    for (let i = 0; i < str.length; i++) {
+        let maxOddPalindromicSubstr = expandAroundCenter(str, i, i);
+        let maxEvenPalindromicSubstr =  expandAroundCenter(str, i, i+1);    
+
+        if(maxOddPalindromicSubstr.length > maxPalindromicSubstr.length) {
+            maxPalindromicSubstr = maxOddPalindromicSubstr;
+        }
+        if(maxEvenPalindromicSubstr.length > maxPalindromicSubstr.length) {
+            maxPalindromicSubstr = maxEvenPalindromicSubstr;
+        }
+    }
+
+    return maxPalindromicSubstr;
+}
+
+function expandAroundCenter(str, left, right) {
+    while(left >=0 && right < str.length && str[left] === str[right]) {
+        left--;
+        right++;
+    }
+
+    return str.substring(left+1, right);
+}
+
+//Expanding around center using redundant code block:- TC:O(n) SC:O(n)
+function longestPalindromicSubstring2(str) {
+    let longestSubstr ="";
+    let longestSubstrLen = 0;
+    let left = 0, right = 0;
+
+    for(let i=0; i< str.length; i++) {
+        //Odd length
+        left = i; right = i;
+        while(left >=0 && right < str.length && str[left] === str[right]) {
+            if(right-left+1 > longestSubstrLen) {
+                longestSubstr = str.substring(left, right+1);
+                longestSubstrLen = right-left+1;
+            }
+            left--;
+            right++;
+        }
+        //Even length
+        left = i; right = i+1;
+        while(left >=0 && right < str.length && str[left] === str[right]) {
+            if(right-left+1 > longestSubstrLen) {
+                longestSubstr = str.substring(left, right+1);
+                longestSubstrLen = right-left+1;
+            }
+            left--;
+            right;
+        }
+    }
+    return longestSubstr;
+}
+
+let str1 = "ababd";
+let str2 = "dbbc";
+console.log(longestPalindromicSubstring1(str1));
+console.log(longestPalindromicSubstring1(str2));
+console.log(longestPalindromicSubstring2(str1));
+console.log(longestPalindromicSubstring2(str2));

src/javascript/algorithms/strings/7.longestPalindromicSubstring/longestPalindromicSubstring.js

@@ -0,0 +1,37 @@
+**Description:**
+Given a string `str`, return the longest palindromic substring of `str`.
+
+**Note:**A palindrome is a string that reads the same backward as forward. If the characters includes non-alphanumerical letters, they needs to be removed and uppercase letters should be converted in a lowercase format. If there are multiple palindromic substrings that have the same length, return any one of them.
+
+### Examples
+Example 1:
+Input: s = "ababd"
+Output: "aba"
+
+Example 2:
+Input: s = "dbbc"
+Output: "bb"
+
+**Algorithmic Steps**
+This problem is solved with the help of **expanding around center** approach where we expand the input string at each position. The algorithmic approach can be summarized as follows:
+
+1. Add a preliminary check by returning `str` if the length of the string is less than or equal to 1.
+
+2. Initialize longest palindromic substring(`maxPalindromicSubstr`) to first character of given string.
+
+3. Iterate over an input string until the end of string.
+
+4. Create a function(`expandAroundCenter`) to expand the string from center for each character position. This function iterates over the string based on left and right pointers. The left pointer will be decremented and right pointer will be incremented when the characters are equals from both the ends and also both pointers exists with in the range of string boundaries.
+
+5. Invoke the function created in the previous step to find both odd(`left = right = i`) and even(`left = i`, `right = i+1`) longest palindromes.
+
+6. Update the longest palindrome by comparing the current longest palindrome with odd and even palindromes. 
+
+7. Repeat steps 4-6 until all the characters traversed within given input string.
+
+8. Return longest palindromic substring(`maxPalindromicSubstr`) from the main function.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n*2)` because expanding a palindrome around its center could take `O(n)` and it needs to repeated for each character(i.e, `n` times). 
+
+Also, it doesn't requires any additional data structure. So the space complexity is `O(1)`.