From d432f2498bd299bca17c3732436fa7591e363ef1 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Tue, 23 Aug 2022 17:25:09 +0800 Subject: [PATCH 01/73] Create 46-permutations.rs --- 46-permutations.rs | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 46-permutations.rs diff --git a/46-permutations.rs b/46-permutations.rs new file mode 100644 index 0000000..6d14992 --- /dev/null +++ b/46-permutations.rs @@ -0,0 +1,39 @@ +// backtrace 公式 +// result = [] +// def backtrack(路径, 选择列表): +// if 满足结束条件: +// result.add(路径) +// return + +// for 选择 in 选择列表: +// 做选择 +// backtrack(路径, 选择列表) +// 撤销选择 + +struct Solution; + +impl Solution { + pub fn permute(mut path: Vec) -> Vec> { + let mut ret = vec![]; + Self::backtrack(&mut path, &mut ret, 0); + ret + } + + fn backtrack(path: &mut Vec, ans: &mut Vec>, begin: usize) { + if begin == path.len() { + ans.push(path.to_vec()); + return; + } + + for i in begin..path.len() { + path.swap(i, begin); + Self::backtrack(path, ans, begin + 1); + path.swap(i, begin); + } + } +} + +fn main() { + let nums = vec![1, 2, 3]; + println!("{:?}", Solution::permute(nums)); +} From 5fda9e05531b0d0168d8c0bf9bbc8c1e8c30d483 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 24 Aug 2022 09:59:22 +0800 Subject: [PATCH 02/73] Create 1910-remove-all-occurrences-of-a-substring.rs --- 1910-remove-all-occurrences-of-a-substring.rs | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 1910-remove-all-occurrences-of-a-substring.rs diff --git a/1910-remove-all-occurrences-of-a-substring.rs b/1910-remove-all-occurrences-of-a-substring.rs new file mode 100644 index 0000000..d6b39f7 --- /dev/null +++ b/1910-remove-all-occurrences-of-a-substring.rs @@ -0,0 +1,21 @@ +// Rust str API: split_once + +pub fn remove_occurrences(s: String, part: String) -> String { + let mut ret = s; + loop { + let parts = ret.split_once(&part); + if parts == None { + break + } else { + let uwparts = parts.unwrap(); + ret = vec![uwparts.0, uwparts.1].join(""); + } + } + ret +} + +fn main() { + let s = "aabababa".to_string(); + let part = "aba".to_string(); + println!("{:?}", remove_occurrences(s, part)); +} From e8a2e7446a50d8739f5b65fd1edc33d6f4229610 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Thu, 25 Aug 2022 09:15:58 +0800 Subject: [PATCH 03/73] Create 503-next-greater-element-ii.rs --- 503-next-greater-element-ii.rs | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 503-next-greater-element-ii.rs diff --git a/503-next-greater-element-ii.rs b/503-next-greater-element-ii.rs new file mode 100644 index 0000000..9fa1427 --- /dev/null +++ b/503-next-greater-element-ii.rs @@ -0,0 +1,25 @@ +pub fn next_greater_elements(nums: Vec) -> Vec { + let mut ret = vec![]; + let nums_len = nums.len(); + 'outer: for i in 0..nums_len { + for j in i+1..nums_len { + if nums[j] > nums[i] { + ret.push(nums[j]); + continue 'outer; + } + } + for k in 0..i { + if nums[k] > nums[i] { + ret.push(nums[k]); + continue 'outer; + } + } + ret.push(-1); + } + ret +} + +fn main() { + let nums = vec![1, 2, 1]; + println!("{:?}", next_greater_elements(nums)); +} From eaa903627a654757132ae1c437ee7c1647b97c42 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Fri, 26 Aug 2022 10:30:27 +0800 Subject: [PATCH 04/73] Create 1006-clumsy-factorial.rs --- 1006-clumsy-factorial.rs | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 1006-clumsy-factorial.rs diff --git a/1006-clumsy-factorial.rs b/1006-clumsy-factorial.rs new file mode 100644 index 0000000..714296b --- /dev/null +++ b/1006-clumsy-factorial.rs @@ -0,0 +1,23 @@ +pub fn clumsy(n: i32) -> i32 { + if n == 1 { return 1 } + if n == 2 { return 2 } + let mut ret = n * (n-1) / (n-2) + n-3; + let mut tmp = 0; + for (i, num) in (1..=n-4).rev().enumerate() { + match i % 4 { + 0 => { tmp = num }, + 1 => { tmp *= num }, + 2 => { + ret -= (tmp as f64 / num as f64).floor() as i32; + tmp = 0 + }, + 3 => { ret += num }, + _ => { }, + } + } + ret - tmp +} + +fn main() { + println!("{:?}", clumsy(2)); +} From 82de72526c454829107b406ccc02867fad2e965f Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sat, 27 Aug 2022 15:24:49 +0800 Subject: [PATCH 05/73] Create 1029-two-city-scheduling.rs --- 1029-two-city-scheduling.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 1029-two-city-scheduling.rs diff --git a/1029-two-city-scheduling.rs b/1029-two-city-scheduling.rs new file mode 100644 index 0000000..e03ad61 --- /dev/null +++ b/1029-two-city-scheduling.rs @@ -0,0 +1,11 @@ +pub fn two_city_sched_cost(costs: Vec>) -> i32 { + let n = costs.len(); + let mut sorted_costs = costs.clone(); + sorted_costs.sort_by(|a, b|(a[0]-a[1]).cmp(&(b[0]-b[1]))); + &sorted_costs[0..n/2].iter().map(|e|e[0]).sum::() + &sorted_costs[n/2..].iter().map(|e|e[1]).sum::() +} + +fn main() { + let costs = vec![[10,20],[30,200],[400,50],[30,20]].iter().map(|e|e.to_vec()).collect(); + println!("{:?}", two_city_sched_cost(costs)); +} From 3419ad7df449fdecd300e6d54d08258b44cdb2f9 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 29 Aug 2022 11:43:20 +0800 Subject: [PATCH 06/73] Create 2043-simple-bank-system.rs --- 2043-simple-bank-system.rs | 58 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 2043-simple-bank-system.rs diff --git a/2043-simple-bank-system.rs b/2043-simple-bank-system.rs new file mode 100644 index 0000000..5fa2880 --- /dev/null +++ b/2043-simple-bank-system.rs @@ -0,0 +1,58 @@ +struct Bank { + balance: Vec +} + +/** + * `&self` means the method takes an immutable reference. + * If you need a mutable reference, change it to `&mut self` instead. + */ + +impl Bank { + fn new(balance: Vec) -> Self { + Bank { + balance: balance + } + } + + fn transfer(&mut self, account1: i32, account2: i32, money: i64) -> bool { + if self.balance.get(account1 as usize - 1) == None { + return false; + } + if self.balance[account1 as usize - 1] < money { + return false; + } + if self.balance.get(account2 as usize - 1) == None { + return false; + } + self.balance[account1 as usize - 1] -= money; + self.balance[account2 as usize - 1] += money; + true + } + + fn deposit(&mut self, account: i32, money: i64) -> bool { + if self.balance.get(account as usize - 1) == None { + return false; + } + self.balance[account as usize - 1] += money; + true + } + + fn withdraw(&mut self, account: i32, money: i64) -> bool { + if self.balance.get(account as usize - 1) == None { + return false; + } + if self.balance[account as usize - 1] < money { + return false; + } + self.balance[account as usize - 1] -= money; + true + } +} + +fn main() { + let mut bank = Bank::new(vec![10, 100, 20, 50, 30]); + bank.transfer(1, 2, 10); + bank.deposit(1, 30); + bank.withdraw(1, 10); + println!("{:?}", bank.balance.get(0)); +} From f05e670b93b9b622211600a61608f6be90d13b41 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 29 Aug 2022 11:44:07 +0800 Subject: [PATCH 07/73] Remove blanks --- 705-design-hashset.rs | 6 +++--- 706-design-hashmap.rs | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/705-design-hashset.rs b/705-design-hashset.rs index 26ceacc..cac0b3a 100644 --- a/705-design-hashset.rs +++ b/705-design-hashset.rs @@ -13,15 +13,15 @@ impl MyHashSet { fn new() -> Self { MyHashSet {set: HashSet::new()} } - + fn add(&mut self, key: i32) { self.set.insert(key); } - + fn remove(&mut self, key: i32) { self.set.remove(&key); } - + fn contains(&self, key: i32) -> bool { self.set.contains(&key) } diff --git a/706-design-hashmap.rs b/706-design-hashmap.rs index b98f771..708d29c 100644 --- a/706-design-hashmap.rs +++ b/706-design-hashmap.rs @@ -15,12 +15,12 @@ impl MyHashMap { fn new() -> Self { MyHashMap{map: HashMap::new()} } - + /** value will always be non-negative. */ fn put(&mut self, key: i32, value: i32) { self.map.insert(key, value); } - + /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */ fn get(&self, key: i32) -> i32 { if self.map.get(&key).is_some() { @@ -29,7 +29,7 @@ impl MyHashMap { -1 } } - + /** Removes the mapping of the specified value key if this map contains a mapping for the key */ fn remove(&mut self, key: i32) { self.map.remove(&key); From d74b96ac7d764f10d92dbc627df89dcf48ae7fa6 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Tue, 30 Aug 2022 09:03:16 +0800 Subject: [PATCH 08/73] Create 2144-minimum-cost-of-buying-candies-with-discount.rs --- ...inimum-cost-of-buying-candies-with-discount.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 2144-minimum-cost-of-buying-candies-with-discount.rs diff --git a/2144-minimum-cost-of-buying-candies-with-discount.rs b/2144-minimum-cost-of-buying-candies-with-discount.rs new file mode 100644 index 0000000..d4a66cd --- /dev/null +++ b/2144-minimum-cost-of-buying-candies-with-discount.rs @@ -0,0 +1,15 @@ +pub fn minimum_cost(cost: Vec) -> i32 { + let mut sorted = cost.clone(); + sorted.sort_by(|a, b|b.cmp(&a)); + let mut ret = 0; + for (i, e) in sorted.iter().enumerate() { + if i % 3 == 2 { continue } + ret += e; + } + ret +} + +fn main() { + let cost = vec![6, 5, 7, 9, 2, 2]; + println!("{:?}", minimum_cost(cost)); +} From f151d1481665f3f9698372c4b83fcd2874b81893 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 31 Aug 2022 09:16:09 +0800 Subject: [PATCH 09/73] Create 1829-maximum-xor-for-each-query.rs --- 1829-maximum-xor-for-each-query.rs | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 1829-maximum-xor-for-each-query.rs diff --git a/1829-maximum-xor-for-each-query.rs b/1829-maximum-xor-for-each-query.rs new file mode 100644 index 0000000..e3b1f70 --- /dev/null +++ b/1829-maximum-xor-for-each-query.rs @@ -0,0 +1,18 @@ +pub fn get_maximum_xor(nums: Vec, maximum_bit: i32) -> Vec { + let max = 2_i32.pow(maximum_bit as u32) - 1; + let mut ret = vec![]; + for i in 0..nums.len() { + let mut tmp = max; + for num in &nums[0..nums.len() - i] { + tmp ^= *num; + } + ret.push(tmp); + } + ret +} + +fn main() { + let nums = vec![2,3,4,7]; + let maximum_bit = 3; + println!("{:?}", get_maximum_xor(nums, maximum_bit)); +} From 123c5557402c5db34fc402602d8758ba453e3b4c Mon Sep 17 00:00:00 2001 From: memorycancel Date: Thu, 1 Sep 2022 08:02:46 +0800 Subject: [PATCH 10/73] Create 677-map-sum-pairs.rs --- 677-map-sum-pairs.rs | 46 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 677-map-sum-pairs.rs diff --git a/677-map-sum-pairs.rs b/677-map-sum-pairs.rs new file mode 100644 index 0000000..33c369c --- /dev/null +++ b/677-map-sum-pairs.rs @@ -0,0 +1,46 @@ +use std::collections::HashMap; + +struct MapSum { + mmp: HashMap, +} + + +/** + * `&self` means the method takes an immutable reference. + * If you need a mutable reference, change it to `&mut self` instead. + */ +impl MapSum { + + fn new() -> Self { + MapSum { + mmp: HashMap::new() + } + } + + fn insert(&mut self, key: String, val: i32) { + if let Some(x) = self.mmp.get_mut(&key) { + *x = val; + } else { + self.mmp.insert(key, val); + } + } + + fn sum(&mut self, prefix: String) -> i32 { + let mut ret = 0; + for (k, v) in &self.mmp { + if k.starts_with(&prefix) { + ret += v; + } + } + ret + } +} + +fn main() { + let mut obj = MapSum::new(); + obj.insert("apple".to_string(), 2); + println!("{:?}", obj.sum("ap".to_string())); + obj.insert("app".to_string(), 3); + obj.insert("apple".to_string(), 3); + println!("{:?}", obj.sum("ap".to_string())); +} From 318cce55f34afcdbcfd1f1d7b95566ea5b8547c7 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sat, 3 Sep 2022 01:23:07 +0800 Subject: [PATCH 11/73] Create 676-implement-magic-dictionary.rs --- 676-implement-magic-dictionary.rs | 45 +++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 676-implement-magic-dictionary.rs diff --git a/676-implement-magic-dictionary.rs b/676-implement-magic-dictionary.rs new file mode 100644 index 0000000..76790b6 --- /dev/null +++ b/676-implement-magic-dictionary.rs @@ -0,0 +1,45 @@ +use std::collections::HashMap; + +struct MagicDictionary { + mmp: HashMap>> +} + +impl MagicDictionary { + fn new() -> Self { + MagicDictionary { + mmp: HashMap::new() + } + } + + fn build_dict(&mut self, dictionary: Vec) { + for s in dictionary { + self.mmp.entry(s.len()).or_insert(Vec::new()).push(s.chars().collect::>()); + } + } + + fn search(&self, search_word: String) -> bool { + let search_word_len = search_word.len(); + let search_res = self.mmp.get(&search_word_len); + let search_chars = search_word.chars().collect::>(); + if search_res == None { + false + } else { + 'outer: for chars in search_res.unwrap() { + let mut count = 0; + for i in 0..search_word_len { + if chars[i] != search_chars[i] { count += 1 } + if count > 1 { continue 'outer } + } + if count == 1 { return true } + } + false + } + } +} + +fn main() { + let mut obj = MagicDictionary::new(); + obj.build_dict(vec!["hello".to_string(),"hallo".to_string(), "judge".to_string()]); + let ret_2: bool = obj.search("judga".to_string()); + println!("{:?}", ret_2); +} From 7954260a293412036240bdad5b9ebd15f299673a Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sun, 4 Sep 2022 09:58:03 +0800 Subject: [PATCH 12/73] Create 1381-design-a-stack-with-increment-operation.rs --- ...design-a-stack-with-increment-operation.rs | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 1381-design-a-stack-with-increment-operation.rs diff --git a/1381-design-a-stack-with-increment-operation.rs b/1381-design-a-stack-with-increment-operation.rs new file mode 100644 index 0000000..480f075 --- /dev/null +++ b/1381-design-a-stack-with-increment-operation.rs @@ -0,0 +1,45 @@ +struct CustomStack { + mmp: Vec, + max_size: i32, +} + +impl CustomStack { + + fn new(max_size: i32) -> Self { + CustomStack { + mmp: vec![], + max_size: max_size, + } + } + + fn push(&mut self, x: i32) { + if self.mmp.len() < self.max_size as usize { self.mmp.push(x) } + } + + fn pop(&mut self) -> i32 { + let len = self.mmp.len(); + if len == 0 { return -1 } + self.mmp.remove(len - 1) + } + + fn increment(&mut self, k: i32, val: i32) { + let index = vec![k as usize, self.mmp.len()].into_iter().min().unwrap(); + for i in 0..index { self.mmp[i] += val } + } +} + +fn main() { + let mut cus_stack = CustomStack::new(3); + cus_stack.push(1); + cus_stack.push(2); + cus_stack.pop(); + cus_stack.push(2); + cus_stack.push(3); + cus_stack.push(4); + cus_stack.increment(5, 100); + cus_stack.increment(2, 100); + cus_stack.pop(); + cus_stack.pop(); + cus_stack.pop(); + cus_stack.pop(); +} From fd083f05a451da63781cfb3457d86a4b2febf016 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 5 Sep 2022 09:54:46 +0800 Subject: [PATCH 13/73] Create 347-top-k-frequent-elements.rs --- 347-top-k-frequent-elements.rs | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 347-top-k-frequent-elements.rs diff --git a/347-top-k-frequent-elements.rs b/347-top-k-frequent-elements.rs new file mode 100644 index 0000000..4e083a7 --- /dev/null +++ b/347-top-k-frequent-elements.rs @@ -0,0 +1,18 @@ +pub fn top_k_frequent(nums: Vec, k: i32) -> Vec { + use std::collections::HashMap; + let mut mmp = HashMap::new(); + for num in nums { + let count = mmp.entry(num).or_insert(0); + *count += 1; + } + let mut mv = mmp.iter().collect::>(); + mv.sort_by(|a, b|b.1.cmp(&a.1)); + mv[0..k as usize].into_iter().map(|e|*e.0).collect() +} + +fn main() { + let nums = vec![1, 1, 1, 2, 2, 3]; + let k = 2; + println!("{:?}", top_k_frequent(nums, k)); + println!("{:?}", top_k_frequent(vec![4,1,-1,2,-1,2,3], 2)); +} From beeabd9632ce0da22d720801ce910eda2539bd96 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Tue, 6 Sep 2022 10:29:20 +0800 Subject: [PATCH 14/73] Create 1544-make-the-string-great.rs --- 1544-make-the-string-great.rs | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 1544-make-the-string-great.rs diff --git a/1544-make-the-string-great.rs b/1544-make-the-string-great.rs new file mode 100644 index 0000000..15a9ea0 --- /dev/null +++ b/1544-make-the-string-great.rs @@ -0,0 +1,30 @@ +pub fn make_good(s: String) -> String { + if s.len() == 1 { return s } + let mut s = s.clone(); + 'outer: loop { + if s.len() == 1 { return s } + for i in 0..s.len() - 2 { + if (s.chars().nth(i).unwrap() as i32 - s.chars().nth(i+1).unwrap() as i32).abs() == 32 { + s.remove(i); + s.remove(i); + continue 'outer; + } + } + break; + } + if (s.chars().nth(s.len()-1).unwrap() as i32 - s.chars().nth(s.len()-2).unwrap() as i32).abs() == 32 { + s.remove(s.len()-1); + s.remove(s.len()-1); + } + s +} + +fn main() { + println!("{:?}", make_good("leEeetcode".to_string())); + println!("{:?}", make_good("abBAcC".to_string())); + println!("{:?}", make_good("A".to_string())); + println!("{:?}", make_good("Aa".to_string())); + println!("{:?}", make_good("asLwGWlSAQq".to_string())); + println!("{:?}", make_good("XxDFOBKRrkbofdXxeEijJIcCsBikPgfxXFGpKIbSemGivrqqQQRVIgMEPBWpPwbpSCWqWQqwQwcsQqasLwGWlSAQq".to_string())); + // println!("{:?}", ('b' as i32 -'B' as i32).abs()); // 32 +} From 1ec558fde9f3a95dafd4f064633e73dce68337cf Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 7 Sep 2022 11:21:27 +0800 Subject: [PATCH 15/73] Create 869-reordered-power-of-2.rs --- 869-reordered-power-of-2.rs | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 869-reordered-power-of-2.rs diff --git a/869-reordered-power-of-2.rs b/869-reordered-power-of-2.rs new file mode 100644 index 0000000..fed9051 --- /dev/null +++ b/869-reordered-power-of-2.rs @@ -0,0 +1,31 @@ +// Enumerate numbers with same length + +pub fn reordered_power_of2(n: i32) -> bool { + let mut candidate_numbers = vec![]; + let n_len = n.to_string().len(); + let mut power = 0; + loop { + let tmp = 2_i32.pow(power); + if tmp.to_string().len() == n_len { + candidate_numbers.push(tmp); + } + if tmp.to_string().len() > n_len { + break; + } + power += 1 + } + let mut sorted_nums = n.to_string().chars().collect::>(); + sorted_nums.sort(); + for number in &candidate_numbers { + let mut sorted_tmp = number.to_string().chars().collect::>(); + sorted_tmp.sort(); + if sorted_tmp == sorted_nums { + return true; + } + } + false +} + +fn main() { + println!("{:?}", reordered_power_of2(10)); +} From ce80e3abb38eb170b37f44ef12ee4cef8a14bba5 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Thu, 8 Sep 2022 11:54:33 +0800 Subject: [PATCH 16/73] Create 1529-minimum-suffix-flips.rs --- 1529-minimum-suffix-flips.rs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 1529-minimum-suffix-flips.rs diff --git a/1529-minimum-suffix-flips.rs b/1529-minimum-suffix-flips.rs new file mode 100644 index 0000000..1981df8 --- /dev/null +++ b/1529-minimum-suffix-flips.rs @@ -0,0 +1,17 @@ +// 数学归纳法：每次遇到不同数位，结果+1 +// 如果target从0开始，结果初始为0，从1，结果初始为1 + +pub fn min_flips(target: String) -> i32 { + let mut prev = target.chars().nth(0).unwrap(); + let mut ret = prev as i32 - '0' as i32; + for c in target.chars().collect::>() { + if c != prev { ret += 1 } + prev = c; + } + ret +} + +fn main() { + let target = "10111".to_string(); + println!("{:?}", min_flips(target)); +} From a0599e0b06ba5e9cda141fa37829c7ec394aae63 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sat, 10 Sep 2022 13:55:12 +0800 Subject: [PATCH 17/73] Create 2389-longest-subsequence-with-limited-sum.rs --- 2389-longest-subsequence-with-limited-sum.rs | 21 ++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 2389-longest-subsequence-with-limited-sum.rs diff --git a/2389-longest-subsequence-with-limited-sum.rs b/2389-longest-subsequence-with-limited-sum.rs new file mode 100644 index 0000000..ba84043 --- /dev/null +++ b/2389-longest-subsequence-with-limited-sum.rs @@ -0,0 +1,21 @@ +pub fn answer_queries(nums: Vec, queries: Vec) -> Vec { + fn cal(q: i32, sorted_nums: &[i32]) -> i32 { + let mut sum = 0; + for (i, n) in sorted_nums.iter().enumerate() { + sum += n; + if sum > q { + return i as i32 + } + } + sorted_nums.len() as i32 + } + let mut sorted_nums = nums.clone(); + sorted_nums.sort(); + queries.iter().map(|e|cal(*e, &sorted_nums)).collect() +} + +fn main() { + let nums = vec![4,5,2,1]; + let queries = vec![3,10,21]; + println!("{:?}", answer_queries(nums, queries)); +} From efa4ffd0a0ea85d2a695303ed62300ff2cf2fe6a Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 12 Sep 2022 09:06:35 +0800 Subject: [PATCH 18/73] Create 648-replace-words.rs --- 648-replace-words.rs | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 648-replace-words.rs diff --git a/648-replace-words.rs b/648-replace-words.rs new file mode 100644 index 0000000..396a678 --- /dev/null +++ b/648-replace-words.rs @@ -0,0 +1,21 @@ +pub fn replace_words(dictionary: Vec, sentence: String) -> String { + let mut dictionary = dictionary; + dictionary.sort_by(|a, b|a.len().cmp(&b.len())); + let mut ret_vec = vec![]; + 'outer: for word in sentence.split_ascii_whitespace() { + for prefix in &dictionary { + if word.starts_with(prefix) { + ret_vec.push(prefix.clone()); + continue 'outer; + } + } + ret_vec.push(word.to_string()) + } + ret_vec.join(" ") +} + +fn main() { + let dictionary = vec!["catt".to_string(), "cat".to_string(), "bat".to_string(), "rat".to_string()]; + let sentence = "the cattle was rattled by the battery".to_string(); + println!("{:?}", replace_words(dictionary, sentence)); +} From 3cb817feac5d4bedf903e23ea0769b079ba3791a Mon Sep 17 00:00:00 2001 From: memorycancel Date: Tue, 13 Sep 2022 13:22:01 +0800 Subject: [PATCH 19/73] Create 946-validate-stack-sequences.rs --- 946-validate-stack-sequences.rs | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 946-validate-stack-sequences.rs diff --git a/946-validate-stack-sequences.rs b/946-validate-stack-sequences.rs new file mode 100644 index 0000000..3a87fc5 --- /dev/null +++ b/946-validate-stack-sequences.rs @@ -0,0 +1,24 @@ +pub fn validate_stack_sequences(pushed: Vec, popped: Vec) -> bool { + let mut stack: Vec = vec![]; + let mut pushed = pushed; + let mut popped = popped; + while pushed.len() > 0 { + let tmp = pushed.remove(0); + stack.push(tmp); + if tmp == popped[0] { + // 这里应该持续出栈 + while stack.iter().last().is_some() && *stack.iter().last().unwrap() == popped[0] { + stack.pop(); + popped.remove(0); + } + } + } + if stack.len() == 0 { return true } + stack.reverse(); + stack == popped +} + +fn main() { + println!("{:?}", validate_stack_sequences(vec![1,2,3,4,5], vec![4,5,3,2,1])); + println!("{:?}", validate_stack_sequences(vec![2,1,0], vec![1,2,0])); +} From 82a0b4e26688fdb0e4bafe565be43922d818c7c9 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 14 Sep 2022 21:18:24 +0800 Subject: [PATCH 20/73] Create lcs-WqXACV.rs --- lcs-WqXACV.rs | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 lcs-WqXACV.rs diff --git a/lcs-WqXACV.rs b/lcs-WqXACV.rs new file mode 100644 index 0000000..c34a6a5 --- /dev/null +++ b/lcs-WqXACV.rs @@ -0,0 +1,22 @@ +pub fn half_questions(questions: Vec) -> i32 { + let n = questions.len() / 2; + use std::collections::HashMap; + let mut mmp = HashMap::new(); + for i in questions { *mmp.entry(i).or_insert(0) += 1 } + let mut mmp_vec: Vec<_> = mmp.iter().collect(); + mmp_vec.sort_by(|b, a|a.1.cmp(&b.1)); + let mut ret = 0; + let mut current = 0; + for e in mmp_vec { + ret += 1; + current += e.1; + if current >= n { break } + } + ret +} + +fn main() { + println!("{:?}", half_questions(vec![13,8,3,7,5,6,11,12,3,6,6,11])); + println!("{:?}", half_questions(vec![2,1,6,2])); + println!("{:?}", half_questions(vec![1,5,1,3,4,5,2,5,3,3,8,6])); +} From 3b072d77b7a80580f6233e48e6106c5c5d05c56e Mon Sep 17 00:00:00 2001 From: memorycancel Date: Thu, 15 Sep 2022 08:03:51 +0800 Subject: [PATCH 21/73] Create 539-minimum-time-difference.rs --- 539-minimum-time-difference.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 539-minimum-time-difference.rs diff --git a/539-minimum-time-difference.rs b/539-minimum-time-difference.rs new file mode 100644 index 0000000..7117601 --- /dev/null +++ b/539-minimum-time-difference.rs @@ -0,0 +1,19 @@ +pub fn find_min_difference(time_points: Vec) -> i32 { + let mut mmp = vec![]; + for p in time_points { + let arr = p.split(":").map(|e|e.parse::().unwrap()).collect::>(); + mmp.push(arr[0]*60+arr[1]); + mmp.push((arr[0]+24)*60+arr[1]); + } + mmp.sort(); + let mut ret = 24 * 60; + for i in 1..mmp.len() { + let tmp = mmp[i] - mmp[i-1]; + if tmp < ret { ret = tmp } + } + ret +} + +fn main() { + println!("{:?}", find_min_difference(vec!["00:00".to_string(),"23:59".to_string(),"00:00".to_string()])); +} From 3b726489558f1345425780ed141c5d3c0845dbb1 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Fri, 16 Sep 2022 10:15:26 +0800 Subject: [PATCH 22/73] Create 841-keys-and-rooms.rs --- 841-keys-and-rooms.rs | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 841-keys-and-rooms.rs diff --git a/841-keys-and-rooms.rs b/841-keys-and-rooms.rs new file mode 100644 index 0000000..49c2ee2 --- /dev/null +++ b/841-keys-and-rooms.rs @@ -0,0 +1,23 @@ +pub fn can_visit_all_rooms(rooms: Vec>) -> bool { + use std::collections::HashSet; + let mut mmp: HashSet = HashSet::new(); + pub fn dfs(mmp: &mut HashSet, rooms: &Vec>, key: i32) { + let keys = rooms.get(key as usize); + if keys == None { return } + for key in keys.unwrap() { + let tmp = mmp.get(key); + if tmp.is_some() { continue } + mmp.insert(*key); + dfs(mmp, rooms, *key); + } + } + dfs(&mut mmp, &rooms, 0); + let mut mmp = mmp.into_iter().collect::>(); + mmp.sort(); + (1..rooms.len() as i32).collect::>() == mmp +} + +fn main() { + println!("{:?}", can_visit_all_rooms(vec![vec![1], vec![2], vec![3], vec![]])); + println!("{:?}", can_visit_all_rooms(vec![vec![1,3], vec![3,0,1], vec![2], vec![0]])); +} From 7ec469e500ad02c6e9c09f87cca3dafe33ddc60c Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sat, 17 Sep 2022 12:27:36 +0800 Subject: [PATCH 23/73] Create 2390-removing-stars-from-a-string.rs --- 2390-removing-stars-from-a-string.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 2390-removing-stars-from-a-string.rs diff --git a/2390-removing-stars-from-a-string.rs b/2390-removing-stars-from-a-string.rs new file mode 100644 index 0000000..e0e6891 --- /dev/null +++ b/2390-removing-stars-from-a-string.rs @@ -0,0 +1,11 @@ +pub fn remove_stars(s: String) -> String { + let mut ret = String::new(); + for c in s.chars().collect::>() { + if c == '*' { ret.pop(); } else { ret.push(c); } + } + ret +} + +fn main() { + println!("{:?}", remove_stars("leet**cod*e".to_string())); +} From 271c32f1c65d680c9a2074e701ab483b4f21055d Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sun, 18 Sep 2022 01:58:53 +0800 Subject: [PATCH 24/73] Create 283-move-zeroes.rs --- 283-move-zeroes.rs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 283-move-zeroes.rs diff --git a/283-move-zeroes.rs b/283-move-zeroes.rs new file mode 100644 index 0000000..40b0e30 --- /dev/null +++ b/283-move-zeroes.rs @@ -0,0 +1,17 @@ +// 跟紧接着不为0的数字互换 +pub fn move_zeroes(nums: &mut Vec) { + for i in 0..nums.len() { + for j in i..nums.len() { + if nums[i] == 0 && nums[j] != 0 { nums.swap(i, j) } + } + } +} + +fn main() { + let mut nums = vec![1, 0, 0, 4, 3, 12]; + move_zeroes(&mut nums); + println!("{:?}", nums); + let mut nums = vec![1, 0, 0, 0, 1]; + move_zeroes(&mut nums); + println!("{:?}", nums); +} From 6f238c967d5af6acfa27d3bddd78199de0facfb6 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sun, 18 Sep 2022 02:01:14 +0800 Subject: [PATCH 25/73] One command commit --- .gitignore | 1 + commit.sh | 5 +++++ 2 files changed, 6 insertions(+) create mode 100644 commit.sh diff --git a/.gitignore b/.gitignore index 4460fb5..175b063 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ *.rb * !*.rs +!commit.sh diff --git a/commit.sh b/commit.sh new file mode 100644 index 0000000..37f5809 --- /dev/null +++ b/commit.sh @@ -0,0 +1,5 @@ +FILE=`git status --porcelain | sed s/^...//` +git add $FILE +git commit -m "Create $FILE" +git push +rm $FILE From 1c5278065bbb05eb7b4f23ca096adda4a9f4be4d Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 19 Sep 2022 17:25:27 +0800 Subject: [PATCH 26/73] Create 1701-average-waiting-time.rs --- 1701-average-waiting-time.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 1701-average-waiting-time.rs diff --git a/1701-average-waiting-time.rs b/1701-average-waiting-time.rs new file mode 100644 index 0000000..b65c859 --- /dev/null +++ b/1701-average-waiting-time.rs @@ -0,0 +1,19 @@ +pub fn average_waiting_time(customers: Vec>) -> f64 { + let mut time = 0f64; + let mut sum = 0f64; + for customer in &customers { + if customer[0] as f64 >= time { + sum += customer[1] as f64; + time = (customer[0] + customer[1]) as f64; + } else { + sum += time + (customer[1] - customer[0]) as f64; + time += customer[1] as f64; + } + } + sum as f64 / customers.len() as f64 +} + +fn main() { + println!("{:?}", average_waiting_time(vec![vec![1,2], vec![2,5], vec![4,3]])); + println!("{:?}", average_waiting_time(vec![vec![5,2], vec![5,4], vec![10,3], vec![20,1]])); +} From e38ac869fe4b876c9e9874af29280db15cb7ef5e Mon Sep 17 00:00:00 2001 From: memorycancel Date: Tue, 20 Sep 2022 08:05:50 +0800 Subject: [PATCH 27/73] Update commit shell --- commit.sh | 1 - 1 file changed, 1 deletion(-) diff --git a/commit.sh b/commit.sh index 37f5809..2d8739d 100644 --- a/commit.sh +++ b/commit.sh @@ -2,4 +2,3 @@ FILE=`git status --porcelain | sed s/^...//` git add $FILE git commit -m "Create $FILE" git push -rm $FILE From f3c2f60366de8901a6e3ce7000469f8f1fc768fc Mon Sep 17 00:00:00 2001 From: memorycancel Date: Tue, 20 Sep 2022 08:26:20 +0800 Subject: [PATCH 28/73] Create 119-pascals-triangle-ii.rs --- 119-pascals-triangle-ii.rs | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 119-pascals-triangle-ii.rs diff --git a/119-pascals-triangle-ii.rs b/119-pascals-triangle-ii.rs new file mode 100644 index 0000000..be24dac --- /dev/null +++ b/119-pascals-triangle-ii.rs @@ -0,0 +1,20 @@ +pub fn get_row(row_index: i32) -> Vec { + let mut ret = vec![vec![1], vec![1, 1]]; + for i in 2..=row_index as usize { + let mut tmp = vec![]; + for j in 1..ret[i-1].len() { + tmp.push(ret[i-1][j] + ret[i-1][j-1]) + } + tmp.push(1); + tmp.insert(0, 1); + ret.push(tmp); + } + ret[row_index as usize].clone() +} + +fn main() { + println!("{:?}", get_row(0)); + println!("{:?}", get_row(1)); + println!("{:?}", get_row(2)); + println!("{:?}", get_row(3)); +} From ac75912172028a91e42553bdcf4ea5a8ed97467f Mon Sep 17 00:00:00 2001 From: memorycancel Date: Thu, 22 Sep 2022 10:01:44 +0800 Subject: [PATCH 29/73] Create 1518-water-bottles.rs --- 1518-water-bottles.rs | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 1518-water-bottles.rs diff --git a/1518-water-bottles.rs b/1518-water-bottles.rs new file mode 100644 index 0000000..7424a55 --- /dev/null +++ b/1518-water-bottles.rs @@ -0,0 +1,21 @@ +pub fn num_water_bottles(num_bottles: i32, num_exchange: i32) -> i32 { + let mut current_nil_bottles = 0; + let mut num_bottles = num_bottles; + let mut ret = 0; + loop { + ret += num_bottles; + current_nil_bottles += num_bottles; + num_bottles = 0; + let tmp = current_nil_bottles / num_exchange; + if tmp > 0 { + num_bottles += tmp; + current_nil_bottles -= tmp * num_exchange; + } + if num_bottles == 0 && tmp == 0 { break } + } + ret +} + +fn main() { + println!("{:?}", num_water_bottles(15, 4)); +} From 919e3a39667a93a684337133b642bb440b95c3cb Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 26 Sep 2022 09:39:15 +0800 Subject: [PATCH 30/73] Create 2294-partition-array-such-that-maximum-difference-is-k.rs --- ...array-such-that-maximum-difference-is-k.rs | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 2294-partition-array-such-that-maximum-difference-is-k.rs diff --git a/2294-partition-array-such-that-maximum-difference-is-k.rs b/2294-partition-array-such-that-maximum-difference-is-k.rs new file mode 100644 index 0000000..b34059a --- /dev/null +++ b/2294-partition-array-such-that-maximum-difference-is-k.rs @@ -0,0 +1,21 @@ +pub fn partition_array(nums: Vec, k: i32) -> i32 { + let mut sorted_nums = nums.clone(); + sorted_nums.sort(); + let mut ret = 1; + let mut tmp = vec![sorted_nums[0]]; + for num in &sorted_nums[1..] { + if num - tmp[0] > k { + tmp = vec![*num]; + ret += 1; + } else { + tmp.push(*num); + } + } + ret +} + +fn main() { + println!("{:?}", partition_array(vec![3, 6, 1, 2, 5], 2)); + println!("{:?}", partition_array(vec![1, 2, 3], 1)); + println!("{:?}", partition_array(vec![2, 2, 4, 5], 0)); +} From 669f9b8d503ad372d0674b76a90ff00417ca0e35 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Tue, 27 Sep 2022 12:56:47 +0800 Subject: [PATCH 31/73] Create 2073-time-needed-to-buy-tickets.rs --- 2073-time-needed-to-buy-tickets.rs | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 2073-time-needed-to-buy-tickets.rs diff --git a/2073-time-needed-to-buy-tickets.rs b/2073-time-needed-to-buy-tickets.rs new file mode 100644 index 0000000..5c944b7 --- /dev/null +++ b/2073-time-needed-to-buy-tickets.rs @@ -0,0 +1,21 @@ +pub fn time_required_to_buy(tickets: Vec, k: i32) -> i32 { + let mut tickets = tickets; + let mut ret = 0; + while tickets[k as usize] != 0 { + for i in 0..tickets.len() { + if tickets[i] != 0 { + tickets[i] -= 1; + ret += 1; + } + if tickets[k as usize] == 0 { + return ret + } + } + } + ret +} + +fn main() { + println!("{:?}", time_required_to_buy(vec![2,3,2], 2)); + println!("{:?}", time_required_to_buy(vec![84,49,5,24,70,77,87,8], 3)); +} From 68ac405face483ec1b78020407f911d60ca0419d Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 28 Sep 2022 13:44:50 +0800 Subject: [PATCH 32/73] Create 1103-distribute-candies-to-people.rs --- 1103-distribute-candies-to-people.rs | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 1103-distribute-candies-to-people.rs diff --git a/1103-distribute-candies-to-people.rs b/1103-distribute-candies-to-people.rs new file mode 100644 index 0000000..c42862c --- /dev/null +++ b/1103-distribute-candies-to-people.rs @@ -0,0 +1,22 @@ +pub fn distribute_candies(candies: i32, num_people: i32) -> Vec { + let mut ret = vec![0; num_people as usize]; + let mut candies = candies; + let mut tmp = 1; + while candies > 0 { + for i in 0..ret.len() { + if candies >= tmp { + ret[i] += tmp; + candies -= tmp; + } else { + ret[i] += candies; + candies = 0; + } + tmp += 1; + } + } + ret +} + +fn main() { + println!("{:?}", distribute_candies(7, 4)); +} From 4552a24e532d6a36de0adf28c3af2863386739c8 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Thu, 29 Sep 2022 10:54:21 +0800 Subject: [PATCH 33/73] Create 1652-defuse-the-bomb.rs --- 1652-defuse-the-bomb.rs | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 1652-defuse-the-bomb.rs diff --git a/1652-defuse-the-bomb.rs b/1652-defuse-the-bomb.rs new file mode 100644 index 0000000..43d6c4f --- /dev/null +++ b/1652-defuse-the-bomb.rs @@ -0,0 +1,31 @@ +pub fn decrypt(code: Vec, k: i32) -> Vec { + if k == 0 { return vec![0; code.len()] } + let mut ret = vec![]; + for i in 0..code.len() { + if k > 0 { + let tail = i + k as usize; + if tail <= code.len() - 1 { + ret.push(code[i+1..=tail].into_iter().sum::()); + } else { + let tmp: i32 = &code[i+1..].into_iter().sum::() + + &code[0..tail-code.len()+1].into_iter().sum::(); + ret.push(tmp); + } + } else { + let head = i as i32 + k; // i =1 k = -2 + if head >= 0 { + ret.push(code[head as usize..i].into_iter().sum::()); + } else { + let tmp: i32 = &code[0..i].into_iter().sum::() + + &code[(head + code.len() as i32) as usize..].into_iter().sum::(); + ret.push(tmp); + } + } + } + ret +} + +fn main() { + println!("{:?}", decrypt(vec![5, 7, 1, 4], 3)); + println!("{:?}", decrypt(vec![2, 4, 9, 3], -2)); +} From 32ec5f46fa3570b801e9b015ce4e85331d55c1bf Mon Sep 17 00:00:00 2001 From: memorycancel Date: Fri, 30 Sep 2022 09:47:35 +0800 Subject: [PATCH 34/73] Create 806-number-of-lines-to-write-string.rs --- 806-number-of-lines-to-write-string.rs | 28 ++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 806-number-of-lines-to-write-string.rs diff --git a/806-number-of-lines-to-write-string.rs b/806-number-of-lines-to-write-string.rs new file mode 100644 index 0000000..98a8b32 --- /dev/null +++ b/806-number-of-lines-to-write-string.rs @@ -0,0 +1,28 @@ +pub fn number_of_lines(widths: Vec, s: String) -> Vec { + use std::collections::HashMap; + let mut mmp = HashMap::new(); + let cs = vec!['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']; + for (i, c) in cs.iter().enumerate() { + mmp.insert(c, widths[i]); + } + let mut current = 0; + let mut line = 1; + for c in s.chars().collect::>() { + if current + mmp[&c] > 100 { + line += 1; + current = mmp[&c]; + } else { + current += mmp[&c]; + } + } + vec![line, current] +} + +fn main() { + let widths = vec![10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]; + let s = "abcdefghijklmnopqrstuvwxyz".to_string(); + println!("{:?}", number_of_lines(widths, s)); + let widths = vec![4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]; + let s = "bbbcccdddaaa".to_string(); + println!("{:?}", number_of_lines(widths, s)); +} From f53a09d3dcf002d7d97bf511e8427d8aade25466 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sat, 1 Oct 2022 12:03:57 +0800 Subject: [PATCH 35/73] Create 892-surface-area-of-3d-shapes.rs --- 892-surface-area-of-3d-shapes.rs | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 892-surface-area-of-3d-shapes.rs diff --git a/892-surface-area-of-3d-shapes.rs b/892-surface-area-of-3d-shapes.rs new file mode 100644 index 0000000..cabe294 --- /dev/null +++ b/892-surface-area-of-3d-shapes.rs @@ -0,0 +1,24 @@ +pub fn surface_area(grid: Vec>) -> i32 { + let mut ret = 0; + for j in 0..grid.len() { + for i in 0..grid.len() { + // 去掉0 + if grid[i][j] == 0 { continue } + ret += grid[i][j] * 4 + 2; + // 减去上下左右的紧贴面积 + if i > 0 { ret -= vec![grid[i-1][j], grid[i][j]].iter().min().unwrap() } + if i+1 < grid.len() { ret -= vec![grid[i+1][j], grid[i][j]].iter().min().unwrap() } + if j > 0 { ret -= vec![grid[i][j-1], grid[i][j]].iter().min().unwrap() } + if j+1 < grid.len() { ret -= vec![grid[i][j+1], grid[i][j]].iter().min().unwrap() } + // println!("{:?}", ret); + } + } + ret +} + +fn main() { + // let grid = vec![vec![1,2],vec![3,4]]; + // println!("{:?}", surface_area(grid)); + let grid = vec![vec![1,1,1],vec![1,0,1],vec![1,1,1]]; + println!("{:?}", surface_area(grid)); +} From 0e9aa206b98d2b3b6e3d0e504092da7c2f18c4d8 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sun, 2 Oct 2022 11:33:56 +0800 Subject: [PATCH 36/73] Create 1603-design-parking-system.rs --- 1603-design-parking-system.rs | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 1603-design-parking-system.rs diff --git a/1603-design-parking-system.rs b/1603-design-parking-system.rs new file mode 100644 index 0000000..b039a85 --- /dev/null +++ b/1603-design-parking-system.rs @@ -0,0 +1,31 @@ +struct ParkingSystem { + current: Vec, + max: Vec +} + +impl ParkingSystem { + fn new(big: i32, medium: i32, small: i32) -> Self { + ParkingSystem { + max: vec!(big, medium, small), + current: vec![0; 3] + } + } + + fn add_car(&mut self, car_type: i32) -> bool { + let car_type = car_type as usize - 1; + if self.current.get(car_type).unwrap() + 1 > *self.max.get(car_type).unwrap() { + false + } else { + *self.current.get_mut(car_type).unwrap() += 1; + true + } + } +} + +fn main() { + let mut obj = ParkingSystem::new(1, 1, 0); + println!("{:?}", obj.add_car(1)); + println!("{:?}", obj.add_car(2)); + println!("{:?}", obj.add_car(3)); + println!("{:?}", obj.add_car(1)); +} From 21e818c86336a435b6dd895daf9efc7b5f9d3e31 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 3 Oct 2022 17:39:13 +0800 Subject: [PATCH 37/73] Create 1472-design-browser-history.rs --- 1472-design-browser-history.rs | 56 ++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 1472-design-browser-history.rs diff --git a/1472-design-browser-history.rs b/1472-design-browser-history.rs new file mode 100644 index 0000000..9d2f44d --- /dev/null +++ b/1472-design-browser-history.rs @@ -0,0 +1,56 @@ +struct BrowserHistory { + his: Vec::, + idx: usize, +} + +impl BrowserHistory { + + fn new(homepage: String) -> Self { + BrowserHistory { + his: vec![homepage.clone()], + idx: 0 + } + } + + fn visit(&mut self, url: String) { + self.his.truncate(self.idx + 1); + self.his.push(url.clone()); + self.idx += 1; + } + + fn back(&mut self, steps: i32) -> String { + let steps = steps as usize; + if self.idx < steps { + self.idx = 0; + } else { + self.idx -= steps; + } + // println!("{:?} {:?}", self.his, self.idx); + self.his[self.idx].clone() + } + + fn forward(&mut self, steps: i32) -> String { + let steps = steps as usize; + if self.idx + steps < self.his.len() { + self.idx += steps; + } else { + self.idx = self.his.len() - 1; + } + // println!("{:?} {:?}", self.his, self.idx); + self.his[self.idx].clone() + } +} + +fn main() { + let mut obj = BrowserHistory::new("leetcode.com".to_string()); + obj.visit("google.com".to_string()); + obj.visit("facebook.com".to_string()); + obj.visit("youtube.com".to_string()); + println!("{:?}", obj.back(1)); + println!("{:?}", obj.back(1)); + println!("{:?}", obj.forward(1)); + obj.visit("linkedin.com".to_string()); + println!("{:?}", obj.forward(2)); // linkedin + println!("{:?}", obj.back(2)); + println!("{:?}", obj.back(7)); +} From 1ba1d8bf8ad816b8413a0bbc3c755df4995337d8 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 5 Oct 2022 11:20:23 +0800 Subject: [PATCH 38/73] Create 398-random-pick-index.rs --- 398-random-pick-index.rs | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 398-random-pick-index.rs diff --git a/398-random-pick-index.rs b/398-random-pick-index.rs new file mode 100644 index 0000000..cc41cf9 --- /dev/null +++ b/398-random-pick-index.rs @@ -0,0 +1,37 @@ +use std::collections::HashMap; + +struct Solution { + mmp: HashMap> +} + +impl Solution { + + fn new(nums: Vec) -> Self { + let mut mmp = HashMap::new(); + for (i, num) in nums.iter().enumerate() { + mmp.entry(*num).or_insert(Vec::new()).push(i); + } + Solution { + mmp: mmp + } + } + + fn pick(&mut self, target: i32) -> i32 { + self.mmp.get_mut(&target).unwrap().rotate_right(1); + self.mmp[&target][0] as i32 + } +} + +fn main() { + let mut obj = Solution::new(vec![1, 2, 3, 3, 3]); + println!("{:?}", obj.pick(3)); + println!("{:?}", obj.pick(1)); + println!("{:?}", obj.pick(3)); + println!("{:?}", obj.pick(3)); + println!("{:?}", obj.pick(3)); + println!("{:?}", obj.pick(3)); + println!("{:?}", obj.pick(3)); + println!("{:?}", obj.pick(3)); + println!("{:?}", obj.pick(3)); + println!("{:?}", obj.pick(3)); +} From 1a4ce78185cbf1fdc2c3d70b5f4f32605cb43bbb Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 5 Oct 2022 17:38:24 +0800 Subject: [PATCH 39/73] Create 788-rotated-digits.rs --- 788-rotated-digits.rs | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 788-rotated-digits.rs diff --git a/788-rotated-digits.rs b/788-rotated-digits.rs new file mode 100644 index 0000000..3f8e44f --- /dev/null +++ b/788-rotated-digits.rs @@ -0,0 +1,24 @@ +pub fn rotated_digits(n: i32) -> i32 { + pub fn is_good(e: i32) -> bool { + let digit_chars = e.to_string().chars().collect::>(); + let mut count = 0; + for digit_char in digit_chars { + if digit_char == '3' || digit_char == '4' + || digit_char == '7' { + return false + } + if digit_char == '2' || digit_char == '5' + || digit_char == '6' || digit_char == '9' { + count += 1 + } + } + count > 0 + } + let mut nums = (1..=n).collect::>(); + nums.retain(|e|is_good(*e)); + nums.len() as i32 +} + +fn main() { + println!("{:?}", rotated_digits(10)); +} From 331bc00ea8462861e95b2f35eab621c44ce593f9 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sat, 8 Oct 2022 11:06:26 +0800 Subject: [PATCH 40/73] Create 1184-distance-between-bus-stops.rs --- 1184-distance-between-bus-stops.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 1184-distance-between-bus-stops.rs diff --git a/1184-distance-between-bus-stops.rs b/1184-distance-between-bus-stops.rs new file mode 100644 index 0000000..e7b718d --- /dev/null +++ b/1184-distance-between-bus-stops.rs @@ -0,0 +1,19 @@ +pub fn distance_between_bus_stops(distance: Vec, start: i32, destination: i32) -> i32 { + let left = vec![start, destination].into_iter().min().unwrap(); + let right = vec![start, destination].into_iter().max().unwrap(); + vec![distance[left as usize..right as usize].iter().sum::(), + distance[0..left as usize].iter().sum::() + + distance[right as usize..].iter().sum::() + ].into_iter().min().unwrap() +} + +fn main() { + let distance = vec![1, 2, 3, 4]; + let start = 0; + let destination = 1; + println!("{:?}", distance_between_bus_stops(distance, start, destination)); + let distance = vec![7,10,1,12,11,14,5,0]; + let start = 7; + let destination = 2; + println!("{:?}", distance_between_bus_stops(distance, start, destination)); +} From 2d94f2ef2d6bd48dc58323bdc7c9d5b39b78c6be Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sun, 9 Oct 2022 11:15:51 +0800 Subject: [PATCH 41/73] Create 661-image-smoother.rs --- 661-image-smoother.rs | 65 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 661-image-smoother.rs diff --git a/661-image-smoother.rs b/661-image-smoother.rs new file mode 100644 index 0000000..5666eba --- /dev/null +++ b/661-image-smoother.rs @@ -0,0 +1,65 @@ +pub fn image_smoother(img: Vec>) -> Vec> { + let mut ret = vec![]; + for i in 0..img.len() { + let mut tmp = vec![]; + let mut tmp_sum = 0; + let mut tmp_count = 0; + for j in 0..img[0].len() { + { + { + tmp_sum += img[i][j]; + tmp_count += 1 + } + if j > 0 { + tmp_sum += img[i][j-1]; + tmp_count += 1 + } + if j + 1 < img[0].len() { + tmp_sum += img[i][j+1]; + tmp_count += 1 + } + } + if i > 0 { + { + tmp_sum += img[i-1][j]; + tmp_count += 1 + } + if j > 0 { + tmp_sum += img[i-1][j-1]; + tmp_count += 1 + } + if j + 1 < img[0].len() { + tmp_sum += img[i-1][j+1]; + tmp_count += 1 + } + } + if i + 1 < img.len() { + { + tmp_sum += img[i+1][j]; + tmp_count += 1 + } + if j > 0 { + tmp_sum += img[i+1][j-1]; + tmp_count += 1 + } + if j + 1 < img[0].len() { + tmp_sum += img[i+1][j+1]; + tmp_count += 1 + } + } + tmp.push((tmp_sum as f64 / tmp_count as f64).floor() as i32); + tmp_sum = 0; + tmp_count = 0; + } + ret.push(tmp); + } + ret +} + +fn main() { + let img = vec![vec![1,1,1], vec![1,0,1], vec![1,1,1]]; + println!("{:?}", image_smoother(img)); + + let img = vec![vec![2,3,4], vec![5,6,7], vec![8,9,10], vec![11,12,13], vec![14,15,16]]; + println!("{:?}", image_smoother(img)); +} From 1c1fc93838cd6e8acb849b0d45b46eefea39ab71 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 10 Oct 2022 14:50:36 +0800 Subject: [PATCH 42/73] Create 1260-shift-2d-grid.rs --- 1260-shift-2d-grid.rs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 1260-shift-2d-grid.rs diff --git a/1260-shift-2d-grid.rs b/1260-shift-2d-grid.rs new file mode 100644 index 0000000..dd9261a --- /dev/null +++ b/1260-shift-2d-grid.rs @@ -0,0 +1,16 @@ +pub fn shift_grid(grid: Vec>, k: i32) -> Vec> { + let grid_len = grid[0].len(); + let mut a = grid.into_iter().flatten().collect::>(); + let a_len = a.len(); + a.rotate_right(k as usize % a_len); + a.chunks(grid_len).into_iter().map(|e|e.to_vec()).collect() +} + +fn main() { + let grid = vec![vec![3,8,1,9],vec![19,7,2,5],vec![4,6,11,10],vec![12,0,21,13]]; + let k = 4; + println!("{:?}", shift_grid(grid, k)); + let grid = vec![vec![1]]; + let k = 100; + println!("{:?}", shift_grid(grid, k)); +} From daa6e6c4e43b41781767f27d6680394932397b24 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Tue, 11 Oct 2022 09:50:20 +0800 Subject: [PATCH 43/73] Create 1475-final-prices-with-a-special-discount-in-a-shop.rs --- ...rices-with-a-special-discount-in-a-shop.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 1475-final-prices-with-a-special-discount-in-a-shop.rs diff --git a/1475-final-prices-with-a-special-discount-in-a-shop.rs b/1475-final-prices-with-a-special-discount-in-a-shop.rs new file mode 100644 index 0000000..de56209 --- /dev/null +++ b/1475-final-prices-with-a-special-discount-in-a-shop.rs @@ -0,0 +1,19 @@ +pub fn final_prices(prices: Vec) -> Vec { + let mut ret = vec![]; + 'outer: for (i, n) in prices[0..prices.len()].iter().enumerate() { + for j in (i+1)..prices.len() { + if prices[j] <= *n { + ret.push(n - prices[j]); + continue 'outer; + } + } + ret.push(*n); + } + ret +} + +fn main() { + println!("{:?}", final_prices(vec![8,4,6,2,3])); + println!("{:?}", final_prices(vec![1,2,3,4,5])); + println!("{:?}", final_prices(vec![10,1,1,6])); +} From 08122ae771d079bc6ff7632af895e7d5f50b1e73 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 12 Oct 2022 17:44:40 +0800 Subject: [PATCH 44/73] Create 350-intersection-of-two-arrays-ii.rs --- 350-intersection-of-two-arrays-ii.rs | 38 ++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 350-intersection-of-two-arrays-ii.rs diff --git a/350-intersection-of-two-arrays-ii.rs b/350-intersection-of-two-arrays-ii.rs new file mode 100644 index 0000000..13ff104 --- /dev/null +++ b/350-intersection-of-two-arrays-ii.rs @@ -0,0 +1,38 @@ +pub fn intersect(nums1: Vec, nums2: Vec) -> Vec { + use std::collections::HashMap; + let mut mmp1 = HashMap::new(); + let mut mmp2 = HashMap::new(); + let mut ret = vec![]; + for num in nums1 { + mmp1.entry(num).and_modify(|m|*m += 1).or_insert(1); + } + for num in nums2 { + mmp2.entry(num).and_modify(|m|*m += 1).or_insert(1); + } + // println!("{:?} {:?}", mmp1, mmp2); + if mmp1.len() < mmp2.len() { + for (k1, v1) in mmp1 { + let v2 = mmp2.get(&k1); + if v2.is_some() { + for _ in 0..**[v2.unwrap(), &v1].iter().min().unwrap() { + ret.push(k1); + } + } + } + } else { + for (k2, v2) in mmp2 { + let v1 = mmp1.get(&k2); + if v1.is_some() { + for _ in 0..**[v1.unwrap(), &v2].iter().min().unwrap() { + ret.push(k2); + } + } + } + } + ret +} + +fn main() { + println!("{:?}", intersect(vec![1,2,2,1], vec![2,2])); + println!("{:?}", intersect(vec![4,9,5], vec![9,4,9,8,4])); +} From 46e643ab9f6bcf69365a21e62a3ae1eaaf65642f Mon Sep 17 00:00:00 2001 From: memorycancel Date: Thu, 13 Oct 2022 19:43:31 +0800 Subject: [PATCH 45/73] Create 520-detect-capital.rs --- 520-detect-capital.rs | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 520-detect-capital.rs diff --git a/520-detect-capital.rs b/520-detect-capital.rs new file mode 100644 index 0000000..e21e0ea --- /dev/null +++ b/520-detect-capital.rs @@ -0,0 +1,30 @@ +pub fn detect_capital_use(word: String) -> bool { + let word_len = word.len(); + let mut count = vec![0, 0]; + let chars = word.chars().collect::>(); + let first_char = chars[0]; + for c in chars { + if c.is_uppercase() { + count[0] += 1 + } else { + count[1] += 1 + } + } + if count[0] == 0 { + true + } else { + if count[1] == 0 { + true + } else { + count[1] == word_len - 1 && first_char.is_uppercase() + } + } +} + +fn main() { + println!("{:?}", detect_capital_use("USA".to_string())); + println!("{:?}", detect_capital_use("leetcode".to_string())); + println!("{:?}", detect_capital_use("Google".to_string())); + println!("{:?}", detect_capital_use("FlaG".to_string())); + println!("{:?}", detect_capital_use("ffffffffffffffffffffF".to_string())); +} From e146bd9974e819b04c2cec14beebd45256687c47 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Fri, 14 Oct 2022 09:31:01 +0800 Subject: [PATCH 46/73] Create lcp-61-6CE719.rs --- lcp-61-6CE719.rs | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 lcp-61-6CE719.rs diff --git a/lcp-61-6CE719.rs b/lcp-61-6CE719.rs new file mode 100644 index 0000000..90ca500 --- /dev/null +++ b/lcp-61-6CE719.rs @@ -0,0 +1,47 @@ +pub fn temperature_trend(temperature_a: Vec, temperature_b: Vec) -> i32 { + let (mut trend_a, mut trend_b) = (vec![], vec![]); + for i in 1..temperature_a.len() { + if temperature_a[i] - temperature_a[i-1] > 0 { + trend_a.push(1); + } + if temperature_a[i] - temperature_a[i-1] == 0 { + trend_a.push(0); + } + if temperature_a[i] - temperature_a[i-1] < 0 { + trend_a.push(-1); + } + if temperature_b[i] - temperature_b[i-1] > 0 { + trend_b.push(1); + } + if temperature_b[i] - temperature_b[i-1] == 0 { + trend_b.push(0); + } + if temperature_b[i] - temperature_b[i-1] < 0 { + trend_b.push(-1); + } + } + let mut last_days = 0; + let mut ret = 0; + for i in 0..trend_a.len() { + if trend_a[i] == trend_b[i] { + last_days += 1; + } else { + if last_days > ret { + ret = last_days + } + last_days = 0; + } + } + if last_days > ret { + ret = last_days + } + println!("{:?} {:?} {:?}", trend_a, trend_b, last_days); + ret +} + + +fn main() { + let temperature_a = vec![5,10,16,-6,15,11,3]; + let temperature_b = vec![16,22,23,23,25,3,-16]; + println!("{:?}", temperature_trend(temperature_a, temperature_b)); +} From 7b400790810ab60ee8de7bdb49760afe40d398db Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sat, 15 Oct 2022 21:50:48 +0800 Subject: [PATCH 47/73] Create 1742-maximum-number-of-balls-in-a-box.rs --- 1742-maximum-number-of-balls-in-a-box.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 1742-maximum-number-of-balls-in-a-box.rs diff --git a/1742-maximum-number-of-balls-in-a-box.rs b/1742-maximum-number-of-balls-in-a-box.rs new file mode 100644 index 0000000..82abd77 --- /dev/null +++ b/1742-maximum-number-of-balls-in-a-box.rs @@ -0,0 +1,15 @@ +pub fn count_balls(low_limit: i32, high_limit: i32) -> i32 { + use std::collections::HashMap; + let mut mmp = HashMap::new(); + for i in low_limit ..= high_limit { + let a = i.to_string().chars().map(|e|e.to_string().parse::().unwrap()).sum::(); + mmp.entry(a).and_modify(|e|*e += 1).or_insert(1); + } + mmp.into_values().into_iter().max().unwrap() +} + +fn main() { + println!("{:?}", count_balls(1, 10)); + println!("{:?}", count_balls(5, 15)); + println!("{:?}", count_balls(19, 28)); +} From 3887c374b623af72ff429d25d61c7b9f5ed30bf6 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sun, 16 Oct 2022 13:04:25 +0800 Subject: [PATCH 48/73] Create 789-escape-the-ghosts.rs --- 789-escape-the-ghosts.rs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 789-escape-the-ghosts.rs diff --git a/789-escape-the-ghosts.rs b/789-escape-the-ghosts.rs new file mode 100644 index 0000000..614aa50 --- /dev/null +++ b/789-escape-the-ghosts.rs @@ -0,0 +1,16 @@ +// 这题考阅读理解和题意转化能力，其实问的就是有没鬼能比你更快到达终点(转) +pub fn escape_ghosts(ghosts: Vec>, target: Vec) -> bool { + let dis = target[0].abs() + target[1].abs(); + for g in ghosts { + if (g[0] - target[0]).abs() + (g[1] - target[1]).abs() <= dis { + return false + } + } + true +} + +fn main() { + println!("{:?}", escape_ghosts(vec![vec![1,0], vec![0,3]], vec![0,1])); + println!("{:?}", escape_ghosts(vec![vec![2,0]], vec![1,0])); + println!("{:?}", escape_ghosts(vec![vec![2,0]], vec![1,0])); +} From 8b4ec28448fb8fa17f0c798b019b083fb4f3cc15 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 17 Oct 2022 12:47:42 +0800 Subject: [PATCH 49/73] Create 985-sum-of-even-numbers-after-queries.rs --- 985-sum-of-even-numbers-after-queries.rs | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 985-sum-of-even-numbers-after-queries.rs diff --git a/985-sum-of-even-numbers-after-queries.rs b/985-sum-of-even-numbers-after-queries.rs new file mode 100644 index 0000000..18b7c60 --- /dev/null +++ b/985-sum-of-even-numbers-after-queries.rs @@ -0,0 +1,21 @@ +pub fn sum_even_after_queries(nums: Vec, queries: Vec>) -> Vec { + let mut ret = vec![]; + let mut nums = nums.clone(); + for i in 0 .. nums.len() { + let val = queries[i][0]; + let index = queries[i][1]; + nums[index as usize] += val; + let mut tmp = 0; + for j in 0 .. nums.len() { + if nums[j] % 2 == 0 { tmp += nums[j] } + } + ret.push(tmp) + } + ret +} + +fn main() { + let nums = vec![1,2,3,4]; + let queries = vec![vec![1,0], vec![-3,1], vec![-4,0], vec![2,3]]; + println!("{:?}", sum_even_after_queries(nums, queries)); +} From 31cf14c8fcd233021bc660da4b2411b6c261f498 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Tue, 18 Oct 2022 08:43:09 +0800 Subject: [PATCH 50/73] Create 1170-compare-strings-by-frequency-of-the-smallest-character.rs --- ...-by-frequency-of-the-smallest-character.rs | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 1170-compare-strings-by-frequency-of-the-smallest-character.rs diff --git a/1170-compare-strings-by-frequency-of-the-smallest-character.rs b/1170-compare-strings-by-frequency-of-the-smallest-character.rs new file mode 100644 index 0000000..6ebc47d --- /dev/null +++ b/1170-compare-strings-by-frequency-of-the-smallest-character.rs @@ -0,0 +1,27 @@ +pub fn num_smaller_by_frequency(queries: Vec, words: Vec) -> Vec { + pub fn string_to_value(s: String) -> i32 { + let mut cs = s.chars().collect::>(); + let min = cs.clone().into_iter().min().unwrap(); + cs.retain(|c|*c == min); + cs.len() as i32 + } + let mut ret = vec![]; + for q in queries { + let q_value = string_to_value(q); + let mut tmp = 0; + for w in &words { + if string_to_value(w.clone()) > q_value { tmp += 1 } + } + ret.push(tmp) + } + ret +} + +fn main() { + let queries = vec!["cbd".to_string()]; + let words = vec!["zaaaz".to_string()]; + println!("{:?}", num_smaller_by_frequency(queries, words)); + let queries = vec!["bbb".to_string(),"cc".to_string()]; + let words = vec!["a".to_string(),"aa".to_string(),"aaa".to_string(),"aaaa".to_string()]; + println!("{:?}", num_smaller_by_frequency(queries, words)); +} From 24a1ad320b448df707c08580e9f30849db668eee Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 19 Oct 2022 12:32:42 +0800 Subject: [PATCH 51/73] Create 1980-find-unique-binary-string.rs --- 1980-find-unique-binary-string.rs | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 1980-find-unique-binary-string.rs diff --git a/1980-find-unique-binary-string.rs b/1980-find-unique-binary-string.rs new file mode 100644 index 0000000..a01b144 --- /dev/null +++ b/1980-find-unique-binary-string.rs @@ -0,0 +1,29 @@ +pub fn find_different_binary_string(nums: Vec) -> String { + let n = nums[0].len(); + let mut arr = (0..=2_i32.pow(n as u32)).map(|e|e as i32).collect::>(); + for num in nums { + let intval = isize::from_str_radix(&num, 2).unwrap(); + arr[intval as usize] = -1; + } + let mut ret = -1; + for i in arr { + if i != -1 { + ret = i; + break + } + } + let ret = format!("{:b}", ret); + let mut prefix = String::new(); + if ret.len() < n { + for _ in 0 .. (n - ret.len()) { + prefix.push('0') + } + } + [prefix, ret].concat() +} + +fn main() { + println!("{:?}", find_different_binary_string(vec!["01".to_string(),"10".to_string()])); + println!("{:?}", find_different_binary_string(vec!["00".to_string(),"01".to_string()])); + println!("{:?}", find_different_binary_string(vec!["111".to_string(),"011".to_string(),"001".to_string()])); +} From e9e9c12056b7ad5a7d2397532dcd443ff5d221b1 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Thu, 20 Oct 2022 10:11:04 +0800 Subject: [PATCH 52/73] Create 647-palindromic-substrings.rs --- 647-palindromic-substrings.rs | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 647-palindromic-substrings.rs diff --git a/647-palindromic-substrings.rs b/647-palindromic-substrings.rs new file mode 100644 index 0000000..e0a8abf --- /dev/null +++ b/647-palindromic-substrings.rs @@ -0,0 +1,22 @@ +pub fn count_substrings(s: String) -> i32 { + pub fn is_palindromic(cs: &[char]) -> bool { + // println!("{:?}", cs.clone().to_vec()); + let tmp = cs.clone().to_vec(); + let mut tmp_rev = cs.clone().to_vec(); + tmp_rev.reverse(); + tmp == tmp_rev + } + let cs = s.chars().collect::>(); + let mut ret = 0; + for i in 1 ..= s.len() { + for j in 0 ..= (s.len() - i) { + if is_palindromic(&cs[j..j+i]) { ret += 1 } + } + } + ret +} + +fn main() { + println!("{:?}", count_substrings("abc".to_string())); + println!("{:?}", count_substrings("aaa".to_string())); +} From 5ae96361cc0af9b31920a07d5843f58e8f12b5f7 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Fri, 21 Oct 2022 09:36:54 +0800 Subject: [PATCH 53/73] Create 122-best-time-to-buy-and-sell-stock-ii.rs 1405-longest-happy-string.rs --- 122-best-time-to-buy-and-sell-stock-ii.rs | 14 ++++++++++++++ 1405-longest-happy-string.rs | 12 ++++++++++++ 2 files changed, 26 insertions(+) create mode 100644 122-best-time-to-buy-and-sell-stock-ii.rs create mode 100644 1405-longest-happy-string.rs diff --git a/122-best-time-to-buy-and-sell-stock-ii.rs b/122-best-time-to-buy-and-sell-stock-ii.rs new file mode 100644 index 0000000..9f80953 --- /dev/null +++ b/122-best-time-to-buy-and-sell-stock-ii.rs @@ -0,0 +1,14 @@ +// 算法可以直接简化为只要今天比昨天大，就卖出，同时也可以买进（但不知道明天是否会涨呢？）。 +// 上帝视角： 扫描一遍 只要后一天比前一天大 就把这两天的差值加一下 + +pub fn max_profit(prices: Vec) -> i32 { + let mut ret = 0; + for i in 0 .. prices.len() - 1 { + if prices[i+1] > prices[i] { ret += prices[i+1] - prices[i] } + } + ret +} + +fn main() { + println!("{:?}", max_profit(vec![7,1,5,3,6,4])); +} diff --git a/1405-longest-happy-string.rs b/1405-longest-happy-string.rs new file mode 100644 index 0000000..1f7eb4d --- /dev/null +++ b/1405-longest-happy-string.rs @@ -0,0 +1,12 @@ +// 贪心：每次都选择剩下数量最多的字母添加 ，因为 数量少的字母需要用做中间隔着，这样才会最长。全局最优由局部最优构成 + +pub fn longest_diverse_string(a: i32, b: i32, c: i32) -> String { + let mut ret = String::new(); + let (mut a, mut b, mut c) = (a, b, c); + let mut pre: _; + ret +} + +fn main() { + println!("{:?}", longest_diverse_string(1, 1, 7)); +} From f0baa1f5516ac969bd75e4afc01936bc1753a4f3 Mon Sep 17 00:00:00 2001 From: Tommy Date: Fri, 21 Oct 2022 23:14:56 +0800 Subject: [PATCH 54/73] Delete 1405-longest-happy-string.rs --- 1405-longest-happy-string.rs | 12 ------------ 1 file changed, 12 deletions(-) delete mode 100644 1405-longest-happy-string.rs diff --git a/1405-longest-happy-string.rs b/1405-longest-happy-string.rs deleted file mode 100644 index 1f7eb4d..0000000 --- a/1405-longest-happy-string.rs +++ /dev/null @@ -1,12 +0,0 @@ -// 贪心：每次都选择剩下数量最多的字母添加 ，因为 数量少的字母需要用做中间隔着，这样才会最长。全局最优由局部最优构成 - -pub fn longest_diverse_string(a: i32, b: i32, c: i32) -> String { - let mut ret = String::new(); - let (mut a, mut b, mut c) = (a, b, c); - let mut pre: _; - ret -} - -fn main() { - println!("{:?}", longest_diverse_string(1, 1, 7)); -} From 45563206730b3b224838019f6ac0f8a87f0129c0 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sat, 22 Oct 2022 10:17:41 +0800 Subject: [PATCH 55/73] Create 2109-adding-spaces-to-a-string.rs --- 2109-adding-spaces-to-a-string.rs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 2109-adding-spaces-to-a-string.rs diff --git a/2109-adding-spaces-to-a-string.rs b/2109-adding-spaces-to-a-string.rs new file mode 100644 index 0000000..ae60676 --- /dev/null +++ b/2109-adding-spaces-to-a-string.rs @@ -0,0 +1,16 @@ +pub fn add_spaces(s: String, spaces: Vec) -> String { + let mut s = s; + let mut z = 0; + for space in spaces { + let idx = space + z; + s.insert(idx as usize, ' '); + z += 1; + } + s +} + +fn main() { + let s = "LeetcodeHelpsMeLearn".to_string(); + let spaces = vec![8,13,15]; + println!("{:?}", add_spaces(s, spaces)); +} From 1bc59b7680bfa2695221d6945e0590e6ec3d2fa5 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 31 Oct 2022 02:10:17 +0800 Subject: [PATCH 56/73] Create 1887-reduction-operations-to-make-the-array-elements-equal.rs --- ...ations-to-make-the-array-elements-equal.rs | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 1887-reduction-operations-to-make-the-array-elements-equal.rs diff --git a/1887-reduction-operations-to-make-the-array-elements-equal.rs b/1887-reduction-operations-to-make-the-array-elements-equal.rs new file mode 100644 index 0000000..72ff12f --- /dev/null +++ b/1887-reduction-operations-to-make-the-array-elements-equal.rs @@ -0,0 +1,21 @@ +pub fn reduction_operations(nums: Vec) -> i32 { + use std::collections::HashMap; + let mut mmp = HashMap::new(); + for num in nums { + mmp.entry(num).and_modify(|e|*e += 1).or_insert(1); + } + let mut mmp_vec: Vec<_> = mmp.iter().collect(); + mmp_vec.sort_by(|a, b|a.0.cmp(&b.0)); + // println!("{:?}", mmp_vec); + let mut ret = 0; + for (i, r) in mmp_vec.iter().enumerate() { + ret += i * r.1 + } + ret as i32 +} + +fn main() { + println!("{:?}", reduction_operations(vec![5,1,3])); + println!("{:?}", reduction_operations(vec![1,1,1])); + println!("{:?}", reduction_operations(vec![1,1,2,2,3])); +} From c98e2f725dd7511083497a9d753911849fd50b15 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Tue, 1 Nov 2022 10:53:52 +0800 Subject: [PATCH 57/73] Create 2452-words-within-two-edits-of-dictionary.rs --- 2452-words-within-two-edits-of-dictionary.rs | 28 ++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 2452-words-within-two-edits-of-dictionary.rs diff --git a/2452-words-within-two-edits-of-dictionary.rs b/2452-words-within-two-edits-of-dictionary.rs new file mode 100644 index 0000000..5c62264 --- /dev/null +++ b/2452-words-within-two-edits-of-dictionary.rs @@ -0,0 +1,28 @@ +pub fn two_edit_words(queries: Vec, dictionary: Vec) -> Vec { + let dic_chars = dictionary.iter().map(|s|s.chars().collect::>()) + .collect::>>(); + let mut queries = queries; + queries.retain(|s|{ + 'outer: for d_ch in &dic_chars { + let mut count = 0; + for (i, c) in s.chars().collect::>().iter().enumerate() { + if d_ch[i] != *c { count += 1 } + if count > 2 { continue 'outer } + } + return true + } + return false + }); + queries +} + +fn main() { + let queries = vec!["word".to_string(), "note".to_string(), + "ants".to_string(), "wood".to_string()]; + let dictionary = vec!["wood".to_string(), + "joke".to_string(), "moat".to_string()]; + println!("{:?}", two_edit_words(queries, dictionary)); + let queries = vec!["yes".to_string()]; + let dictionary = vec!["not".to_string()]; + println!("{:?}", two_edit_words(queries, dictionary)); +} From 4ab9513232b62632c56c5a3ed018eebeb2607897 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 2 Nov 2022 12:26:10 +0800 Subject: [PATCH 58/73] Create 2455-average-value-of-even-numbers-that-are-divisible-by-three.rs --- ...alue-of-even-numbers-that-are-divisible-by-three.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 2455-average-value-of-even-numbers-that-are-divisible-by-three.rs diff --git a/2455-average-value-of-even-numbers-that-are-divisible-by-three.rs b/2455-average-value-of-even-numbers-that-are-divisible-by-three.rs new file mode 100644 index 0000000..8c44767 --- /dev/null +++ b/2455-average-value-of-even-numbers-that-are-divisible-by-three.rs @@ -0,0 +1,10 @@ +pub fn average_value(nums: Vec) -> i32 { + let mut nums = nums; + nums.retain(|num| { num % 6 == 0 }); + (nums.iter().sum::() as f64 / nums.len() as f64).floor() as i32 +} + +fn main() { + println!("{:?}", average_value(vec![1,3,6,10,12,15])); + println!("{:?}", average_value(vec![1,2,4,7,10])); +} From cdd4d346546c51a03666a0e64f901c32f3a04c1f Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 2 Nov 2022 12:27:30 +0800 Subject: [PATCH 59/73] Upsert commit.sh --- commit.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/commit.sh b/commit.sh index 2d8739d..e77c3d9 100644 --- a/commit.sh +++ b/commit.sh @@ -1,4 +1,4 @@ FILE=`git status --porcelain | sed s/^...//` git add $FILE -git commit -m "Create $FILE" -git push +git commit -m "Upsert $FILE" +https_proxy=localhost:1088 git push From 92956594ac332574641bcb3199391ecd2e998665 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Thu, 3 Nov 2022 23:56:24 +0800 Subject: [PATCH 60/73] Upsert 1523-count-odd-numbers-in-an-interval-range.rs --- 1523-count-odd-numbers-in-an-interval-range.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 1523-count-odd-numbers-in-an-interval-range.rs diff --git a/1523-count-odd-numbers-in-an-interval-range.rs b/1523-count-odd-numbers-in-an-interval-range.rs new file mode 100644 index 0000000..a66d398 --- /dev/null +++ b/1523-count-odd-numbers-in-an-interval-range.rs @@ -0,0 +1,15 @@ +impl Solution { + pub fn count_odds(low: i32, high: i32) -> i32 { + let mut ret = 0; + + if low % 2 == 1 { ret += 1 } + if high % 2 == 1 { ret += 1 } + + if ret == 2 { + ret += (high - low)/2 - 1 + } else { + ret += (high - low)/2 + } + ret + } +} From 14c97cca6b3885e1e2a87e1cfd4d206bd92f3ef7 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sat, 5 Nov 2022 00:07:10 +0800 Subject: [PATCH 61/73] Upsert 1338-reduce-array-size-to-the-half.rs --- 1338-reduce-array-size-to-the-half.rs | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 1338-reduce-array-size-to-the-half.rs diff --git a/1338-reduce-array-size-to-the-half.rs b/1338-reduce-array-size-to-the-half.rs new file mode 100644 index 0000000..21c5e6e --- /dev/null +++ b/1338-reduce-array-size-to-the-half.rs @@ -0,0 +1,24 @@ +pub fn min_set_size(arr: Vec) -> i32 { + let arr_len = arr.len(); + use std::collections::HashMap; + let mut mmp = HashMap::new(); + for e in arr { + mmp.entry(e).and_modify(|e|*e+=1).or_insert(1); + } + let mut mmp_vec: Vec<_> = mmp.iter().collect(); + mmp_vec.sort_by(|b, a|a.1.cmp(&b.1)); + let mut tmp = 0; + let mut ret = 0; + for p in mmp_vec { + tmp += p.1; + ret += 1; + if tmp >= arr_len / 2 { break } + } + ret +} + +fn main() { + println!("{:?}", min_set_size(vec![3, 3, 3, 3, 5, 5, 5, 2, 2, 7])); + println!("{:?}", min_set_size(vec![7, 7, 7, 7, 7, 7])); + println!("{:?}", min_set_size(vec![1, 9])); +} From 3283e59af6bb24882c1f208ad21f73fe0fe19734 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Fri, 9 Dec 2022 12:00:15 +0800 Subject: [PATCH 62/73] Upsert 2341-maximum-number-of-pairs-in-array.rs --- 2341-maximum-number-of-pairs-in-array.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 2341-maximum-number-of-pairs-in-array.rs diff --git a/2341-maximum-number-of-pairs-in-array.rs b/2341-maximum-number-of-pairs-in-array.rs new file mode 100644 index 0000000..cf1ed0b --- /dev/null +++ b/2341-maximum-number-of-pairs-in-array.rs @@ -0,0 +1,19 @@ +pub fn number_of_pairs(nums: Vec) -> Vec { + use std::collections::HashMap; + let mut mmp = HashMap::new(); + let nums_len = nums.len(); + for n in nums { + mmp.entry(n).and_modify(|e|*e += 1).or_insert(1); + } + let mut a = 0; + for (_, v) in mmp { + a += v % 2; + } + vec!((nums_len as i32 - a) / 2, a) +} + +fn main() { + println!("{:?}", number_of_pairs(vec![1,3,2,1,3,2,2])); + println!("{:?}", number_of_pairs(vec![1,1])); + println!("{:?}", number_of_pairs(vec![0])); +} From 77ca029519223d41e2d987667ebc40cd77e80c27 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sat, 10 Dec 2022 15:31:27 +0800 Subject: [PATCH 63/73] Upsert 1784-check-if-binary-string-has-at-most-one-segment-of-ones.rs --- ...y-string-has-at-most-one-segment-of-ones.rs | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 1784-check-if-binary-string-has-at-most-one-segment-of-ones.rs diff --git a/1784-check-if-binary-string-has-at-most-one-segment-of-ones.rs b/1784-check-if-binary-string-has-at-most-one-segment-of-ones.rs new file mode 100644 index 0000000..67ed821 --- /dev/null +++ b/1784-check-if-binary-string-has-at-most-one-segment-of-ones.rs @@ -0,0 +1,18 @@ +pub fn check_ones_segment(s: String) -> bool { + if s == "1".to_string() { return true } + let cs = s.chars().collect::>(); + let mut prev_char = '1'; + let mut change_times = 0; + for c in &cs[1..] { + if *c != prev_char { change_times += 1 } + prev_char = *c; + } + change_times <= 1 +} + +fn main() { + println!("{:?}", check_ones_segment("1001".to_string())); // false + println!("{:?}", check_ones_segment("110".to_string())); // true + println!("{:?}", check_ones_segment("1".to_string())); // true + println!("{:?}", check_ones_segment("10".to_string())); // true +} From e4fc31a5003e07d32437b465fdc14fc12ebdd465 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 12 Dec 2022 21:20:51 +0800 Subject: [PATCH 64/73] Upsert 434-number-of-segments-in-a-string.rs --- 434-number-of-segments-in-a-string.rs | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 434-number-of-segments-in-a-string.rs diff --git a/434-number-of-segments-in-a-string.rs b/434-number-of-segments-in-a-string.rs new file mode 100644 index 0000000..48a873a --- /dev/null +++ b/434-number-of-segments-in-a-string.rs @@ -0,0 +1,7 @@ +pub fn count_segments(s: String) -> i32 { + s.split_ascii_whitespace().count() as i32 +} + +fn main() { + println!("{:?}", count_segments("s Hello, my name is John".to_string())); +} From 0137431d2c762be528ca42ea835edb9e385c5452 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Fri, 30 Dec 2022 17:08:29 +0800 Subject: [PATCH 65/73] Upsert 2460-apply-operations-to-an-array.rs --- 2460-apply-operations-to-an-array.rs | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 2460-apply-operations-to-an-array.rs diff --git a/2460-apply-operations-to-an-array.rs b/2460-apply-operations-to-an-array.rs new file mode 100644 index 0000000..609901b --- /dev/null +++ b/2460-apply-operations-to-an-array.rs @@ -0,0 +1,24 @@ +pub fn apply_operations(nums: Vec) -> Vec { + let mut none_zero = vec![]; + let mut zero = vec![]; + let mut nums_clone = nums.clone(); + for i in 0 .. nums.len() { + if nums_clone[i] == 0 { + zero.push(0); + continue + } + if i + 1 < nums.len() && nums[i] == nums[i + 1] { + nums_clone[i] *= 2; + nums_clone[i + 1] = 0 + } + none_zero.push(nums_clone[i]); + } + [none_zero, zero].concat() +} + +fn main() { + println!("{:?}", apply_operations(vec![1, 2, 2, 1, 1, 0])); + println!("{:?}", apply_operations(vec![847,847,0,0,0,399,416,416,879,879,206,206,206,272])); + println!("{:?}", apply_operations(vec![0, 1])); + +} From 48e2d91e99e2c72e7f9bce7dec38c5923ac59301 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 13 Feb 2023 19:17:21 +0800 Subject: [PATCH 66/73] Add 888-fair-candy-swap.rs --- 888-fair-candy-swap.rs | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 888-fair-candy-swap.rs diff --git a/888-fair-candy-swap.rs b/888-fair-candy-swap.rs new file mode 100644 index 0000000..2ac7eca --- /dev/null +++ b/888-fair-candy-swap.rs @@ -0,0 +1,21 @@ +pub fn fair_candy_swap(alice_sizes: Vec, bob_sizes: Vec) -> Vec { + let diff: i32 = alice_sizes.iter().sum::() - bob_sizes.iter().sum::(); + let abs_diff = diff / 2; + let mut ret = vec![]; + 'o: for i in &alice_sizes { + for j in &bob_sizes { + if abs_diff == *i - *j { + ret = vec![*i, *j]; + break 'o + } + } + } + ret +} + +fn main() { + println!("{:?}", fair_candy_swap(vec![1, 1], vec![2, 2])); + println!("{:?}", fair_candy_swap(vec![1, 2], vec![2, 3])); + println!("{:?}", fair_candy_swap(vec![2], vec![1, 3])); + println!("{:?}", fair_candy_swap(vec![1, 2, 5], vec![2, 4])); +} From a864dbe508f138ad6b9753d8d0ea414f6911ca7c Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 13 Feb 2023 19:17:34 +0800 Subject: [PATCH 67/73] Add 384-shuffle-an-array.rs --- 384-shuffle-an-array.rs | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 384-shuffle-an-array.rs diff --git a/384-shuffle-an-array.rs b/384-shuffle-an-array.rs new file mode 100644 index 0000000..11f155d --- /dev/null +++ b/384-shuffle-an-array.rs @@ -0,0 +1,33 @@ +use std::time::{SystemTime, UNIX_EPOCH}; +struct Solution { + nums: Vec +} +impl Solution { + fn new(nums: Vec) -> Self { + Self { nums } + } + fn reset(&self) -> Vec { + self.nums.clone() + } + fn shuffle(&self) -> Vec { + let mut nums = self.nums.clone(); + let mut n = nums.len() as u128; + while n > 1 { + let m = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos() % n; + nums.swap(m as usize, n as usize - 1); + n -= 1; + } + nums + } +} + +fn main() { + let nums = vec![1, 2, 3]; + let obj = Solution::new(nums); + let ret_1: Vec = obj.reset(); + println!("{:?}", ret_1); + let ret_2: Vec = obj.shuffle(); + println!("{:?}", ret_2); + let ret_3: Vec = obj.reset(); + println!("{:?}", ret_3); +} From 16bcc60ef848d50cab5ff27d97cb2af12149c6f6 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Mon, 13 Feb 2023 19:17:47 +0800 Subject: [PATCH 68/73] Add 352-data-stream-as-disjoint-intervals.rs --- 352-data-stream-as-disjoint-intervals.rs | 32 ++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 352-data-stream-as-disjoint-intervals.rs diff --git a/352-data-stream-as-disjoint-intervals.rs b/352-data-stream-as-disjoint-intervals.rs new file mode 100644 index 0000000..48d6d9a --- /dev/null +++ b/352-data-stream-as-disjoint-intervals.rs @@ -0,0 +1,32 @@ +use std::cmp; +struct SummaryRanges { + set: std::collections::BTreeSet<(i32, i32)>, +} + +impl SummaryRanges { + + fn new() -> Self { + SummaryRanges { + set: std::collections::BTreeSet::new(), + } + } + + fn add_num(&mut self, val: i32) { + let mut new = (val, val); + let l = *self.set.range(..(val, val)).last().unwrap_or(&new); + let r= *self.set.range((val, val)..).next().unwrap_or(&new); + if l.1 >= val - 1 { + new = (l.0, cmp::max(val, l.1)); + self.set.remove(&l); + } + if r.0 <= val + 1 && new.1 < r.1 { + new.1 = r.1; + self.set.remove(&r); + } + self.set.insert(new); + } + + fn get_intervals(&self) -> Vec> { + self.set.iter().map(|(l, r)| vec![*l, *r]).collect() + } +} From 0faa96b806ca60e45d121a8f95ed18e3c93fbafa Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 8 Mar 2023 16:19:15 +0800 Subject: [PATCH 69/73] Upsert 23350-minimum-amount-of-time-to-fill-cups.rs --- 23350-minimum-amount-of-time-to-fill-cups.rs | 24 ++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 23350-minimum-amount-of-time-to-fill-cups.rs diff --git a/23350-minimum-amount-of-time-to-fill-cups.rs b/23350-minimum-amount-of-time-to-fill-cups.rs new file mode 100644 index 0000000..6e174a6 --- /dev/null +++ b/23350-minimum-amount-of-time-to-fill-cups.rs @@ -0,0 +1,24 @@ +pub fn fill_cups(amount: Vec) -> i32 { + let mut sort_am = amount.clone(); + sort_am.sort(); + if sort_am[2] >= sort_am[0] + sort_am[1] { + // return amount[0] + amount[1] + amount[2] - (amount[0] + amount[1]) + sort_am[2] + } else { + let mut ret = sort_am[2]; + let left = sort_am[0] + sort_am[1] - sort_am[2]; + if left % 2 == 0 { + ret += left / 2 + } else { + ret += left / 2 + 1 + } + ret + } +} + +fn main() { + println!("{:?}", fill_cups(vec![1,4,2])); + println!("{:?}", fill_cups(vec![5,4,4])); + println!("{:?}", fill_cups(vec![3,4,5])); + println!("{:?}", fill_cups(vec![5,0,0])); +} From 0eaeacc7933b692438cbea4d17fc3901116ebee8 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Thu, 9 Mar 2023 10:01:45 +0800 Subject: [PATCH 70/73] Upsert 1807-evaluate-the-bracket-pairs-of-a-string.rs --- ...-evaluate-the-bracket-pairs-of-a-string.rs | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 1807-evaluate-the-bracket-pairs-of-a-string.rs diff --git a/1807-evaluate-the-bracket-pairs-of-a-string.rs b/1807-evaluate-the-bracket-pairs-of-a-string.rs new file mode 100644 index 0000000..f570709 --- /dev/null +++ b/1807-evaluate-the-bracket-pairs-of-a-string.rs @@ -0,0 +1,47 @@ +pub fn evaluate(s: String, knowledge: Vec>) -> String { + use std::collections::HashMap; + let mut mmp = HashMap::new(); + for pair in knowledge { + mmp.insert(pair[0].clone(), pair[1].clone()); + } + // println!("{:?}", mmp); + let mut ret = String::new(); + let mut current_word = String::new(); + let mut start = false; + for c in s.chars() { + if c == '(' { + start = true; + continue + } + if c == ')' { + start = false; + let get = mmp.get(¤t_word); + if get == None { + ret.push('?') + } else { + ret.push_str(get.unwrap()) + } + current_word = String::new(); + continue + } + if start { + current_word.push(c) + } else { + ret.push(c) + } + } + ret +} + +fn main() { + println!( + "{:?}", + evaluate( + "(name)is(age)yearsold(asd)".to_string(), + vec![ + vec!["name".to_string(), "bob".to_string()], + vec!["age".to_string(), "two".to_string()] + ] + ) + ); +} From 5a5ba4b629da1547dff7831ec0c12d5dfd881bbe Mon Sep 17 00:00:00 2001 From: memorycancel Date: Fri, 10 Mar 2023 10:41:58 +0800 Subject: [PATCH 71/73] Upsert 2566-maximum-difference-by-remapping-a-digit.rs --- ...maximum-difference-by-remapping-a-digit.rs | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 2566-maximum-difference-by-remapping-a-digit.rs diff --git a/2566-maximum-difference-by-remapping-a-digit.rs b/2566-maximum-difference-by-remapping-a-digit.rs new file mode 100644 index 0000000..cec8baf --- /dev/null +++ b/2566-maximum-difference-by-remapping-a-digit.rs @@ -0,0 +1,35 @@ +pub fn min_max_difference(num: i32) -> i32 { + let num_str = num.to_string().chars().collect::>(); + // println!("{:?}", num_str[0]); + let mut idx = 0; + for (i, c) in num_str.iter().enumerate() { + if *c != '9' { + idx = i; + break + } + } + let mut max_str = String::new(); + let mut min_str = String::new(); + for c in &num_str { + if *c == num_str[idx] { + max_str.push('9'); + } else { + max_str.push(*c); + } + if *c == num_str[0] { + min_str.push('0'); + } else { + min_str.push(*c); + } + } + + let max = max_str.parse::().unwrap(); + let min = min_str.parse::().unwrap(); + max - min +} + +fn main() { + println!("{:?}", min_max_difference(11891)); // 99009 + println!("{:?}", min_max_difference(90)); // 99 + println!("{:?}", min_max_difference(2)); // 9 +} From 7e64e46fe832d3f55525930ccf6cfc25ed4b2091 Mon Sep 17 00:00:00 2001 From: memorycancel Date: Sat, 11 Mar 2023 11:01:42 +0800 Subject: [PATCH 72/73] Upsert 2278-percentage-of-letter-in-string.rs --- 2278-percentage-of-letter-in-string.rs | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 2278-percentage-of-letter-in-string.rs diff --git a/2278-percentage-of-letter-in-string.rs b/2278-percentage-of-letter-in-string.rs new file mode 100644 index 0000000..9888182 --- /dev/null +++ b/2278-percentage-of-letter-in-string.rs @@ -0,0 +1,13 @@ +pub fn percentage_letter(s: String, letter: char) -> i32 { + let mut counter = 0; + for c in s.chars().collect::>() { + if c == letter { + counter += 1 + } + } + (100.0 * counter as f64 / s.len() as f64) as i32 +} + +fn main() { + println!("{:?}", percentage_letter("foobar".to_string(), 'o')); +} From b7d6b0f153271c8645f188170b08f32c1aee629c Mon Sep 17 00:00:00 2001 From: memorycancel Date: Wed, 15 Mar 2023 20:16:36 +0800 Subject: [PATCH 73/73] Upsert 2490-circular-sentence.rs --- 2490-circular-sentence.rs | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 2490-circular-sentence.rs diff --git a/2490-circular-sentence.rs b/2490-circular-sentence.rs new file mode 100644 index 0000000..111d293 --- /dev/null +++ b/2490-circular-sentence.rs @@ -0,0 +1,26 @@ +pub fn is_circular_sentence(sentence: String) -> bool { + if sentence.chars().nth(0).unwrap() != + sentence.chars().nth(sentence.len() - 1).unwrap() { + return false + } + let mut count = 0; + let mut prev_char: char = '?'; + for word in sentence.split_ascii_whitespace() { + if count == 0 { + prev_char = word.chars().last().unwrap() + } else { + let curr_char = word.chars().nth(0).unwrap(); + if curr_char != prev_char { return false } + prev_char = word.chars().last().unwrap(); + } + count += 1 + } + true +} + +fn main() { + let sentence = "leetcode exercises sound delightful".to_string(); + println!("{:?}", is_circular_sentence(sentence)); + let sentence = "eetcode".to_string(); + println!("{:?}", is_circular_sentence(sentence)); +}