Update README_EN.md

Author: yanglbme

solution/1100-1199/1190.Reverse Substrings Between Each Pair of Parentheses/README_EN.md

@@ -66,9 +66,9 @@ tags:
 
 ### Solution 1: Simulation
 
-We can use a double-ended queue or stack to simulate the reversal process.
+We can directly use a stack to simulate the reversal process.
 
-The time complexity is $O(n^2)$, where $n$ is the length of the string $s$.
+The time complexity is $O(n^2)$, and the space complexity is $O(n)$, where $n$ is the length of the string $s$.
 
 <!-- tabs:start -->
 
@@ -79,46 +79,37 @@ class Solution:
     def reverseParentheses(self, s: str) -> str:
         stk = []
         for c in s:
-            if c == ')':
+            if c == ")":
                 t = []
-                while stk[-1] != '(':
+                while stk[-1] != "(":
                     t.append(stk.pop())
                 stk.pop()
                 stk.extend(t)
             else:
                 stk.append(c)
-        return ''.join(stk)
+        return "".join(stk)
 ```
 
 #### Java
 
 ```java
 class Solution {
     public String reverseParentheses(String s) {
-        int n = s.length();
-        int[] d = new int[n];
-        Deque<Integer> stk = new ArrayDeque<>();
-        for (int i = 0; i < n; ++i) {
-            if (s.charAt(i) == '(') {
-                stk.push(i);
-            } else if (s.charAt(i) == ')') {
-                int j = stk.pop();
-                d[i] = j;
-                d[j] = i;
-            }
-        }
-        StringBuilder ans = new StringBuilder();
-        int i = 0, x = 1;
-        while (i < n) {
-            if (s.charAt(i) == '(' || s.charAt(i) == ')') {
-                i = d[i];
-                x = -x;
+        StringBuilder stk = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            if (c == ')') {
+                StringBuilder t = new StringBuilder();
+                while (stk.charAt(stk.length() - 1) != '(') {
+                    t.append(stk.charAt(stk.length() - 1));
+                    stk.deleteCharAt(stk.length() - 1);
+                }
+                stk.deleteCharAt(stk.length() - 1);
+                stk.append(t);
             } else {
-                ans.append(s.charAt(i));
+                stk.append(c);
             }
-            i += x;
         }
-        return ans.toString();
+        return stk.toString();
     }
 }
 ```
@@ -170,6 +161,27 @@ func reverseParentheses(s string) string {
 }
 ```
 
+#### TypeScript
+
+```ts
+function reverseParentheses(s: string): string {
+    const stk: string[] = [];
+    for (const c of s) {
+        if (c === ')') {
+            const t: string[] = [];
+            while (stk.at(-1)! !== '(') {
+                t.push(stk.pop()!);
+            }
+            stk.pop();
+            stk.push(...t);
+        } else {
+            stk.push(c);
+        }
+    }
+    return stk.join('');
+}
+```
+
 #### JavaScript
 
 ```js
@@ -178,83 +190,38 @@ func reverseParentheses(s string) string {
  * @return {string}
  */
 var reverseParentheses = function (s) {
-    const n = s.length;
-    const d = new Array(n).fill(0);
     const stk = [];
-    for (let i = 0; i < n; ++i) {
-        if (s[i] == '(') {
-            stk.push(i);
-        } else if (s[i] == ')') {
-            const j = stk.pop();
-            d[i] = j;
-            d[j] = i;
-        }
-    }
-    let i = 0;
-    let x = 1;
-    const ans = [];
-    while (i < n) {
-        const c = s.charAt(i);
-        if (c == '(' || c == ')') {
-            i = d[i];
-            x = -x;
+    for (const c of s) {
+        if (c === ')') {
+            const t = [];
+            while (stk.at(-1) !== '(') {
+                t.push(stk.pop());
+            }
+            stk.pop();
+            stk.push(...t);
         } else {
-            ans.push(c);
+            stk.push(c);
         }
-        i += x;
     }
-    return ans.join('');
+    return stk.join('');
 };
 ```
 
-#### TypeScript
-
-```ts
-function reverseParentheses(s: string): string {
-    const n = s.length;
-    const d = new Array(n).fill(0);
-    const stk: number[] = [];
-    for (let i = 0; i < n; ++i) {
-        if (s[i] === '(') {
-            stk.push(i);
-        } else if (s[i] === ')') {
-            const j = stk.pop()!;
-            d[i] = j;
-            d[j] = i;
-        }
-    }
-    let i = 0;
-    let x = 1;
-    const ans: string[] = [];
-    while (i < n) {
-        const c = s.charAt(i);
-        if (c === '(' || c === ')') {
-            i = d[i];
-            x = -x;
-        } else {
-            ans.push(c);
-        }
-        i += x;
-    }
-    return ans.join('');
-}
-```
-
 <!-- tabs:end -->
 
 <!-- solution:end -->
 
 <!-- solution:start -->
 
-### Solution 2: Quick Thinking
+### Solution 2: Brain Teaser
 
-We observe that during the traversal of the string, each time we encounter '(' or ')', we jump to the corresponding ')' or '(', then reverse the traversal direction and continue.
+We observe that, when traversing the string, each time we encounter `(` or `)`, we jump to the corresponding `)` or `(` and then reverse the direction of traversal to continue.
 
-Therefore, we can use an array $d$ to record the position of the other bracket corresponding to each '(' or ')', i.e., $d[i]$ represents the position of the other bracket corresponding to the bracket at position $i$. We can directly use a stack to calculate the array $d$.
+Therefore, we can use an array $d$ to record the position of the corresponding other bracket for each `(` or `)`, i.e., $d[i]$ represents the position of the other bracket corresponding to the bracket at position $i$. We can directly use a stack to compute the array $d$.
 
-Then, we traverse the string from left to right. When we encounter '(' or ')', we jump to the corresponding position according to the array $d$, then reverse the direction and continue to traverse until the entire string is traversed.
+Then, we traverse the string from left to right. When encountering `(` or `)`, we jump to the corresponding position according to the array $d$, then reverse the direction and continue traversing until the entire string is traversed.
 
-The time complexity is $O(n)$, where $n$ is the length of the string $s$.
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the string $s$.
 
 <!-- tabs:start -->
 
@@ -267,21 +234,54 @@ class Solution:
         d = [0] * n
         stk = []
         for i, c in enumerate(s):
-            if c == '(':
+            if c == "(":
                 stk.append(i)
-            elif c == ')':
+            elif c == ")":
                 j = stk.pop()
                 d[i], d[j] = j, i
         i, x = 0, 1
         ans = []
         while i < n:
-            if s[i] in '()':
+            if s[i] in "()":
                 i = d[i]
                 x = -x
             else:
                 ans.append(s[i])
             i += x
-        return ''.join(ans)
+        return "".join(ans)
+```
+
+#### Java
+
+```java
+class Solution {
+    public String reverseParentheses(String s) {
+        int n = s.length();
+        int[] d = new int[n];
+        Deque<Integer> stk = new ArrayDeque<>();
+        for (int i = 0; i < n; ++i) {
+            if (s.charAt(i) == '(') {
+                stk.push(i);
+            } else if (s.charAt(i) == ')') {
+                int j = stk.pop();
+                d[i] = j;
+                d[j] = i;
+            }
+        }
+        StringBuilder ans = new StringBuilder();
+        int i = 0, x = 1;
+        while (i < n) {
+            if (s.charAt(i) == '(' || s.charAt(i) == ')') {
+                i = d[i];
+                x = -x;
+            } else {
+                ans.append(s.charAt(i));
+            }
+            i += x;
+        }
+        return ans.toString();
+    }
+}
 ```
 
 #### C++
@@ -350,80 +350,74 @@ func reverseParentheses(s string) string {
 }
 ```
 
-#### JavaScript
+#### TypeScript
 
-```js
-function reverseParentheses(s) {
-    const res = [];
+```ts
+function reverseParentheses(s: string): string {
     const n = s.length;
-    const d = Array(n).fill(-1);
-    const stk = [];
-
-    for (let i = 0; i < n; i++) {
-        if (s[i] === '(') stk.push(i);
-        else if (s[i] === ')') {
-            const j = stk.pop();
+    const d: number[] = Array(n).fill(0);
+    const stk: number[] = [];
+    for (let i = 0; i < n; ++i) {
+        if (s[i] === '(') {
+            stk.push(i);
+        } else if (s[i] === ')') {
+            const j = stk.pop()!;
             d[i] = j;
             d[j] = i;
         }
     }
-
-    for (let i = 0, forward = true; i < n; ) {
-        const ch = s[i];
-
-        switch (s[i]) {
-            case '(':
-            case ')':
-                i = forward ? d[i] - 1 : d[i] + 1;
-                forward = !forward;
-                break;
-
-            default:
-                res.push(ch);
-                i = forward ? i + 1 : i - 1;
+    let i = 0;
+    let x = 1;
+    const ans: string[] = [];
+    while (i < n) {
+        const c = s.charAt(i);
+        if ('()'.includes(c)) {
+            i = d[i];
+            x = -x;
+        } else {
+            ans.push(c);
         }
+        i += x;
     }
-
-    return res.join('');
+    return ans.join('');
 }
 ```
 
-#### TypeScript
+#### JavaScript
 
-```ts
-function reverseParentheses(s: string): string {
-    const res: string[] = [];
+```js
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var reverseParentheses = function (s) {
     const n = s.length;
-    const d = Array(n).fill(-1);
-    const stk: number[] = [];
-
-    for (let i = 0; i < n; i++) {
-        if (s[i] === '(') stk.push(i);
-        else if (s[i] === ')') {
-            const j = stk.pop()!;
+    const d = Array(n).fill(0);
+    const stk = [];
+    for (let i = 0; i < n; ++i) {
+        if (s[i] === '(') {
+            stk.push(i);
+        } else if (s[i] === ')') {
+            const j = stk.pop();
             d[i] = j;
             d[j] = i;
         }
     }
-
-    for (let i = 0, forward = true; i < n; ) {
-        const ch = s[i];
-
-        switch (s[i]) {
-            case '(':
-            case ')':
-                i = forward ? d[i] - 1 : d[i] + 1;
-                forward = !forward;
-                break;
-
-            default:
-                res.push(ch);
-                i = forward ? i + 1 : i - 1;
+    let i = 0;
+    let x = 1;
+    const ans = [];
+    while (i < n) {
+        const c = s.charAt(i);
+        if ('()'.includes(c)) {
+            i = d[i];
+            x = -x;
+        } else {
+            ans.push(c);
         }
+        i += x;
     }
-
-    return res.join('');
-}
+    return ans.join('');
+};
 ```
 
 <!-- tabs:end -->