From 78d53e17f065681176c8f181a07ef1268d250567 Mon Sep 17 00:00:00 2001 From: Libin YANG Date: Wed, 3 Sep 2025 07:07:08 +0800 Subject: [PATCH] feat: add solutions to lc problems: No.2349,2749 --- .../README.md | 78 ++++++++++++++++++ .../README_EN.md | 80 ++++++++++++++++++- .../Solution.cs | 32 ++++++++ .../Solution.rs | 39 +++++++++ .../README.md | 41 ++++++++++ .../README_EN.md | 41 ++++++++++ .../Solution.cs | 15 ++++ .../Solution.rs | 16 ++++ 8 files changed, 341 insertions(+), 1 deletion(-) create mode 100644 solution/2300-2399/2349.Design a Number Container System/Solution.cs create mode 100644 solution/2300-2399/2349.Design a Number Container System/Solution.rs create mode 100644 solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/Solution.cs create mode 100644 solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/Solution.rs diff --git a/solution/2300-2399/2349.Design a Number Container System/README.md b/solution/2300-2399/2349.Design a Number Container System/README.md index be2105e863cce..9bfe236ef07e7 100644 --- a/solution/2300-2399/2349.Design a Number Container System/README.md +++ b/solution/2300-2399/2349.Design a Number Container System/README.md @@ -747,6 +747,84 @@ class TreeSet { */ ``` +#### Rust + +```rust +use std::collections::{HashMap, BTreeSet}; + +struct NumberContainers { + d: HashMap, + g: HashMap>, +} + +/** + * `&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 d = new Dictionary(); + private Dictionary> g = new Dictionary>(); + + 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(); + } + 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); + */ +``` + diff --git a/solution/2300-2399/2349.Design a Number Container System/README_EN.md b/solution/2300-2399/2349.Design a Number Container System/README_EN.md index b55a94b3c5cfd..e7c944a54d4ea 100644 --- a/solution/2300-2399/2349.Design a Number Container System/README_EN.md +++ b/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. @@ -745,6 +745,84 @@ class TreeSet { */ ``` +#### Rust + +```rust +use std::collections::{HashMap, BTreeSet}; + +struct NumberContainers { + d: HashMap, + g: HashMap>, +} + +/** + * `&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 d = new Dictionary(); + private Dictionary> g = new Dictionary>(); + + 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(); + } + 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); + */ +``` + diff --git a/solution/2300-2399/2349.Design a Number Container System/Solution.cs b/solution/2300-2399/2349.Design a Number Container System/Solution.cs new file mode 100644 index 0000000000000..50db264bf915d --- /dev/null +++ b/solution/2300-2399/2349.Design a Number Container System/Solution.cs @@ -0,0 +1,32 @@ +public class NumberContainers { + private Dictionary d = new Dictionary(); + private Dictionary> g = new Dictionary>(); + + 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(); + } + 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); + */ diff --git a/solution/2300-2399/2349.Design a Number Container System/Solution.rs b/solution/2300-2399/2349.Design a Number Container System/Solution.rs new file mode 100644 index 0000000000000..a3ff35da74bf1 --- /dev/null +++ b/solution/2300-2399/2349.Design a Number Container System/Solution.rs @@ -0,0 +1,39 @@ +use std::collections::{BTreeSet, HashMap}; + +struct NumberContainers { + d: HashMap, + g: HashMap>, +} + +/** + * `&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, + } + } +} diff --git a/solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/README.md b/solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/README.md index 530456ee5699e..60c524662c3d5 100644 --- a/solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/README.md +++ b/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; + } +} +``` + diff --git a/solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/README_EN.md b/solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/README_EN.md index e7bc954df6367..658cada9fe45b 100644 --- a/solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/README_EN.md +++ b/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; + } +} +``` + diff --git a/solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/Solution.cs b/solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/Solution.cs new file mode 100644 index 0000000000000..cbf5694fa9924 --- /dev/null +++ b/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; + } +} diff --git a/solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/Solution.rs b/solution/2700-2799/2749.Minimum Operations to Make the Integer Zero/Solution.rs new file mode 100644 index 0000000000000..8a1d13b43d759 --- /dev/null +++ b/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 + } +}