Skip to content

Commit 9b63834

Browse files
YangFongYangFong
committed
feat: add rust solution to lc problems: No.0034,0074
1 parent 36f3a87 commit 9b63834

File tree

6 files changed

+159
-111
lines changed

6 files changed

+159
-111
lines changed

‎solution/0000-0099/0034.Find First and Last Position of Element in Sorted Array/README.md

Lines changed: 41 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -214,49 +214,28 @@ func searchRange(nums []int, target int) []int {
214214
### **Rust**
215215

216216
```rust
217-
use std::cmp::Ordering;
218-
219217
impl Solution {
220218
pub fn search_range(nums: Vec<i32>, target: i32) -> Vec<i32> {
221219
let n = nums.len();
222-
let mut l = 0;
223-
let mut r = n;
224-
while l < r {
225-
let mid = l + (r - l) / 2;
226-
match nums[mid].cmp(&target) {
227-
Ordering::Less => l = mid + 1,
228-
Ordering::Greater => r = mid,
229-
Ordering::Equal => {
230-
let mut res = vec![mid as i32, mid as i32];
231-
let mut t = mid;
232-
while l < t {
233-
let mid = l + (t - l) / 2;
234-
match nums[mid].cmp(&target) {
235-
Ordering::Less => l = mid + 1,
236-
Ordering::Greater => t = mid,
237-
Ordering::Equal => {
238-
res[0] = mid as i32;
239-
t = mid;
240-
}
241-
}
242-
}
243-
t = mid + 1;
244-
while t < r {
245-
let mid = t + (r - t) / 2;
246-
match nums[mid].cmp(&target) {
247-
Ordering::Less => t = mid + 1,
248-
Ordering::Greater => r = mid,
249-
Ordering::Equal => {
250-
res[1] = mid as i32;
251-
t = mid + 1;
252-
}
253-
}
254-
}
255-
return res;
220+
let search = |target| {
221+
let mut left = 0;
222+
let mut right = n;
223+
while left < right {
224+
let mid = left + (right - left) / 2;
225+
if nums[mid] < target {
226+
left = mid + 1;
227+
} else {
228+
right = mid;
256229
}
257230
}
231+
left
232+
};
233+
let start = search(target);
234+
let end = search(target + 1) - 1;
235+
if start >= n || nums[start] != target {
236+
return vec![-1, -1];
258237
}
259-
vec![-1, -1]
238+
vec![start as i32, end as i32]
260239
}
261240
}
262241
```
@@ -284,6 +263,31 @@ function searchRange(nums: number[], target: number): number[] {
284263
}
285264
```
286265

266+
```ts
267+
function searchRange(nums: number[], target: number): number[] {
268+
const n = nums.length;
269+
const search = (target: number) => {
270+
let left = 0;
271+
let right = n;
272+
while (left < right) {
273+
const mid = (left + right) >>> 1;
274+
if (nums[mid] < target) {
275+
left = mid + 1;
276+
} else {
277+
right = mid;
278+
}
279+
}
280+
return left;
281+
};
282+
const start = search(target);
283+
const end = search(target + 1) - 1;
284+
if (nums[start] !== target) {
285+
return [-1, -1];
286+
}
287+
return [start, end];
288+
}
289+
```
290+
287291
### **...**
288292

289293
```

‎solution/0000-0099/0034.Find First and Last Position of Element in Sorted Array/README_EN.md

Lines changed: 41 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -177,49 +177,28 @@ func searchRange(nums []int, target int) []int {
177177
### **Rust**
178178

179179
```rust
180-
use std::cmp::Ordering;
181-
182180
impl Solution {
183181
pub fn search_range(nums: Vec<i32>, target: i32) -> Vec<i32> {
184182
let n = nums.len();
185-
let mut l = 0;
186-
let mut r = n;
187-
while l < r {
188-
let mid = l + (r - l) / 2;
189-
match nums[mid].cmp(&target) {
190-
Ordering::Less => l = mid + 1,
191-
Ordering::Greater => r = mid,
192-
Ordering::Equal => {
193-
let mut res = vec![mid as i32, mid as i32];
194-
let mut t = mid;
195-
while l < t {
196-
let mid = l + (t - l) / 2;
197-
match nums[mid].cmp(&target) {
198-
Ordering::Less => l = mid + 1,
199-
Ordering::Greater => t = mid,
200-
Ordering::Equal => {
201-
res[0] = mid as i32;
202-
t = mid;
203-
}
204-
}
205-
}
206-
t = mid + 1;
207-
while t < r {
208-
let mid = t + (r - t) / 2;
209-
match nums[mid].cmp(&target) {
210-
Ordering::Less => t = mid + 1,
211-
Ordering::Greater => r = mid,
212-
Ordering::Equal => {
213-
res[1] = mid as i32;
214-
t = mid + 1;
215-
}
216-
}
217-
}
218-
return res;
183+
let search = |target| {
184+
let mut left = 0;
185+
let mut right = n;
186+
while left < right {
187+
let mid = left + (right - left) / 2;
188+
if nums[mid] < target {
189+
left = mid + 1;
190+
} else {
191+
right = mid;
219192
}
220193
}
194+
left
195+
};
196+
let start = search(target);
197+
let end = search(target + 1) - 1;
198+
if start >= n || nums[start] != target {
199+
return vec![-1, -1];
221200
}
222-
vec![-1, -1]
201+
vec![start as i32, end as i32]
223202
}
224203
}
225204
```
@@ -247,6 +226,31 @@ function searchRange(nums: number[], target: number): number[] {
247226
}
248227
```
249228

229+
```ts
230+
function searchRange(nums: number[], target: number): number[] {
231+
const n = nums.length;
232+
const search = (target: number) => {
233+
let left = 0;
234+
let right = n;
235+
while (left < right) {
236+
const mid = (left + right) >>> 1;
237+
if (nums[mid] < target) {
238+
left = mid + 1;
239+
} else {
240+
right = mid;
241+
}
242+
}
243+
return left;
244+
};
245+
const start = search(target);
246+
const end = search(target + 1) - 1;
247+
if (nums[start] !== target) {
248+
return [-1, -1];
249+
}
250+
return [start, end];
251+
}
252+
```
253+
250254
### **...**
251255

252256
```

‎solution/0000-0099/0034.Find First and Last Position of Element in Sorted Array/Solution.rs

Lines changed: 16 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -1,45 +1,24 @@
1-
use std::cmp::Ordering;
2-
31
impl Solution {
42
pub fn search_range(nums: Vec<i32>, target: i32) -> Vec<i32> {
53
let n = nums.len();
6-
let mut l = 0;
7-
let mut r = n;
8-
while l < r {
9-
let mid = l + (r - l) / 2;
10-
match nums[mid].cmp(&target) {
11-
Ordering::Less => l = mid + 1,
12-
Ordering::Greater => r = mid,
13-
Ordering::Equal => {
14-
let mut res = vec![mid as i32, mid as i32];
15-
let mut t = mid;
16-
while l < t {
17-
let mid = l + (t - l) / 2;
18-
match nums[mid].cmp(&target) {
19-
Ordering::Less => l = mid + 1,
20-
Ordering::Greater => t = mid,
21-
Ordering::Equal => {
22-
res[0] = mid as i32;
23-
t = mid;
24-
}
25-
}
26-
}
27-
t = mid + 1;
28-
while t < r {
29-
let mid = t + (r - t) / 2;
30-
match nums[mid].cmp(&target) {
31-
Ordering::Less => t = mid + 1,
32-
Ordering::Greater => r = mid,
33-
Ordering::Equal => {
34-
res[1] = mid as i32;
35-
t = mid + 1;
36-
}
37-
}
38-
}
39-
return res;
4+
let search = |target| {
5+
let mut left = 0;
6+
let mut right = n;
7+
while left < right {
8+
let mid = left + (right - left) / 2;
9+
if nums[mid] < target {
10+
left = mid + 1;
11+
} else {
12+
right = mid;
4013
}
4114
}
15+
left
16+
};
17+
let start = search(target);
18+
let end = search(target + 1) - 1;
19+
if start >= n || nums[start] != target {
20+
return vec![-1, -1];
4221
}
43-
vec![-1, -1]
22+
vec![start as i32, end as i32]
4423
}
4524
}

‎solution/0000-0099/0074.Search a 2D Matrix/README.md

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -284,6 +284,28 @@ func searchMatrix(matrix [][]int, target int) bool {
284284
}
285285
```
286286

287+
### **Rust**
288+
289+
```rust
290+
use std::cmp::Ordering;
291+
impl Solution {
292+
pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
293+
let m = matrix.len();
294+
let n = matrix[0].len();
295+
let mut i = 0;
296+
let mut j = n;
297+
while i < m && j > 0 {
298+
match matrix[i][j - 1].cmp(&target) {
299+
Ordering::Equal => return true,
300+
Ordering::Less => i += 1,
301+
Ordering::Greater => j -= 1,
302+
}
303+
}
304+
false
305+
}
306+
}
307+
```
308+
287309
### **...**
288310

289311
```

‎solution/0000-0099/0074.Search a 2D Matrix/README_EN.md

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -236,6 +236,28 @@ func searchMatrix(matrix [][]int, target int) bool {
236236
}
237237
```
238238

239+
### **Rust**
240+
241+
```rust
242+
use std::cmp::Ordering;
243+
impl Solution {
244+
pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
245+
let m = matrix.len();
246+
let n = matrix[0].len();
247+
let mut i = 0;
248+
let mut j = n;
249+
while i < m && j > 0 {
250+
match matrix[i][j - 1].cmp(&target) {
251+
Ordering::Equal => return true,
252+
Ordering::Less => i += 1,
253+
Ordering::Greater => j -= 1,
254+
}
255+
}
256+
false
257+
}
258+
}
259+
```
260+
239261
### **...**
240262

241263
```

‎solution/0000-0099/0074.Search a 2D Matrix/Solution.rs

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
use std::cmp::Ordering;
2+
impl Solution {
3+
pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
4+
let m = matrix.len();
5+
let n = matrix[0].len();
6+
let mut i = 0;
7+
let mut j = n;
8+
while i < m && j > 0 {
9+
match matrix[i][j - 1].cmp(&target) {
10+
Ordering::Equal => return true,
11+
Ordering::Less => i += 1,
12+
Ordering::Greater => j -= 1,
13+
}
14+
}
15+
false
16+
}
17+
}

0 commit comments

Comments
 (0)