feat: add solutions to lc problems: No.2515~2518

* No.2515.Shortest Distance to Target String in a Circular Array
* No.2516.Take K of Each Character From Left and Right
* No.2517.Maximum Tastiness of Candy Basket
* No.2518.Number of Great Partitions

Author: yanglbme

solution/0300-0399/0395.Longest Substring with At Least K Repeating Characters/Solution.py

@@ -1,7 +1,7 @@
 class Solution:
     def longestSubstring(self, s: str, k: int) -> int:
         def dfs(l, r):
-            cnt = Counter(s[l: r + 1])
+            cnt = Counter(s[l : r + 1])
             split = next((c for c, v in cnt.items() if v < k), '')
             if not split:
                 return r - l + 1
@@ -19,5 +19,5 @@ def dfs(l, r):
                 ans = max(ans, t)
                 i = j
             return ans
-        
-        return dfs(0, len(s) - 1)
+
+        return dfs(0, len(s) - 1)

solution/0600-0699/0697.Degree of an Array/Solution.py

@@ -13,4 +13,4 @@ def findShortestSubArray(self, nums: List[int]) -> int:
                 t = right[v] - left[v] + 1
                 if ans > t:
                     ans = t
-        return ans
+        return ans

solution/1700-1799/1763.Longest Nice Substring/Solution.py

@@ -10,5 +10,5 @@ def longestNiceSubstring(self, s: str) -> str:
                 else:
                     upper |= 1 << (ord(s[j]) - ord('A'))
                 if lower == upper and len(ans) < j - i + 1:
-                    ans = s[i: j + 1]
+                    ans = s[i : j + 1]
         return ans

solution/1900-1999/1947.Maximum Compatibility Score Sum/Solution.py

@@ -1,5 +1,7 @@
 class Solution:
-    def maxCompatibilitySum(self, students: List[List[int]], mentors: List[List[int]]) -> int:
+    def maxCompatibilitySum(
+        self, students: List[List[int]], mentors: List[List[int]]
+    ) -> int:
         def dfs(i, t):
             if i == m:
                 nonlocal ans

solution/2500-2599/2515.Shortest Distance to Target String in a Circular Array/README.md

@@ -68,27 +68,89 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def closetTarget(self, words: List[str], target: str, startIndex: int) -> int:
+        n = len(words)
+        ans = n
+        for i, w in enumerate(words):
+            if w == target:
+                t = abs(i - startIndex)
+                ans = min(ans, t, n - t)
+        return -1 if ans == n else ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int closetTarget(String[] words, String target, int startIndex) {
+        int n = words.length;
+        int ans = n;
+        for (int i = 0; i < n; ++i) {
+            String w = words[i];
+            if (w.equals(target)) {
+                int t = Math.abs(i - startIndex);
+                ans = Math.min(ans, Math.min(t, n - t));
+            }
+        }
+        return ans == n ? -1 : ans;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int closetTarget(vector<string>& words, string target, int startIndex) {
+        int n = words.size();
+        int ans = n;
+        for (int i = 0; i < n; ++i) {
+            auto w = words[i];
+            if (w == target) {
+                int t = abs(i - startIndex);
+                ans = min(ans, min(t, n - t));
+            }
+        }
+        return ans == n ? -1 : ans;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
-
+func closetTarget(words []string, target string, startIndex int) int {
+	n := len(words)
+	ans := n
+	for i, w := range words {
+		if w == target {
+			t := abs(i - startIndex)
+			ans = min(ans, min(t, n-t))
+		}
+	}
+	if ans == n {
+		return -1
+	}
+	return ans
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/2500-2599/2515.Shortest Distance to Target String in a Circular Array/README_EN.md

@@ -63,25 +63,87 @@ The shortest distance to reach &quot;leetcode&quot; is 1.</pre>
 ### **Python3**
 
 ```python
-
+class Solution:
+    def closetTarget(self, words: List[str], target: str, startIndex: int) -> int:
+        n = len(words)
+        ans = n
+        for i, w in enumerate(words):
+            if w == target:
+                t = abs(i - startIndex)
+                ans = min(ans, t, n - t)
+        return -1 if ans == n else ans
 ```
 
 ### **Java**
 
 ```java
-
+class Solution {
+    public int closetTarget(String[] words, String target, int startIndex) {
+        int n = words.length;
+        int ans = n;
+        for (int i = 0; i < n; ++i) {
+            String w = words[i];
+            if (w.equals(target)) {
+                int t = Math.abs(i - startIndex);
+                ans = Math.min(ans, Math.min(t, n - t));
+            }
+        }
+        return ans == n ? -1 : ans;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int closetTarget(vector<string>& words, string target, int startIndex) {
+        int n = words.size();
+        int ans = n;
+        for (int i = 0; i < n; ++i) {
+            auto w = words[i];
+            if (w == target) {
+                int t = abs(i - startIndex);
+                ans = min(ans, min(t, n - t));
+            }
+        }
+        return ans == n ? -1 : ans;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
-
+func closetTarget(words []string, target string, startIndex int) int {
+	n := len(words)
+	ans := n
+	for i, w := range words {
+		if w == target {
+			t := abs(i - startIndex)
+			ans = min(ans, min(t, n-t))
+		}
+	}
+	if ans == n {
+		return -1
+	}
+	return ans
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/2500-2599/2515.Shortest Distance to Target String in a Circular Array/Solution.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int closetTarget(vector<string>& words, string target, int startIndex) {
+        int n = words.size();
+        int ans = n;
+        for (int i = 0; i < n; ++i) {
+            auto w = words[i];
+            if (w == target) {
+                int t = abs(i - startIndex);
+                ans = min(ans, min(t, n - t));
+            }
+        }
+        return ans == n ? -1 : ans;
+    }
+};

solution/2500-2599/2515.Shortest Distance to Target String in a Circular Array/Solution.go

@@ -0,0 +1,28 @@
+func closetTarget(words []string, target string, startIndex int) int {
+	n := len(words)
+	ans := n
+	for i, w := range words {
+		if w == target {
+			t := abs(i - startIndex)
+			ans = min(ans, min(t, n-t))
+		}
+	}
+	if ans == n {
+		return -1
+	}
+	return ans
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

solution/2500-2599/2515.Shortest Distance to Target String in a Circular Array/Solution.java

@@ -0,0 +1,14 @@
+class Solution {
+    public int closetTarget(String[] words, String target, int startIndex) {
+        int n = words.length;
+        int ans = n;
+        for (int i = 0; i < n; ++i) {
+            String w = words[i];
+            if (w.equals(target)) {
+                int t = Math.abs(i - startIndex);
+                ans = Math.min(ans, Math.min(t, n - t));
+            }
+        }
+        return ans == n ? -1 : ans;
+    }
+}

solution/2500-2599/2515.Shortest Distance to Target String in a Circular Array/Solution.py

@@ -0,0 +1,9 @@
+class Solution:
+    def closetTarget(self, words: List[str], target: str, startIndex: int) -> int:
+        n = len(words)
+        ans = n
+        for i, w in enumerate(words):
+            if w == target:
+                t = abs(i - startIndex)
+                ans = min(ans, t, n - t)
+        return -1 if ans == n else ans