feat: add solutions to lc problem: No.2343

No.2343.Query Kth Smallest Trimmed Number

Author: yanglbme

solution/2300-2399/2342.Max Sum of a Pair With Equal Sum of Digits/README.md

@@ -47,7 +47,7 @@
 
 对于数组中的每个元素，计算其数位和，将其存入哈希表 $d$ 中，哈希表的键为数位和，值为数组中所有数位和为该键的元素组成的数组。
 
-遍历哈希表 $d$，对于每个键值对，如果该键对应的数组长度大于 1，则对该数组进行降序排序，取前两个元素相加，更新答案。
+遍历哈希表 $d$，对于每个键值对，如果该键对应的数组长度大于 $1$，则对该数组进行降序排序，取前两个元素相加，更新答案。
 
 最终返回答案。
 
@@ -61,7 +61,7 @@
 
 最终返回答案。
 
-时间复杂度 $O(n)$，空间复杂度 $O(C)$。其中 $n$ 为数组 `nums` 的长度，而 $C$ 为数组 `nums` 中元素最大值的数位和。本题中 $C \leq 9 \times 10^8$，因此我们固定取 $C=100$。
+时间复杂度 $O(n)$，空间复杂度 $O(C)$。其中 $n$ 为数组 `nums` 的长度，而 $C$ 为数组 `nums` 的最大数位和。本题中 $nums[i] \leq 10^9$，因此我们固定取 $C=100$ 即可。
 
 <!-- tabs:start -->
 

solution/2300-2399/2343.Query Kth Smallest Trimmed Number/README.md

@@ -74,6 +74,12 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：模拟**
+
+根据题意，我们可以模拟裁剪过程，然后对裁剪后的字符串进行排序，最后根据下标找到对应的数字即可。
+
+时间复杂度 $O(m \times \ n \times \log n \times s)$，空间复杂度 $O(n)$。其中 $m$ 和 $n$ 分别为 `nums` 和 `queries` 的长度，而 $s$ 为 $nums[i]$ 字符串的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -86,13 +92,9 @@ class Solution:
         self, nums: List[str], queries: List[List[int]]
     ) -> List[int]:
         ans = []
-        for k, t in queries:
-            x = nums[:]
-            for i, v in enumerate(x):
-                x[i] = v[-t:]
-            p = list(zip(x, range(len(x))))
-            p.sort(key=lambda v: (int(v[0]), v[1]))
-            ans.append(p[k - 1][1])
+        for k, trim in queries:
+            t = sorted((v[-trim:], i) for i, v in enumerate(nums))
+            ans.append(t[k - 1][1])
         return ans
 ```
 
@@ -103,24 +105,66 @@ class Solution:
 ```java
 class Solution {
     public int[] smallestTrimmedNumbers(String[] nums, int[][] queries) {
-        int n = queries.length;
-        int m = nums.length;
-        int[] ans = new int[n];
-        for (int i = 0; i < n; ++i) {
-            int k = queries[i][0], t = queries[i][1];
-            String[][] arr = new String[m][2];
-            for (int j = 0; j < m; ++j) {
-                arr[j][0] = nums[j].substring(nums[j].length() - t);
-                arr[j][1] = String.valueOf(j);
+        int n = nums.length;
+        int m = queries.length;
+        int[] ans = new int[m];
+        String[][] t = new String[n][2];
+        for (int i = 0; i < m; ++i) {
+            int k = queries[i][0], trim = queries[i][1];
+            for (int j = 0; j < n; ++j) {
+                t[j] = new String[] {nums[j].substring(nums[j].length() - trim), String.valueOf(j)};
             }
-            Arrays.sort(arr, (a, b) -> {
+            Arrays.sort(t, (a, b) -> {
                 int x = a[0].compareTo(b[0]);
                 return x == 0 ? Long.compare(Integer.valueOf(a[1]), Integer.valueOf(b[1])) : x;
             });
-            ans[i] = Integer.valueOf(arr[k - 1][1]);
+            ans[i] = Integer.valueOf(t[k - 1][1]);
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> smallestTrimmedNumbers(vector<string>& nums, vector<vector<int>>& queries) {
+        int n = nums.size();
+        vector<pair<string, int>> t(n);
+        vector<int> ans;
+        for (auto& q : queries) {
+            int k = q[0], trim = q[1];
+            for (int j = 0; j < n; ++j) {
+                t[j] = {nums[j].substr(nums[j].size() - trim), j};
+            }
+            sort(t.begin(), t.end());
+            ans.push_back(t[k - 1].second);
         }
         return ans;
     }
+};
+```
+
+### **Go**
+
+```go
+func smallestTrimmedNumbers(nums []string, queries [][]int) []int {
+	type pair struct {
+		s string
+		i int
+	}
+	ans := make([]int, len(queries))
+	t := make([]pair, len(nums))
+	for i, q := range queries {
+		for j, s := range nums {
+			t[j] = pair{s[len(s)-q[1]:], j}
+		}
+		sort.Slice(t, func(i, j int) bool { a, b := t[i], t[j]; return a.s < b.s || a.s == b.s && a.i < b.i })
+		ans[i] = t[q[0]-1].i
+	}
+	return ans
 }
 ```
 

solution/2300-2399/2343.Query Kth Smallest Trimmed Number/README_EN.md

@@ -77,13 +77,9 @@ class Solution:
         self, nums: List[str], queries: List[List[int]]
     ) -> List[int]:
         ans = []
-        for k, t in queries:
-            x = nums[:]
-            for i, v in enumerate(x):
-                x[i] = v[-t:]
-            p = list(zip(x, range(len(x))))
-            p.sort(key=lambda v: (int(v[0]), v[1]))
-            ans.append(p[k - 1][1])
+        for k, trim in queries:
+            t = sorted((v[-trim:], i) for i, v in enumerate(nums))
+            ans.append(t[k - 1][1])
         return ans
 ```
 
@@ -92,27 +88,69 @@ class Solution:
 ```java
 class Solution {
     public int[] smallestTrimmedNumbers(String[] nums, int[][] queries) {
-        int n = queries.length;
-        int m = nums.length;
-        int[] ans = new int[n];
-        for (int i = 0; i < n; ++i) {
-            int k = queries[i][0], t = queries[i][1];
-            String[][] arr = new String[m][2];
-            for (int j = 0; j < m; ++j) {
-                arr[j][0] = nums[j].substring(nums[j].length() - t);
-                arr[j][1] = String.valueOf(j);
+        int n = nums.length;
+        int m = queries.length;
+        int[] ans = new int[m];
+        String[][] t = new String[n][2];
+        for (int i = 0; i < m; ++i) {
+            int k = queries[i][0], trim = queries[i][1];
+            for (int j = 0; j < n; ++j) {
+                t[j] = new String[] {nums[j].substring(nums[j].length() - trim), String.valueOf(j)};
             }
-            Arrays.sort(arr, (a, b) -> {
+            Arrays.sort(t, (a, b) -> {
                 int x = a[0].compareTo(b[0]);
                 return x == 0 ? Long.compare(Integer.valueOf(a[1]), Integer.valueOf(b[1])) : x;
             });
-            ans[i] = Integer.valueOf(arr[k - 1][1]);
+            ans[i] = Integer.valueOf(t[k - 1][1]);
         }
         return ans;
     }
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> smallestTrimmedNumbers(vector<string>& nums, vector<vector<int>>& queries) {
+        int n = nums.size();
+        vector<pair<string, int>> t(n);
+        vector<int> ans;
+        for (auto& q : queries) {
+            int k = q[0], trim = q[1];
+            for (int j = 0; j < n; ++j) {
+                t[j] = {nums[j].substr(nums[j].size() - trim), j};
+            }
+            sort(t.begin(), t.end());
+            ans.push_back(t[k - 1].second);
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func smallestTrimmedNumbers(nums []string, queries [][]int) []int {
+	type pair struct {
+		s string
+		i int
+	}
+	ans := make([]int, len(queries))
+	t := make([]pair, len(nums))
+	for i, q := range queries {
+		for j, s := range nums {
+			t[j] = pair{s[len(s)-q[1]:], j}
+		}
+		sort.Slice(t, func(i, j int) bool { a, b := t[i], t[j]; return a.s < b.s || a.s == b.s && a.i < b.i })
+		ans[i] = t[q[0]-1].i
+	}
+	return ans
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/2300-2399/2343.Query Kth Smallest Trimmed Number/Solution.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    vector<int> smallestTrimmedNumbers(vector<string>& nums, vector<vector<int>>& queries) {
+        int n = nums.size();
+        vector<pair<string, int>> t(n);
+        vector<int> ans;
+        for (auto& q : queries) {
+            int k = q[0], trim = q[1];
+            for (int j = 0; j < n; ++j) {
+                t[j] = {nums[j].substr(nums[j].size() - trim), j};
+            }
+            sort(t.begin(), t.end());
+            ans.push_back(t[k - 1].second);
+        }
+        return ans;
+    }
+};

solution/2300-2399/2343.Query Kth Smallest Trimmed Number/Solution.go

@@ -0,0 +1,16 @@
+func smallestTrimmedNumbers(nums []string, queries [][]int) []int {
+	type pair struct {
+		s string
+		i int
+	}
+	ans := make([]int, len(queries))
+	t := make([]pair, len(nums))
+	for i, q := range queries {
+		for j, s := range nums {
+			t[j] = pair{s[len(s)-q[1]:], j}
+		}
+		sort.Slice(t, func(i, j int) bool { a, b := t[i], t[j]; return a.s < b.s || a.s == b.s && a.i < b.i })
+		ans[i] = t[q[0]-1].i
+	}
+	return ans
+}

solution/2300-2399/2343.Query Kth Smallest Trimmed Number/Solution.java

@@ -1,20 +1,19 @@
 class Solution {
     public int[] smallestTrimmedNumbers(String[] nums, int[][] queries) {
-        int n = queries.length;
-        int m = nums.length;
-        int[] ans = new int[n];
-        for (int i = 0; i < n; ++i) {
-            int k = queries[i][0], t = queries[i][1];
-            String[][] arr = new String[m][2];
-            for (int j = 0; j < m; ++j) {
-                arr[j][0] = nums[j].substring(nums[j].length() - t);
-                arr[j][1] = String.valueOf(j);
+        int n = nums.length;
+        int m = queries.length;
+        int[] ans = new int[m];
+        String[][] t = new String[n][2];
+        for (int i = 0; i < m; ++i) {
+            int k = queries[i][0], trim = queries[i][1];
+            for (int j = 0; j < n; ++j) {
+                t[j] = new String[] {nums[j].substring(nums[j].length() - trim), String.valueOf(j)};
             }
-            Arrays.sort(arr, (a, b) -> {
+            Arrays.sort(t, (a, b) -> {
                 int x = a[0].compareTo(b[0]);
                 return x == 0 ? Long.compare(Integer.valueOf(a[1]), Integer.valueOf(b[1])) : x;
             });
-            ans[i] = Integer.valueOf(arr[k - 1][1]);
+            ans[i] = Integer.valueOf(t[k - 1][1]);
         }
         return ans;
     }

solution/2300-2399/2343.Query Kth Smallest Trimmed Number/Solution.py

@@ -3,11 +3,7 @@ def smallestTrimmedNumbers(
         self, nums: List[str], queries: List[List[int]]
     ) -> List[int]:
         ans = []
-        for k, t in queries:
-            x = nums[:]
-            for i, v in enumerate(x):
-                x[i] = v[-t:]
-            p = list(zip(x, range(len(x))))
-            p.sort(key=lambda v: (int(v[0]), v[1]))
-            ans.append(p[k - 1][1])
+        for k, trim in queries:
+            t = sorted((v[-trim:], i) for i, v in enumerate(nums))
+            ans.append(t[k - 1][1])
         return ans