Skip to content

Commit 78788f7

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problems: No.2418~2421
* No.2418.Sort the People * No.2419.Longest Subarray With Maximum Bitwise AND * No.2420.Find All Good Indices * No.2421.Number of Good Paths
1 parent 21216cc commit 78788f7

24 files changed

+1227
-7
lines changed

‎solution/2400-2499/2418.Sort the People/README.md

+65-1
Original file line numberDiff line numberDiff line change
@@ -45,22 +45,86 @@
4545

4646
<!-- 这里可写通用的实现逻辑 -->
4747

48+
**方法一：直接模拟**
49+
50+
直接按照题意，从高到低遍历身高数组，将对应的名字加入结果数组即可。
51+
52+
时间复杂度 $O(n\log n)$。其中 $n$ 为数组 `heights` 的长度。
53+
4854
<!-- tabs:start -->
4955

5056
### **Python3**
5157

5258
<!-- 这里可写当前语言的特殊实现逻辑 -->
5359

5460
```python
55-
61+
class Solution:
62+
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
63+
idx = list(range(len(heights)))
64+
idx.sort(key=lambda i: -heights[i])
65+
return [names[i] for i in idx]
5666
```
5767

5868
### **Java**
5969

6070
<!-- 这里可写当前语言的特殊实现逻辑 -->
6171

6272
```java
73+
class Solution {
74+
public String[] sortPeople(String[] names, int[] heights) {
75+
int n = heights.length;
76+
int[][] arr = new int[n][2];
77+
for (int i = 0; i < n; ++i) {
78+
arr[i] = new int[] {heights[i], i};
79+
}
80+
Arrays.sort(arr, (a, b) -> b[0] - a[0]);
81+
String[] ans = new String[n];
82+
for (int i = 0; i < n; ++i) {
83+
ans[i] = names[arr[i][1]];
84+
}
85+
return ans;
86+
}
87+
}
88+
```
89+
90+
### **C++**
91+
92+
```cpp
93+
class Solution {
94+
public:
95+
vector<string> sortPeople(vector<string>& names, vector<int>& heights) {
96+
int n = heights.size();
97+
vector<pair<int, int>> arr(n);
98+
for (int i = 0; i < n; ++i) {
99+
arr[i] = {-heights[i], i};
100+
}
101+
sort(arr.begin(), arr.end());
102+
vector<string> ans(n);
103+
for (int i = 0; i < n; ++i) {
104+
ans[i] = names[arr[i].second];
105+
}
106+
return ans;
107+
}
108+
};
109+
```
63110
111+
### **Go**
112+
113+
```go
114+
func sortPeople(names []string, heights []int) []string {
115+
n := len(heights)
116+
type pair struct{ v, i int }
117+
arr := make([]pair, n)
118+
for i, v := range heights {
119+
arr[i] = pair{v, i}
120+
}
121+
sort.Slice(arr, func(i, j int) bool { return arr[i].v > arr[j].v })
122+
ans := make([]string, n)
123+
for i, v := range arr {
124+
ans[i] = names[v.i]
125+
}
126+
return ans
127+
}
64128
```
65129

66130
### **TypeScript**

‎solution/2400-2499/2418.Sort the People/README_EN.md

+59-1
Original file line numberDiff line numberDiff line change
@@ -46,13 +46,71 @@
4646
### **Python3**
4747

4848
```python
49-
49+
class Solution:
50+
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
51+
idx = list(range(len(heights)))
52+
idx.sort(key=lambda i: -heights[i])
53+
return [names[i] for i in idx]
5054
```
5155

5256
### **Java**
5357

5458
```java
59+
class Solution {
60+
public String[] sortPeople(String[] names, int[] heights) {
61+
int n = heights.length;
62+
int[][] arr = new int[n][2];
63+
for (int i = 0; i < n; ++i) {
64+
arr[i] = new int[] {heights[i], i};
65+
}
66+
Arrays.sort(arr, (a, b) -> b[0] - a[0]);
67+
String[] ans = new String[n];
68+
for (int i = 0; i < n; ++i) {
69+
ans[i] = names[arr[i][1]];
70+
}
71+
return ans;
72+
}
73+
}
74+
```
75+
76+
### **C++**
77+
78+
```cpp
79+
class Solution {
80+
public:
81+
vector<string> sortPeople(vector<string>& names, vector<int>& heights) {
82+
int n = heights.size();
83+
vector<pair<int, int>> arr(n);
84+
for (int i = 0; i < n; ++i) {
85+
arr[i] = {-heights[i], i};
86+
}
87+
sort(arr.begin(), arr.end());
88+
vector<string> ans(n);
89+
for (int i = 0; i < n; ++i) {
90+
ans[i] = names[arr[i].second];
91+
}
92+
return ans;
93+
}
94+
};
95+
```
5596
97+
### **Go**
98+
99+
```go
100+
func sortPeople(names []string, heights []int) []string {
101+
n := len(heights)
102+
type pair struct{ v, i int }
103+
arr := make([]pair, n)
104+
for i, v := range heights {
105+
arr[i] = pair{v, i}
106+
}
107+
sort.Slice(arr, func(i, j int) bool { return arr[i].v > arr[j].v })
108+
ans := make([]string, n)
109+
for i, v := range arr {
110+
ans[i] = names[v.i]
111+
}
112+
return ans
113+
}
56114
```
57115

58116
### **TypeScript**

‎solution/2400-2499/2418.Sort the People/Solution.cpp

+16
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
class Solution {
2+
public:
3+
vector<string> sortPeople(vector<string>& names, vector<int>& heights) {
4+
int n = heights.size();
5+
vector<pair<int, int>> arr(n);
6+
for (int i = 0; i < n; ++i) {
7+
arr[i] = {-heights[i], i};
8+
}
9+
sort(arr.begin(), arr.end());
10+
vector<string> ans(n);
11+
for (int i = 0; i < n; ++i) {
12+
ans[i] = names[arr[i].second];
13+
}
14+
return ans;
15+
}
16+
};

‎solution/2400-2499/2418.Sort the People/Solution.go

+14
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
func sortPeople(names []string, heights []int) []string {
2+
n := len(heights)
3+
type pair struct{ v, i int }
4+
arr := make([]pair, n)
5+
for i, v := range heights {
6+
arr[i] = pair{v, i}
7+
}
8+
sort.Slice(arr, func(i, j int) bool { return arr[i].v > arr[j].v })
9+
ans := make([]string, n)
10+
for i, v := range arr {
11+
ans[i] = names[v.i]
12+
}
13+
return ans
14+
}

‎solution/2400-2499/2418.Sort the People/Solution.java

+15
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
class Solution {
2+
public String[] sortPeople(String[] names, int[] heights) {
3+
int n = heights.length;
4+
int[][] arr = new int[n][2];
5+
for (int i = 0; i < n; ++i) {
6+
arr[i] = new int[] {heights[i], i};
7+
}
8+
Arrays.sort(arr, (a, b) -> b[0] - a[0]);
9+
String[] ans = new String[n];
10+
for (int i = 0; i < n; ++i) {
11+
ans[i] = names[arr[i][1]];
12+
}
13+
return ans;
14+
}
15+
}

‎solution/2400-2499/2418.Sort the People/Solution.py

+5
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
class Solution:
2+
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
3+
idx = list(range(len(heights)))
4+
idx.sort(key=lambda i: -heights[i])
5+
return [names[i] for i in idx]

‎solution/2400-2499/2419.Longest Subarray With Maximum Bitwise AND/README.md

+87-1
Original file line numberDiff line numberDiff line change
@@ -55,22 +55,108 @@
5555

5656
<!-- 这里可写通用的实现逻辑 -->
5757

58+
**方法一：脑筋急转弯**
59+
60+
由于按位与的操作，不会使得数字变大，因此最大值就是数组中的最大值。
61+
62+
题目可以转换为求最大值在数组中最多连续出现的次数。
63+
64+
先遍历一遍数组，求出最大值，然后再遍历一遍数组，求出最大值连续出现的次数，最后返回这个次数即可。
65+
66+
时间复杂度 $O(n)$。其中 $n$ 为数组的长度。
67+
5868
<!-- tabs:start -->
5969

6070
### **Python3**
6171

6272
<!-- 这里可写当前语言的特殊实现逻辑 -->
6373

6474
```python
65-
75+
class Solution:
76+
def longestSubarray(self, nums: List[int]) -> int:
77+
mx = max(nums)
78+
ans = cnt = 0
79+
for v in nums:
80+
if v == mx:
81+
cnt += 1
82+
ans = max(ans, cnt)
83+
else:
84+
cnt = 0
85+
return ans
6686
```
6787

6888
### **Java**
6989

7090
<!-- 这里可写当前语言的特殊实现逻辑 -->
7191

7292
```java
93+
class Solution {
94+
public int longestSubarray(int[] nums) {
95+
int mx = 0;
96+
for (int v : nums) {
97+
mx = Math.max(mx, v);
98+
}
99+
int ans = 0, cnt = 0;
100+
for (int v : nums) {
101+
if (v == mx) {
102+
++cnt;
103+
ans = Math.max(ans, cnt);
104+
} else {
105+
cnt = 0;
106+
}
107+
}
108+
return ans;
109+
}
110+
}
111+
```
112+
113+
### **C++**
114+
115+
```cpp
116+
class Solution {
117+
public:
118+
int longestSubarray(vector<int>& nums) {
119+
int mx = *max_element(nums.begin(), nums.end());
120+
int ans = 0, cnt = 0;
121+
for (int v : nums) {
122+
if (v == mx) {
123+
++cnt;
124+
ans = max(ans, cnt);
125+
} else {
126+
cnt = 0;
127+
}
128+
}
129+
return ans;
130+
}
131+
};
132+
```
73133
134+
### **Go**
135+
136+
```go
137+
func longestSubarray(nums []int) int {
138+
mx := 0
139+
for _, v := range nums {
140+
mx = max(mx, v)
141+
}
142+
ans, cnt := 0, 0
143+
for _, v := range nums {
144+
if v == mx {
145+
cnt++
146+
ans = max(ans, cnt)
147+
} else {
148+
cnt = 0
149+
}
150+
}
151+
return ans
152+
}
153+
154+
func max(a, b int) int {
155+
if a > b {
156+
return a
157+
}
158+
return b
159+
}
74160
```
75161

76162
### **TypeScript**

0 commit comments

Comments
 (0)