feat: add solutions to lc problem: No.1792 (#4683)

No.1792.Maximum Average Pass Ratio

Author: yanglbme

solution/1700-1799/1792.Maximum Average Pass Ratio/README.md

@@ -191,6 +191,100 @@ func (h *hp) Push(v any)   { *h = append(*h, v.(tuple)) }
 func (h *hp) Pop() any     { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
 ```
 
+#### TypeScript
+
+```ts
+function maxAverageRatio(classes: number[][], extraStudents: number): number {
+    function calcGain(a: number, b: number): number {
+        return (a + 1) / (b + 1) - a / b;
+    }
+    const pq = new PriorityQueue<[number, number]>(
+        (p, q) => calcGain(q[0], q[1]) - calcGain(p[0], p[1]),
+    );
+    for (const [a, b] of classes) {
+        pq.enqueue([a, b]);
+    }
+    while (extraStudents-- > 0) {
+        const item = pq.dequeue();
+        const [a, b] = item;
+        pq.enqueue([a + 1, b + 1]);
+    }
+    let ans = 0;
+    while (!pq.isEmpty()) {
+        const item = pq.dequeue()!;
+        const [a, b] = item;
+        ans += a / b;
+    }
+    return ans / classes.length;
+}
+```
+
+#### Rust
+
+```rust
+use std::cmp::Ordering;
+use std::collections::BinaryHeap;
+
+impl Solution {
+    pub fn max_average_ratio(classes: Vec<Vec<i32>>, extra_students: i32) -> f64 {
+        struct Node {
+            gain: f64,
+            a: i32,
+            b: i32,
+        }
+
+        impl PartialEq for Node {
+            fn eq(&self, other: &Self) -> bool {
+                self.gain == other.gain
+            }
+        }
+        impl Eq for Node {}
+
+        impl PartialOrd for Node {
+            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+                self.gain.partial_cmp(&other.gain)
+            }
+        }
+        impl Ord for Node {
+            fn cmp(&self, other: &Self) -> Ordering {
+                self.partial_cmp(other).unwrap()
+            }
+        }
+
+        fn calc_gain(a: i32, b: i32) -> f64 {
+            (a + 1) as f64 / (b + 1) as f64 - a as f64 / b as f64
+        }
+
+        let n = classes.len() as f64;
+        let mut pq = BinaryHeap::new();
+
+        for c in classes {
+            let a = c[0];
+            let b = c[1];
+            pq.push(Node { gain: calc_gain(a, b), a, b });
+        }
+
+        let mut extra = extra_students;
+        while extra > 0 {
+            if let Some(mut node) = pq.pop() {
+                node.a += 1;
+                node.b += 1;
+                node.gain = calc_gain(node.a, node.b);
+                pq.push(node);
+            }
+            extra -= 1;
+        }
+
+        let mut sum = 0.0;
+        while let Some(node) = pq.pop() {
+            sum += node.a as f64 / node.b as f64;
+        }
+
+        sum / n
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1700-1799/1792.Maximum Average Pass Ratio/README_EN.md

@@ -189,6 +189,100 @@ func (h *hp) Push(v any)   { *h = append(*h, v.(tuple)) }
 func (h *hp) Pop() any     { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
 ```
 
+#### TypeScript
+
+```ts
+function maxAverageRatio(classes: number[][], extraStudents: number): number {
+    function calcGain(a: number, b: number): number {
+        return (a + 1) / (b + 1) - a / b;
+    }
+    const pq = new PriorityQueue<[number, number]>(
+        (p, q) => calcGain(q[0], q[1]) - calcGain(p[0], p[1]),
+    );
+    for (const [a, b] of classes) {
+        pq.enqueue([a, b]);
+    }
+    while (extraStudents-- > 0) {
+        const item = pq.dequeue();
+        const [a, b] = item;
+        pq.enqueue([a + 1, b + 1]);
+    }
+    let ans = 0;
+    while (!pq.isEmpty()) {
+        const item = pq.dequeue()!;
+        const [a, b] = item;
+        ans += a / b;
+    }
+    return ans / classes.length;
+}
+```
+
+#### Rust
+
+```rust
+use std::cmp::Ordering;
+use std::collections::BinaryHeap;
+
+impl Solution {
+    pub fn max_average_ratio(classes: Vec<Vec<i32>>, extra_students: i32) -> f64 {
+        struct Node {
+            gain: f64,
+            a: i32,
+            b: i32,
+        }
+
+        impl PartialEq for Node {
+            fn eq(&self, other: &Self) -> bool {
+                self.gain == other.gain
+            }
+        }
+        impl Eq for Node {}
+
+        impl PartialOrd for Node {
+            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+                self.gain.partial_cmp(&other.gain)
+            }
+        }
+        impl Ord for Node {
+            fn cmp(&self, other: &Self) -> Ordering {
+                self.partial_cmp(other).unwrap()
+            }
+        }
+
+        fn calc_gain(a: i32, b: i32) -> f64 {
+            (a + 1) as f64 / (b + 1) as f64 - a as f64 / b as f64
+        }
+
+        let n = classes.len() as f64;
+        let mut pq = BinaryHeap::new();
+
+        for c in classes {
+            let a = c[0];
+            let b = c[1];
+            pq.push(Node { gain: calc_gain(a, b), a, b });
+        }
+
+        let mut extra = extra_students;
+        while extra > 0 {
+            if let Some(mut node) = pq.pop() {
+                node.a += 1;
+                node.b += 1;
+                node.gain = calc_gain(node.a, node.b);
+                pq.push(node);
+            }
+            extra -= 1;
+        }
+
+        let mut sum = 0.0;
+        while let Some(node) = pq.pop() {
+            sum += node.a as f64 / node.b as f64;
+        }
+
+        sum / n
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1700-1799/1792.Maximum Average Pass Ratio/Solution.rs

@@ -0,0 +1,65 @@
+use std::cmp::Ordering;
+use std::collections::BinaryHeap;
+
+impl Solution {
+    pub fn max_average_ratio(classes: Vec<Vec<i32>>, extra_students: i32) -> f64 {
+        struct Node {
+            gain: f64,
+            a: i32,
+            b: i32,
+        }
+
+        impl PartialEq for Node {
+            fn eq(&self, other: &Self) -> bool {
+                self.gain == other.gain
+            }
+        }
+        impl Eq for Node {}
+
+        impl PartialOrd for Node {
+            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+                self.gain.partial_cmp(&other.gain)
+            }
+        }
+        impl Ord for Node {
+            fn cmp(&self, other: &Self) -> Ordering {
+                self.partial_cmp(other).unwrap()
+            }
+        }
+
+        fn calc_gain(a: i32, b: i32) -> f64 {
+            (a + 1) as f64 / (b + 1) as f64 - a as f64 / b as f64
+        }
+
+        let n = classes.len() as f64;
+        let mut pq = BinaryHeap::new();
+
+        for c in classes {
+            let a = c[0];
+            let b = c[1];
+            pq.push(Node {
+                gain: calc_gain(a, b),
+                a,
+                b,
+            });
+        }
+
+        let mut extra = extra_students;
+        while extra > 0 {
+            if let Some(mut node) = pq.pop() {
+                node.a += 1;
+                node.b += 1;
+                node.gain = calc_gain(node.a, node.b);
+                pq.push(node);
+            }
+            extra -= 1;
+        }
+
+        let mut sum = 0.0;
+        while let Some(node) = pq.pop() {
+            sum += node.a as f64 / node.b as f64;
+        }
+
+        sum / n
+    }
+}

solution/1700-1799/1792.Maximum Average Pass Ratio/Solution.ts

@@ -0,0 +1,23 @@
+function maxAverageRatio(classes: number[][], extraStudents: number): number {
+    function calcGain(a: number, b: number): number {
+        return (a + 1) / (b + 1) - a / b;
+    }
+    const pq = new PriorityQueue<[number, number]>(
+        (p, q) => calcGain(q[0], q[1]) - calcGain(p[0], p[1]),
+    );
+    for (const [a, b] of classes) {
+        pq.enqueue([a, b]);
+    }
+    while (extraStudents-- > 0) {
+        const item = pq.dequeue();
+        const [a, b] = item;
+        pq.enqueue([a + 1, b + 1]);
+    }
+    let ans = 0;
+    while (!pq.isEmpty()) {
+        const item = pq.dequeue()!;
+        const [a, b] = item;
+        ans += a / b;
+    }
+    return ans / classes.length;
+}

solution/3200-3299/3264.Final Array State After K Multiplication Operations I/README.md

@@ -240,9 +240,10 @@ func (h *hp) Push(x any) {
 
 ```ts
 function getFinalState(nums: number[], k: number, multiplier: number): number[] {
-    const pq = new PriorityQueue({
-        compare: (i, j) => (nums[i] === nums[j] ? i - j : nums[i] - nums[j]),
-    });
+    const pq = new PriorityQueue<number>((i, j) =>
+        nums[i] === nums[j] ? i - j : nums[i] - nums[j],
+    );
+
     for (let i = 0; i < nums.length; ++i) {
         pq.enqueue(i);
     }

solution/3200-3299/3264.Final Array State After K Multiplication Operations I/README_EN.md

@@ -238,9 +238,10 @@ func (h *hp) Push(x any) {
 
 ```ts
 function getFinalState(nums: number[], k: number, multiplier: number): number[] {
-    const pq = new PriorityQueue({
-        compare: (i, j) => (nums[i] === nums[j] ? i - j : nums[i] - nums[j]),
-    });
+    const pq = new PriorityQueue<number>((i, j) =>
+        nums[i] === nums[j] ? i - j : nums[i] - nums[j],
+    );
+
     for (let i = 0; i < nums.length; ++i) {
         pq.enqueue(i);
     }

solution/3200-3299/3264.Final Array State After K Multiplication Operations I/Solution.ts

@@ -1,7 +1,8 @@
 function getFinalState(nums: number[], k: number, multiplier: number): number[] {
-    const pq = new PriorityQueue({
-        compare: (i, j) => (nums[i] === nums[j] ? i - j : nums[i] - nums[j]),
-    });
+    const pq = new PriorityQueue<number>((i, j) =>
+        nums[i] === nums[j] ? i - j : nums[i] - nums[j],
+    );
+
     for (let i = 0; i < nums.length; ++i) {
         pq.enqueue(i);
     }