feat: add solutions to lc problem: No.1898

Author: Zuoqiu-Yingyi

solution/1800-1899/1898.Maximum Number of Removable Characters/README.md

@@ -337,6 +337,93 @@ impl Solution {
 }
 ```
 
+#### JavaScript
+
+```js
+/**
+ * @param {string} s
+ * @param {string} p
+ * @param {number[]} removable
+ * @return {number}
+ */
+function maximumRemovals(s, p, removable) {
+    const str_len = s.length;
+    const sub_len = p.length;
+
+    /**
+     * @param {number} k
+     * @return {boolean}
+     */
+    function isSub(k) {
+        const removed = new Set(removable.slice(0, k));
+
+        let sub_i = 0;
+        for (let str_i = 0; str_i < str_len; ++str_i) {
+            if (s.charAt(str_i) === p.charAt(sub_i) && !removed.has(str_i)) {
+                ++sub_i;
+                if (sub_i >= sub_len) {
+                    break;
+                }
+            }
+        }
+        return sub_i === sub_len;
+    }
+
+    let left = 0;
+    let right = removable.length;
+
+    while (left < right) {
+        const middle = (left + right) >> 1;
+        if (isSub(middle + 1)) {
+            left = middle + 1;
+        } else {
+            right = middle;
+        }
+    }
+    return left;
+}
+```
+
+#### Kotlin
+
+```kotlin
+class Solution {
+  fun maximumRemovals(s: String, p: String, removable: IntArray): Int {
+      val strLen = s.length
+      val subLen = p.length
+
+      fun isSub(k: Int): Boolean {
+          val removed = removable.sliceArray(0 ..< k).toHashSet()
+
+          var subIndex = 0
+          for (strIndex in 0 ..< strLen) {
+              if (s[strIndex] == p[subIndex] && !removed.contains(strIndex)) {
+                  ++subIndex
+                  if (subIndex >= subLen) {
+                      break
+                  }
+              }
+          }
+
+          return subIndex == subLen
+      }
+
+      var left = 0
+      var right = removable.size
+
+      while (left < right) {
+          val middle = (left + right) / 2
+          if (isSub(middle + 1)) {
+              left = middle + 1
+          } else {
+              right = middle
+          }
+      }
+      return left
+  }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1800-1899/1898.Maximum Number of Removable Characters/README_EN.md

@@ -282,6 +282,93 @@ impl Solution {
 }
 ```
 
+#### JavaScript
+
+```js
+/**
+ * @param {string} s
+ * @param {string} p
+ * @param {number[]} removable
+ * @return {number}
+ */
+function maximumRemovals(s, p, removable) {
+    const str_len = s.length;
+    const sub_len = p.length;
+
+    /**
+     * @param {number} k
+     * @return {boolean}
+     */
+    function isSub(k) {
+        const removed = new Set(removable.slice(0, k));
+
+        let sub_i = 0;
+        for (let str_i = 0; str_i < str_len; ++str_i) {
+            if (s.charAt(str_i) === p.charAt(sub_i) && !removed.has(str_i)) {
+                ++sub_i;
+                if (sub_i >= sub_len) {
+                    break;
+                }
+            }
+        }
+        return sub_i === sub_len;
+    }
+
+    let left = 0;
+    let right = removable.length;
+
+    while (left < right) {
+        const middle = (left + right) >> 1;
+        if (isSub(middle + 1)) {
+            left = middle + 1;
+        } else {
+            right = middle;
+        }
+    }
+    return left;
+}
+```
+
+#### Kotlin
+
+```kotlin
+class Solution {
+  fun maximumRemovals(s: String, p: String, removable: IntArray): Int {
+      val strLen = s.length
+      val subLen = p.length
+
+      fun isSub(k: Int): Boolean {
+          val removed = removable.sliceArray(0 ..< k).toHashSet()
+
+          var subIndex = 0
+          for (strIndex in 0 ..< strLen) {
+              if (s[strIndex] == p[subIndex] && !removed.contains(strIndex)) {
+                  ++subIndex
+                  if (subIndex >= subLen) {
+                      break
+                  }
+              }
+          }
+
+          return subIndex == subLen
+      }
+
+      var left = 0
+      var right = removable.size
+
+      while (left < right) {
+          val middle = (left + right) / 2
+          if (isSub(middle + 1)) {
+              left = middle + 1
+          } else {
+              right = middle
+          }
+      }
+      return left
+  }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1800-1899/1898.Maximum Number of Removable Characters/Solution.js

@@ -0,0 +1,42 @@
+/**
+ * @param {string} s
+ * @param {string} p
+ * @param {number[]} removable
+ * @return {number}
+ */
+function maximumRemovals(s, p, removable) {
+    const str_len = s.length;
+    const sub_len = p.length;
+
+    /**
+     * @param {number} k
+     * @return {boolean}
+     */
+    function isSub(k) {
+        const removed = new Set(removable.slice(0, k));
+
+        let sub_i = 0;
+        for (let str_i = 0; str_i < str_len; ++str_i) {
+            if (s.charAt(str_i) === p.charAt(sub_i) && !removed.has(str_i)) {
+                ++sub_i;
+                if (sub_i >= sub_len) {
+                    break;
+                }
+            }
+        }
+        return sub_i === sub_len;
+    }
+
+    let left = 0;
+    let right = removable.length;
+
+    while (left < right) {
+        const middle = (left + right) >> 1;
+        if (isSub(middle + 1)) {
+            left = middle + 1;
+        } else {
+            right = middle;
+        }
+    }
+    return left;
+}

solution/1800-1899/1898.Maximum Number of Removable Characters/Solution.kt

@@ -0,0 +1,35 @@
+class Solution {
+  fun maximumRemovals(s: String, p: String, removable: IntArray): Int {
+      val strLen = s.length
+      val subLen = p.length
+
+      fun isSub(k: Int): Boolean {
+          val removed = removable.sliceArray(0 ..< k).toHashSet()
+
+          var subIndex = 0
+          for (strIndex in 0 ..< strLen) {
+              if (s[strIndex] == p[subIndex] && !removed.contains(strIndex)) {
+                  ++subIndex
+                  if (subIndex >= subLen) {
+                      break
+                  }
+              }
+          }
+
+          return subIndex == subLen
+      }
+
+      var left = 0
+      var right = removable.size
+
+      while (left < right) {
+          val middle = (left + right) / 2
+          if (isSub(middle + 1)) {
+              left = middle + 1
+          } else {
+              right = middle
+          }
+      }
+      return left
+  }
+}