feat: add solutions to lc problems: No.3083~3085 (doocs#2453)

* No.3083.Existence of a Substring in a String and Its Reverse
* No.3084.Count Substrings Starting and Ending with Given Character
* No.3085.Minimum Deletions to Make String K-Special

Author: yanglbme

solution/3000-3099/3083.Existence of a Substring in a String and Its Reverse/README.md

@@ -55,24 +55,88 @@
 
 ## 解法
 
-### 方法一
+### 方法一：哈希表或数组
+
+我们可以用一个哈希表或者二维数组 $st$ 来存储字符串 $s$ 反转后的所有长度为 $2$ 的子字符串。
+
+然后我们遍历字符串 $s$，对于每一个长度为 $2$ 的子字符串，我们判断它是否在 $st$ 中出现过，是则返回 `true`。否则，遍历结束后返回 `false`。
+
+时间复杂度 $O(n)$，空间复杂度 $O(|\Sigma|^2)$。其中 $n$ 为字符串 $s$ 的长度；而 $\Sigma$ 为字符串 $s$ 的字符集，本题中 $\Sigma$ 为小写英文字母，所以 $|\Sigma| = 26$。
 
 <!-- tabs:start -->
 
 ```python
-
+class Solution:
+    def isSubstringPresent(self, s: str) -> bool:
+        st = {(a, b) for a, b in pairwise(s[::-1])}
+        return any((a, b) in st for a, b in pairwise(s))
 ```
 
 ```java
-
+class Solution {
+    public boolean isSubstringPresent(String s) {
+        boolean[][] st = new boolean[26][26];
+        int n = s.length();
+        for (int i = 0; i < n - 1; ++i) {
+            st[s.charAt(i + 1) - 'a'][s.charAt(i) - 'a'] = true;
+        }
+        for (int i = 0; i < n - 1; ++i) {
+            if (st[s.charAt(i) - 'a'][s.charAt(i + 1) - 'a']) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    bool isSubstringPresent(string s) {
+        bool st[26][26]{};
+        int n = s.size();
+        for (int i = 0; i < n - 1; ++i) {
+            st[s[i + 1] - 'a'][s[i] - 'a'] = true;
+        }
+        for (int i = 0; i < n - 1; ++i) {
+            if (st[s[i] - 'a'][s[i + 1] - 'a']) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
 ```
 
 ```go
+func isSubstringPresent(s string) bool {
+	st := [26][26]bool{}
+	for i := 0; i < len(s)-1; i++ {
+		st[s[i+1]-'a'][s[i]-'a'] = true
+	}
+	for i := 0; i < len(s)-1; i++ {
+		if st[s[i]-'a'][s[i+1]-'a'] {
+			return true
+		}
+	}
+	return false
+}
+```
 
+```ts
+function isSubstringPresent(s: string): boolean {
+    const st: boolean[][] = Array.from({ length: 26 }, () => Array(26).fill(false));
+    for (let i = 0; i < s.length - 1; ++i) {
+        st[s.charCodeAt(i + 1) - 97][s.charCodeAt(i) - 97] = true;
+    }
+    for (let i = 0; i < s.length - 1; ++i) {
+        if (st[s.charCodeAt(i) - 97][s.charCodeAt(i + 1) - 97]) {
+            return true;
+        }
+    }
+    return false;
+}
 ```
 
 <!-- tabs:end -->

solution/3000-3099/3083.Existence of a Substring in a String and Its Reverse/README_EN.md

@@ -51,24 +51,88 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Hash Table or Array
+
+We can use a hash table or a two-dimensional array $st$ to store all substrings of length $2$ of the reversed string $s$.
+
+Then we traverse the string $s$. For each substring of length $2$, we check whether it has appeared in $st$. If it has, we return `true`. Otherwise, we return `false` after the traversal.
+
+The time complexity is $O(n)$ and the space complexity is $O(|\Sigma|^2)$. Here, $n$ is the length of the string $s$, and $\Sigma$ is the character set of the string $s$. In this problem, $\Sigma$ consists of lowercase English letters, so $|\Sigma| = 26$.
 
 <!-- tabs:start -->
 
 ```python
-
+class Solution:
+    def isSubstringPresent(self, s: str) -> bool:
+        st = {(a, b) for a, b in pairwise(s[::-1])}
+        return any((a, b) in st for a, b in pairwise(s))
 ```
 
 ```java
-
+class Solution {
+    public boolean isSubstringPresent(String s) {
+        boolean[][] st = new boolean[26][26];
+        int n = s.length();
+        for (int i = 0; i < n - 1; ++i) {
+            st[s.charAt(i + 1) - 'a'][s.charAt(i) - 'a'] = true;
+        }
+        for (int i = 0; i < n - 1; ++i) {
+            if (st[s.charAt(i) - 'a'][s.charAt(i + 1) - 'a']) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    bool isSubstringPresent(string s) {
+        bool st[26][26]{};
+        int n = s.size();
+        for (int i = 0; i < n - 1; ++i) {
+            st[s[i + 1] - 'a'][s[i] - 'a'] = true;
+        }
+        for (int i = 0; i < n - 1; ++i) {
+            if (st[s[i] - 'a'][s[i + 1] - 'a']) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
 ```
 
 ```go
+func isSubstringPresent(s string) bool {
+	st := [26][26]bool{}
+	for i := 0; i < len(s)-1; i++ {
+		st[s[i+1]-'a'][s[i]-'a'] = true
+	}
+	for i := 0; i < len(s)-1; i++ {
+		if st[s[i]-'a'][s[i+1]-'a'] {
+			return true
+		}
+	}
+	return false
+}
+```
 
+```ts
+function isSubstringPresent(s: string): boolean {
+    const st: boolean[][] = Array.from({ length: 26 }, () => Array(26).fill(false));
+    for (let i = 0; i < s.length - 1; ++i) {
+        st[s.charCodeAt(i + 1) - 97][s.charCodeAt(i) - 97] = true;
+    }
+    for (let i = 0; i < s.length - 1; ++i) {
+        if (st[s.charCodeAt(i) - 97][s.charCodeAt(i + 1) - 97]) {
+            return true;
+        }
+    }
+    return false;
+}
 ```
 
 <!-- tabs:end -->

solution/3000-3099/3083.Existence of a Substring in a String and Its Reverse/Solution.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    bool isSubstringPresent(string s) {
+        bool st[26][26]{};
+        int n = s.size();
+        for (int i = 0; i < n - 1; ++i) {
+            st[s[i + 1] - 'a'][s[i] - 'a'] = true;
+        }
+        for (int i = 0; i < n - 1; ++i) {
+            if (st[s[i] - 'a'][s[i + 1] - 'a']) {
+                return true;
+            }
+        }
+        return false;
+    }
+};

solution/3000-3099/3083.Existence of a Substring in a String and Its Reverse/Solution.go

@@ -0,0 +1,12 @@
+func isSubstringPresent(s string) bool {
+	st := [26][26]bool{}
+	for i := 0; i < len(s)-1; i++ {
+		st[s[i+1]-'a'][s[i]-'a'] = true
+	}
+	for i := 0; i < len(s)-1; i++ {
+		if st[s[i]-'a'][s[i+1]-'a'] {
+			return true
+		}
+	}
+	return false
+}

solution/3000-3099/3083.Existence of a Substring in a String and Its Reverse/Solution.java

@@ -0,0 +1,15 @@
+class Solution {
+    public boolean isSubstringPresent(String s) {
+        boolean[][] st = new boolean[26][26];
+        int n = s.length();
+        for (int i = 0; i < n - 1; ++i) {
+            st[s.charAt(i + 1) - 'a'][s.charAt(i) - 'a'] = true;
+        }
+        for (int i = 0; i < n - 1; ++i) {
+            if (st[s.charAt(i) - 'a'][s.charAt(i + 1) - 'a']) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

solution/3000-3099/3083.Existence of a Substring in a String and Its Reverse/Solution.py

@@ -0,0 +1,4 @@
+class Solution:
+    def isSubstringPresent(self, s: str) -> bool:
+        st = {(a, b) for a, b in pairwise(s[::-1])}
+        return any((a, b) in st for a, b in pairwise(s))

solution/3000-3099/3083.Existence of a Substring in a String and Its Reverse/Solution.ts

@@ -0,0 +1,12 @@
+function isSubstringPresent(s: string): boolean {
+    const st: boolean[][] = Array.from({ length: 26 }, () => Array(26).fill(false));
+    for (let i = 0; i < s.length - 1; ++i) {
+        st[s.charCodeAt(i + 1) - 97][s.charCodeAt(i) - 97] = true;
+    }
+    for (let i = 0; i < s.length - 1; ++i) {
+        if (st[s.charCodeAt(i) - 97][s.charCodeAt(i + 1) - 97]) {
+            return true;
+        }
+    }
+    return false;
+}

solution/3000-3099/3084.Count Substrings Starting and Ending with Given Character/README.md

@@ -43,24 +43,56 @@
 
 ## 解法
 
-### 方法一
+### 方法一：数学
+
+我们可以先统计字符串 $s$ 中字符 $c$ 的个数，记为 $cnt$。
+
+每个 $c$ 字符可以单独作为一个子字符串，所以有 $cnt$ 个子字符串满足条件。每个 $c$ 字符可以和其他 $c$ 字符组成一个满足条件的子字符串，所以有 $\frac{cnt \times (cnt - 1)}{2}$ 个子字符串满足条件。
+
+所以答案为 $cnt + \frac{cnt \times (cnt - 1)}{2}$。
+
+时间复杂度 $O(n)$，其中 $n$ 为字符串 $s$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 ```python
-
+class Solution:
+    def countSubstrings(self, s: str, c: str) -> int:
+        cnt = s.count(c)
+        return cnt + cnt * (cnt - 1) // 2
 ```
 
 ```java
-
+class Solution {
+    public long countSubstrings(String s, char c) {
+        long cnt = s.chars().filter(ch -> ch == c).count();
+        return cnt + cnt * (cnt - 1) / 2;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    long long countSubstrings(string s, char c) {
+        long long cnt = ranges::count(s, c);
+        return cnt + cnt * (cnt - 1) / 2;
+    }
+};
 ```
 
 ```go
+func countSubstrings(s string, c byte) int64 {
+	cnt := int64(strings.Count(s, string(c)))
+	return cnt + cnt*(cnt-1)/2
+}
+```
 
+```ts
+function countSubstrings(s: string, c: string): number {
+    const cnt = s.split('').filter(ch => ch === c).length;
+    return cnt + Math.floor((cnt * (cnt - 1)) / 2);
+}
 ```
 
 <!-- tabs:end -->

solution/3000-3099/3084.Count Substrings Starting and Ending with Given Character/README_EN.md

@@ -39,24 +39,56 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Mathematics
+
+First, we can count the number of character $c$ in string $s$, denoted as $cnt$.
+
+Each character $c$ can form a substring on its own, so there are $cnt$ substrings that meet the condition. Each character $c$ can form a substring with other $c$ characters, so there are $\frac{cnt \times (cnt - 1)}{2}$ substrings that meet the condition.
+
+Therefore, the answer is $cnt + \frac{cnt \times (cnt - 1)}{2}$.
+
+The time complexity is $O(n)$, where $n$ is the length of the string $s$. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
 ```python
-
+class Solution:
+    def countSubstrings(self, s: str, c: str) -> int:
+        cnt = s.count(c)
+        return cnt + cnt * (cnt - 1) // 2
 ```
 
 ```java
-
+class Solution {
+    public long countSubstrings(String s, char c) {
+        long cnt = s.chars().filter(ch -> ch == c).count();
+        return cnt + cnt * (cnt - 1) / 2;
+    }
+}
 ```
 
 ```cpp
-
+class Solution {
+public:
+    long long countSubstrings(string s, char c) {
+        long long cnt = ranges::count(s, c);
+        return cnt + cnt * (cnt - 1) / 2;
+    }
+};
 ```
 
 ```go
+func countSubstrings(s string, c byte) int64 {
+	cnt := int64(strings.Count(s, string(c)))
+	return cnt + cnt*(cnt-1)/2
+}
+```
 
+```ts
+function countSubstrings(s: string, c: string): number {
+    const cnt = s.split('').filter(ch => ch === c).length;
+    return cnt + Math.floor((cnt * (cnt - 1)) / 2);
+}
 ```
 
 <!-- tabs:end -->

solution/3000-3099/3084.Count Substrings Starting and Ending with Given Character/Solution.cpp

@@ -0,0 +1,7 @@
+class Solution {
+public:
+    long long countSubstrings(string s, char c) {
+        long long cnt = ranges::count(s, c);
+        return cnt + cnt * (cnt - 1) / 2;
+    }
+};