Skip to content

Commit 1ed702f

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2191
No.2191: Sort the Jumbled Numbers
1 parent 753ba8c commit 1ed702f

File tree

7 files changed

+286
-123
lines changed

7 files changed

+286
-123
lines changed

‎solution/2100-2199/2191.Sort the Jumbled Numbers/README.md

+101-41
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,10 @@
6161

6262
**方法一：自定义排序**
6363

64+
我们遍历数组 $nums$ 中的每个元素 $nums[i]$，将其映射后的值 $y$ 与下标 $i$ 一起存入数组 $arr$ 中，然后对数组 $arr$ 进行排序，最后将排序后的数组 $arr$ 中的下标 $i$ 取出，转换为原数组 $nums$ 中的元素 $nums[i]$ 即可。
65+
66+
时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
67+
6468
<!-- tabs:start -->
6569

6670
### **Python3**
@@ -70,21 +74,17 @@
7074
```python
7175
class Solution:
7276
def sortJumbled(self, mapping: List[int], nums: List[int]) -> List[int]:
73-
m = []
74-
for i, v in enumerate(nums):
75-
a, b, t = v, 0, 1
76-
while 1:
77-
a, x = divmod(a, 10)
78-
x = mapping[x]
79-
b = x * t + b
80-
t *= 10
81-
if a == 0:
82-
break
83-
m.append((b, i, v))
84-
m.sort()
85-
for i, v in enumerate(m):
86-
nums[i] = v[2]
87-
return nums
77+
arr = []
78+
for i, x in enumerate(nums):
79+
y = mapping[0] if x == 0 else 0
80+
k = 1
81+
while x:
82+
x, v = divmod(x, 10)
83+
y = mapping[v] * k + y
84+
k *= 10
85+
arr.append((y, i))
86+
arr.sort()
87+
return [nums[i] for _, i in arr]
8888
```
8989

9090
### **Java**
@@ -94,43 +94,103 @@ class Solution:
9494
```java
9595
class Solution {
9696
public int[] sortJumbled(int[] mapping, int[] nums) {
97-
List<int[]> m = new ArrayList<>();
98-
for (int i = 0; i < nums.length; ++i) {
99-
int v = nums[i];
100-
int a = v, b = 0, t = 1;
101-
while (true) {
102-
int x = a % 10;
103-
x = mapping[x];
104-
a /= 10;
105-
b = x * t + b;
106-
t *= 10;
107-
if (a == 0) {
108-
break;
109-
}
97+
int n = nums.length;
98+
int[][] arr = new int[n][2];
99+
for (int i = 0; i < n; ++i) {
100+
int x = nums[i];
101+
int y = x == 0 ? mapping[0] : 0;
102+
int k = 1;
103+
for (; x > 0; x /= 10) {
104+
y += k * mapping[x % 10];
105+
k *= 10;
110106
}
111-
m.add(new int[] {b, i, v});
107+
arr[i] = new int[]{y, i};
112108
}
113-
m.sort((a, b) -> {
114-
if (a[0] != b[0]) {
115-
return a[0] - b[0];
116-
}
117-
if (a[1] != b[1]) {
118-
return a[1] - b[1];
109+
Arrays.sort(arr, (a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]);
110+
int[] ans = new int[n];
111+
for (int i = 0; i < n; ++i) {
112+
ans[i] = nums[arr[i][1]];
113+
}
114+
return ans;
115+
}
116+
}
117+
```
118+
119+
### **C++**
120+
121+
```cpp
122+
class Solution {
123+
public:
124+
vector<int> sortJumbled(vector<int>& mapping, vector<int>& nums) {
125+
int n = nums.size();
126+
vector<pair<int, int>> arr(n);
127+
for (int i = 0; i < n; ++i) {
128+
int x = nums[i];
129+
int y = x == 0 ? mapping[0] : 0;
130+
int k = 1;
131+
for (; x; x /= 10) {
132+
y += k * mapping[x % 10];
133+
k *= 10;
119134
}
120-
return 0;
121-
});
122-
for (int i = 0; i < m.size(); ++i) {
123-
nums[i] = m.get(i)[2];
135+
arr[i] = {y, i};
136+
}
137+
sort(arr.begin(), arr.end());
138+
vector<int> ans;
139+
for (auto& [_, i] : arr) {
140+
ans.push_back(nums[i]);
124141
}
125-
return nums;
142+
return ans;
126143
}
144+
};
145+
```
146+
147+
### **Go**
148+
149+
```go
150+
func sortJumbled(mapping []int, nums []int) (ans []int) {
151+
n := len(nums)
152+
arr := make([][2]int, n)
153+
for i, x := range nums {
154+
y := 0
155+
if x == 0 {
156+
y = mapping[0]
157+
}
158+
k := 1
159+
for ; x > 0; x /= 10 {
160+
y += k * mapping[x%10]
161+
k *= 10
162+
}
163+
arr[i] = [2]int{y, i}
164+
}
165+
sort.Slice(arr, func(i, j int) bool {
166+
a, b := arr[i], arr[j]
167+
return a[0] < b[0] || a[0] == b[0] && a[1] < b[1]
168+
})
169+
for _, x := range arr {
170+
ans = append(ans, nums[x[1]])
171+
}
172+
return
127173
}
128174
```
129175

130176
### **TypeScript**
131177

132178
```ts
133-
179+
function sortJumbled(mapping: number[], nums: number[]): number[] {
180+
const n = nums.length;
181+
const arr: number[][] = [];
182+
for (let i = 0; i < n; ++i) {
183+
let x = nums[i];
184+
let y = x === 0 ? mapping[0] : 0;
185+
let k = 1;
186+
for (; x > 0; x = Math.floor(x / 10), k *= 10) {
187+
y += mapping[x % 10] * k;
188+
}
189+
arr.push([y, i]);
190+
}
191+
arr.sort((a, b) => (a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]));
192+
return arr.map(a => nums[a[1]]);
193+
}
134194
```
135195

136196
### **...**

‎solution/2100-2199/2191.Sort the Jumbled Numbers/README_EN.md

+97-41
Original file line numberDiff line numberDiff line change
@@ -62,65 +62,121 @@ Thus, the sorted array is [338,38,991].
6262
```python
6363
class Solution:
6464
def sortJumbled(self, mapping: List[int], nums: List[int]) -> List[int]:
65-
m = []
66-
for i, v in enumerate(nums):
67-
a, b, t = v, 0, 1
68-
while 1:
69-
a, x = divmod(a, 10)
70-
x = mapping[x]
71-
b = x * t + b
72-
t *= 10
73-
if a == 0:
74-
break
75-
m.append((b, i, v))
76-
m.sort()
77-
for i, v in enumerate(m):
78-
nums[i] = v[2]
79-
return nums
65+
arr = []
66+
for i, x in enumerate(nums):
67+
y = mapping[0] if x == 0 else 0
68+
k = 1
69+
while x:
70+
x, v = divmod(x, 10)
71+
y = mapping[v] * k + y
72+
k *= 10
73+
arr.append((y, i))
74+
arr.sort()
75+
return [nums[i] for _, i in arr]
8076
```
8177

8278
### **Java**
8379

8480
```java
8581
class Solution {
8682
public int[] sortJumbled(int[] mapping, int[] nums) {
87-
List<int[]> m = new ArrayList<>();
88-
for (int i = 0; i < nums.length; ++i) {
89-
int v = nums[i];
90-
int a = v, b = 0, t = 1;
91-
while (true) {
92-
int x = a % 10;
93-
x = mapping[x];
94-
a /= 10;
95-
b = x * t + b;
96-
t *= 10;
97-
if (a == 0) {
98-
break;
99-
}
83+
int n = nums.length;
84+
int[][] arr = new int[n][2];
85+
for (int i = 0; i < n; ++i) {
86+
int x = nums[i];
87+
int y = x == 0 ? mapping[0] : 0;
88+
int k = 1;
89+
for (; x > 0; x /= 10) {
90+
y += k * mapping[x % 10];
91+
k *= 10;
10092
}
101-
m.add(new int[] {b, i, v});
93+
arr[i] = new int[]{y, i};
10294
}
103-
m.sort((a, b) -> {
104-
if (a[0] != b[0]) {
105-
return a[0] - b[0];
106-
}
107-
if (a[1] != b[1]) {
108-
return a[1] - b[1];
95+
Arrays.sort(arr, (a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]);
96+
int[] ans = new int[n];
97+
for (int i = 0; i < n; ++i) {
98+
ans[i] = nums[arr[i][1]];
99+
}
100+
return ans;
101+
}
102+
}
103+
```
104+
105+
### **C++**
106+
107+
```cpp
108+
class Solution {
109+
public:
110+
vector<int> sortJumbled(vector<int>& mapping, vector<int>& nums) {
111+
int n = nums.size();
112+
vector<pair<int, int>> arr(n);
113+
for (int i = 0; i < n; ++i) {
114+
int x = nums[i];
115+
int y = x == 0 ? mapping[0] : 0;
116+
int k = 1;
117+
for (; x; x /= 10) {
118+
y += k * mapping[x % 10];
119+
k *= 10;
109120
}
110-
return 0;
111-
});
112-
for (int i = 0; i < m.size(); ++i) {
113-
nums[i] = m.get(i)[2];
121+
arr[i] = {y, i};
114122
}
115-
return nums;
123+
sort(arr.begin(), arr.end());
124+
vector<int> ans;
125+
for (auto& [_, i] : arr) {
126+
ans.push_back(nums[i]);
127+
}
128+
return ans;
116129
}
130+
};
131+
```
132+
133+
### **Go**
134+
135+
```go
136+
func sortJumbled(mapping []int, nums []int) (ans []int) {
137+
n := len(nums)
138+
arr := make([][2]int, n)
139+
for i, x := range nums {
140+
y := 0
141+
if x == 0 {
142+
y = mapping[0]
143+
}
144+
k := 1
145+
for ; x > 0; x /= 10 {
146+
y += k * mapping[x%10]
147+
k *= 10
148+
}
149+
arr[i] = [2]int{y, i}
150+
}
151+
sort.Slice(arr, func(i, j int) bool {
152+
a, b := arr[i], arr[j]
153+
return a[0] < b[0] || a[0] == b[0] && a[1] < b[1]
154+
})
155+
for _, x := range arr {
156+
ans = append(ans, nums[x[1]])
157+
}
158+
return
117159
}
118160
```
119161

120162
### **TypeScript**
121163

122164
```ts
123-
165+
function sortJumbled(mapping: number[], nums: number[]): number[] {
166+
const n = nums.length;
167+
const arr: number[][] = [];
168+
for (let i = 0; i < n; ++i) {
169+
let x = nums[i];
170+
let y = x === 0 ? mapping[0] : 0;
171+
let k = 1;
172+
for (; x > 0; x = Math.floor(x / 10), k *= 10) {
173+
y += mapping[x % 10] * k;
174+
}
175+
arr.push([y, i]);
176+
}
177+
arr.sort((a, b) => (a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]));
178+
return arr.map(a => nums[a[1]]);
179+
}
124180
```
125181

126182
### **...**

‎solution/2100-2199/2191.Sort the Jumbled Numbers/Solution.cpp

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public:
3+
vector<int> sortJumbled(vector<int>& mapping, vector<int>& nums) {
4+
int n = nums.size();
5+
vector<pair<int, int>> arr(n);
6+
for (int i = 0; i < n; ++i) {
7+
int x = nums[i];
8+
int y = x == 0 ? mapping[0] : 0;
9+
int k = 1;
10+
for (; x; x /= 10) {
11+
y += k * mapping[x % 10];
12+
k *= 10;
13+
}
14+
arr[i] = {y, i};
15+
}
16+
sort(arr.begin(), arr.end());
17+
vector<int> ans;
18+
for (auto& [_, i] : arr) {
19+
ans.push_back(nums[i]);
20+
}
21+
return ans;
22+
}
23+
};

‎solution/2100-2199/2191.Sort the Jumbled Numbers/Solution.go

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
func sortJumbled(mapping []int, nums []int) (ans []int) {
2+
n := len(nums)
3+
arr := make([][2]int, n)
4+
for i, x := range nums {
5+
y := 0
6+
if x == 0 {
7+
y = mapping[0]
8+
}
9+
k := 1
10+
for ; x > 0; x /= 10 {
11+
y += k * mapping[x%10]
12+
k *= 10
13+
}
14+
arr[i] = [2]int{y, i}
15+
}
16+
sort.Slice(arr, func(i, j int) bool {
17+
a, b := arr[i], arr[j]
18+
return a[0] < b[0] || a[0] == b[0] && a[1] < b[1]
19+
})
20+
for _, x := range arr {
21+
ans = append(ans, nums[x[1]])
22+
}
23+
return
24+
}

0 commit comments

Comments
 (0)