Add solutions for problems 3667, 3668, 3669, 3670, and 3671

- Implemented sorting by absolute value in C++, Go, Java, Python, Rust, and TypeScript for problem 3667.
- Developed a solution to restore finishing order for friends in C++, Go, Java, Python, and TypeScript for problem 3668.
- Created a balanced K-factor decomposition solution in C++, Go, Java, Python, and TypeScript for problem 3669.
- Added a problem statement for maximum product of two integers with no common bits (3670) without a solution yet.
- Introduced a problem statement for the sum of beautiful subsequences (3671) without a solution yet.

Author: trinhminhtriet

solutions/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
+    }
+}

solutions/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;
+}

solutions/3600-3699/3663.find-the-least-frequent-digit/README.md

@@ -0,0 +1,174 @@
+---
+comments: true
+difficulty: Easy
+---
+
+<!-- problem:start -->
+
+# [3663. Find The Least Frequent Digit](https://leetcode.com/problems/find-the-least-frequent-digit)
+
+[中文文档](/solution/3600-3699/3663.Find%20The%20Least%20Frequent%20Digit/README.md)
+
+## Description
+
+<!-- description:start -->
+
+<p>Given an integer <code>n</code>, find the digit that occurs <strong>least</strong> frequently in its decimal representation. If multiple digits have the same frequency, choose the <strong>smallest</strong> digit.</p>
+
+<p>Return the chosen digit as an integer.</p>
+The <strong>frequency</strong> of a digit <code>x</code> is the number of times it appears in the decimal representation of <code>n</code>.
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 1553322</span></p>
+
+<p><strong>Output:</strong> 1</p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The least frequent digit in <code>n</code> is 1, which appears only once. All other digits appear twice.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">n = 723344511</span></p>
+
+<p><strong>Output:</strong> 2</p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The least frequent digits in <code>n</code> are 7, 2, and 5; each appears only once.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 2<sup>31</sup>​​​​​​​ - 1</code></li>
+</ul>
+
+<!-- description:end -->
+
+## Solutions
+
+<!-- solution:start -->
+
+### Solution 1: Counting
+
+We use an array $\textit{cnt}$ to count the frequency of each digit. We iterate through each digit of the number $n$ and update the $\textit{cnt}$ array.
+
+Then, we use a variable $f$ to record the current lowest frequency among the digits, and a variable $\textit{ans}$ to record the corresponding digit.
+
+Next, we iterate through the $\textit{cnt}$ array. If $0 < \textit{cnt}[x] < f$, it means we have found a digit with a lower frequency, so we update $f = \textit{cnt}[x]$ and $\textit{ans} = x$.
+
+After the iteration, we return $\textit{ans}$ as the answer.
+
+The time complexity is $O(\log n)$, and the space complexity is $O(1)$.
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def getLeastFrequentDigit(self, n: int) -> int:
+        cnt = [0] * 10
+        while n:
+            n, x = divmod(n, 10)
+            cnt[x] += 1
+        ans, f = 0, inf
+        for x, v in enumerate(cnt):
+            if 0 < v < f:
+                f = v
+                ans = x
+        return ans
+```
+
+#### Java
+
+```java
+class Solution {
+    public int getLeastFrequentDigit(int n) {
+        int[] cnt = new int[10];
+        for (; n > 0; n /= 10) {
+            ++cnt[n % 10];
+        }
+        int ans = 0, f = 1 << 30;
+        for (int x = 0; x < 10; ++x) {
+            if (cnt[x] > 0 && cnt[x] < f) {
+                f = cnt[x];
+                ans = x;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    int getLeastFrequentDigit(int n) {
+        int cnt[10]{};
+        for (; n > 0; n /= 10) {
+            ++cnt[n % 10];
+        }
+        int ans = 0, f = 1 << 30;
+        for (int x = 0; x < 10; ++x) {
+            if (cnt[x] > 0 && cnt[x] < f) {
+                f = cnt[x];
+                ans = x;
+            }
+        }
+        return ans;
+    }
+};
+```
+
+#### Go
+
+```go
+func getLeastFrequentDigit(n int) (ans int) {
+	cnt := [10]int{}
+	for ; n > 0; n /= 10 {
+		cnt[n%10]++
+	}
+	f := 1 << 30
+	for x, v := range cnt {
+		if v > 0 && v < f {
+			f = v
+			ans = x
+		}
+	}
+	return
+}
+```
+
+#### TypeScript
+
+```ts
+function getLeastFrequentDigit(n: number): number {
+    const cnt: number[] = Array(10).fill(0);
+    for (; n; n = (n / 10) | 0) {
+        cnt[n % 10]++;
+    }
+    let [ans, f] = [0, Number.MAX_SAFE_INTEGER];
+    for (let x = 0; x < 10; ++x) {
+        if (cnt[x] > 0 && cnt[x] < f) {
+            f = cnt[x];
+            ans = x;
+        }
+    }
+    return ans;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
+<!-- problem:end -->

solutions/3600-3699/3663.find-the-least-frequent-digit/Solution.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int getLeastFrequentDigit(int n) {
+        int cnt[10]{};
+        for (; n > 0; n /= 10) {
+            ++cnt[n % 10];
+        }
+        int ans = 0, f = 1 << 30;
+        for (int x = 0; x < 10; ++x) {
+            if (cnt[x] > 0 && cnt[x] < f) {
+                f = cnt[x];
+                ans = x;
+            }
+        }
+        return ans;
+    }
+};

solutions/3600-3699/3663.find-the-least-frequent-digit/Solution.go

@@ -0,0 +1,14 @@
+func getLeastFrequentDigit(n int) (ans int) {
+	cnt := [10]int{}
+	for ; n > 0; n /= 10 {
+		cnt[n%10]++
+	}
+	f := 1 << 30
+	for x, v := range cnt {
+		if v > 0 && v < f {
+			f = v
+			ans = x
+		}
+	}
+	return
+}

solutions/3600-3699/3663.find-the-least-frequent-digit/Solution.java

@@ -0,0 +1,16 @@
+class Solution {
+    public int getLeastFrequentDigit(int n) {
+        int[] cnt = new int[10];
+        for (; n > 0; n /= 10) {
+            ++cnt[n % 10];
+        }
+        int ans = 0, f = 1 << 30;
+        for (int x = 0; x < 10; ++x) {
+            if (cnt[x] > 0 && cnt[x] < f) {
+                f = cnt[x];
+                ans = x;
+            }
+        }
+        return ans;
+    }
+}

solutions/3600-3699/3663.find-the-least-frequent-digit/Solution.py

@@ -0,0 +1,12 @@
+class Solution:
+    def getLeastFrequentDigit(self, n: int) -> int:
+        cnt = [0] * 10
+        while n:
+            n, x = divmod(n, 10)
+            cnt[x] += 1
+        ans, f = 0, inf
+        for x, v in enumerate(cnt):
+            if 0 < v < f:
+                f = v
+                ans = x
+        return ans

solutions/3600-3699/3663.find-the-least-frequent-digit/Solution.ts

@@ -0,0 +1,14 @@
+function getLeastFrequentDigit(n: number): number {
+    const cnt: number[] = Array(10).fill(0);
+    for (; n; n = (n / 10) | 0) {
+        cnt[n % 10]++;
+    }
+    let [ans, f] = [0, Number.MAX_SAFE_INTEGER];
+    for (let x = 0; x < 10; ++x) {
+        if (cnt[x] > 0 && cnt[x] < f) {
+            f = cnt[x];
+            ans = x;
+        }
+    }
+    return ans;
+}