feat: update solutions to lc problems

* No.2207.Maximize Number of Subsequences in a String
* No.2300.Successful Pairs of Spells and Potions

Author: yanglbme

solution/2200-2299/2207.Maximize Number of Subsequences in a String/README.md

@@ -58,15 +58,85 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def maximumSubsequenceCount(self, text: str, pattern: str) -> int:
+        ans = 0
+        cnt = Counter()
+        for c in text:
+            if c == pattern[1]:
+                ans += cnt[pattern[0]]
+            cnt[c] += 1
+        ans += max(cnt[pattern[0]], cnt[pattern[1]])
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public long maximumSubsequenceCount(String text, String pattern) {
+        int[] cnt = new int[26];
+        char a = pattern.charAt(0);
+        char b = pattern.charAt(1);
+        long ans = 0;
+        for (char c : text.toCharArray()) {
+            if (c == b) {
+                ans += cnt[a - 'a'];
+            }
+            cnt[c - 'a']++;
+        }
+        ans += Math.max(cnt[a - 'a'], cnt[b - 'a']);
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    long long maximumSubsequenceCount(string text, string pattern) {
+        long long ans = 0;
+        char a = pattern[0], b = pattern[1];
+        vector<int> cnt(26);
+        for (char& c : text)
+        {
+            if (c == b) ans += cnt[a - 'a'];
+            cnt[c - 'a']++;
+        }
+        ans += max(cnt[a - 'a'], cnt[b - 'a']);
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func maximumSubsequenceCount(text string, pattern string) int64 {
+	ans := 0
+	cnt := make([]int, 26)
+	a, b := pattern[0], pattern[1]
+	for i := range text {
+		c := text[i]
+		if c == b {
+			ans += cnt[a-'a']
+		}
+		cnt[c-'a']++
+	}
+	ans += max(cnt[a-'a'], cnt[b-'a'])
+	return int64(ans)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **TypeScript**

solution/2200-2299/2207.Maximize Number of Subsequences in a String/README_EN.md

@@ -50,13 +50,83 @@ Some of the strings which can be obtained from text and have 6 subsequences &quo
 ### **Python3**
 
 ```python
-
+class Solution:
+    def maximumSubsequenceCount(self, text: str, pattern: str) -> int:
+        ans = 0
+        cnt = Counter()
+        for c in text:
+            if c == pattern[1]:
+                ans += cnt[pattern[0]]
+            cnt[c] += 1
+        ans += max(cnt[pattern[0]], cnt[pattern[1]])
+        return ans
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public long maximumSubsequenceCount(String text, String pattern) {
+        int[] cnt = new int[26];
+        char a = pattern.charAt(0);
+        char b = pattern.charAt(1);
+        long ans = 0;
+        for (char c : text.toCharArray()) {
+            if (c == b) {
+                ans += cnt[a - 'a'];
+            }
+            cnt[c - 'a']++;
+        }
+        ans += Math.max(cnt[a - 'a'], cnt[b - 'a']);
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    long long maximumSubsequenceCount(string text, string pattern) {
+        long long ans = 0;
+        char a = pattern[0], b = pattern[1];
+        vector<int> cnt(26);
+        for (char& c : text)
+        {
+            if (c == b) ans += cnt[a - 'a'];
+            cnt[c - 'a']++;
+        }
+        ans += max(cnt[a - 'a'], cnt[b - 'a']);
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func maximumSubsequenceCount(text string, pattern string) int64 {
+	ans := 0
+	cnt := make([]int, 26)
+	a, b := pattern[0], pattern[1]
+	for i := range text {
+		c := text[i]
+		if c == b {
+			ans += cnt[a-'a']
+		}
+		cnt[c-'a']++
+	}
+	ans += max(cnt[a-'a'], cnt[b-'a'])
+	return int64(ans)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **TypeScript**

solution/2200-2299/2207.Maximize Number of Subsequences in a String/Solution.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    long long maximumSubsequenceCount(string text, string pattern) {
+        long long ans = 0;
+        char a = pattern[0], b = pattern[1];
+        vector<int> cnt(26);
+        for (char& c : text)
+        {
+            if (c == b) ans += cnt[a - 'a'];
+            cnt[c - 'a']++;
+        }
+        ans += max(cnt[a - 'a'], cnt[b - 'a']);
+        return ans;
+    }
+};

solution/2200-2299/2207.Maximize Number of Subsequences in a String/Solution.go

@@ -0,0 +1,21 @@
+func maximumSubsequenceCount(text string, pattern string) int64 {
+	ans := 0
+	cnt := make([]int, 26)
+	a, b := pattern[0], pattern[1]
+	for i := range text {
+		c := text[i]
+		if c == b {
+			ans += cnt[a-'a']
+		}
+		cnt[c-'a']++
+	}
+	ans += max(cnt[a-'a'], cnt[b-'a'])
+	return int64(ans)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

solution/2200-2299/2207.Maximize Number of Subsequences in a String/Solution.java

@@ -0,0 +1,16 @@
+class Solution {
+    public long maximumSubsequenceCount(String text, String pattern) {
+        int[] cnt = new int[26];
+        char a = pattern.charAt(0);
+        char b = pattern.charAt(1);
+        long ans = 0;
+        for (char c : text.toCharArray()) {
+            if (c == b) {
+                ans += cnt[a - 'a'];
+            }
+            cnt[c - 'a']++;
+        }
+        ans += Math.max(cnt[a - 'a'], cnt[b - 'a']);
+        return ans;
+    }
+}

solution/2200-2299/2207.Maximize Number of Subsequences in a String/Solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def maximumSubsequenceCount(self, text: str, pattern: str) -> int:
+        ans = 0
+        cnt = Counter()
+        for c in text:
+            if c == pattern[1]:
+                ans += cnt[pattern[0]]
+            cnt[c] += 1
+        ans += max(cnt[pattern[0]], cnt[pattern[1]])
+        return ans

solution/2300-2399/2300.Successful Pairs of Spells and Potions/README.md

@@ -66,17 +66,7 @@ class Solution:
     def successfulPairs(self, spells: List[int], potions: List[int], success: int) -> List[int]:
         potions.sort()
         m = len(potions)
-        ans = []
-        for s in spells:
-            left, right = 0, m
-            while left < right:
-                mid = (left + right) >> 1
-                if s * potions[mid] >= success:
-                    right = mid
-                else:
-                    left = mid + 1
-            ans.append(m - left)
-        return ans
+        return [m - bisect_left(potions, success, key=lambda x: s * x) for s in spells]
 ```
 
 ### **Java**

solution/2300-2399/2300.Successful Pairs of Spells and Potions/README_EN.md

@@ -58,17 +58,7 @@ class Solution:
     def successfulPairs(self, spells: List[int], potions: List[int], success: int) -> List[int]:
         potions.sort()
         m = len(potions)
-        ans = []
-        for s in spells:
-            left, right = 0, m
-            while left < right:
-                mid = (left + right) >> 1
-                if s * potions[mid] >= success:
-                    right = mid
-                else:
-                    left = mid + 1
-            ans.append(m - left)
-        return ans
+        return [m - bisect_left(potions, success, key=lambda x: s * x) for s in spells]
 ```
 
 ### **Java**

solution/2300-2399/2300.Successful Pairs of Spells and Potions/Solution.py

@@ -1,17 +1,5 @@
 class Solution:
-    def successfulPairs(
-        self, spells: List[int], potions: List[int], success: int
-    ) -> List[int]:
+    def successfulPairs(self, spells: List[int], potions: List[int], success: int) -> List[int]:
         potions.sort()
         m = len(potions)
-        ans = []
-        for s in spells:
-            left, right = 0, m
-            while left < right:
-                mid = (left + right) >> 1
-                if s * potions[mid] >= success:
-                    right = mid
-                else:
-                    left = mid + 1
-            ans.append(m - left)
-        return ans
+        return [m - bisect_left(potions, success, key=lambda x: s * x) for s in spells]