Skip to content

Commit 559703b

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problems: No.2349,2749 (#4693)
1 parent dd52bbf commit 559703b

File tree

8 files changed

+341
-1
lines changed

8 files changed

+341
-1
lines changed

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

Lines changed: 78 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -747,6 +747,84 @@ class TreeSet<T = number> {
747747
*/
748748
```
749749

750+
#### Rust
751+
752+
```rust
753+
use std::collections::{HashMap, BTreeSet};
754+
755+
struct NumberContainers {
756+
d: HashMap<i32, i32>,
757+
g: HashMap<i32, BTreeSet<i32>>,
758+
}
759+
760+
/**
761+
* `&self` means the method takes an immutable reference.
762+
* If you need a mutable reference, change it to `&mut self` instead.
763+
*/
764+
impl NumberContainers {
765+
fn new() -> Self {
766+
Self {
767+
d: HashMap::new(),
768+
g: HashMap::new(),
769+
}
770+
}
771+
772+
fn change(&mut self, index: i32, number: i32) {
773+
if let Some(&old_number) = self.d.get(&index) {
774+
if let Some(set) = self.g.get_mut(&old_number) {
775+
set.remove(&index);
776+
}
777+
}
778+
self.d.insert(index, number);
779+
self.g.entry(number).or_insert_with(BTreeSet::new).insert(index);
780+
}
781+
782+
fn find(&self, number: i32) -> i32 {
783+
match self.g.get(&number) {
784+
Some(set) if !set.is_empty() => *set.iter().next().unwrap(),
785+
_ => -1,
786+
}
787+
}
788+
}
789+
```
790+
791+
#### C#
792+
793+
```cs
794+
public class NumberContainers {
795+
private Dictionary<int, int> d = new Dictionary<int, int>();
796+
private Dictionary<int, SortedSet<int>> g = new Dictionary<int, SortedSet<int>>();
797+
798+
public NumberContainers() {
799+
}
800+
801+
public void Change(int index, int number) {
802+
if (d.TryGetValue(index, out int oldNumber)) {
803+
g[oldNumber].Remove(index);
804+
}
805+
d[index] = number;
806+
if (!g.ContainsKey(number)) {
807+
g[number] = new SortedSet<int>();
808+
}
809+
g[number].Add(index);
810+
}
811+
812+
public int Find(int number) {
813+
if (!g.ContainsKey(number) || g[number].Count == 0) {
814+
return -1;
815+
}
816+
return g[number].Min;
817+
}
818+
}
819+
820+
/**
821+
* Your NumberContainers object will be instantiated and called as such:
822+
* NumberContainers obj = new NumberContainers();
823+
* obj.Change(index, number);
824+
* int param_2 = obj.Find(number);
825+
*/
826+
```
827+
750828
<!-- tabs:end -->
751829

752830
<!-- solution:end -->

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

Lines changed: 79 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -54,7 +54,7 @@ nc.change(1, 10); // Your container at index 1 will be filled with number 10.
5454
nc.change(3, 10); // Your container at index 3 will be filled with number 10.
5555
nc.change(5, 10); // Your container at index 5 will be filled with number 10.
5656
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.
57-
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.
57+
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.
5858
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.
5959
</pre>
6060

@@ -745,6 +745,84 @@ class TreeSet<T = number> {
745745
*/
746746
```
747747

748+
#### Rust
749+
750+
```rust
751+
use std::collections::{HashMap, BTreeSet};
752+
753+
struct NumberContainers {
754+
d: HashMap<i32, i32>,
755+
g: HashMap<i32, BTreeSet<i32>>,
756+
}
757+
758+
/**
759+
* `&self` means the method takes an immutable reference.
760+
* If you need a mutable reference, change it to `&mut self` instead.
761+
*/
762+
impl NumberContainers {
763+
fn new() -> Self {
764+
Self {
765+
d: HashMap::new(),
766+
g: HashMap::new(),
767+
}
768+
}
769+
770+
fn change(&mut self, index: i32, number: i32) {
771+
if let Some(&old_number) = self.d.get(&index) {
772+
if let Some(set) = self.g.get_mut(&old_number) {
773+
set.remove(&index);
774+
}
775+
}
776+
self.d.insert(index, number);
777+
self.g.entry(number).or_insert_with(BTreeSet::new).insert(index);
778+
}
779+
780+
fn find(&self, number: i32) -> i32 {
781+
match self.g.get(&number) {
782+
Some(set) if !set.is_empty() => *set.iter().next().unwrap(),
783+
_ => -1,
784+
}
785+
}
786+
}
787+
```
788+
789+
#### C#
790+
791+
```cs
792+
public class NumberContainers {
793+
private Dictionary<int, int> d = new Dictionary<int, int>();
794+
private Dictionary<int, SortedSet<int>> g = new Dictionary<int, SortedSet<int>>();
795+
796+
public NumberContainers() {
797+
}
798+
799+
public void Change(int index, int number) {
800+
if (d.TryGetValue(index, out int oldNumber)) {
801+
g[oldNumber].Remove(index);
802+
}
803+
d[index] = number;
804+
if (!g.ContainsKey(number)) {
805+
g[number] = new SortedSet<int>();
806+
}
807+
g[number].Add(index);
808+
}
809+
810+
public int Find(int number) {
811+
if (!g.ContainsKey(number) || g[number].Count == 0) {
812+
return -1;
813+
}
814+
return g[number].Min;
815+
}
816+
}
817+
818+
/**
819+
* Your NumberContainers object will be instantiated and called as such:
820+
* NumberContainers obj = new NumberContainers();
821+
* obj.Change(index, number);
822+
* int param_2 = obj.Find(number);
823+
*/
824+
```
825+
748826
<!-- tabs:end -->
749827

750828
<!-- solution:end -->

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

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
public class NumberContainers {
2+
private Dictionary<int, int> d = new Dictionary<int, int>();
3+
private Dictionary<int, SortedSet<int>> g = new Dictionary<int, SortedSet<int>>();
4+
5+
public NumberContainers() {
6+
}
7+
8+
public void Change(int index, int number) {
9+
if (d.TryGetValue(index, out int oldNumber)) {
10+
g[oldNumber].Remove(index);
11+
}
12+
d[index] = number;
13+
if (!g.ContainsKey(number)) {
14+
g[number] = new SortedSet<int>();
15+
}
16+
g[number].Add(index);
17+
}
18+
19+
public int Find(int number) {
20+
if (!g.ContainsKey(number) || g[number].Count == 0) {
21+
return -1;
22+
}
23+
return g[number].Min;
24+
}
25+
}
26+
27+
/**
28+
* Your NumberContainers object will be instantiated and called as such:
29+
* NumberContainers obj = new NumberContainers();
30+
* obj.Change(index, number);
31+
* int param_2 = obj.Find(number);
32+
*/

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

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
use std::collections::{BTreeSet, HashMap};
2+
3+
struct NumberContainers {
4+
d: HashMap<i32, i32>,
5+
g: HashMap<i32, BTreeSet<i32>>,
6+
}
7+
8+
/**
9+
* `&self` means the method takes an immutable reference.
10+
* If you need a mutable reference, change it to `&mut self` instead.
11+
*/
12+
impl NumberContainers {
13+
fn new() -> Self {
14+
Self {
15+
d: HashMap::new(),
16+
g: HashMap::new(),
17+
}
18+
}
19+
20+
fn change(&mut self, index: i32, number: i32) {
21+
if let Some(&old_number) = self.d.get(&index) {
22+
if let Some(set) = self.g.get_mut(&old_number) {
23+
set.remove(&index);
24+
}
25+
}
26+
self.d.insert(index, number);
27+
self.g
28+
.entry(number)
29+
.or_insert_with(BTreeSet::new)
30+
.insert(index);
31+
}
32+
33+
fn find(&self, number: i32) -> i32 {
34+
match self.g.get(&number) {
35+
Some(set) if !set.is_empty() => *set.iter().next().unwrap(),
36+
_ => -1,
37+
}
38+
}
39+
}

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

Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -169,6 +169,47 @@ function makeTheIntegerZero(num1: number, num2: number): number {
169169
}
170170
```
171171

172+
#### Rust
173+
174+
```rust
175+
impl Solution {
176+
pub fn make_the_integer_zero(num1: i32, num2: i32) -> i32 {
177+
let num1 = num1 as i64;
178+
let num2 = num2 as i64;
179+
for k in 1.. {
180+
let x = num1 - k * num2;
181+
if x < 0 {
182+
break;
183+
}
184+
if (x.count_ones() as i64) <= k && k <= x {
185+
return k as i32;
186+
}
187+
}
188+
-1
189+
}
190+
}
191+
```
192+
193+
#### C#
194+
195+
```cs
196+
public class Solution {
197+
public int MakeTheIntegerZero(int num1, int num2) {
198+
long a = num1, b = num2;
199+
for (long k = 1; ; ++k) {
200+
long x = a - k * b;
201+
if (x < 0) {
202+
break;
203+
}
204+
if (BitOperations.PopCount((ulong)x) <= k && k <= x) {
205+
return (int)k;
206+
}
207+
}
208+
return -1;
209+
}
210+
}
211+
```
212+
172213
<!-- tabs:end -->
173214

174215
<!-- solution:end -->

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

Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -167,6 +167,47 @@ function makeTheIntegerZero(num1: number, num2: number): number {
167167
}
168168
```
169169

170+
#### Rust
171+
172+
```rust
173+
impl Solution {
174+
pub fn make_the_integer_zero(num1: i32, num2: i32) -> i32 {
175+
let num1 = num1 as i64;
176+
let num2 = num2 as i64;
177+
for k in 1.. {
178+
let x = num1 - k * num2;
179+
if x < 0 {
180+
break;
181+
}
182+
if (x.count_ones() as i64) <= k && k <= x {
183+
return k as i32;
184+
}
185+
}
186+
-1
187+
}
188+
}
189+
```
190+
191+
#### C#
192+
193+
```cs
194+
public class Solution {
195+
public int MakeTheIntegerZero(int num1, int num2) {
196+
long a = num1, b = num2;
197+
for (long k = 1; ; ++k) {
198+
long x = a - k * b;
199+
if (x < 0) {
200+
break;
201+
}
202+
if (BitOperations.PopCount((ulong)x) <= k && k <= x) {
203+
return (int)k;
204+
}
205+
}
206+
return -1;
207+
}
208+
}
209+
```
210+
170211
<!-- tabs:end -->
171212

172213
<!-- solution:end -->

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

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
public class Solution {
2+
public int MakeTheIntegerZero(int num1, int num2) {
3+
long a = num1, b = num2;
4+
for (long k = 1; ; ++k) {
5+
long x = a - k * b;
6+
if (x < 0) {
7+
break;
8+
}
9+
if (BitOperations.PopCount((ulong)x) <= k && k <= x) {
10+
return (int)k;
11+
}
12+
}
13+
return -1;
14+
}
15+
}

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

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
impl Solution {
2+
pub fn make_the_integer_zero(num1: i32, num2: i32) -> i32 {
3+
let num1 = num1 as i64;
4+
let num2 = num2 as i64;
5+
for k in 1.. {
6+
let x = num1 - k * num2;
7+
if x < 0 {
8+
break;
9+
}
10+
if (x.count_ones() as i64) <= k && k <= x {
11+
return k as i32;
12+
}
13+
}
14+
-1
15+
}
16+
}

0 commit comments

Comments
 (0)