feat: add solutions to lc problems: No.2349,2749

solution/2300-2399/2349.Design a Number Container System/README.md

@@ -747,6 +747,84 @@ class TreeSet<T = number> {
  */
 ```
 
+#### Rust
+
+```rust
+use std::collections::{HashMap, BTreeSet};
+
+struct NumberContainers {
+    d: HashMap<i32, i32>,
+    g: HashMap<i32, BTreeSet<i32>>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl NumberContainers {
+    fn new() -> Self {
+        Self {
+            d: HashMap::new(),
+            g: HashMap::new(),
+        }
+    }
+
+    fn change(&mut self, index: i32, number: i32) {
+        if let Some(&old_number) = self.d.get(&index) {
+            if let Some(set) = self.g.get_mut(&old_number) {
+                set.remove(&index);
+            }
+        }
+        self.d.insert(index, number);
+        self.g.entry(number).or_insert_with(BTreeSet::new).insert(index);
+    }
+
+    fn find(&self, number: i32) -> i32 {
+        match self.g.get(&number) {
+            Some(set) if !set.is_empty() => *set.iter().next().unwrap(),
+            _ => -1,
+        }
+    }
+}
+```
+
+#### C#
+
+```cs
+public class NumberContainers {
+    private Dictionary<int, int> d = new Dictionary<int, int>();
+    private Dictionary<int, SortedSet<int>> g = new Dictionary<int, SortedSet<int>>();
+
+    public NumberContainers() {
+    }
+
+    public void Change(int index, int number) {
+        if (d.TryGetValue(index, out int oldNumber)) {
+            g[oldNumber].Remove(index);
+        }
+        d[index] = number;
+        if (!g.ContainsKey(number)) {
+            g[number] = new SortedSet<int>();
+        }
+        g[number].Add(index);
+    }
+
+    public int Find(int number) {
+        if (!g.ContainsKey(number) || g[number].Count == 0) {
+            return -1;
+        }
+        return g[number].Min;
+    }
+}
+
+/**
+ * Your NumberContainers object will be instantiated and called as such:
+ * NumberContainers obj = new NumberContainers();
+ * obj.Change(index, number);
+ * int param_2 = obj.Find(number);
+ */
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2300-2399/2349.Design a Number Container System/README_EN.md

@@ -54,7 +54,7 @@ nc.change(1, 10); // Your container at index 1 will be filled with number 10.
 nc.change(3, 10); // Your container at index 3 will be filled with number 10.
 nc.change(5, 10); // Your container at index 5 will be filled with number 10.
 nc.find(10); // Number 10 is at the indices 1, 2, 3, and 5. Since the smallest index that is filled with 10 is 1, we return 1.
-nc.change(1, 20); // Your container at index 1 will be filled with number 20. Note that index 1 was filled with 10 and then replaced with 20. 
+nc.change(1, 20); // Your container at index 1 will be filled with number 20. Note that index 1 was filled with 10 and then replaced with 20.
 nc.find(10); // Number 10 is at the indices 2, 3, and 5. The smallest index that is filled with 10 is 2. Therefore, we return 2.
 </pre>
 
@@ -745,6 +745,84 @@ class TreeSet<T = number> {
  */
 ```
 
+#### Rust
+
+```rust
+use std::collections::{HashMap, BTreeSet};
+
+struct NumberContainers {
+    d: HashMap<i32, i32>,
+    g: HashMap<i32, BTreeSet<i32>>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl NumberContainers {
+    fn new() -> Self {
+        Self {
+            d: HashMap::new(),
+            g: HashMap::new(),
+        }
+    }
+
+    fn change(&mut self, index: i32, number: i32) {
+        if let Some(&old_number) = self.d.get(&index) {
+            if let Some(set) = self.g.get_mut(&old_number) {
+                set.remove(&index);
+            }
+        }
+        self.d.insert(index, number);
+        self.g.entry(number).or_insert_with(BTreeSet::new).insert(index);
+    }
+
+    fn find(&self, number: i32) -> i32 {
+        match self.g.get(&number) {
+            Some(set) if !set.is_empty() => *set.iter().next().unwrap(),
+            _ => -1,
+        }
+    }
+}
+```
+
+#### C#
+
+```cs
+public class NumberContainers {
+    private Dictionary<int, int> d = new Dictionary<int, int>();
+    private Dictionary<int, SortedSet<int>> g = new Dictionary<int, SortedSet<int>>();
+
+    public NumberContainers() {
+    }
+
+    public void Change(int index, int number) {
+        if (d.TryGetValue(index, out int oldNumber)) {
+            g[oldNumber].Remove(index);
+        }
+        d[index] = number;
+        if (!g.ContainsKey(number)) {
+            g[number] = new SortedSet<int>();
+        }
+        g[number].Add(index);
+    }
+
+    public int Find(int number) {
+        if (!g.ContainsKey(number) || g[number].Count == 0) {
+            return -1;
+        }
+        return g[number].Min;
+    }
+}
+
+/**
+ * Your NumberContainers object will be instantiated and called as such:
+ * NumberContainers obj = new NumberContainers();
+ * obj.Change(index, number);
+ * int param_2 = obj.Find(number);
+ */
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2300-2399/2349.Design a Number Container System/Solution.cs

@@ -0,0 +1,32 @@
+public class NumberContainers {
+    private Dictionary<int, int> d = new Dictionary<int, int>();
+    private Dictionary<int, SortedSet<int>> g = new Dictionary<int, SortedSet<int>>();
+
+    public NumberContainers() {
+    }
+
+    public void Change(int index, int number) {
+        if (d.TryGetValue(index, out int oldNumber)) {
+            g[oldNumber].Remove(index);
+        }
+        d[index] = number;
+        if (!g.ContainsKey(number)) {
+            g[number] = new SortedSet<int>();
+        }
+        g[number].Add(index);
+    }
+
+    public int Find(int number) {
+        if (!g.ContainsKey(number) || g[number].Count == 0) {
+            return -1;
+        }
+        return g[number].Min;
+    }
+}
+
+/**
+ * Your NumberContainers object will be instantiated and called as such:
+ * NumberContainers obj = new NumberContainers();
+ * obj.Change(index, number);
+ * int param_2 = obj.Find(number);
+ */

solution/2300-2399/2349.Design a Number Container System/Solution.rs

@@ -0,0 +1,39 @@
+use std::collections::{BTreeSet, HashMap};
+
+struct NumberContainers {
+    d: HashMap<i32, i32>,
+    g: HashMap<i32, BTreeSet<i32>>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl NumberContainers {
+    fn new() -> Self {
+        Self {
+            d: HashMap::new(),
+            g: HashMap::new(),
+        }
+    }
+
+    fn change(&mut self, index: i32, number: i32) {
+        if let Some(&old_number) = self.d.get(&index) {
+            if let Some(set) = self.g.get_mut(&old_number) {
+                set.remove(&index);
+            }
+        }
+        self.d.insert(index, number);
+        self.g
+            .entry(number)
+            .or_insert_with(BTreeSet::new)
+            .insert(index);
+    }
+
+    fn find(&self, number: i32) -> i32 {
+        match self.g.get(&number) {
+            Some(set) if !set.is_empty() => *set.iter().next().unwrap(),
+            _ => -1,
+        }
+    }
+}

solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/README.md

@@ -169,6 +169,47 @@ function makeTheIntegerZero(num1: number, num2: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn make_the_integer_zero(num1: i32, num2: i32) -> i32 {
+        let num1 = num1 as i64;
+        let num2 = num2 as i64;
+        for k in 1.. {
+            let x = num1 - k * num2;
+            if x < 0 {
+                break;
+            }
+            if (x.count_ones() as i64) <= k && k <= x {
+                return k as i32;
+            }
+        }
+        -1
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int MakeTheIntegerZero(int num1, int num2) {
+        long a = num1, b = num2;
+        for (long k = 1; ; ++k) {
+            long x = a - k * b;
+            if (x < 0) {
+                break;
+            }
+            if (BitOperations.PopCount((ulong)x) <= k && k <= x) {
+                return (int)k;
+            }
+        }
+        return -1;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/README_EN.md

@@ -167,6 +167,47 @@ function makeTheIntegerZero(num1: number, num2: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn make_the_integer_zero(num1: i32, num2: i32) -> i32 {
+        let num1 = num1 as i64;
+        let num2 = num2 as i64;
+        for k in 1.. {
+            let x = num1 - k * num2;
+            if x < 0 {
+                break;
+            }
+            if (x.count_ones() as i64) <= k && k <= x {
+                return k as i32;
+            }
+        }
+        -1
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int MakeTheIntegerZero(int num1, int num2) {
+        long a = num1, b = num2;
+        for (long k = 1; ; ++k) {
+            long x = a - k * b;
+            if (x < 0) {
+                break;
+            }
+            if (BitOperations.PopCount((ulong)x) <= k && k <= x) {
+                return (int)k;
+            }
+        }
+        return -1;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/Solution.cs

@@ -0,0 +1,15 @@
+public class Solution {
+    public int MakeTheIntegerZero(int num1, int num2) {
+        long a = num1, b = num2;
+        for (long k = 1; ; ++k) {
+            long x = a - k * b;
+            if (x < 0) {
+                break;
+            }
+            if (BitOperations.PopCount((ulong)x) <= k && k <= x) {
+                return (int)k;
+            }
+        }
+        return -1;
+    }
+}

solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/Solution.rs

@@ -0,0 +1,16 @@
+impl Solution {
+    pub fn make_the_integer_zero(num1: i32, num2: i32) -> i32 {
+        let num1 = num1 as i64;
+        let num2 = num2 as i64;
+        for k in 1.. {
+            let x = num1 - k * num2;
+            if x < 0 {
+                break;
+            }
+            if (x.count_ones() as i64) <= k && k <= x {
+                return k as i32;
+            }
+        }
+        -1
+    }
+}