Add solution #1111

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,140 LeetCode solutions in JavaScript
+# 1,141 LeetCode solutions in JavaScript
 
 [https://leetcodejavascript.com](https://leetcodejavascript.com)
 
@@ -884,6 +884,7 @@
 1108|[Defanging an IP Address](./solutions/1108-defanging-an-ip-address.js)|Easy|
 1109|[Corporate Flight Bookings](./solutions/1109-corporate-flight-bookings.js)|Medium|
 1110|[Delete Nodes And Return Forest](./solutions/1110-delete-nodes-and-return-forest.js)|Medium|
+1111|[Maximum Nesting Depth of Two Valid Parentheses Strings](./solutions/1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js)|Medium|
 1122|[Relative Sort Array](./solutions/1122-relative-sort-array.js)|Easy|
 1123|[Lowest Common Ancestor of Deepest Leaves](./solutions/1123-lowest-common-ancestor-of-deepest-leaves.js)|Medium|
 1137|[N-th Tribonacci Number](./solutions/1137-n-th-tribonacci-number.js)|Easy|

solutions/1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js

@@ -0,0 +1,47 @@
+/**
+ * 1111. Maximum Nesting Depth of Two Valid Parentheses Strings
+ * https://leetcode.com/problems/maximum-nesting-depth-of-two-valid-parentheses-strings/
+ * Difficulty: Medium
+ *
+ * A string is a valid parentheses string (denoted VPS) if and only if it consists of "(" and ")"
+ * characters only, and:
+ * - It is the empty string, or
+ * - It can be written as AB (A concatenated with B), where A and B are VPS's, or
+ * - It can be written as (A), where A is a VPS.
+ *
+ * We can similarly define the nesting depth depth(S) of any VPS S as follows:
+ * - depth("") = 0
+ * - depth(A + B) = max(depth(A), depth(B)), where A and B are VPS's
+ * - depth("(" + A + ")") = 1 + depth(A), where A is a VPS.
+ *
+ * For example,  "", "()()", and "()(()())" are VPS's (with nesting depths 0, 1, and 2),
+ * and ")(" and "(()" are not VPS's.
+ *
+ * Given a VPS seq, split it into two disjoint subsequences A and B, such that A and B are VPS's
+ * (and A.length + B.length = seq.length).
+ *
+ * Now choose any such A and B such that max(depth(A), depth(B)) is the minimum possible value.
+ *
+ * Return an answer array (of length seq.length) that encodes such a choice of A and B:
+ * answer[i] = 0 if seq[i] is part of A, else answer[i] = 1.  Note that even though multiple
+ * answers may exist, you may return any of them.
+ */
+
+/**
+ * @param {string} seq
+ * @return {number[]}
+ */
+var maxDepthAfterSplit = function(seq) {
+  const result = new Array(seq.length);
+  let depth = 0;
+
+  for (let i = 0; i < seq.length; i++) {
+    if (seq[i] === '(') {
+      result[i] = depth++ % 2;
+    } else {
+      result[i] = --depth % 2;
+    }
+  }
+
+  return result;
+};