feat: add solutions to lc problem: No.1471

No.1471.The k Strongest Values in an Array

Author: yanglbme

solution/1400-1499/1471.The k Strongest Values in an Array/README.md

@@ -74,22 +74,92 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：自定义排序**
+
+时间复杂度 O(2nlogn)。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def getStrongest(self, arr: List[int], k: int) -> List[int]:
+        arr.sort()
+        m = arr[(len(arr) - 1) >> 1]
+        arr.sort(key=lambda x: (-abs(x - m), -x))
+        return arr[:k]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int[] getStrongest(int[] arr, int k) {
+        Arrays.sort(arr);
+        int m = arr[(arr.length - 1) >> 1];
+        List<Integer> nums = new ArrayList<>();
+        for (int v : arr) {
+            nums.add(v);
+        }
+        nums.sort((a, b) -> {
+            int x = Math.abs(a - m);
+            int y = Math.abs(b - m);
+            return x == y ? b - a : y - x;
+        });
+        int[] ans = new int[k];
+        for (int i = 0; i < k; ++i) {
+            ans[i] = nums.get(i);
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> getStrongest(vector<int>& arr, int k) {
+        sort(arr.begin(), arr.end());
+        int m = arr[(arr.size() - 1) >> 1];
+        sort(arr.begin(), arr.end(), [&](int a, int b) {
+            int x = abs(a - m), y = abs(b - m);
+            return x == y ? a > b : x > y;
+        });
+        vector<int> ans(arr.begin(), arr.begin() + k);
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func getStrongest(arr []int, k int) []int {
+	sort.Ints(arr)
+	m := arr[(len(arr)-1)>>1]
+	sort.Slice(arr, func(i, j int) bool {
+		x, y := abs(arr[i]-m), abs(arr[j]-m)
+		if x == y {
+			return arr[i] > arr[j]
+		}
+		return x > y
+	})
+	return arr[:k]
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
 ```
 
 ### **...**

solution/1400-1499/1471.The k Strongest Values in an Array/README_EN.md

@@ -61,13 +61,79 @@ Any permutation of [11,8,6,6,7] is <strong>accepted</strong>.
 ### **Python3**
 
 ```python
-
+class Solution:
+    def getStrongest(self, arr: List[int], k: int) -> List[int]:
+        arr.sort()
+        m = arr[(len(arr) - 1) >> 1]
+        arr.sort(key=lambda x: (-abs(x - m), -x))
+        return arr[:k]
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int[] getStrongest(int[] arr, int k) {
+        Arrays.sort(arr);
+        int m = arr[(arr.length - 1) >> 1];
+        List<Integer> nums = new ArrayList<>();
+        for (int v : arr) {
+            nums.add(v);
+        }
+        nums.sort((a, b) -> {
+            int x = Math.abs(a - m);
+            int y = Math.abs(b - m);
+            return x == y ? b - a : y - x;
+        });
+        int[] ans = new int[k];
+        for (int i = 0; i < k; ++i) {
+            ans[i] = nums.get(i);
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> getStrongest(vector<int>& arr, int k) {
+        sort(arr.begin(), arr.end());
+        int m = arr[(arr.size() - 1) >> 1];
+        sort(arr.begin(), arr.end(), [&](int a, int b) {
+            int x = abs(a - m), y = abs(b - m);
+            return x == y ? a > b : x > y;
+        });
+        vector<int> ans(arr.begin(), arr.begin() + k);
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func getStrongest(arr []int, k int) []int {
+	sort.Ints(arr)
+	m := arr[(len(arr)-1)>>1]
+	sort.Slice(arr, func(i, j int) bool {
+		x, y := abs(arr[i]-m), abs(arr[j]-m)
+		if x == y {
+			return arr[i] > arr[j]
+		}
+		return x > y
+	})
+	return arr[:k]
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
 ```
 
 ### **...**

solution/1400-1499/1471.The k Strongest Values in an Array/Solution.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    vector<int> getStrongest(vector<int>& arr, int k) {
+        sort(arr.begin(), arr.end());
+        int m = arr[(arr.size() - 1) >> 1];
+        sort(arr.begin(), arr.end(), [&](int a, int b) {
+            int x = abs(a - m), y = abs(b - m);
+            return x == y ? a > b : x > y;
+        });
+        vector<int> ans(arr.begin(), arr.begin() + k);
+        return ans;
+    }
+};

solution/1400-1499/1471.The k Strongest Values in an Array/Solution.go

@@ -0,0 +1,19 @@
+func getStrongest(arr []int, k int) []int {
+	sort.Ints(arr)
+	m := arr[(len(arr)-1)>>1]
+	sort.Slice(arr, func(i, j int) bool {
+		x, y := abs(arr[i]-m), abs(arr[j]-m)
+		if x == y {
+			return arr[i] > arr[j]
+		}
+		return x > y
+	})
+	return arr[:k]
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}

solution/1400-1499/1471.The k Strongest Values in an Array/Solution.java

@@ -0,0 +1,20 @@
+class Solution {
+    public int[] getStrongest(int[] arr, int k) {
+        Arrays.sort(arr);
+        int m = arr[(arr.length - 1) >> 1];
+        List<Integer> nums = new ArrayList<>();
+        for (int v : arr) {
+            nums.add(v);
+        }
+        nums.sort((a, b) -> {
+            int x = Math.abs(a - m);
+            int y = Math.abs(b - m);
+            return x == y ? b - a : y - x;
+        });
+        int[] ans = new int[k];
+        for (int i = 0; i < k; ++i) {
+            ans[i] = nums.get(i);
+        }
+        return ans;
+    }
+}

solution/1400-1499/1471.The k Strongest Values in an Array/Solution.py

@@ -0,0 +1,6 @@
+class Solution:
+    def getStrongest(self, arr: List[int], k: int) -> List[int]:
+        arr.sort()
+        m = arr[(len(arr) - 1) >> 1]
+        arr.sort(key=lambda x: (-abs(x - m), -x))
+        return arr[:k]