From 2af045dfca2b93fc6f822324b7677902c2cae598 Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Mon, 1 Dec 2025 07:21:46 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.2141 --- .../README.md | 73 +++++++++-------- .../README_EN.md | 81 ++++++++++--------- .../Solution.cs | 25 ++++++ .../Solution.rs | 49 +++-------- 4 files changed, 122 insertions(+), 106 deletions(-) create mode 100644 solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.cs diff --git a/solution/2100-2199/2141.Maximum Running Time of N Computers/README.md b/solution/2100-2199/2141.Maximum Running Time of N Computers/README.md index 84ddddc7e8989..f9210397a96e2 100644 --- a/solution/2100-2199/2141.Maximum Running Time of N Computers/README.md +++ b/solution/2100-2199/2141.Maximum Running Time of N Computers/README.md @@ -206,51 +206,58 @@ function maxRunTime(n: number, batteries: number[]): number { ```rust impl Solution { - #[allow(dead_code)] pub fn max_run_time(n: i32, batteries: Vec) -> i64 { - // First sort the batteries - let mut batteries = batteries; - let m = batteries.len() as i32; - batteries.sort(); - - let mut extra_sum: i64 = 0; - for i in 0..(m - n) as usize { - extra_sum += batteries[i] as i64; - } + let n = n as i64; + let mut l: i64 = 0; + let mut r: i64 = batteries.iter().map(|&x| x as i64).sum(); + + while l < r { + let mid = (l + r + 1) >> 1; + let mut s: i64 = 0; - let mut i = (m - n) as usize; - let mut cur_height = batteries[i]; - let mut ret = cur_height as i64; - while extra_sum != 0 { - if i + 1 == (m as usize) { - assert!(cur_height == *batteries.last().unwrap()); - ret += extra_sum / (n as i64); - break; + for &x in &batteries { + let v = x as i64; + s += if v < mid { v } else { mid }; } - if batteries[i] == batteries[i + 1] { - i += 1; - continue; + if s >= n * mid { + l = mid; + } else { + r = mid - 1; } + } - let diff = extra_sum / ((i - ((m - n) as usize) + 1) as i64); + l + } +} +``` - if (cur_height as i64) + diff <= (batteries[i + 1] as i64) { - ret = (cur_height as i64) + diff; - break; - } else { - extra_sum -= ((batteries[i + 1] - batteries[i]) as i64) - * ((i - ((m - n) as usize) + 1) as i64); - ret = batteries[i + 1] as i64; +#### C# + +```cs +public class Solution { + public long MaxRunTime(int n, int[] batteries) { + long l = 0, r = 0; + foreach (int x in batteries) { + r += x; + } + + while (l < r) { + long mid = (l + r + 1) >> 1; + long s = 0; + + foreach (int x in batteries) { + s += Math.Min(mid, (long)x); } - i += 1; - if i != (m as usize) { - cur_height = batteries[i]; + if (s >= (long)n * mid) { + l = mid; + } else { + r = mid - 1; } } - ret + return l; } } ``` diff --git a/solution/2100-2199/2141.Maximum Running Time of N Computers/README_EN.md b/solution/2100-2199/2141.Maximum Running Time of N Computers/README_EN.md index 9e461165829d9..08e205c813f6c 100644 --- a/solution/2100-2199/2141.Maximum Running Time of N Computers/README_EN.md +++ b/solution/2100-2199/2141.Maximum Running Time of N Computers/README_EN.md @@ -35,7 +35,7 @@ tags: 
 Input: n = 2, batteries = [3,3,3]
 Output: 4
-Explanation: 
+Explanation:
 Initially, insert battery 0 into the first computer and battery 1 into the second computer.
 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.
 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
 
 Input: n = 2, batteries = [1,1,1,1]
 Output: 2
-Explanation: 
-Initially, insert battery 0 into the first computer and battery 2 into the second computer. 
-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. 
+Explanation:
+Initially, insert battery 0 into the first computer and battery 2 into the second computer.
+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.
 After another minute, battery 1 and battery 3 are also drained so the first and second computers are no longer running.
 We can run the two computers simultaneously for at most 2 minutes, so we return 2.
 

@@ -203,51 +203,58 @@ function maxRunTime(n: number, batteries: number[]): number {
 
 ```rust
 impl Solution {
-    #[allow(dead_code)]
     pub fn max_run_time(n: i32, batteries: Vec) -> i64 {
-        // First sort the batteries
-        let mut batteries = batteries;
-        let m = batteries.len() as i32;
-        batteries.sort();
-
-        let mut extra_sum: i64 = 0;
-        for i in 0..(m - n) as usize {
-            extra_sum += batteries[i] as i64;
-        }
+        let n = n as i64;
+        let mut l: i64 = 0;
+        let mut r: i64 = batteries.iter().map(|&x| x as i64).sum();
+
+        while l < r {
+            let mid = (l + r + 1) >> 1;
+            let mut s: i64 = 0;
 
-        let mut i = (m - n) as usize;
-        let mut cur_height = batteries[i];
-        let mut ret = cur_height as i64;
-        while extra_sum != 0 {
-            if i + 1 == (m as usize) {
-                assert!(cur_height == *batteries.last().unwrap());
-                ret += extra_sum / (n as i64);
-                break;
+            for &x in &batteries {
+                let v = x as i64;
+                s += if v < mid { v } else { mid };
             }
 
-            if batteries[i] == batteries[i + 1] {
-                i += 1;
-                continue;
+            if s >= n * mid {
+                l = mid;
+            } else {
+                r = mid - 1;
             }
+        }
 
-            let diff = extra_sum / ((i - ((m - n) as usize) + 1) as i64);
+        l
+    }
+}
+```
 
-            if (cur_height as i64) + diff <= (batteries[i + 1] as i64) {
-                ret = (cur_height as i64) + diff;
-                break;
-            } else {
-                extra_sum -= ((batteries[i + 1] - batteries[i]) as i64)
-                    * ((i - ((m - n) as usize) + 1) as i64);
-                ret = batteries[i + 1] as i64;
+#### C#
+
+```cs
+public class Solution {
+    public long MaxRunTime(int n, int[] batteries) {
+        long l = 0, r = 0;
+        foreach (int x in batteries) {
+            r += x;
+        }
+
+        while (l < r) {
+            long mid = (l + r + 1) >> 1;
+            long s = 0;
+
+            foreach (int x in batteries) {
+                s += Math.Min(mid, (long)x);
             }
 
-            i += 1;
-            if i != (m as usize) {
-                cur_height = batteries[i];
+            if (s >= (long)n * mid) {
+                l = mid;
+            } else {
+                r = mid - 1;
             }
         }
 
-        ret
+        return l;
     }
 }
 ```
diff --git a/solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.cs b/solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.cs
new file mode 100644
index 0000000000000..ce142db185725
--- /dev/null
+++ b/solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.cs	
@@ -0,0 +1,25 @@
+public class Solution {
+    public long MaxRunTime(int n, int[] batteries) {
+        long l = 0, r = 0;
+        foreach (int x in batteries) {
+            r += x;
+        }
+
+        while (l < r) {
+            long mid = (l + r + 1) >> 1;
+            long s = 0;
+
+            foreach (int x in batteries) {
+                s += Math.Min(mid, (long)x);
+            }
+
+            if (s >= (long)n * mid) {
+                l = mid;
+            } else {
+                r = mid - 1;
+            }
+        }
+
+        return l;
+    }
+}
diff --git a/solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.rs b/solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.rs
index 343c2f29230ba..6a3f481057161 100644
--- a/solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.rs	
+++ b/solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.rs	
@@ -1,48 +1,25 @@
 impl Solution {
-    #[allow(dead_code)]
     pub fn max_run_time(n: i32, batteries: Vec) -> i64 {
-        // First sort the batteries
-        let mut batteries = batteries;
-        let m = batteries.len() as i32;
-        batteries.sort();
+        let n = n as i64;
+        let mut l: i64 = 0;
+        let mut r: i64 = batteries.iter().map(|&x| x as i64).sum();
 
-        let mut extra_sum: i64 = 0;
-        for i in 0..(m - n) as usize {
-            extra_sum += batteries[i] as i64;
-        }
-
-        let mut i = (m - n) as usize;
-        let mut cur_height = batteries[i];
-        let mut ret = cur_height as i64;
-        while extra_sum != 0 {
-            if i + 1 == (m as usize) {
-                assert!(cur_height == *batteries.last().unwrap());
-                ret += extra_sum / (n as i64);
-                break;
-            }
+        while l < r {
+            let mid = (l + r + 1) >> 1;
+            let mut s: i64 = 0;
 
-            if batteries[i] == batteries[i + 1] {
-                i += 1;
-                continue;
+            for &x in &batteries {
+                let v = x as i64;
+                s += if v < mid { v } else { mid };
             }
 
-            let diff = extra_sum / ((i - ((m - n) as usize) + 1) as i64);
-
-            if (cur_height as i64) + diff <= (batteries[i + 1] as i64) {
-                ret = (cur_height as i64) + diff;
-                break;
+            if s >= n * mid {
+                l = mid;
             } else {
-                extra_sum -= ((batteries[i + 1] - batteries[i]) as i64)
-                    * ((i - ((m - n) as usize) + 1) as i64);
-                ret = batteries[i + 1] as i64;
-            }
-
-            i += 1;
-            if i != (m as usize) {
-                cur_height = batteries[i];
+                r = mid - 1;
             }
         }
 
-        ret
+        l
     }
 }