Add reverse words in string problem

Author: sudheerj

README.md

@@ -100,6 +100,8 @@ List of Programs related to data structures and algorithms
 
    10. Greatest common devisor of strings: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/10.greatestCommonDivisor/greatestCommonDivisor.js)  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/10.greatestCommonDivisor/greatestCommonDivisor.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/10.greatestCommonDivisor/greatestCommonDivisor.md)
 
+   11. Reverse words in string: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/11.reverseWordsInString/reverseWordsInString.js)  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/11.reverseWordsInString/reverseWordsInString.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/11.reverseWordsInString/reverseWordsInString.md)
+
 ### Dynamic programming
 
    1. Climbing stairs: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/dynamicProgramming/climbingStairs.js)

src/java1/algorithms/strings/reverseWordsInString/ReverseWordsInString.java

@@ -4,18 +4,6 @@ public class ReverseWordsInString {
 
     // TC: O(n) SC: O(n)
     private static String reverseWordsInString1(String str) {
-        String[] arr = str.split("\\s+");
-
-        String res = "";
-        for (int i = arr.length - 1; i >= 0; i--) {
-            res += arr[i] + " ";
-        }
-
-        return res.substring(0, res.length() - 1);
-    }
-
-    // TC: O(n) SC: O(1)
-    private static String reverseWordsInString2(String str) {
         String[] words = str.split("\\s+");
         int i = 0, j = words.length - 1;
 
@@ -29,9 +17,24 @@ private static String reverseWordsInString2(String str) {
         return String.join(" ", words);
     }
 
+    // TC: O(n) SC: O(n)
+    private static String reverseWordsInString2(String str) {
+        String[] arr = str.split("\\s+");
+
+        String res = "";
+        for (int i = arr.length - 1; i >= 0; i--) {
+            res += arr[i];
+            if(i != 0){
+                res += " ";               
+            }
+        }
+
+        return res.substring(0, res.length());
+    }
+
     public static void main(String[] args) {
-        String str1 = "the sky is blue";
-        String str2 = "  hello world  ";
+        String str1 = "It is fun to learn DSA";
+        String str2 = "  hello DSA  ";
         System.out.println(reverseWordsInString1(str1));
         System.out.println(reverseWordsInString1(str2));
 

src/java1/algorithms/strings/reverseWordsInString/ReverseWordsInString.md

@@ -0,0 +1,33 @@
+**Description:**
+Given an input string `str`, Return a string of the words in reverse order concatenated by a single space without having extra spaces.
+
+### Examples
+Example 1:
+Input: "It is fun to learn DSA"
+Output: "DSA learn to fun is It"
+
+Example 2:
+Input: "hello DSA"
+Output: "DSA hello"
+
+**Algorithmic Steps**
+This problem is solved with the help of basic string and array operations. The algorithmic approach can be summarized as follows:
+
+1. Split the input sentence `str` into array of words based on a space separator(one or more spaces). Store the result into `words` variable.
+
+2. Initialize two pointers (`left` and `right`) pointing to the beginning and ending index of the sentence.
+
+3. Iterate over the input sentence until left pointer is less than or equal to right pointer.
+
+4. Swap the words indexed with left and right pointers.
+
+5. Shrink the window by incrementing left pointer and decrementing the right pointer.
+
+6. Repeat steps 4-5 until the iteration condition failed.
+
+7. Join the reversed words with a space delimitor and return the result.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)` where `n` is the length of first string. This is because we need to traverse the string at once for spliting the string based on a space, reversing the string, and joining the words back to a string. All these operations requires `O(n)`. Since all these operations performed sequentially, the overall time complexity combining these operations doesn't exceed `O(n)`.
+
+Also, it takes space complexity of `O(n)` due to storing all the characters in an array.

src/javascript/algorithms/strings/reverseWordsInString/reverseWordsInString.js

@@ -1,31 +1,30 @@
 //TC: O(n) SC: O(n)
 function reverseWordsInString1(str) {
-  let words = str.trim().split("/s+/");
-  let result = "";
+  let words = str.trim().split(/\s+/);
+  let i = 0, j = words.length - 1;
 
-  for (let i = words.length - 1; i >= 0; i--) {
-    result += words[i] + " ";
+  while (i <= j) {
+    [words[i], words[j]] = [words[j], words[i]];
+    i++;
+    j--;
   }
-
-  return result.slice(0, result.length - 1);
+  return words.join(' ');
 }
 
-//TC: O(n) SC: O(1)
+//TC: O(n) SC: O(n)
 function reverseWordsInString2(str) {
-  let words = str.trim().split("/\s+/");
-  let i = 0, j = str.length - 1;
+  let words = str.trim().split(/\s+/);
+  let result = "";
 
-  while (i <= j) {
-    [words[i], words[j]] = [words[j], words[i]];
-    i++;
-    j--;
+  for (let i = words.length - 1; i >= 0; i--) {
+    result += words[i] + " ";
   }
 
-  return words.join("");
+  return result.slice(0, result.length - 1);
 }
 
-let str1 = "the sky is blue";
-let str2 = "  hello world  ";
+let str1 = "It is fun to learn DSA";
+let str2 = "  hello DSA  ";
 console.log(reverseWordsInString1(str1));
 console.log(reverseWordsInString1(str2));
 

src/javascript/algorithms/strings/reverseWordsInString/reverseWordsInString.md

@@ -0,0 +1,33 @@
+**Description:**
+Given an input string `str`, Return a string of the words in reverse order concatenated by a single space without having extra spaces.
+
+### Examples
+Example 1:
+Input: "It is fun to learn DSA"
+Output: "DSA learn to fun is It"
+
+Example 2:
+Input: "hello DSA"
+Output: "DSA hello"
+
+**Algorithmic Steps**
+This problem is solved with the help of basic string and array operations. The algorithmic approach can be summarized as follows:
+
+1. Split the input sentence `str` into array of words based on a space separator(one or more spaces). Store the result into `words` variable.
+
+2. Initialize two pointers (`left` and `right`) pointing to the beginning and ending index of the sentence.
+
+3. Iterate over the input sentence until left pointer is less than or equal to right pointer.
+
+4. Swap the words indexed with left and right pointers.
+
+5. Shrink the window by incrementing left pointer and decrementing the right pointer.
+
+6. Repeat steps 4-5 until the iteration condition failed.
+
+7. Join the reversed words with a space delimitor and return the result.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)` where `n` is the length of first string. This is because we need to traverse the string at once for spliting the string based on a space, reversing the string, and joining the words back to a string. All these operations requires `O(n)`. Since all these operations performed sequentially, the overall time complexity combining these operations doesn't exceed `O(n)`.
+
+Also, it takes space complexity of `O(n)` due to storing all the characters in an array.