Added linear time solution for Leet Code 1190.

anxious-coder-lhs · anxious-coder-lhs · commit eb9c0647886c · 2020-10-12T12:27:14.000+05:30
diff --git a/README.md b/README.md
@@ -50,7 +50,7 @@ Happy to accept any contributions to this in any langugage.
 15. [Leet Code 362 Design Hit Counter](https://leetcode.com/problems/design-hit-counter/) | [Solution 1](./level_medium/LeetCode_362_Hit_Counter_1.ts) | [Solution 2](./level_medium/LeetCode_362_Hit_Counter_Medium.ts)
 16. [LeetCode Web Crawler 1242](https://leetcode.com/problems/web-crawler-multithreaded/) | [Solution 1 ](./level_medium/LeetCode_WebCrawler_MultiThreaded_1242.java) | [Solution 2](level_medium/LeetCode_WebCrawler_MultiThreaded_1242_1.java)
 17. [Leet Code 554 Brick Wall](https://leetcode.com/problems/brick-wall/) | [Solution 1](./level_medium/LeetCode_554_Brick_Wall_Medium.ts)
-18. [Leet Code 1190 Reverse Substrings Between Each Pair of Paranthesis](https://leetcode.com/problems/reverse-substrings-between-each-pair-of-parentheses/) | [Solution 1](level_medium/LeetCode_1190_Reverse_Substrings.ts)
+18. [Leet Code 1190 Reverse Substrings Between Each Pair of Paranthesis](https://leetcode.com/problems/reverse-substrings-between-each-pair-of-parentheses/) | [Solution 1](level_medium/LeetCode_1190_Reverse_Substrings.ts) | [Solution Optimized](level_medium/LeetCode_1190_Reverse_Substrings_1.ts)
 
 
 ## Hard
diff --git a/level_medium/LeetCode_1190_Reverse_Substrings.ts b/level_medium/LeetCode_1190_Reverse_Substrings.ts
@@ -10,7 +10,8 @@
  * The elements of the internal brackets are added after reversing them back into the
  * stack for further processing.
  * 
- * Complexity: Time O(n), Space O(n)
+ * Complexity: Time O(n^2) in the worst case as the loop for stack might be happening almost n/2 times.
+ * Space O(n)
  * 
  * @param s 
  */
diff --git a/level_medium/LeetCode_1190_Reverse_Substrings_1.ts b/level_medium/LeetCode_1190_Reverse_Substrings_1.ts
@@ -0,0 +1,57 @@
+/**
+ * Problem: Leet Code 1190.
+ * 
+ * Solution: Solution uses an intuitive approach which is a linear time approach of solving the 
+ * problem. Given the problem, the positions of the characters within braces are reversed
+ * a number of times. The inner positions(braces) are reversed whenever we get another
+ * braces at the end.
+ * 
+ * If we start producing the results from the outer boundaries in the reverse order, which is
+ * the right to left direction, we can switch the direction of listing (left to right), upon
+ * encountering an internal braces. This also means that the listing position should also
+ * change from left boundary to right boundary, as opposed to right boundary to left boundary.
+ * 
+ * The process continues changing the direction of listing and the boundary start and end
+ * position.
+ * 
+ * Complexity: Time O(n) and Space O(n).
+ * 
+ * @param s 
+ */
+function reverseParentheses(s: string): string {
+    
+    // Building a pair wise list of all the braces, so that the elements within can be reversed.
+    const pairs: number[] = Array(s.length);
+    const stack: number[] = []
+    for (let idx = 0; idx < s.length; idx++) {
+        if (s[idx] === '(') {
+            stack.push(idx);
+        } else if (s[idx] === ')') {
+            // Saving pairs of opposing positions which mark the boundaries for reversal.
+            const openingPos = stack.pop();
+            if (openingPos !== undefined) {
+                pairs[idx] = openingPos;
+                pairs[openingPos] = idx;    
+            }
+        }
+    }
+    
+    
+    // Use the boundaries for reversal traversing in either (left->right) or (right->left)
+    const result: string[] = []
+    for (let pos = 0, direction = 1; pos < s.length; pos += direction) {
+        // Push the element in the final result stack moving either to left or right.
+        // If moving from right to left, we swtich the position to the right and direction -1
+        // If moving from left to right, we switch position again to the left and direction to 1
+        const elem = s[pos];
+        if (elem === '(' || elem === ')') {
+            // Need to change the position to reverse and direction to reverse.
+            pos = pairs[pos];
+            direction *= -1;
+        } else {
+            result.push(s[pos]);
+        }
+    }
+    
+    return result.join("");
+};

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,8 @@`
`10`	`10`	`* The elements of the internal brackets are added after reversing them back into the`
`11`	`11`	`* stack for further processing.`
`12`	`12`	`*`
`13`		`- * Complexity: Time O(n), Space O(n)`
	`13`	`+ * Complexity: Time O(n^2) in the worst case as the loop for stack might be happening almost n/2 times.`
	`14`	`+ * Space O(n)`
`14`	`15`	`*`
`15`	`16`	`* @param s`
`16`	`17`	`*/`