feat: add rust solution to lc problems: No.2335,2336

- No.2335.Minimum Amount of Time to Fill Cups
- No.2336.Smallest Number in Infinite Set

Author: YangFong

solution/2300-2399/2335.Minimum Amount of Time to Fill Cups/README.md

@@ -141,10 +141,26 @@ func fillCups(amount []int) int {
 function fillCups(amount: number[]): number {
     amount.sort((a, b) => a - b);
     let [a, b, c] = amount;
-    let diff =  (a + b) - c;
+    let diff = a + b - c;
     if (diff <= 0) return c;
-    else return Math.floor((diff + 1) / 2)  + c;
-};
+    else return Math.floor((diff + 1) / 2) + c;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn fill_cups(mut amount: Vec<i32>) -> i32 {
+        amount.sort();
+        let dif = amount[0] + amount[1] - amount[2];
+        if dif <= 0 {
+            return amount[2];
+        }
+        (dif + 1) / 2 + amount[2]
+    }
+}
+
 ```
 
 ### **...**

solution/2300-2399/2335.Minimum Amount of Time to Fill Cups/README_EN.md

@@ -130,16 +130,31 @@ func fillCups(amount []int) int {
 function fillCups(amount: number[]): number {
     amount.sort((a, b) => a - b);
     let [a, b, c] = amount;
-    let diff =  (a + b) - c;
+    let diff = a + b - c;
     if (diff <= 0) return c;
-    else return Math.floor((diff + 1) / 2)  + c;
-};
+    else return Math.floor((diff + 1) / 2) + c;
+}
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn fill_cups(mut amount: Vec<i32>) -> i32 {
+        amount.sort();
+        let dif = amount[0] + amount[1] - amount[2];
+        if dif <= 0 {
+            return amount[2];
+        }
+        (dif + 1) / 2 + amount[2]
+    }
+}
+
 ### **...**
 
 ```
 
 ```
 
 <!-- tabs:end -->
+```

solution/2300-2399/2335.Minimum Amount of Time to Fill Cups/Solution.rs

@@ -0,0 +1,10 @@
+impl Solution {
+    pub fn fill_cups(mut amount: Vec<i32>) -> i32 {
+        amount.sort();
+        let dif = amount[0] + amount[1] - amount[2];
+        if dif <= 0 {
+            return amount[2];
+        }
+        (dif + 1) / 2 + amount[2]
+    }
+}

solution/2300-2399/2336.Smallest Number in Infinite Set/README.md

@@ -328,7 +328,8 @@ func (h *hp) top() int             { a := *h; return a[0] }
 
 ```ts
 class SmallestInfiniteSet {
-    hashMap;
+    private hashMap: boolean[];
+
     constructor() {
         this.hashMap = new Array(1001).fill(true);
     }
@@ -340,6 +341,7 @@ class SmallestInfiniteSet {
                 return i;
             }
         }
+        return -1;
     }
 
     addBack(num: number): void {
@@ -357,6 +359,49 @@ class SmallestInfiniteSet {
  */
 ```
 
+### **Rust**
+
+```rust
+struct SmallestInfiniteSet {
+    counter: [bool; 1000]
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl SmallestInfiniteSet {
+
+    fn new() -> Self {
+        Self {
+            counter: [true; 1000]
+        }
+    }
+
+    fn pop_smallest(&mut self) -> i32 {
+        for i in 0..1000 {
+            if self.counter[i] {
+                self.counter[i] = false;
+                return i as i32 + 1;
+            }
+        }
+        -1
+    }
+
+    fn add_back(&mut self, num: i32) {
+        self.counter[num as usize - 1] = true;
+    }
+}
+
+/**
+ * Your SmallestInfiniteSet object will be instantiated and called as such:
+ * let obj = SmallestInfiniteSet::new();
+ * let ret_1: i32 = obj.pop_smallest();
+ * obj.add_back(num);
+ */
+```
+
 ### **...**
 
 ```

solution/2300-2399/2336.Smallest Number in Infinite Set/README_EN.md

@@ -316,7 +316,8 @@ func (h *hp) top() int             { a := *h; return a[0] }
 
 ```ts
 class SmallestInfiniteSet {
-    hashMap;
+    private hashMap: boolean[];
+
     constructor() {
         this.hashMap = new Array(1001).fill(true);
     }
@@ -328,6 +329,7 @@ class SmallestInfiniteSet {
                 return i;
             }
         }
+        return -1;
     }
 
     addBack(num: number): void {
@@ -345,6 +347,49 @@ class SmallestInfiniteSet {
  */
 ```
 
+### **Rust**
+
+```rust
+struct SmallestInfiniteSet {
+    counter: [bool; 1000]
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl SmallestInfiniteSet {
+
+    fn new() -> Self {
+        Self {
+            counter: [true; 1000]
+        }
+    }
+
+    fn pop_smallest(&mut self) -> i32 {
+        for i in 0..1000 {
+            if self.counter[i] {
+                self.counter[i] = false;
+                return i as i32 + 1;
+            }
+        }
+        -1
+    }
+
+    fn add_back(&mut self, num: i32) {
+        self.counter[num as usize - 1] = true;
+    }
+}
+
+/**
+ * Your SmallestInfiniteSet object will be instantiated and called as such:
+ * let obj = SmallestInfiniteSet::new();
+ * let ret_1: i32 = obj.pop_smallest();
+ * obj.add_back(num);
+ */
+```
+
 ### **...**
 
 ```

solution/2300-2399/2336.Smallest Number in Infinite Set/Solution.rs

@@ -0,0 +1,38 @@
+struct SmallestInfiniteSet {
+    counter: [bool; 1000]
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl SmallestInfiniteSet {
+
+    fn new() -> Self {
+        Self {
+            counter: [true; 1000]
+        }
+    }
+
+    fn pop_smallest(&mut self) -> i32 {
+        for i in 0..1000 {
+            if self.counter[i] {
+                self.counter[i] = false;
+                return i as i32 + 1;
+            }
+        }
+        -1
+    }
+
+    fn add_back(&mut self, num: i32) {
+        self.counter[num as usize - 1] = true;
+    }
+}
+
+/**
+ * Your SmallestInfiniteSet object will be instantiated and called as such:
+ * let obj = SmallestInfiniteSet::new();
+ * let ret_1: i32 = obj.pop_smallest();
+ * obj.add_back(num);
+ */

solution/2300-2399/2336.Smallest Number in Infinite Set/Solution.ts

@@ -1,5 +1,6 @@
 class SmallestInfiniteSet {
-    hashMap;
+    private hashMap: boolean[];
+
     constructor() {
         this.hashMap = new Array(1001).fill(true);
     }
@@ -11,6 +12,7 @@ class SmallestInfiniteSet {
                 return i;
             }
         }
+        return -1;
     }
 
     addBack(num: number): void {
@@ -25,4 +27,4 @@ class SmallestInfiniteSet {
  * var obj = new SmallestInfiniteSet()
  * var param_1 = obj.popSmallest()
  * obj.addBack(num)
- */
+ */