12/20/2020

Author: safrannn

README.md

@@ -167,3 +167,5 @@ leetcode practise solution in rust
 |1680|[Concatenation of Consecutive Binary Numbers](src/_1680_concatenation_of_consecutive_binary_numbers.rs)|
 |1684|[Count the Number of Consistent Strings](src/_1684_count_the_number_of_consistent_strings.rs)|
 |1685|[Sum of Absolute Differences in a Sorted Array](src/_1685_sum_of_absolute_differences_in_a_sorted_array.rs)|
+|1694|[Reformat Phone Number](src/_1694_reformat_phone_number.rs)|
+|1695|[Maximum Erasure Value](src/_1695_maximum_erasure_value.rs)|

src/_1680_concatenation_of_consecutive_binary_numbers.rs

@@ -11,7 +11,7 @@ impl Solution {
         result as i32
     }
 
-    fn binary_digits(mut decimal: usize) -> usize {
+    fn binary_digits(decimal: usize) -> usize {
         let mut bits = 0;
         while decimal > 0 {
             bits += 1;

src/_1694_reformat_phone_number.rs

@@ -0,0 +1,45 @@
+struct Solution;
+
+impl Solution {
+    pub fn reformat_number(number: String) -> String {
+        let nums: Vec<char> = number.chars().filter(|&c| c >= '0' && c <= '9').collect();
+        let n = nums.len();
+        let tail = n % 3;
+
+        let mut result = "".to_string();
+        for i in 0..n {
+            if (tail == 1 && i == n - 2) || (i % 3 == 0 && i != 0) {
+                result.push('-');
+            }
+            result.push(nums[i]);
+            if tail == 1 && i == n - 2 {
+                result.push(nums[i + 1]);
+                break;
+            }
+        }
+        result
+    }
+}
+#[test]
+fn test() {
+    assert_eq!(
+        Solution::reformat_number("1-23-45 6".to_string()),
+        "123-456".to_string()
+    );
+    assert_eq!(
+        Solution::reformat_number("123 4-567".to_string()),
+        "123-45-67".to_string()
+    );
+    assert_eq!(
+        Solution::reformat_number("123 4-5678".to_string()),
+        "123-456-78".to_string()
+    );
+    assert_eq!(
+        Solution::reformat_number("12".to_string()),
+        "12".to_string()
+    );
+    assert_eq!(
+        Solution::reformat_number("--17-5 229 35-39475 ".to_string()),
+        "175-229-353-94-75".to_string()
+    );
+}

src/_1695_maximum_erasure_value.rs

@@ -0,0 +1,39 @@
+use std::collections::HashSet;
+struct Solution;
+
+impl Solution {
+    pub fn maximum_unique_subarray(nums: Vec<i32>) -> i32 {
+        let mut result = 0;
+        let mut sum = 0;
+        let mut set: HashSet<i32> = HashSet::new();
+        let mut left: usize = 0;
+        let mut right: usize = 0;
+
+        while right < nums.len() {
+            let cur = nums[right];
+            if set.contains(&cur) {
+                while nums[left] != cur {
+                    set.remove(&nums[left]);
+                    sum -= nums[left];
+                    left += 1;
+                }
+                left += 1;
+            } else {
+                set.insert(cur);
+                sum += cur;
+            }
+            result = result.max(sum);
+            right += 1;
+        }
+        result as i32
+    }
+}
+
+#[test]
+fn test() {
+    assert_eq!(Solution::maximum_unique_subarray(vec![4, 2, 4, 5, 6]), 17);
+    assert_eq!(
+        Solution::maximum_unique_subarray(vec![5, 2, 1, 2, 5, 2, 1, 2, 5]),
+        8
+    );
+}

src/lib.rs

@@ -342,4 +342,8 @@ mod _1684_count_the_number_of_consistent_strings;
 //
 mod _1685_sum_of_absolute_differences_in_a_sorted_array;
 //
+mod _1694_reformat_phone_number;
+//
+mod _1695_maximum_erasure_value;
+//
 mod test;