Skip to content

Commit 99b081b

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.2141 (#4869)
1 parent a4696bc commit 99b081b

File tree

4 files changed

+122
-106
lines changed

4 files changed

+122
-106
lines changed

‎solution/2100-2199/2141.Maximum Running Time of N Computers/README.md‎

Lines changed: 40 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -206,51 +206,58 @@ function maxRunTime(n: number, batteries: number[]): number {
206206

207207
```rust
208208
impl Solution {
209-
#[allow(dead_code)]
210209
pub fn max_run_time(n: i32, batteries: Vec<i32>) -> i64 {
211-
// First sort the batteries
212-
let mut batteries = batteries;
213-
let m = batteries.len() as i32;
214-
batteries.sort();
215-
216-
let mut extra_sum: i64 = 0;
217-
for i in 0..(m - n) as usize {
218-
extra_sum += batteries[i] as i64;
219-
}
210+
let n = n as i64;
211+
let mut l: i64 = 0;
212+
let mut r: i64 = batteries.iter().map(|&x| x as i64).sum();
213+
214+
while l < r {
215+
let mid = (l + r + 1) >> 1;
216+
let mut s: i64 = 0;
220217

221-
let mut i = (m - n) as usize;
222-
let mut cur_height = batteries[i];
223-
let mut ret = cur_height as i64;
224-
while extra_sum != 0 {
225-
if i + 1 == (m as usize) {
226-
assert!(cur_height == *batteries.last().unwrap());
227-
ret += extra_sum / (n as i64);
228-
break;
218+
for &x in &batteries {
219+
let v = x as i64;
220+
s += if v < mid { v } else { mid };
229221
}
230222

231-
if batteries[i] == batteries[i + 1] {
232-
i += 1;
233-
continue;
223+
if s >= n * mid {
224+
l = mid;
225+
} else {
226+
r = mid - 1;
234227
}
228+
}
235229

236-
let diff = extra_sum / ((i - ((m - n) as usize) + 1) as i64);
230+
l
231+
}
232+
}
233+
```
237234

238-
if (cur_height as i64) + diff <= (batteries[i + 1] as i64) {
239-
ret = (cur_height as i64) + diff;
240-
break;
241-
} else {
242-
extra_sum -= ((batteries[i + 1] - batteries[i]) as i64)
243-
* ((i - ((m - n) as usize) + 1) as i64);
244-
ret = batteries[i + 1] as i64;
235+
#### C#
236+
237+
```cs
238+
public class Solution {
239+
public long MaxRunTime(int n, int[] batteries) {
240+
long l = 0, r = 0;
241+
foreach (int x in batteries) {
242+
r += x;
243+
}
244+
245+
while (l < r) {
246+
long mid = (l + r + 1) >> 1;
247+
long s = 0;
248+
249+
foreach (int x in batteries) {
250+
s += Math.Min(mid, (long)x);
245251
}
246252

247-
i += 1;
248-
if i != (m as usize) {
249-
cur_height = batteries[i];
253+
if (s >= (long)n * mid) {
254+
l = mid;
255+
} else {
256+
r = mid - 1;
250257
}
251258
}
252259

253-
ret
260+
return l;
254261
}
255262
}
256263
```

‎solution/2100-2199/2141.Maximum Running Time of N Computers/README_EN.md‎

Lines changed: 44 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ tags:
3535
<pre>
3636
<strong>Input:</strong> n = 2, batteries = [3,3,3]
3737
<strong>Output:</strong> 4
38-
<strong>Explanation:</strong>
38+
<strong>Explanation:</strong>
3939
Initially, insert battery 0 into the first computer and battery 1 into the second computer.
4040
After two minutes, remove battery 1 from the second computer and insert battery 2 instead. Note that battery 1 can still run for one minute.
4141
At the end of the third minute, battery 0 is drained, and you need to remove it from the first computer and insert battery 1 instead.
@@ -49,9 +49,9 @@ We can run the two computers simultaneously for at most 4 minutes, so we return
4949
<pre>
5050
<strong>Input:</strong> n = 2, batteries = [1,1,1,1]
5151
<strong>Output:</strong> 2
52-
<strong>Explanation:</strong>
53-
Initially, insert battery 0 into the first computer and battery 2 into the second computer.
54-
After one minute, battery 0 and battery 2 are drained so you need to remove them and insert battery 1 into the first computer and battery 3 into the second computer.
52+
<strong>Explanation:</strong>
53+
Initially, insert battery 0 into the first computer and battery 2 into the second computer.
54+
After one minute, battery 0 and battery 2 are drained so you need to remove them and insert battery 1 into the first computer and battery 3 into the second computer.
5555
After another minute, battery 1 and battery 3 are also drained so the first and second computers are no longer running.
5656
We can run the two computers simultaneously for at most 2 minutes, so we return 2.
5757
</pre>
@@ -203,51 +203,58 @@ function maxRunTime(n: number, batteries: number[]): number {
203203

204204
```rust
205205
impl Solution {
206-
#[allow(dead_code)]
207206
pub fn max_run_time(n: i32, batteries: Vec<i32>) -> i64 {
208-
// First sort the batteries
209-
let mut batteries = batteries;
210-
let m = batteries.len() as i32;
211-
batteries.sort();
212-
213-
let mut extra_sum: i64 = 0;
214-
for i in 0..(m - n) as usize {
215-
extra_sum += batteries[i] as i64;
216-
}
207+
let n = n as i64;
208+
let mut l: i64 = 0;
209+
let mut r: i64 = batteries.iter().map(|&x| x as i64).sum();
210+
211+
while l < r {
212+
let mid = (l + r + 1) >> 1;
213+
let mut s: i64 = 0;
217214

218-
let mut i = (m - n) as usize;
219-
let mut cur_height = batteries[i];
220-
let mut ret = cur_height as i64;
221-
while extra_sum != 0 {
222-
if i + 1 == (m as usize) {
223-
assert!(cur_height == *batteries.last().unwrap());
224-
ret += extra_sum / (n as i64);
225-
break;
215+
for &x in &batteries {
216+
let v = x as i64;
217+
s += if v < mid { v } else { mid };
226218
}
227219

228-
if batteries[i] == batteries[i + 1] {
229-
i += 1;
230-
continue;
220+
if s >= n * mid {
221+
l = mid;
222+
} else {
223+
r = mid - 1;
231224
}
225+
}
232226

233-
let diff = extra_sum / ((i - ((m - n) as usize) + 1) as i64);
227+
l
228+
}
229+
}
230+
```
234231

235-
if (cur_height as i64) + diff <= (batteries[i + 1] as i64) {
236-
ret = (cur_height as i64) + diff;
237-
break;
238-
} else {
239-
extra_sum -= ((batteries[i + 1] - batteries[i]) as i64)
240-
* ((i - ((m - n) as usize) + 1) as i64);
241-
ret = batteries[i + 1] as i64;
232+
#### C#
233+
234+
```cs
235+
public class Solution {
236+
public long MaxRunTime(int n, int[] batteries) {
237+
long l = 0, r = 0;
238+
foreach (int x in batteries) {
239+
r += x;
240+
}
241+
242+
while (l < r) {
243+
long mid = (l + r + 1) >> 1;
244+
long s = 0;
245+
246+
foreach (int x in batteries) {
247+
s += Math.Min(mid, (long)x);
242248
}
243249

244-
i += 1;
245-
if i != (m as usize) {
246-
cur_height = batteries[i];
250+
if (s >= (long)n * mid) {
251+
l = mid;
252+
} else {
253+
r = mid - 1;
247254
}
248255
}
249256

250-
ret
257+
return l;
251258
}
252259
}
253260
```

‎solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.cs‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
public class Solution {
2+
public long MaxRunTime(int n, int[] batteries) {
3+
long l = 0, r = 0;
4+
foreach (int x in batteries) {
5+
r += x;
6+
}
7+
8+
while (l < r) {
9+
long mid = (l + r + 1) >> 1;
10+
long s = 0;
11+
12+
foreach (int x in batteries) {
13+
s += Math.Min(mid, (long)x);
14+
}
15+
16+
if (s >= (long)n * mid) {
17+
l = mid;
18+
} else {
19+
r = mid - 1;
20+
}
21+
}
22+
23+
return l;
24+
}
25+
}

‎solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.rs‎

Lines changed: 13 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -1,48 +1,25 @@
11
impl Solution {
2-
#[allow(dead_code)]
32
pub fn max_run_time(n: i32, batteries: Vec<i32>) -> i64 {
4-
// First sort the batteries
5-
let mut batteries = batteries;
6-
let m = batteries.len() as i32;
7-
batteries.sort();
3+
let n = n as i64;
4+
let mut l: i64 = 0;
5+
let mut r: i64 = batteries.iter().map(|&x| x as i64).sum();
86

9-
let mut extra_sum: i64 = 0;
10-
for i in 0..(m - n) as usize {
11-
extra_sum += batteries[i] as i64;
12-
}
13-
14-
let mut i = (m - n) as usize;
15-
let mut cur_height = batteries[i];
16-
let mut ret = cur_height as i64;
17-
while extra_sum != 0 {
18-
if i + 1 == (m as usize) {
19-
assert!(cur_height == *batteries.last().unwrap());
20-
ret += extra_sum / (n as i64);
21-
break;
22-
}
7+
while l < r {
8+
let mid = (l + r + 1) >> 1;
9+
let mut s: i64 = 0;
2310

24-
if batteries[i] == batteries[i + 1] {
25-
i += 1;
26-
continue;
11+
for &x in &batteries {
12+
let v = x as i64;
13+
s += if v < mid { v } else { mid };
2714
}
2815

29-
let diff = extra_sum / ((i - ((m - n) as usize) + 1) as i64);
30-
31-
if (cur_height as i64) + diff <= (batteries[i + 1] as i64) {
32-
ret = (cur_height as i64) + diff;
33-
break;
16+
if s >= n * mid {
17+
l = mid;
3418
} else {
35-
extra_sum -= ((batteries[i + 1] - batteries[i]) as i64)
36-
* ((i - ((m - n) as usize) + 1) as i64);
37-
ret = batteries[i + 1] as i64;
38-
}
39-
40-
i += 1;
41-
if i != (m as usize) {
42-
cur_height = batteries[i];
19+
r = mid - 1;
4320
}
4421
}
4522

46-
ret
23+
l
4724
}
4825
}

0 commit comments

Comments
 (0)