feat: add rust solution to lc problems: No.0303,1603

- No,0303.Range Sum Query - Immutable
- No.1603.Design Parking System

Author: YangFong

solution/0300-0399/0303.Range Sum Query - Immutable/README.md

@@ -106,6 +106,74 @@ class NumArray {
  */
 ```
 
+### **Rust**
+
+```rust
+struct NumArray {
+    nums: Vec<i32>
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl NumArray {
+
+    fn new(nums: Vec<i32>) -> Self {
+        Self {
+            nums
+        }
+    }
+
+    fn sum_range(&self, left: i32, right: i32) -> i32 {
+        let (left, right) = (left as usize, right as usize);
+        self.nums[left..=right].iter().sum::<i32>()
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * let obj = NumArray::new(nums);
+ * let ret_1: i32 = obj.sum_range(left, right);
+ */
+```
+
+```rust
+struct NumArray {
+    nums: Vec<i32>
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl NumArray {
+
+    fn new(mut nums: Vec<i32>) -> Self {
+        let n = nums.len();
+        for i in 1..n {
+            nums[i] += nums[i - 1];
+        }
+        Self {
+            nums
+        }
+    }
+
+    fn sum_range(&self, left: i32, right: i32) -> i32 {
+        let (left, right) = (left as usize, right as usize);
+        self.nums[right] - if left == 0 { 0 } else { self.nums[left - 1] }
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * let obj = NumArray::new(nums);
+ * let ret_1: i32 = obj.sum_range(left, right);
+ */
+```
+
 ### **...**
 
 ```

solution/0300-0399/0303.Range Sum Query - Immutable/README_EN.md

@@ -96,6 +96,74 @@ class NumArray {
  */
 ```
 
+### **Rust**
+
+```rust
+struct NumArray {
+    nums: Vec<i32>
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl NumArray {
+
+    fn new(nums: Vec<i32>) -> Self {
+        Self {
+            nums
+        }
+    }
+
+    fn sum_range(&self, left: i32, right: i32) -> i32 {
+        let (left, right) = (left as usize, right as usize);
+        self.nums[left..=right].iter().sum::<i32>()
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * let obj = NumArray::new(nums);
+ * let ret_1: i32 = obj.sum_range(left, right);
+ */
+```
+
+```rust
+struct NumArray {
+    nums: Vec<i32>
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl NumArray {
+
+    fn new(mut nums: Vec<i32>) -> Self {
+        let n = nums.len();
+        for i in 1..n {
+            nums[i] += nums[i - 1];
+        }
+        Self {
+            nums
+        }
+    }
+
+    fn sum_range(&self, left: i32, right: i32) -> i32 {
+        let (left, right) = (left as usize, right as usize);
+        self.nums[right] - if left == 0 { 0 } else { self.nums[left - 1] }
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * let obj = NumArray::new(nums);
+ * let ret_1: i32 = obj.sum_range(left, right);
+ */
+```
+
 ### **...**
 
 ```

solution/0300-0399/0303.Range Sum Query - Immutable/Solution.rs

@@ -0,0 +1,32 @@
+struct NumArray {
+    nums: Vec<i32>
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl NumArray {
+
+    fn new(mut nums: Vec<i32>) -> Self {
+        let n = nums.len();
+        for i in 1..n {
+            nums[i] += nums[i - 1];
+        }
+        Self {
+            nums
+        }
+    }
+
+    fn sum_range(&self, left: i32, right: i32) -> i32 {
+        let (left, right) = (left as usize, right as usize);
+        self.nums[right] - if left == 0 { 0 } else { self.nums[left - 1] }
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * let obj = NumArray::new(nums);
+ * let ret_1: i32 = obj.sum_range(left, right);
+ */

solution/1600-1699/1603.Design Parking System/README.md

@@ -106,6 +106,43 @@ class ParkingSystem {
  */
 ```
 
+### **Rust**
+
+```rust
+struct ParkingSystem {
+    list: [i32; 3],
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl ParkingSystem {
+
+    fn new(big: i32, medium: i32, small: i32) -> Self {
+        Self {
+            list: [big, medium, small]
+        }
+    }
+
+    fn add_car(&mut self, car_type: i32) -> bool {
+        let i = (car_type - 1) as usize;
+        if self.list[i] == 0 {
+            return false;
+        }
+        self.list[i] -= 1;
+        true
+    }
+}
+
+/**
+ * Your ParkingSystem object will be instantiated and called as such:
+ * let obj = ParkingSystem::new(big, medium, small);
+ * let ret_1: bool = obj.add_car(carType);
+ */
+```
+
 ### **...**
 
 ```

solution/1600-1699/1603.Design Parking System/README_EN.md

@@ -94,6 +94,43 @@ class ParkingSystem {
  */
 ```
 
+### **Rust**
+
+```rust
+struct ParkingSystem {
+    list: [i32; 3],
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl ParkingSystem {
+
+    fn new(big: i32, medium: i32, small: i32) -> Self {
+        Self {
+            list: [big, medium, small]
+        }
+    }
+
+    fn add_car(&mut self, car_type: i32) -> bool {
+        let i = (car_type - 1) as usize;
+        if self.list[i] == 0 {
+            return false;
+        }
+        self.list[i] -= 1;
+        true
+    }
+}
+
+/**
+ * Your ParkingSystem object will be instantiated and called as such:
+ * let obj = ParkingSystem::new(big, medium, small);
+ * let ret_1: bool = obj.add_car(carType);
+ */
+```
+
 ### **...**
 
 ```

solution/1600-1699/1603.Design Parking System/Solution.rs

@@ -0,0 +1,32 @@
+struct ParkingSystem {
+    list: [i32; 3],
+}
+
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl ParkingSystem {
+
+    fn new(big: i32, medium: i32, small: i32) -> Self {
+        Self {
+            list: [big, medium, small]
+        }
+    }
+
+    fn add_car(&mut self, car_type: i32) -> bool {
+        let i = (car_type - 1) as usize;
+        if self.list[i] == 0 {
+            return false;
+        }
+        self.list[i] -= 1;
+        true
+    }
+}
+
+/**
+ * Your ParkingSystem object will be instantiated and called as such:
+ * let obj = ParkingSystem::new(big, medium, small);
+ * let ret_1: bool = obj.add_car(carType);
+ */