Update palindromic substring

Author: sudheerj

README.md

@@ -94,7 +94,7 @@ List of Programs related to data structures and algorithms
 
    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)
+   8. Palindromic substrings: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/8.palindromicSubstrings/palindromicSubstrings.js)  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/8.palindromicSubstrings/palindromicSubstrings.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/8.palindromicSubstrings/palindromicSubstrings.md)
 
    9. Encode and decode strings: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/encodeDecodeStrings.js)
 

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

@@ -5,11 +5,11 @@ Given a string `str`, return the longest palindromic substring of `str`.
 
 ### Examples
 Example 1:
-Input: s = "ababd"
+Input: str = "ababd"
 Output: "aba"
 
 Example 2:
-Input: s = "dbbc"
+Input: str = "dbbc"
 Output: "bb"
 
 **Algorithmic Steps**

src/java1/algorithms/strings/palindromicSubstrings/PalindromicSubstrings.java

@@ -9,13 +9,13 @@ private static int countSubstrings(String str) {
 
         int count = 0;
         for(int i=0; i < str.length(); i++) {
-            count += countPalindrome(str, i, i);
-            count += countPalindrome(str, i, i+1);
+            count += countPalindromes(str, i, i);
+            count += countPalindromes(str, i, i+1);
         }
         return count;
     }
 
-    private static int countPalindrome(String str, int left, int right) {
+    private static int countPalindromes(String str, int left, int right) {
 
         int count = 0;
         while(left >=0 && right < str.length() && str.charAt(left) == str.charAt(right)) {
@@ -30,7 +30,7 @@ public static void main(String[] args) {
         String str = "baaab";
         System.out.println(countSubstrings(str));
 
-        String str1 = "abc";
+        String str1 = "abcd";
         System.out.println(countSubstrings(str1));
 
         String str2 = "aaa";

src/java1/algorithms/strings/palindromicSubstrings/PalindromicSubstrings.md

@@ -1,20 +1,37 @@
+**Description:**
+Given a string `str`,  return the number of substrings within`str` that are palindromes.
+
+**Note:**A palindrome is a string that reads the same backward as forward.
+
+### Examples
+Example 1:
+Input: str = "abcd"
+Output: 4
+
+Example 2:
+Input: str = "aaa"
+Output: 3
+
+
 **Algorithmic Steps**
-This problem is solved with the help of Two pointer approach(Expand around center). The algorithmic approach can be summarized as follows:
+This problem is solved with the help of **Expand around center** approach. The algorithmic approach can be summarized as follows:
 
-1. Write a preliminary check by returning the input string length when its size is less than 2.
+1. Write a preliminary check by just returning the input string length when its size is less than 2.
 
-2. Initialize count variable to 0, to store the palindromic substrings count.
+2. Initialize count(`count`) variable to 0, which is used to store the palindromic substrings count.
 
-3. Iterate over the input string using an iteration variable i(from 0 to length of string).
+3. Iterate over the input string using an iteration variable `i`(from 0 to end of string).
 
-4. For each iteration, calculate the total count of odd palindromic substrings using a separate common function(step6). This common function accepts current iteration variable `i` as left and right pointer values.
+4. For each iteration, calculate the total count of odd palindromic substrings using a separate common function(step6). This common function accepts current iteration variable `i` for both left and right pointer values.
 
 5. For each iteration, calculate the total count of even palindromic substrings using a separate common function(step6). This common function accepts current iteration variable `i` as left and `i+1` as right pointer values.
 
-6. The common function iterate over the given string using starting(i.e, left) and ending(i.e, right) index arguments. The left pointer is going to be decremented and right pointer is going to be incremented  whenever the respective character values are equal.
+6. The common function is created to iterate over the given string using starting(i.e, `left`) and ending(i.e, `right`) index arguments. The left pointer is going to be decremented and right pointer is going to be incremented whenever the respective character values are equal.
 
-7. The sum of even and odd palindromic substring count is going to be returned as total count for palindromic substrings.
+7. The sum of even and odd palindromic substring's count is going to be returned as total count for palindromic substrings.
 
 
 **Time and Space complexity:**
-This algorithm has a time complexity of O(n * 2)( O(n * 2) + O(n * 2)) because either odd or event need to iterate over the input string atleast once which takes O(n) and substrings calculate on each position takes O(n). Also, it takes space complexity of O(1) without using any data structure.
+This algorithm has a time complexity of `O(n * 2)`(i.e, `O(n * 2) + O(n * 2)`) because finding both odd and event length palindrome takes `O(n) +O(n)` time complexity and it needs to be repeated on each character position which takes O(n). 
+
+Also, it takes space complexity of `O(1)` without using any additional data structure.

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

@@ -5,11 +5,11 @@ Given a string `str`, return the longest palindromic substring of `str`.
 
 ### Examples
 Example 1:
-Input: s = "ababd"
+Input: str = "ababd"
 Output: "aba"
 
 Example 2:
-Input: s = "dbbc"
+Input: str = "dbbc"
 Output: "bb"
 
 **Algorithmic Steps**

src/javascript/algorithms/strings/palindromicSubstrings/palindromicStrings.js src/javascript/algorithms/strings/8.palindromicSubstrings/palindromicSubstrings.js

@@ -1,6 +1,6 @@
 //Expand around center:- TC:O(n*2) SC:O(1)
 
-function countPalindromicStrings(str) {
+function countPalindromicSubstrings(str) {
 
     if(str.length < 2) return str.length;
 
@@ -23,10 +23,10 @@ function countPalindromes(str, left, right) {
 }
 
 let str = "baaab";
-console.log(countPalindromicStrings(str));
+console.log(countPalindromicSubstrings(str));
 
-let str1 = "abc";
-console.log(countPalindromicStrings(str1));
+let str1 = "abcd";
+console.log(countPalindromicSubstrings(str1));
 
 let str2 = "aaa";
-console.log(countPalindromicStrings(str2));
+console.log(countPalindromicSubstrings(str2));

src/javascript/algorithms/strings/8.palindromicSubstrings/palindromicSubstrings.md

@@ -0,0 +1,37 @@
+**Description:**
+Given a string `str`,  return the number of substrings within`str` that are palindromes.
+
+**Note:**A palindrome is a string that reads the same backward as forward.
+
+### Examples
+Example 1:
+Input: str = "abcd"
+Output: 4
+
+Example 2:
+Input: str = "aaa"
+Output: 3
+
+
+**Algorithmic Steps**
+This problem is solved with the help of **Expand around center** approach. The algorithmic approach can be summarized as follows:
+
+1. Write a preliminary check by just returning the input string length when its size is less than 2.
+
+2. Initialize count(`count`) variable to 0, which is used to store the palindromic substrings count.
+
+3. Iterate over the input string using an iteration variable `i`(from 0 to end of string).
+
+4. For each iteration, calculate the total count of odd palindromic substrings using a separate common function(step6). This common function accepts current iteration variable `i` for both left and right pointer values.
+
+5. For each iteration, calculate the total count of even palindromic substrings using a separate common function(step6). This common function accepts current iteration variable `i` as left and `i+1` as right pointer values.
+
+6. The common function is created to iterate over the given string using starting(i.e, `left`) and ending(i.e, `right`) index arguments. The left pointer is going to be decremented and right pointer is going to be incremented whenever the respective character values are equal.
+
+7. The sum of even and odd palindromic substring's count is going to be returned as total count for palindromic substrings.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n * 2)`(i.e, `O(n * 2) + O(n * 2)`) because finding both odd and event length palindrome takes `O(n) +O(n)` time complexity and it needs to be repeated on each character position which takes O(n). 
+
+Also, it takes space complexity of `O(1)` without using any additional data structure.