update palindrome substrings and encode decode string algorithms

Author: sudheerj

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

@@ -1,32 +1,47 @@
-//Expand around center:- TC:O(n*2) SC:O(1)
-
+/**
+ * TC:O(n*2) SC:O(1)
+ * Counts the number of palindromic substrings in a given string using expand-around-center.
+ * @param {string} str
+ * @returns {number}
+ */
 function countPalindromicSubstrings(str) {
-
- if(str.length < 2) return str.length;
-
- let count = 0;
- for(let i=0; i< str.length; i++) {
- count += countPalindromes(str, i, i);
- count += countPalindromes(str, i, i+1);
- }
- return count;
+ if (!str || str.length < 1) return 0;
+ let count = 0;
+ for (let i = 0; i < str.length; i++) {
+ count += expandAroundCenter(str, i, i); // Odd length palindromes
+ count += expandAroundCenter(str, i, i + 1); // Even length palindromes
+ }
+ return count;
 }
 
-function countPalindromes(str, left, right) {
- let count = 0;
- while(left >=0 && right < str.length && str[left] === str[right]) {
- count++;
- left--;
- right++;
- }
- return count;
+/**
+ * Expands around the given center and counts palindromic substrings.
+ * @param {string} str
+ * @param {number} left
+ * @param {number} right
+ * @returns {number}
+ */
+function expandAroundCenter(str, left, right) {
+ let count = 0;
+ while (left >= 0 && right < str.length && str[left] === str[right]) {
+ count++;
+ left--;
+ right++;
+ }
+ return count;
 }
 
-let str = "baaab";
-console.log(countPalindromicSubstrings(str));
+// Test cases
+const testCases = [
+ { str: "baaab", expected: 9 },
+ { str: "abcd", expected: 4 },
+ { str: "aaa", expected: 6 },
+ { str: "", expected: 0 },
+ { str: "a", expected: 1 },
+ { str: "abccba", expected: 9 },
+];
 
-let str1 = "abcd";
-console.log(countPalindromicSubstrings(str1));
-
-let str2 = "aaa";
-console.log(countPalindromicSubstrings(str2));
+for (const { str, expected } of testCases) {
+ const result = countPalindromicSubstrings(str);
+ console.log(`Input: "${str}" | Output: ${result} | Expected: ${expected}`);
+}

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

@@ -1,37 +1,36 @@
 **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.
+**Note:** A palindrome is a string that reads the same backward as forward.
 
-### Examples
-Example 1:
-Input: str = "abcd"
-Output: 4
+## Examples
 
-Example 2:
-Input: str = "aaa"
-Output: 3
+**Example 1:** 
+Input: `str = "abcd"` 
+Output: `4` 
+Explanation: Each character is a palindrome.
 
+**Example 2:** 
+Input: `str = "aaa"` 
+Output: `6` 
+Explanation: All substrings are palindromes: `"a"`, `"a"`, `"a"`, `"aa"`, `"aa"`, `"aaa"`.
 
-**Algorithmic Steps**
-This problem is solved with the help of **Expanding around center** approach. The algorithmic approach can be summarized as follows:
+**Example 3:** 
+Input: `str = "baaab"` 
+Output: `9`
 
-1. Write a preliminary check by just returning the input string length when its size is less than 2.
+## Algorithm
 
-2. Initialize count(`count`) variable to 0, which is used to store the palindromic substrings count.
+This problem is efficiently solved using the **expand around center** approach:
 
-3. Iterate over the input string using an iteration variable `i`(from 0 to end of string).
+1. If the string is empty, return 0.
+2. For each character in the string, treat it as the center of a palindrome and expand outwards to count all odd and even length palindromic substrings.
+3. Use a helper function to expand around the center and count palindromes.
+4. Sum the counts for all centers and return the total.
 
-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.
+## Complexity
 
-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.
+- **Time Complexity:** O(n²)(i.e, O(n²) + O(n²)), where n is the length of the string (for each center, expand up to n). This is 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).
 
-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.
+- **Space Complexity:** O(1), as no extra data structures are used.

src/javascript/algorithms/strings/9.encodeDecodeStrings/encodeDecodeStrings.js

@@ -1,4 +1,10 @@
-//TC: O(n) SC: O(n)
+/**
+ * TC: O(n) SC: O(n)
+ * Encodes a list of strings to a single string.
+ * Uses length-prefix encoding with '#' as a delimiter.
+ * @param {string[]} strs
+ * @returns {string}
+ */
 function encodeStrings(strs) {
  let encodedStr = "";
  for (let str of strs) {
@@ -7,27 +13,42 @@ function encodeStrings(strs) {
  return encodedStr;
 }
 
+/**
+ * Decodes a single string to a list of strings.
+ * @param {string} str
+ * @returns {string[]}
+ */
 function decodeString(str) {
  let decodedStrArr = [];
  let i = 0;
  while (i < str.length) {
  let j = i;
- while (str[j] != "#") j++;
- let start = j+1;
+ while (str[j] !== "#" && j < str.length) j++;
  let wordLength = Number.parseInt(str.substring(i, j));
+ let start = j + 1;
  let subStr = str.substring(start, start + wordLength);
  decodedStrArr.push(subStr);
  i = start + wordLength;
  }
  return decodedStrArr;
 }
 
-let strs1 = ["learn", "datastructure", "algorithms", "easily"];
-let encodedStr1 = encodeStrings(strs1);
-console.log(encodedStr1);
-console.log(decodeString(encodedStr1));
+// Test cases
+const testCases = [
+ ["learn", "datastructure", "algorithms", "easily"],
+ ["one", "two", "three"],
+ ["", "a", ""],
+ ["#", "##", "abc#def"],
+ [],
+ ["", ""],
+];
 
-let strs2 = ["one", "two", "three"];
-let encodedStr2 = encodeStrings(strs2);
-console.log(encodedStr2);
-console.log(decodeString(encodedStr2));
+for (const arr of testCases) {
+ const encoded = encodeStrings(arr);
+ const decoded = decodeString(encoded);
+ console.log(
+ `Input: ${JSON.stringify(
+ arr
+ )} | Encoded: "${encoded}" | Decoded: ${JSON.stringify(decoded)}`
+ );
+}

src/javascript/algorithms/strings/9.encodeDecodeStrings/encodeDecodeStrings.md

@@ -1,45 +1,39 @@
 **Description:**
-Write an algorithm to encode a list of strings to a single string. After that, the encoded string is decoded back to the original list of strings. Please implement `encode` and `decode`
 
-### Examples
-Example 1:
-Input: ["learn", "datastructure", "algorithms", "easily"]
-Output: ["learn", "datastructure", "algorithms", "easily"]
+Write an algorithm to encode a list of strings to a single string, and then decode it back to the original list. Implement both `encode` and `decode` functions.
 
-Example 2:
-Input: ["one", "two", "three"]
-Output: ["one", "two", "three"]
+#### Examples
 
+**Example 1:** 
+Input: `["learn", "datastructure", "algorithms", "easily"]` 
+Output: `["learn", "datastructure", "algorithms", "easily"]`
 
-**Algorithmic Steps**
-This problem is solved with the help of basic string and array built-in operations. The algorithmic approach can be summarized as follows:
+**Example 2:** 
+Input: `["one", "two", "three"]` 
+Output: `["one", "two", "three"]`
 
-**Encode string**
-1. Initialize an empty string(`encodedStr`) to store the encoded string.
+**Example 3:** 
+Input: `["#", "##", "abc#def"]` 
+Output: `["#", "##", "abc#def"]`
 
-2. Iterate over the array of strings. For each string iteration, add a prefix with the combination of string length and special(`#`) symbol before each word/string.
+## Algorithm
 
-3. Return the encoded string as an output.
+### Encode
 
-**Decode string**
+1. Initialize an empty string `encodedStr`.
+2. For each string in the input array, append its length, a delimiter (e.g., `#`), and the string itself to `encodedStr`.
+3. Return the concatenated string.
 
-1. Initialize an empty array(`decodedStrArr`) to store the decoded string.
+### Decode
 
-2. Initialize an index variable(`i`) to 0, which is used to iterate over the input string.
+1. Initialize an empty array `decodedStrArr` and an index variable `i = 0`.
+2. While `i` is less than the length of the encoded string:
+ - Find the next delimiter (`#`) to determine the length prefix.
+ - Parse the length, extract the substring of that length, and add it to the result array.
+ - Move the index past the extracted substring and repeat.
+3. Return the array of decoded strings.
 
-3. Iterate over an input string until the end of its length.
+## Complexity
 
-4. Create a temporary variable(`j`) which is assigned to index variable.
-
-5. Skip the prefix related to each string's length until the character reaches special(`#`) symbol. The number of characters ignored are indicated by incremental value of `j`. The next character position(`j+1`) indicates the beginning of a string.
-
-6. Calculate the word length followed by substring using the index variables.
-
-7. Add each substring to the decoded string array. Also, increment the index variable to be used for the next substring.
-
-8. Repeat steps 4-7 until all the strings decoded and return the decoded strings.
-
-**Time and Space complexity:**
-This algorithm has a time complexity of `O(n)` for both encoding and decoding functions, where `n` is the number of total characters for each string in the input array. This is because we need to iterate over each string in the array to perform constant-time operations for encoding function. In the same way, we need iterate over all the characters of a encoded string for decoding function.
-
-Also, it takes space complexity of `O(n)` to store all the characters.
+- **Time Complexity:** O(n) for both encoding and decoding, where n is the total number of characters in all strings.
+- **Space Complexity:** O(n), for the encoded string and the decoded array.