Update encoding and decoding problem

Author: sudheerj

README.md

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

src/java1/algorithms/strings/EncodeDecodeStrings.java

@@ -0,0 +1,42 @@
+//TC: O(n) SC: O(n)
+package java1.algorithms.strings.encodeDecodeStrings;
+
+import java.util.*;
+
+public class EncodeDecodeStrings {
+    private static String encodeString(String[] strs) {
+        String encodedStr = "";
+        for(String str: strs) {
+            encodedStr += str.length()+"#"+str;
+        }
+        return encodedStr;
+    }
+
+    private static List<String> decodeString(String str) {
+        List<String> decodedStringsList = new ArrayList<>();
+
+        int i=0;
+        while(i < str.length()) {
+            int j = i;
+            while(str.charAt(j) != '#') j++;
+            int start = j+1;
+            int wordLength = Integer.parseInt(str, i, j, 10);
+            String subStr = str.substring(start, start+wordLength);
+            decodedStringsList.add(subStr);
+            i = start+wordLength;
+        }
+        return decodedStringsList;
+    }
+
+    public static void main(String[] args) {
+        String[] strs1 = {"learn", "datastructure", "algorithms", "easily"};
+        String encodedStr1 = encodeString(strs1);
+        System.out.println(encodedStr1);
+        System.out.println(decodeString(encodedStr1));
+
+        String[] strs2 = {"one", "two", "three"};
+        String encodedStr2 = encodeString(strs2);
+        System.out.println(encodedStr2);
+        System.out.println(decodeString(encodedStr2));
+    }
+}

src/java1/algorithms/strings/encodeDecodeStrings/EncodeDecodeStrings.java

@@ -0,0 +1,45 @@
+**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"]
+
+Example 2:
+Input: ["one", "two", "three"]
+Output: ["one", "two", "three"]
+
+
+**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:
+
+**Encode string**
+1. Initialize an empty string(`encodedStr`) to store the encoded string.
+
+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.
+
+3. Return the encoded string as an output.
+
+**Decode string**
+
+1. Initialize an empty array(`decodedStringsList`) to store the decoded string.
+
+2. Initialize an index variable(`i`) to 0, which is used to iterate over the input string.
+
+3. Iterate over an input string until the end of its length.
+
+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 beggining of a string.
+
+6. Calculate the word length followed by substring using the index variables.
+
+7. Add each substring to the decoded string list. 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 operation. In the same way, we need iterate over all the characters of a encoded string for decoding operation.
+
+Also, it takes space complexity of `O(n)` to store all the characters.

src/java1/algorithms/strings/encodeDecodeStrings/EncodeDecodeStrings.md

@@ -0,0 +1,33 @@
+//TC: O(n) SC: O(n)
+function encodeStrings(strs) {
+  let encodedStr = "";
+  for (let str of strs) {
+    encodedStr += str.length + "#" + str;
+  }
+  return encodedStr;
+}
+
+function decodeString(str) {
+  let decodedStrArr = [];
+  let i = 0;
+  while (i < str.length) {
+    let j = i;
+    while (str[j] != "#") j++;
+    let start = j+1;
+    let wordLength = Number.parseInt(str.substring(i, j));
+    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));
+
+let strs2 = ["one", "two", "three"];
+let encodedStr2 = encodeStrings(strs2);
+console.log(encodedStr2);
+console.log(decodeString(encodedStr2));

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

@@ -0,0 +1,45 @@
+**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"]
+
+Example 2:
+Input: ["one", "two", "three"]
+Output: ["one", "two", "three"]
+
+
+**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:
+
+**Encode string**
+1. Initialize an empty string(`encodedStr`) to store the encoded string.
+
+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.
+
+3. Return the encoded string as an output.
+
+**Decode string**
+
+1. Initialize an empty array(`decodedStrArr`) to store the decoded string.
+
+2. Initialize an index variable(`i`) to 0, which is used to iterate over the input string.
+
+3. Iterate over an input string until the end of its length.
+
+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 beggining 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.