├── .gitignore ├── S0001-two-sum ├── Cargo.toml └── src │ └── main.rs ├── S0002-add-two-numbers ├── Cargo.toml └── src │ └── main.rs ├── S0003-longest-substring-without-repeating-characters ├── Cargo.toml └── src │ └── main.rs ├── S0007-reverse-integer ├── Cargo.toml └── src │ └── main.rs ├── S0019-remove-nth-node-from-end-of-list ├── Cargo.toml └── src │ └── main.rs ├── S0021-merge-two-sorted-lists ├── Cargo.toml └── src │ └── main.rs ├── S0023-merge-k-sorted-lists ├── Cargo.toml └── src │ └── main.rs ├── S0024-swap-nodes-in-pairs ├── Cargo.toml └── src │ └── main.rs ├── S0029-divide-two-integers ├── Cargo.toml └── src │ └── main.rs ├── S0034-find-first-and-last-position-of-element-in-sorted-array ├── Cargo.toml └── src │ └── main.rs ├── S0036-valid-sudoku ├── Cargo.toml └── src │ └── main.rs ├── S0048-rotate-image ├── Cargo.toml └── src │ └── main.rs ├── S0050-powx-n ├── Cargo.toml └── src │ └── main.rs ├── S0056-merge-intervals ├── Cargo.toml └── src │ └── main.rs ├── S0057-insert-interval ├── Cargo.toml └── src │ └── main.rs ├── S0061-rotate-list ├── Cargo.toml └── src │ └── main.rs ├── S0062-unique-paths ├── Cargo.toml └── src │ └── main.rs ├── S0063-unique-paths-ii ├── Cargo.toml └── src │ └── main.rs ├── S0066-plus-one ├── Cargo.toml └── src │ └── main.rs ├── S0067-add-binary ├── Cargo.toml └── src │ └── main.rs ├── S0069-sqrtx ├── Cargo.toml └── src │ └── main.rs ├── S0075-sort-colors ├── Cargo.toml └── src │ └── main.rs ├── S0080-remove-duplicates-from-sorted-array-ii ├── Cargo.toml └── src │ └── main.rs ├── S0086-partition-list ├── Cargo.toml └── src │ └── main.rs ├── S0092-reverse-linked-list-ii ├── Cargo.toml └── src │ └── main.rs ├── S0094-binary-tree-inorder-traversal ├── Cargo.toml └── src │ ├── main.rs │ └── main2.rs ├── S0100-same-tree ├── Cargo.toml └── src │ └── main.rs ├── S0101-symmetric-tree ├── Cargo.toml └── src │ └── main.rs ├── S0104-maximum-depth-of-binary-tree ├── Cargo.toml └── src │ └── main.rs ├── S0105-construct-binary-tree-from-preorder-and-inorder-traversal ├── Cargo.toml └── src │ └── main.rs ├── S0106-construct-binary-tree-from-inorder-and-postorder-traversal ├── Cargo.toml └── src │ └── main.rs ├── S0114-flatten-binary-tree-to-linked-list ├── Cargo.toml └── src │ └── main.rs ├── S0125-valid-palindrome ├── Cargo.toml └── src │ └── main.rs ├── S0128-longest-consecutive-sequence ├── Cargo.toml └── src │ └── main.rs ├── S0144-binary-tree-preorder-traversal ├── Cargo.toml └── src │ └── main.rs ├── S0145-binary-tree-postorder-traversal ├── Cargo.toml └── src │ └── main.rs ├── S0150-evaluate-reverse-polish-notation ├── Cargo.toml └── src │ └── main.rs ├── S0165-compare-version-numbers ├── Cargo.toml └── src │ └── main.rs ├── S0179-largest-number ├── Cargo.toml └── src │ └── main.rs ├── S0199-binary-tree-right-side-view ├── Cargo.toml └── src │ └── main.rs ├── S0203-remove-linked-list-elements ├── Cargo.toml └── src │ └── main.rs ├── S0206-reverse-linked-list ├── Cargo.toml └── src │ └── main.rs ├── S0222-count-complete-tree-nodes ├── Cargo.toml └── src │ └── main.rs ├── S0224-basic-calculator ├── Cargo.toml └── src │ └── main.rs ├── S0225-implement-stack-using-queues ├── Cargo.toml └── src │ └── main.rs ├── S0230-kth-smallest-element-in-a-bst ├── Cargo.toml └── src │ └── main.rs ├── S0334-increasing-triplet-subsequence ├── Cargo.toml └── src │ └── main.rs ├── S0349-intersection-of-two-arrays ├── Cargo.toml └── src │ └── main.rs ├── S0350-intersection-of-two-arrays-ii ├── Cargo.toml └── src │ └── main.rs ├── S0398-random-pick-index ├── Cargo.toml └── src │ └── main.rs ├── S0441-arranging-coins ├── Cargo.toml └── src │ └── main.rs ├── S0443-string-compression ├── Cargo.toml ├── readme.md └── src │ └── main.rs ├── S0448-find-all-numbers-disappeared-in-an-array ├── Cargo.toml └── src │ └── main.rs ├── S0451-sort-characters-by-frequency ├── Cargo.toml └── src │ └── main.rs ├── S0485-max-consecutive-ones ├── Cargo.toml └── src │ └── main.rs ├── S0506-relative-ranks ├── Cargo.toml └── src │ └── main.rs ├── S0508-most-frequent-subtree-sum ├── Cargo.toml └── src │ └── main.rs ├── S0513-find-bottom-left-tree-value ├── Cargo.toml └── src │ └── main.rs ├── S0530-minimum-absolute-difference-in-bst ├── Cargo.toml └── src │ └── main.rs ├── S0617-merge-two-binary-trees ├── Cargo.toml └── src │ └── main.rs ├── S0637-average-of-levels-in-binary-tree ├── Cargo.toml └── src │ └── main.rs ├── S0654-maximum-binary-tree ├── Cargo.toml └── src │ └── main.rs ├── S0662-maximum-width-of-binary-tree ├── Cargo.toml └── src │ ├── lib.rs │ └── main.rs ├── S0670-maximum-swap ├── Cargo.toml └── src │ └── main.rs ├── S0671-second-minimum-node-in-a-binary-tree ├── Cargo.toml └── src │ └── main.rs ├── S0680-valid-palindrome-ii ├── Cargo.toml └── src │ └── main.rs ├── S0709-to-lower-case ├── Cargo.toml └── src │ └── main.rs ├── S0725-split-linked-list-in-parts ├── Cargo.toml └── src │ └── main.rs ├── S0748-shortest-completing-word ├── Cargo.toml └── src │ └── main.rs ├── S0771-jewels-and-stones ├── Cargo.toml └── src │ └── main.rs ├── S0789-escape-the-ghosts ├── Cargo.toml └── src │ └── main.rs ├── S0817-linked-list-components ├── Cargo.toml └── src │ └── main.rs ├── S0876-middle-of-the-linked-list ├── Cargo.toml └── src │ └── main.rs ├── S0877-stone-game ├── Cargo.toml └── src │ └── main.rs ├── S0884-uncommon-words-from-two-sentences ├── Cargo.toml └── src │ └── main.rs ├── S0889-construct-binary-tree-from-preorder-and-postorder-traversal ├── Cargo.toml └── src │ └── main.rs ├── S0897-increasing-order-search-tree ├── Cargo.toml └── src │ └── main.rs ├── S0901-online-stock-span ├── Cargo.toml └── src │ └── main.rs ├── S0908-smallest-range-i ├── Cargo.toml └── src │ └── main.rs ├── S0917-reverse-only-letters ├── Cargo.toml └── src │ └── main.rs ├── S0922-sort-array-by-parity-ii ├── Cargo.toml └── src │ └── main.rs ├── S0923-3sum-with-multiplicity ├── Cargo.toml └── src │ └── main.rs ├── S0925-long-pressed-name ├── Cargo.toml └── src │ └── main.rs ├── S0929-unique-email-addresses ├── Cargo.toml └── src │ └── main.rs ├── S0938-range-sum-of-bst ├── Cargo.toml └── src │ └── main.rs ├── S0942-di-string-match ├── Cargo.toml └── src │ └── main.rs ├── S0946-validate-stack-sequences ├── Cargo.toml └── src │ └── main.rs ├── S0949-largest-time-for-given-digits ├── Cargo.toml └── src │ └── main.rs ├── S0951-flip-equivalent-binary-trees ├── Cargo.toml └── src │ └── main.rs ├── S0953-verifying-an-alien-dictionary ├── Cargo.toml └── src │ └── main.rs ├── S0958-check-completeness-of-a-binary-tree ├── Cargo.toml └── src │ └── main.rs ├── S0961-n-repeated-element-in-size-2n-array ├── Cargo.toml └── src │ └── main.rs ├── S0965-univalued-binary-tree ├── Cargo.toml └── src │ └── main.rs ├── S0966-vowel-spellchecker ├── Cargo.toml └── src │ └── main.rs ├── S0970-powerful-integers ├── Cargo.toml └── src │ └── main.rs ├── S0973-k-closest-points-to-origin ├── Cargo.toml └── src │ └── main.rs ├── S0976-largest-perimeter-triangle ├── Cargo.toml └── src │ └── main.rs ├── S0977-squares-of-a-sorted-array ├── Cargo.toml └── src │ └── main.rs ├── S0978-longest-turbulent-subarray ├── Cargo.toml └── src │ └── main.rs ├── S0979-distribute-coins-in-binary-tree ├── Cargo.toml └── src │ └── main.rs ├── S0982-triples-with-bitwise-and-equal-to-zero ├── Cargo.toml └── src │ └── main.rs ├── S0993-cousins-in-binary-tree ├── Cargo.toml └── src │ └── main.rs ├── S1019-next-greater-node-in-linked-list ├── Cargo.toml ├── readme.md └── src │ └── main.rs ├── S1154-ordinal-number-of-date ├── Cargo.toml └── src │ └── main.rs ├── S1342-number-of-steps-to-reduce-a-number-to-zero ├── Cargo.toml └── src │ └── main.rs ├── SORT └── ms.rs ├── crack_interview └── S17-19-missing-two-lcci │ ├── Cargo.toml │ ├── src │ └── main.rs │ └── target │ └── .rustc_info.json └── readme.md /.gitignore: -------------------------------------------------------------------------------- 1 | */.idea 2 | */target 3 | .DS_Store 4 | .idea 5 | cargo.lock 6 | */target/* 7 | -------------------------------------------------------------------------------- /S0001-two-sum/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "s0001" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0001-two-sum/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashMap; 2 | 3 | struct Solution {} 4 | 5 | impl Solution { 6 | pub fn two_sum(nums: Vec, target: i32) -> Vec { 7 | let mut h: HashMap = HashMap::new(); 8 | for (idx, i) in nums.iter().enumerate() { 9 | let left = target - i; 10 | match h.get(&left) { 11 | Some(v) => return vec![*v, idx as i32], 12 | None => h.insert(*i, idx as i32), 13 | }; 14 | } 15 | return vec![]; 16 | } 17 | } 18 | 19 | fn main() { 20 | let v = vec![1, 2, 3, 4]; 21 | println!("{:?}", Solution::two_sum(v, 5)); 22 | } 23 | -------------------------------------------------------------------------------- /S0002-add-two-numbers/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0002" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0002-add-two-numbers/src/main.rs: -------------------------------------------------------------------------------- 1 | #[derive(PartialEq, Eq, Debug)] 2 | pub struct ListNode { 3 | pub val: i32, 4 | pub next: Option>, 5 | } 6 | 7 | impl ListNode { 8 | #[inline] 9 | fn new(val: i32) -> Self { 10 | ListNode { next: None, val } 11 | } 12 | } 13 | 14 | impl Solution { 15 | pub fn add_two_numbers( 16 | l1: Option>, 17 | l2: Option>, 18 | ) -> Option> { 19 | let mut head = Some(Box::new(ListNode::new(0))); 20 | let (mut p, mut q, mut carry) = (l1, l2, 0); 21 | let mut current = head.as_mut(); 22 | while p.is_some() || q.is_some() { 23 | let mut sum = carry; 24 | if let Some(v) = p { 25 | sum += v.val; 26 | p = v.next; 27 | } 28 | if let Some(v) = q { 29 | sum += v.val; 30 | q = v.next; 31 | } 32 | 33 | carry = sum / 10; 34 | if let Some(cur) = current { 35 | cur.next = Some(Box::new(ListNode::new(sum % 10))); 36 | current = cur.next.as_mut(); 37 | } 38 | } 39 | 40 | if carry > 0 { 41 | current.unwrap().next = Some(Box::new(ListNode::new(1))); 42 | } 43 | head.unwrap().next 44 | } 45 | } 46 | struct Solution {} 47 | 48 | fn main() { 49 | let mut l1 = Some(Box::new(ListNode::new(1))); 50 | let mut l2 = Some(Box::new(ListNode::new(9))); 51 | l1.as_mut().unwrap().next = Some(Box::new(ListNode::new(3))); 52 | 53 | //let l3 = Solution::add_two_numbers(l1,l2); 54 | 55 | //println!("{:?}", l3); 56 | println!("l1 {:?}", l1); 57 | println!("l2 {:?}", l2); 58 | let mut x = Solution::add_two_numbers(l1, l2); 59 | println!("res {:?}", x); 60 | } 61 | -------------------------------------------------------------------------------- /S0003-longest-substring-without-repeating-characters/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0003-longest-substring-without-repeating-characters" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0003-longest-substring-without-repeating-characters/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use std::collections::HashSet; 3 | impl Solution { 4 | pub fn length_of_longest_substring(s: String) -> i32 { 5 | let mut max_len = 0; 6 | let mut char_set = HashSet::new(); 7 | let mut cur_len = 0; 8 | let mut cc = s.chars().collect::>(); 9 | for (idx, c) in cc.iter().enumerate() { 10 | if char_set.contains(&c) { 11 | for i in (idx-cur_len)..idx { 12 | // 这里如果用 s.chars().nth() 会非常非常非常非常慢 13 | let char_at_i = cc[i]; 14 | char_set.remove(&char_at_i); 15 | cur_len -= 1; 16 | if char_at_i == *c { 17 | break 18 | } 19 | } 20 | } 21 | char_set.insert(c); 22 | cur_len += 1; 23 | max_len = max_len.max(cur_len); 24 | } 25 | 26 | return max_len as i32 27 | } 28 | } 29 | 30 | fn main() { 31 | println!("{}", Solution::length_of_longest_substring("abcabcbb".to_string())); 32 | println!("{}", Solution::length_of_longest_substring("bbbbb".to_string())); 33 | println!("{}", Solution::length_of_longest_substring("pwwkew".to_string())); 34 | } 35 | 36 | /* 37 | 38 | impl Solution { 39 | pub fn length_of_longest_substring(str: String) -> i32 { 40 | let s = str.as_bytes(); 41 | let (mut start, mut end) = (0, 0); 42 | let (mut current, mut max ) = (0, 0); 43 | 44 | for k in 0..s.len() { 45 | for i in start..end { 46 | if s[end] == s[i] { 47 | current = end - start; 48 | if current > max { 49 | max = current; 50 | } 51 | start = i + 1; 52 | break; 53 | } 54 | } 55 | end += 1; 56 | } 57 | std::cmp::max(end - start, max) as i32 58 | } 59 | } 60 | */ 61 | 62 | /* 63 | 64 | impl Solution { 65 | #[inline] 66 | fn find_and_romove(v: &mut Vec, target: char) -> Option<(usize, Vec)> { 67 | for (i, ch) in v.iter().enumerate() { 68 | if target == *ch { 69 | return Some((v.len(), v.split_off(i+1))) 70 | } 71 | } 72 | None 73 | } 74 | 75 | 76 | fn length_of_longest_substring(s: String) -> i32 { 77 | let mut v = vec![]; 78 | let (mut current, mut max ) = (0, 0); 79 | for ch in s.chars() { 80 | if let Some((c, list)) = Solution::find_and_romove(&mut v, ch) { 81 | current = c; 82 | v = list; 83 | if current > max { 84 | max = current; 85 | } 86 | } 87 | v.push(ch); 88 | } 89 | std::cmp::max(v.len(), max) as i32 90 | } 91 | } 92 | */ 93 | 94 | /* 95 | se std::cmp; 96 | use std::collections::HashSet; 97 | impl Solution { 98 | pub fn length_of_longest_substring(s: String) -> i32 { 99 | let len = s.len(); 100 | let chars: Vec = s.chars().collect(); 101 | let mut set = HashSet::new(); 102 | let mut output = 0; 103 | let mut i = 0; 104 | let mut j = 0; 105 | 106 | while i"] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0007-reverse-integer/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution {} 2 | 3 | impl Solution { 4 | pub fn reverse(x: i32) -> i32 { 5 | let mut x: i64 = x as i64; 6 | let mut neg = false; 7 | if x < 0 { 8 | x = -x; 9 | neg = true; 10 | } 11 | 12 | let mut v = vec![]; 13 | while x > 0 { 14 | v.push(x % 10); 15 | x = x / 10; 16 | } 17 | 18 | let mut res: i64 = 0; 19 | for i in v { 20 | res = res * 10 + i as i64; 21 | if res > i32::max_value() as i64 { 22 | res = 0; 23 | break; 24 | } 25 | } 26 | 27 | if neg { 28 | res = -res 29 | } 30 | return res as i32; 31 | } 32 | } 33 | 34 | fn main() { 35 | println!("res : {}", Solution::reverse(111112147)); 36 | } 37 | -------------------------------------------------------------------------------- /S0019-remove-nth-node-from-end-of-list/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0019" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0019-remove-nth-node-from-end-of-list/src/main.rs: -------------------------------------------------------------------------------- 1 | // Definition for singly-linked list. 2 | #[derive(PartialEq, Eq, Debug)] 3 | pub struct ListNode { 4 | pub val: i32, 5 | pub next: Option>, 6 | } 7 | 8 | impl ListNode { 9 | #[inline] 10 | fn new(val: i32) -> Self { 11 | ListNode { next: None, val } 12 | } 13 | } 14 | 15 | struct Solution; 16 | impl Solution { 17 | pub fn remove_nth_from_end(head: Option>, n: i32) -> Option> { 18 | let mut step_cnt = 0; 19 | let mut t = head.as_ref().unwrap(); 20 | 21 | while step_cnt < n { 22 | if let Some(_) = t.next { 23 | t = t.next.as_ref().unwrap(); 24 | step_cnt += 1; 25 | } else { 26 | return head.unwrap().next; 27 | } 28 | } 29 | let mut cur = head.as_ref().unwrap(); 30 | let mut res = Some(Box::new(ListNode::new(cur.val))); 31 | let mut res_cur = res.as_mut().unwrap(); 32 | 33 | while t.next.is_some() { 34 | t = t.next.as_ref().unwrap(); 35 | cur = cur.next.as_ref().unwrap(); 36 | res_cur.next = Some(Box::new(ListNode::new(cur.val))); 37 | res_cur = res_cur.next.as_mut().unwrap(); 38 | } 39 | 40 | cur = cur.next.as_ref().unwrap(); 41 | // skip cur, and to the end 42 | while cur.next.is_some() { 43 | if let Some(ref n) = cur.next { 44 | res_cur.next = Some(Box::new(ListNode::new(n.val))); 45 | } 46 | cur = cur.next.as_ref().unwrap(); 47 | res_cur = res_cur.next.as_mut().unwrap(); 48 | } 49 | 50 | return res; 51 | } 52 | } 53 | fn main() { 54 | let mut a = Some(Box::new(ListNode::new(1))); 55 | a.as_mut().unwrap().next = Some(Box::new(ListNode::new(2))); 56 | a.as_mut().unwrap().next.as_mut().unwrap().next = Some(Box::new(ListNode::new(3))); 57 | a.as_mut().unwrap().next.as_mut().unwrap().next.as_mut().unwrap().next = Some(Box::new(ListNode::new(4))); 58 | 59 | println!("{:?}",Solution::remove_nth_from_end(a, 4)); 60 | } 61 | 62 | /* 63 | impl Solution { 64 | pub fn remove_nth_from_end(head: Option>, n: i32) -> Option> { 65 | fn rebuild(head: Option>, n: i32) -> (Option>, i32) { 66 | if let Some(mut node) = head { 67 | let (tail, m) = rebuild(node.next, n); 68 | if m == n { 69 | (tail, m + 1) 70 | } else { 71 | node.next = tail; 72 | (Some(node), m + 1) 73 | } 74 | } else { 75 | (None, 1) 76 | } 77 | } 78 | rebuild(head, n).0 79 | } 80 | } 81 | */ 82 | 83 | /* 84 | pub fn remove(head: Option>, n: i32) -> (i32, Option>) { 85 | if let Some(boxed) = head { 86 | let (mut tail_index, tail) = remove(boxed.next, n); 87 | tail_index += 1; 88 | 89 | if tail_index == n { 90 | (tail_index, tail) 91 | } else { 92 | (tail_index, Some(Box::new(ListNode { 93 | val: boxed.val, 94 | next: tail 95 | }))) 96 | } 97 | } else { 98 | (0, None) 99 | } 100 | } 101 | 102 | impl Solution { 103 | pub fn remove_nth_from_end(head: Option>, n: i32) -> Option> { 104 | remove(head, n).1 105 | } 106 | } 107 | */ 108 | -------------------------------------------------------------------------------- /S0021-merge-two-sorted-lists/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0021-merge-two-sorted-lists" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude = "^0.1" 9 | 10 | -------------------------------------------------------------------------------- /S0021-merge-two-sorted-lists/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | // Definition for singly-linked list. 4 | // #[derive(PartialEq, Eq, Debug)] 5 | // pub struct ListNode { 6 | // pub val: i32, 7 | // pub next: Option> 8 | // } 9 | // 10 | // impl ListNode { 11 | // #[inline] 12 | // fn new(val: i32) -> Self { 13 | // ListNode { 14 | // next: None, 15 | // val 16 | // } 17 | // } 18 | // } 19 | impl Solution { 20 | pub fn merge_two_lists( 21 | mut l1: Option>, 22 | mut l2: Option>, 23 | ) -> Option> { 24 | let mut h = Box::new(ListNode::new(0)); 25 | let mut cursor = &mut h; 26 | 27 | let (mut l1, mut l2) = (&mut l1, &mut l2); 28 | 29 | loop { 30 | match (l1.as_ref(), l2.as_ref()) { 31 | (Some(n1), Some(n2)) => { 32 | if n1.val < n2.val { 33 | std::mem::swap(&mut cursor.next, l1); 34 | std::mem::swap(&mut cursor.next.as_mut().unwrap().next, l1); 35 | /* 其实把向后移动放这里可能更直观一些 36 | std::mem::swap(&mut l3.next, &mut l1); 37 | l3 = l3.next.as_mut().unwrap(); 38 | std::mem::swap(&mut l3.next, &mut l1); 39 | 这么写的话，if 外面那个 cur = cur.next 就不用写了 40 | */ 41 | } else { 42 | std::mem::swap(&mut cursor.next, l2); 43 | std::mem::swap(&mut cursor.next.as_mut().unwrap().next, l2); 44 | } 45 | cursor = cursor.next.as_mut().unwrap(); 46 | } 47 | (None, Some(n2)) => { 48 | std::mem::swap(&mut cursor.next, l2); 49 | break; 50 | } 51 | (Some(n1), None) => { 52 | std::mem::swap(&mut cursor.next, l1); 53 | break; 54 | } 55 | (None, None) => break, 56 | } 57 | } 58 | 59 | return h.next; 60 | } 61 | } 62 | 63 | fn main() { 64 | let l1 = linkedlist![1, 2, 3, 4]; 65 | let l2 = linkedlist![1, 2, 3, 4]; 66 | let l3 = Solution::merge_two_lists(l1, l2); 67 | println!("{:?}", l3); 68 | } 69 | 70 | /* 71 | leetcode 上的递归解法 72 | impl Solution { 73 | pub fn merge_two_lists(l1: Option>, l2: Option>) -> Option> { 74 | if let Some(l1) = l1 { 75 | if let Some(l2) = l2 { 76 | if l1.val < l2.val { 77 | let l1 = *l1; 78 | let merged_rest = Self::merge_two_lists(l1.next, Some(l2)); 79 | Some(Box::new(ListNode{val:l1.val, next: merged_rest})) 80 | } else { 81 | let l2 = *l2; 82 | let merged_rest = Self::merge_two_lists(Some(l1), l2.next); 83 | Some(Box::new(ListNode{val:l2.val, next: merged_rest})) 84 | } 85 | } else { 86 | Some(l1) 87 | } 88 | } else { 89 | l2 90 | } 91 | } 92 | } 93 | */ 94 | -------------------------------------------------------------------------------- /S0023-merge-k-sorted-lists/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0023-merge-k-sorted-lists" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" 9 | 10 | -------------------------------------------------------------------------------- /S0023-merge-k-sorted-lists/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | use std::cmp::Ord; 4 | use std::cmp::Ordering; 5 | use std::collections::BinaryHeap; 6 | 7 | // Definition for singly-linked list. 8 | // #[derive(PartialEq, Eq, Debug)] 9 | // pub struct ListNode { 10 | // pub val: i32, 11 | // pub next: Option> 12 | // } 13 | // 14 | // impl ListNode { 15 | // #[inline] 16 | // fn new(val: i32) -> Self { 17 | // ListNode { 18 | // next: None, 19 | // val 20 | // } 21 | // } 22 | // } 23 | #[derive(Debug)] 24 | struct HeapNode { 25 | val: i32, 26 | idx: usize, 27 | } 28 | 29 | impl HeapNode { 30 | pub fn new(val: i32, idx: usize) -> Self { 31 | return HeapNode { val, idx }; 32 | } 33 | } 34 | 35 | impl PartialEq for HeapNode { 36 | fn eq(&self, other: &Self) -> bool { 37 | return self.val == other.val; 38 | } 39 | } 40 | impl Eq for HeapNode {} 41 | 42 | impl std::cmp::Ord for HeapNode { 43 | fn cmp(&self, other: &Self) -> Ordering { 44 | return self.val.cmp(&other.val); 45 | } 46 | } 47 | 48 | impl std::cmp::PartialOrd for HeapNode { 49 | fn partial_cmp(&self, other: &HeapNode) -> Option { 50 | if self.val < other.val { 51 | return Some(Ordering::Greater); 52 | } else { 53 | return Some(Ordering::Less); 54 | } 55 | } 56 | } 57 | 58 | impl Solution { 59 | // 基本思路，构建小顶堆 60 | // 每次取堆顶，并把对应位置的数组索引后移 61 | // 最大时间复杂度，应该是 lg(n) * (n*m) 62 | // 如果是 merge_k_lists2 的解法的话，时间复杂度是 (n*m)*log(n*m) 63 | // 但是从这道题给的数据上，是看不出这两种算法的区别的 64 | pub fn merge_k_lists(lists: Vec>>) -> Option> { 65 | let mut heap = BinaryHeap::new(); 66 | // build heap 67 | let mut list_cursors = vec![]; 68 | for (idx, l) in lists.iter().enumerate() { 69 | if l.is_some() { 70 | heap.push(HeapNode::new(l.as_ref().unwrap().val, idx)); 71 | } 72 | list_cursors.push(l); 73 | } 74 | // println!("{:?}\n {:?}", heap, list_cursors); 75 | let mut dummy = Box::new(ListNode::new(0)); 76 | let mut cursor = &mut dummy; 77 | loop { 78 | let x = heap.pop(); 79 | if x.is_none() { 80 | break; 81 | } 82 | 83 | // 结果链表 84 | cursor.next = Some(Box::new(ListNode::new(x.as_ref().unwrap().val))); 85 | cursor = cursor.next.as_mut().unwrap(); 86 | 87 | let (idx, prev_v) = (x.as_ref().unwrap().idx, x.as_ref().unwrap().val); 88 | 89 | let mut next = &list_cursors[idx].as_ref().unwrap().next; 90 | if next.is_some() { 91 | let v = next.as_ref().unwrap().val; 92 | heap.push(HeapNode::new(v, idx)); 93 | } 94 | list_cursors[idx] = next; 95 | } 96 | dummy.next 97 | } 98 | 99 | pub fn merge_k_lists2(lists: Vec>>) -> Option> { 100 | let mut num_vec = vec![]; 101 | for l in lists { 102 | let mut inner_list = l; 103 | while inner_list.is_some() { 104 | num_vec.push(inner_list.as_ref().unwrap().val); 105 | inner_list = inner_list.unwrap().next; 106 | } 107 | } 108 | num_vec.sort(); 109 | let mut dummy = Box::new(ListNode::new(0)); 110 | let mut cursor = &mut dummy; 111 | for num in num_vec { 112 | let node = Some(Box::new(ListNode::new(num))); 113 | cursor.next = node; 114 | cursor = cursor.next.as_mut().unwrap(); 115 | } 116 | return dummy.next; 117 | } 118 | } 119 | 120 | fn main() { 121 | let v = vec![linkedlist![1, 2, 3], linkedlist![2, 3, 4]]; 122 | let l = Solution::merge_k_lists(v); 123 | println!("{:?}", l); 124 | } 125 | -------------------------------------------------------------------------------- /S0024-swap-nodes-in-pairs/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0024-swap-nodes-in-pairs" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="0.1" -------------------------------------------------------------------------------- /S0029-divide-two-integers/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0029-divide-two-integers" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0029-divide-two-integers/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | impl Solution { 3 | pub fn divide(mut dividend: i32, mut divisor: i32) -> i32 { 4 | let sign = if (dividend < 0 && divisor > 0) || (dividend > 0 && divisor < 0) { 5 | -1 6 | } else { 7 | 1 8 | }; 9 | 10 | let mut adj = 0; 11 | let mut q = 0; 12 | let mut r = 0; 13 | 14 | if divisor == std::i32::MIN { 15 | if divisor == dividend { 16 | return 1 17 | } else { 18 | return 0 19 | } 20 | } 21 | 22 | if dividend == std::i32::MIN { 23 | if divisor == 1 { 24 | return std::i32::MIN; 25 | } 26 | if divisor == -1 { 27 | return std::i32::MAX; 28 | } 29 | dividend += divisor.abs(); 30 | adj += 1; 31 | } 32 | 33 | dividend = dividend.abs(); 34 | divisor = divisor.abs(); 35 | 36 | for i in (0..32).rev() { 37 | r <<= 1; 38 | if dividend & (1 << i) != 0 { 39 | r |= 1; 40 | } 41 | if r >= divisor { 42 | r -= divisor; 43 | q = q | (1 << i); 44 | } 45 | } 46 | 47 | if sign < 0 { 48 | -q - adj 49 | } else { 50 | q + adj 51 | } 52 | } 53 | } 54 | 55 | fn main() {} 56 | -------------------------------------------------------------------------------- /S0034-find-first-and-last-position-of-element-in-sorted-array/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0034-find-first-and-last-position-of-element-in-sorted-array" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0034-find-first-and-last-position-of-element-in-sorted-array/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn search_range(nums: Vec, target: i32) -> Vec { 5 | if nums.len() == 0 { 6 | return vec![-1,-1]; 7 | } 8 | 9 | let (mut left_most, mut right_most) = (-1 as i32, -1 as i32); 10 | 11 | // left most 12 | let (mut low, mut high) = (0 as i32, (nums.len()-1) as i32); 13 | while low <= high { 14 | let mid = low + (high - low)/2; 15 | if nums[mid as usize] == target { 16 | if left_most == -1 || left_most > mid { 17 | left_most = mid; 18 | } 19 | high = mid-1; 20 | continue; 21 | } 22 | if nums[mid as usize] < target { 23 | low = mid+1;continue; 24 | } 25 | if nums[mid as usize] > target { 26 | high = mid-1;continue; 27 | } 28 | } 29 | 30 | // right most 31 | let (mut low, mut high) = (0 as i32, (nums.len()-1) as i32); 32 | while low <= high { 33 | let mid = low + (high - low)/2; 34 | if nums[mid as usize] == target { 35 | if right_most < mid { 36 | right_most = mid; 37 | low = mid+1; 38 | } 39 | continue; 40 | } 41 | if nums[mid as usize] < target { 42 | low = mid+1;continue; 43 | } 44 | if nums[mid as usize] > target { 45 | high = mid-1;continue; 46 | } 47 | } 48 | return vec![left_most, right_most]; 49 | } 50 | } 51 | 52 | fn main() { 53 | println!("{:?}", Solution::search_range(vec![5,7,7,8,8,10],8)); 54 | println!("{:?}", Solution::search_range(vec![5,7,7,8,8,10],6)); 55 | println!("{:?}", Solution::search_range(vec![],0)); 56 | println!("{:?}", Solution::search_range(vec![1],0)); 57 | } 58 | -------------------------------------------------------------------------------- /S0036-valid-sudoku/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0036" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0036-valid-sudoku/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashSet; 2 | 3 | struct Solution; 4 | 5 | impl Solution { 6 | pub fn is_valid_sudoku(board: Vec>) -> bool { 7 | // 同一行 8 | for i in 0..board.len() { 9 | let mut map = HashSet::new(); 10 | for j in 0..board.len() { 11 | if board[i][j] == '.' { 12 | continue; 13 | } 14 | if map.contains(&board[i][j]) { 15 | //println!('{:?}, {}', map, board[i][j]); 16 | return false; 17 | } 18 | map.insert(board[i][j]); 19 | } 20 | } 21 | 22 | // 同一列 23 | for i in 0..board.len() { 24 | let mut map = HashSet::new(); 25 | for j in 0..board.len() { 26 | if board[j][i] == '.' { 27 | continue; 28 | } 29 | if map.contains(&board[j][i]) { 30 | //println!('{:?}, {}', map, board[j][i]); 31 | return false; 32 | } 33 | map.insert(board[j][i]); 34 | } 35 | } 36 | // 同一个九宫格 37 | for i in 0..board.len() { 38 | for j in 0..board.len() { 39 | if board[i][j] == '.' { 40 | continue; 41 | } 42 | let (inner_i, inner_j) = (i - i % 3, j - j % 3); 43 | // println!('fuck {},{},{},{}', i/3,j/3,inner_i,inner_j); 44 | for inner_i in inner_i..(inner_i + 3) { 45 | for inner_j in inner_j..(inner_j + 3) { 46 | if (inner_i != i || inner_j != j) && board[i][j] == board[inner_i][inner_j] 47 | { 48 | //println!('{},{},{},{}', i,j,inner_i,inner_j); 49 | return false; 50 | } 51 | } 52 | } 53 | } 54 | } 55 | return true; 56 | } 57 | } 58 | 59 | fn main() { 60 | let sudoku = vec![ 61 | vec!['5', '3', '.', '.', '7', '.', '.', '.', '.'], 62 | vec!['6', '.', '.', '1', '9', '5', '.', '.', '.'], 63 | vec!['.', '9', '8', '.', '.', '.', '.', '6', '.'], 64 | vec!['8', '.', '.', '.', '6', '.', '.', '.', '3'], 65 | vec!['4', '.', '.', '8', '.', '3', '.', '.', '1'], 66 | vec!['7', '.', '.', '.', '2', '.', '.', '.', '6'], 67 | vec!['.', '6', '.', '.', '.', '.', '2', '8', '.'], 68 | vec!['.', '.', '.', '4', '1', '9', '.', '.', '5'], 69 | vec!['.', '.', '.', '.', '8', '.', '.', '7', '9'], 70 | ]; 71 | assert_eq!(true, Solution::is_valid_sudoku(sudoku)); 72 | //Solution::is_valid_sudoku(sudoku); 73 | let sudoku = vec![ 74 | vec!['8', '3', '.', '.', '7', '.', '.', '.', '.'], 75 | vec!['6', '.', '.', '1', '9', '5', '.', '.', '.'], 76 | vec!['.', '9', '8', '.', '.', '.', '.', '6', '.'], 77 | vec!['8', '.', '.', '.', '6', '.', '.', '.', '3'], 78 | vec!['4', '.', '.', '8', '.', '3', '.', '.', '1'], 79 | vec!['7', '.', '.', '.', '2', '.', '.', '.', '6'], 80 | vec!['.', '6', '.', '.', '.', '.', '2', '8', '.'], 81 | vec!['.', '.', '.', '4', '1', '9', '.', '.', '5'], 82 | vec!['.', '.', '.', '.', '8', '.', '.', '7', '9'], 83 | ]; 84 | assert_eq!(false, Solution::is_valid_sudoku(sudoku)); 85 | } 86 | -------------------------------------------------------------------------------- /S0048-rotate-image/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0048-rotate-image" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0048-rotate-image/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | impl Solution { 3 | pub fn rotate(matrix: &mut Vec>) { 4 | let (row, col) = (matrix.len(), matrix[0].len()); 5 | for i in 0..row { 6 | for j in i..col { 7 | let tmp = matrix[i][j]; 8 | matrix[i][j] = matrix[j][i]; 9 | matrix[j][i] = tmp; 10 | } 11 | } 12 | for i in 0..row { 13 | for j in 0..col/2 { 14 | matrix[i].swap(j, col-j-1); 15 | } 16 | } 17 | } 18 | } 19 | 20 | fn main() { 21 | let mut matrix = vec![vec![1,2,3], vec![4,5,6], vec![7,8,9]]; 22 | Solution::rotate(&mut matrix); 23 | println!("{:?}", matrix); 24 | } 25 | -------------------------------------------------------------------------------- /S0050-powx-n/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0050-powx-n" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0050-powx-n/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn my_pow(x: f64, n: i32) -> f64 { 5 | return x.powf(n as f64); 6 | } 7 | } 8 | 9 | fn main() { 10 | println!("{}", Solution::my_pow(2.00,-2)); 11 | } 12 | -------------------------------------------------------------------------------- /S0056-merge-intervals/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0056-merge-intervals" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0056-merge-intervals/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | // Definition for an interval. 3 | #[derive(Debug, PartialEq, Eq)] 4 | pub struct Interval { 5 | pub start: i32, 6 | pub end: i32, 7 | } 8 | 9 | impl Interval { 10 | #[inline] 11 | pub fn new(start: i32, end: i32) -> Self { 12 | Interval { start, end } 13 | } 14 | } 15 | impl Solution { 16 | pub fn merge(intervals: Vec) -> Vec { 17 | let mut intervals = intervals; 18 | intervals.sort_by(|x, y| x.start.cmp(&y.start)); 19 | let mut res = vec![]; 20 | for span in intervals { 21 | if res.len() == 0 { 22 | res.push(span); 23 | continue; 24 | } 25 | 26 | // can be merged with the top of the stack? 27 | if res[res.len() - 1].end >= span.start { 28 | let start = res[res.len() - 1].start.min(span.start); 29 | let end = res[res.len() - 1].end.max(span.end); 30 | res.pop(); 31 | res.push(Interval::new(start, end)); 32 | } else { 33 | res.push(span); 34 | } 35 | } 36 | 37 | return res; 38 | } 39 | } 40 | 41 | fn main() { 42 | let spans = vec![ 43 | Interval::new(1, 3), 44 | Interval::new(2, 6), 45 | Interval::new(8, 10), 46 | Interval::new(15, 18), 47 | ]; 48 | println!("{:?}", Solution::merge(spans)); 49 | 50 | let spans = vec![Interval::new(1, 4), Interval::new(4, 5)]; 51 | println!("{:?}", Solution::merge(spans)); 52 | } 53 | -------------------------------------------------------------------------------- /S0057-insert-interval/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0057-insert-interval" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0057-insert-interval/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | // Definition for an interval. 3 | #[derive(Debug, PartialEq, Eq)] 4 | pub struct Interval { 5 | pub start: i32, 6 | pub end: i32, 7 | } 8 | 9 | impl Interval { 10 | #[inline] 11 | pub fn new(start: i32, end: i32) -> Self { 12 | Interval { 13 | start, 14 | end 15 | } 16 | } 17 | } 18 | 19 | impl Solution { 20 | pub fn merge(intervals: Vec) -> Vec { 21 | let mut intervals = intervals; 22 | intervals.sort_by(|x, y| x.start.cmp(&y.start)); 23 | let mut res = vec![]; 24 | for span in intervals { 25 | if res.len() == 0 { 26 | res.push(span); 27 | continue; 28 | } 29 | 30 | // can be merged with the top of the stack? 31 | if res[res.len() - 1].end >= span.start { 32 | let start = res[res.len() - 1].start.min(span.start); 33 | let end = res[res.len() - 1].end.max(span.end); 34 | res.pop(); 35 | res.push(Interval::new(start, end)); 36 | } else { 37 | res.push(span); 38 | } 39 | } 40 | 41 | return res; 42 | } 43 | 44 | pub fn insert(intervals: Vec, new_interval: Interval) -> Vec { 45 | let mut intervals = intervals; 46 | intervals.push(new_interval); 47 | return Solution::merge(intervals); 48 | } 49 | } 50 | 51 | fn main() { 52 | println!("Hello, world!"); 53 | } 54 | -------------------------------------------------------------------------------- /S0061-rotate-list/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0061-rotate-list" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0061-rotate-list/src/main.rs: -------------------------------------------------------------------------------- 1 | use leetcode_prelude::*; 2 | struct Solution; 3 | 4 | use std::mem::replace; 5 | // Definition for singly-linked list. 6 | impl Solution { 7 | pub fn rotate_right(mut head: Option>, k: i32) -> Option> { 8 | if head.is_none() || head.as_ref().unwrap().next.is_none() || k == 0 { 9 | return head; 10 | } 11 | let mut cursor = &mut head; 12 | // count len 13 | let mut len = 0; 14 | while cursor.as_ref().is_some() { 15 | len += 1; 16 | cursor = &mut cursor.as_mut().unwrap().next; 17 | } 18 | 19 | let (k, mut cnt) = (len-k % len, 0); 20 | cursor = &mut head; 21 | 22 | loop { 23 | if cnt == k { 24 | let mut target = replace(cursor, None); 25 | // find the tail 26 | let mut tail = &mut target; 27 | while tail.is_some() { 28 | tail = &mut tail.as_mut().unwrap().next; 29 | } 30 | // now tail is None 31 | // replace it to head 32 | // set the tail.next = head 33 | replace(tail, head); 34 | return target; 35 | } 36 | cursor = &mut cursor.as_mut().unwrap().next; 37 | cnt += 1; 38 | } 39 | 40 | } 41 | } 42 | 43 | fn main() { 44 | let l = linkedlist![1, 2, 3, 4, 5]; 45 | println!("{:?}", Solution::rotate_right(l, 2)); 46 | let l = linkedlist![0,1,2]; 47 | println!("{:?}", Solution::rotate_right(l, 4)); 48 | let l = linkedlist![1,2]; 49 | println!("{:?}", Solution::rotate_right(l, 1)); 50 | } 51 | 52 | /* 53 | // Definition for singly-linked list. 54 | // #[derive(PartialEq, Eq, Debug)] 55 | // pub struct ListNode { 56 | // pub val: i32, 57 | // pub next: Option> 58 | // } 59 | // 60 | // impl ListNode { 61 | // #[inline] 62 | // fn new(val: i32) -> Self { 63 | // ListNode { 64 | // next: None, 65 | // val 66 | // } 67 | // } 68 | // } 69 | impl Solution { 70 | pub fn rotate_right(mut head: Option>, k: i32) -> Option> { 71 | use std::mem::swap; 72 | 73 | let len = Solution::len(&head); 74 | if k == 0 || len == 0 || k as usize % len == 0 { 75 | return head; 76 | } 77 | 78 | let mut node = &mut head; 79 | for _ in 0..(len - (k as usize % len) - 1) { 80 | if let Some(ref mut n) = node { 81 | node = &mut n.next; 82 | } 83 | } 84 | 85 | let mut new_head = None; 86 | if let Some(ref mut node) = node { 87 | swap(&mut node.next, &mut new_head); 88 | } 89 | 90 | // we have now cut the linked list in half 91 | // now we have to put it back together backwards 92 | 93 | if let Some(ref mut new_head) = new_head { 94 | let mut node = new_head; 95 | while let Some(ref mut next) = node.next { 96 | node = next; 97 | } 98 | node.next = head; 99 | } 100 | 101 | new_head 102 | } 103 | 104 | fn len(head: &Option>) -> usize { 105 | if let Some(ref n) = head { 106 | let mut len = 1; 107 | let mut node = n; 108 | while let Some(ref next) = node.next { 109 | len += 1; 110 | node = next; 111 | } 112 | len 113 | } 114 | else { 115 | 0 116 | } 117 | } 118 | } 119 | */ 120 | -------------------------------------------------------------------------------- /S0062-unique-paths/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0062-unique-paths" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0062-unique-paths/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn unique_paths(m: i32, n: i32) -> i32 { 5 | // C(m + n- 2) , (n-1) 6 | let mut res = 1i128; 7 | for i in 1..=(m+n-2) { 8 | res = res * (i as i128); 9 | // 放一个 for 循环里可以防止溢出 10 | if i <= n-1 { 11 | res = res / (i as i128); 12 | } else { 13 | res = res / ((i-n+1) as i128); 14 | } 15 | } 16 | return res as i32; 17 | } 18 | } 19 | 20 | fn main() { 21 | println!("{}", Solution::unique_paths(3,2)); 22 | println!("{}", Solution::unique_paths(6,2)); 23 | println!("{}", Solution::unique_paths(36,7)); 24 | } 25 | -------------------------------------------------------------------------------- /S0063-unique-paths-ii/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0064-unique-paths-ii" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0063-unique-paths-ii/src/main.rs: -------------------------------------------------------------------------------- 1 | 2 | struct Solution; 3 | impl Solution { 4 | pub fn unique_paths_with_obstacles(obstacle_grid: Vec>) -> i32 { 5 | 6 | let mut res = vec![vec![0;obstacle_grid[0].len()]; obstacle_grid.len()]; 7 | (0..obstacle_grid.len()).for_each(|i| { 8 | (0..obstacle_grid[0].len()).for_each(|j|{ 9 | if obstacle_grid[i][j] == 0 { 10 | if i == 0 && j == 0 { 11 | // do nothing 12 | if obstacle_grid[0][0] == 0 { 13 | res[0][0] = 1; 14 | } else { 15 | res[0][0] = 0; 16 | } 17 | } else if i == 0 { 18 | res[i][j] = res[i][j-1]; 19 | } else if j == 0 { 20 | res[i][j] = res[i-1][j]; 21 | } else { 22 | res[i][j] = res[i-1][j] + res[i][j-1]; 23 | } 24 | } else { 25 | res[i][j] = 0; 26 | } 27 | }) 28 | }); 29 | 30 | let (i,j) = (obstacle_grid.len() -1, obstacle_grid[0].len()-1); 31 | 32 | res[i][j] as i32 33 | } 34 | } 35 | 36 | fn main() { 37 | let input = vec![vec![0,0,0],vec![0,1,0],vec![0,0,0]]; 38 | println!("{:?}", Solution::unique_paths_with_obstacles(input)); 39 | let input = vec![vec![1,0]]; 40 | println!("{:?}", Solution::unique_paths_with_obstacles(input)); 41 | } -------------------------------------------------------------------------------- /S0066-plus-one/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0066" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0066-plus-one/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | impl Solution { 3 | pub fn plus_one(digits: Vec) -> Vec { 4 | let mut digits = digits; 5 | let mut cur = digits.len() as i32 - 1; 6 | let mut carry = 1; 7 | let mut res = vec![1]; 8 | while cur >= 0 { 9 | let prev = digits[cur as usize]; 10 | digits[cur as usize] = (prev + carry )% 10; 11 | if prev + carry >= 10 { 12 | carry = 1; 13 | } else { 14 | carry = 0; 15 | } 16 | cur -= 1; 17 | } 18 | if carry == 1 { 19 | res.append(&mut digits); 20 | return res; 21 | } 22 | return digits; 23 | } 24 | } 25 | 26 | fn main() { 27 | let x = Solution::plus_one(vec![1,2,3]); 28 | println!("{:?}",x); 29 | let x = Solution::plus_one(vec![1,2,9]); 30 | println!("{:?}",x); 31 | let x = Solution::plus_one(vec![9,9,9]); 32 | println!("{:?}",x); 33 | } 34 | -------------------------------------------------------------------------------- /S0067-add-binary/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0067" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0067-add-binary/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn add_binary(a: String, b: String) -> String { 5 | let (a, b) = ( 6 | a.chars().rev().collect::().into_bytes(), 7 | b.chars().rev().collect::().into_bytes(), 8 | ); 9 | 10 | let (mut res, mut idx, mut carry) = ("".to_string(), 0, 0); 11 | 12 | while a.get(idx).is_some() || b.get(idx).is_some() { 13 | let mut sum = carry; 14 | if a.get(idx).is_some() { 15 | sum += a.get(idx).unwrap() - 48; 16 | } 17 | if b.get(idx).is_some() { 18 | sum += b.get(idx).unwrap() - 48; 19 | } 20 | 21 | carry = sum / 2; 22 | if sum % 2 == 0 { 23 | res.push('0'); 24 | } else { 25 | res.push('1'); 26 | } 27 | 28 | idx = idx + 1; 29 | } 30 | 31 | if carry == 1 { 32 | res.push('1'); 33 | } 34 | return res.chars().rev().collect::(); 35 | } 36 | } 37 | 38 | fn main() { 39 | assert_eq!("100", Solution::add_binary("11".to_string(),"1".to_string())); 40 | println!( 41 | "{}", 42 | Solution::add_binary("111".to_string(), "1".to_string()) 43 | ); 44 | } 45 | -------------------------------------------------------------------------------- /S0069-sqrtx/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0069-sqrtx" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0069-sqrtx/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("Hello, world!"); 3 | } 4 | 5 | struct Solution; 6 | //https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division 7 | impl Solution { 8 | pub fn my_sqrt(x: i32) -> i32 { 9 | let x = x as f64; 10 | let (mut a1, mut a2) = (1.0f64, 0.0f64); 11 | 12 | while (a1 - a2).abs() >= 0.1 { 13 | a2 = a1; 14 | a1 = (a1 + x / a1) / 2.0; 15 | } 16 | a1 as i32 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /S0075-sort-colors/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0075-sort-colors" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0075-sort-colors/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn sort_colors(nums: &mut Vec) { 5 | if nums.len() <=1 { 6 | return; 7 | } 8 | let mut zero_pos = 0usize; 9 | let mut two_pos = nums.len()-1; 10 | let mut i =0; 11 | while i < nums.len() { 12 | //println!("zero_pos:{}, two_pos:{}, i:{}", zero_pos, two_pos, i); 13 | if nums[i] == 0 { 14 | nums.swap(i, zero_pos); 15 | zero_pos += 1; 16 | i = zero_pos; 17 | } else if nums[i] == 2 { 18 | nums.swap(i,two_pos); 19 | two_pos -= 1; 20 | i = zero_pos; 21 | } else { 22 | i+=1; 23 | } 24 | //println!("after zero_pos:{}, two_pos:{}, i:{}", zero_pos, two_pos, i); 25 | if zero_pos == two_pos || i > two_pos { 26 | break; 27 | } 28 | //println!("nums {:?}", nums); 29 | } 30 | } 31 | 32 | pub fn sort_colors2(nums: &mut Vec) { 33 | nums.sort(); 34 | } 35 | } 36 | 37 | fn main() { 38 | let mut nums = vec![1,2,0]; 39 | Solution::sort_colors(&mut nums); 40 | println!("{:?}", nums); 41 | let mut nums = vec![2]; 42 | Solution::sort_colors(&mut nums); 43 | println!("{:?}", nums); 44 | 45 | let mut nums = vec![0,2,1]; 46 | Solution::sort_colors(&mut nums); 47 | println!("{:?}", nums); 48 | } 49 | -------------------------------------------------------------------------------- /S0080-remove-duplicates-from-sorted-array-ii/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0080-remove-duplicates-from-sorted-array-ii" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0080-remove-duplicates-from-sorted-array-ii/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn remove_duplicates(nums: &mut Vec) -> i32 { 5 | if nums.len() == 0 { 6 | return 0; 7 | } 8 | let (mut cursor, mut i) = (0usize, 0usize); 9 | let mut counter = 0; 10 | let mut cur_val = nums[0]; 11 | while i < nums.len() { 12 | if nums[i] == cur_val { 13 | counter += 1; 14 | } else { 15 | counter = 1; 16 | cur_val = nums[i]; 17 | } 18 | 19 | match counter { 20 | 0 => println!("unreqchable"), 21 | 1 => { 22 | nums.swap(cursor,i); 23 | i+=1;cursor+=1; 24 | }, 25 | 2 => { 26 | nums.swap(cursor,i); 27 | i+=1;cursor+=1; 28 | }, 29 | _ => { 30 | // find next 31 | while i < nums.len() && nums[i] == cur_val { 32 | i+=1; 33 | } 34 | }, 35 | } 36 | 37 | } 38 | return cursor as i32; 39 | } 40 | } 41 | 42 | fn main() { 43 | let mut v = vec![1,1,1,2,2,3]; 44 | println!("{}", Solution::remove_duplicates(&mut v)); 45 | println!("{:?}", v); 46 | let mut v = vec![1,1,1,1,2,2,2,3,3]; 47 | println!("{}", Solution::remove_duplicates(&mut v)); 48 | println!("{:?}", v); 49 | let mut v = vec![]; 50 | println!("{}", Solution::remove_duplicates(&mut v)); 51 | println!("{:?}", v); 52 | let mut v = vec![1]; 53 | println!("{}", Solution::remove_duplicates(&mut v)); 54 | println!("{:?}", v); 55 | } 56 | 57 | /* 58 | 这个解法比我的慢 59 | use std::collections::HashMap; 60 | 61 | impl Solution { 62 | pub fn remove_duplicates(nums: &mut Vec) -> i32 { 63 | let mut m: HashMap = HashMap::new(); 64 | let mut i = 0; 65 | while i != nums.len() { 66 | let val = nums[i]; 67 | 68 | let v = m.get(&val).map_or(1, |x| x + 1); 69 | 70 | if v > 2 { 71 | nums.remove(i); 72 | } else { 73 | m.insert(val, v); 74 | i += 1; 75 | } 76 | } 77 | 78 | nums.len() as i32 79 | } 80 | } 81 | */ -------------------------------------------------------------------------------- /S0086-partition-list/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0086-partition-list" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0086-partition-list/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | // Definition for singly-linked list. 3 | #[derive(PartialEq, Eq, Debug)] 4 | pub struct ListNode { 5 | pub val: i32, 6 | pub next: Option>, 7 | } 8 | 9 | impl ListNode { 10 | #[inline] 11 | fn new(val: i32) -> Self { 12 | ListNode { next: None, val } 13 | } 14 | } 15 | impl Solution { 16 | pub fn partition(mut head: Option>, x: i32) -> Option> { 17 | if head.is_none() { 18 | return head; 19 | } 20 | 21 | // 遍历链表 22 | // 一个数组记小于的，另一个记大于等于的 23 | let (mut v_left, mut v_right) = (vec![], vec![]); 24 | let mut cur = head.unwrap(); 25 | loop { 26 | if cur.val < x { 27 | v_left.push(cur.val); 28 | } else { 29 | v_right.push(cur.val); 30 | } 31 | 32 | if cur.next.is_some() { 33 | cur = cur.next.unwrap(); 34 | } else { 35 | break; 36 | } 37 | } 38 | println!("{:?}, {:?}", v_left, v_right); 39 | let mut dummy = Box::new(ListNode::new(0)); 40 | let mut cursor = &mut dummy; 41 | for num in v_left { 42 | cursor.next = Some(Box::new(ListNode::new(num))); 43 | cursor = cursor.next.as_mut().unwrap(); 44 | } 45 | for num in v_right { 46 | cursor.next = Some(Box::new(ListNode::new(num))); 47 | cursor = cursor.next.as_mut().unwrap(); 48 | } 49 | return dummy.next; 50 | } 51 | } 52 | 53 | fn main() { 54 | println!("Hello, world!"); 55 | } 56 | -------------------------------------------------------------------------------- /S0092-reverse-linked-list-ii/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0092-reverse-linked-list-ii" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" -------------------------------------------------------------------------------- /S0092-reverse-linked-list-ii/src/main.rs: -------------------------------------------------------------------------------- 1 | use leetcode_prelude::*; 2 | fn main() { 3 | let l = linkedlist![1,2,3,4,5]; 4 | let x = Solution::reverse_between(l, 2,4); 5 | println!("{:?}", x); 6 | } 7 | 8 | // 本质上还是遍历了 1.x 遍 9 | // 好像没有办法像其它语言那样记录多个指针？ 10 | struct Solution; 11 | impl Solution { 12 | pub fn reverse_between(mut head: Option>, m: i32, n: i32) -> Option> { 13 | if head.is_none() { 14 | return head 15 | } 16 | let mut cur = &mut head; 17 | let mut cur_idx = 1; 18 | while cur_idx != m { 19 | cur_idx += 1; 20 | cur = &mut cur.as_mut().unwrap().next; 21 | } 22 | 23 | let mut prev = None; 24 | while cur_idx <= n { 25 | cur_idx += 1; 26 | // swap(prev, next) 27 | // prev == next 28 | std::mem::swap(&mut cur.as_mut().unwrap().next, &mut prev); 29 | // swap(prev, cur 30 | std::mem::swap(&mut prev, &mut cur); 31 | } 32 | 33 | let tail = std::mem::replace(cur, None); 34 | 35 | // connect mid and tail 36 | let mut mid_cur = &mut prev; 37 | while mid_cur.is_some() { 38 | mid_cur = &mut mid_cur.as_mut().unwrap().next; 39 | } 40 | std::mem::replace(mid_cur, tail); 41 | 42 | // connect head and mid 43 | let mut head_cur = &mut head; 44 | while head_cur.is_some() { 45 | head_cur = &mut head_cur.as_mut().unwrap().next; 46 | } 47 | std::mem::replace(head_cur, prev); 48 | 49 | head 50 | } 51 | } -------------------------------------------------------------------------------- /S0094-binary-tree-inorder-traversal/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0094" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0094-binary-tree-inorder-traversal/src/main.rs: -------------------------------------------------------------------------------- 1 | // 递归能写出来就不错了。。。。 2 | // Definition for a binary tree node. 3 | struct Solution; 4 | 5 | #[derive(Debug, PartialEq, Eq)] 6 | pub struct TreeNode { 7 | pub val: i32, 8 | pub left: Option>>, 9 | pub right: Option>>, 10 | } 11 | 12 | impl TreeNode { 13 | #[inline] 14 | pub fn new(val: i32) -> Self { 15 | TreeNode { 16 | val, 17 | left: None, 18 | right: None, 19 | } 20 | } 21 | } 22 | 23 | use std::cell::RefCell; 24 | use std::rc::Rc; 25 | impl Solution { 26 | pub fn inorder_traversal(root: Option>>) -> Vec { 27 | if root.is_none() { 28 | let res_vec: Vec = vec![]; 29 | return res_vec; 30 | } 31 | let val; 32 | let mut left_vec: Vec = vec![]; 33 | let mut right_vec: Vec = vec![]; 34 | unsafe { 35 | let root_ptr = root.as_ref().unwrap().as_ptr(); 36 | val = (*root_ptr).val; 37 | 38 | if let Some(l) = &(*root_ptr).left { 39 | left_vec = Solution::inorder_traversal(Some(Rc::clone(l))); 40 | } 41 | if let Some(r) = &(*root_ptr).right { 42 | right_vec = Solution::inorder_traversal(Some(Rc::clone(r))); 43 | } 44 | } 45 | 46 | // 左子树结果 + cur 节点值 + 右子树结果 47 | left_vec.push(val); 48 | left_vec.append(&mut right_vec); 49 | println!("{:?}", left_vec); 50 | println!("{:?}", root); 51 | return left_vec; 52 | } 53 | } 54 | 55 | fn main() { 56 | let mut r = TreeNode::new(1); 57 | r.left = Some(Rc::new(RefCell::new(TreeNode::new(2)))); 58 | r.right = Some(Rc::new(RefCell::new(TreeNode::new(3)))); 59 | let root = Some(Rc::new(RefCell::new(r))); 60 | println!("{:?}", root); 61 | Solution::inorder_traversal(root); 62 | } 63 | -------------------------------------------------------------------------------- /S0094-binary-tree-inorder-traversal/src/main2.rs: -------------------------------------------------------------------------------- 1 | // 递归能写出来就不错了。。。。 2 | // Definition for a binary tree node. 3 | struct Solution; 4 | 5 | #[derive(Debug, PartialEq, Eq)] 6 | pub struct TreeNode { 7 | pub val: i32, 8 | pub left: Option>>, 9 | pub right: Option>>, 10 | } 11 | 12 | impl TreeNode { 13 | #[inline] 14 | pub fn new(val: i32) -> Self { 15 | TreeNode { 16 | val, 17 | left: None, 18 | right: None, 19 | } 20 | } 21 | } 22 | 23 | use std::cell::RefCell; 24 | use std::rc::Rc; 25 | impl Solution { 26 | pub fn inorder_traversal(root: Option>>) -> Vec { 27 | if root.is_none() { 28 | let res_vec: Vec = vec![]; 29 | return res_vec; 30 | } 31 | let val; 32 | let mut left_vec: Vec = vec![]; 33 | let mut right_vec: Vec = vec![]; 34 | 35 | let root_ptr = root.as_ref().unwrap().borrow_mut(); 36 | val = root_ptr.val; 37 | 38 | if let Some(l) = &root_ptr.left { 39 | left_vec = Solution::inorder_traversal(Some(Rc::clone(l))); 40 | } 41 | if let Some(r) = &root_ptr.right { 42 | right_vec = Solution::inorder_traversal(Some(Rc::clone(r))); 43 | } 44 | 45 | // 把 borrow 的还回去 46 | drop(root_ptr); 47 | 48 | // 左子树结果 + cur 节点值 + 右子树结果 49 | left_vec.push(val); 50 | left_vec.append(&mut right_vec); 51 | println!("{:?}", left_vec); 52 | println!("{:?}", root); 53 | return left_vec; 54 | } 55 | } 56 | 57 | fn main() { 58 | let mut r = TreeNode::new(1); 59 | r.left = Some(Rc::new(RefCell::new(TreeNode::new(2)))); 60 | r.right = Some(Rc::new(RefCell::new(TreeNode::new(3)))); 61 | let root = Some(Rc::new(RefCell::new(r))); 62 | println!("{:?}", root); 63 | Solution::inorder_traversal(root); 64 | } 65 | -------------------------------------------------------------------------------- /S0100-same-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S100-same-tree" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0100-same-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | // Definition for a binary tree node. 2 | 3 | #[derive(Debug, PartialEq, Eq)] 4 | pub struct TreeNode { 5 | pub val: i32, 6 | pub left: Option>>, 7 | pub right: Option>>, 8 | } 9 | 10 | impl TreeNode { 11 | #[inline] 12 | pub fn new(val: i32) -> Self { 13 | TreeNode { 14 | val, 15 | left: None, 16 | right: None, 17 | } 18 | } 19 | } 20 | 21 | use std::cell::RefCell; 22 | use std::rc::Rc; 23 | struct Solution; 24 | 25 | impl Solution { 26 | pub fn is_same_tree( 27 | p: Option>>, 28 | q: Option>>, 29 | ) -> bool { 30 | match (p, q) { 31 | (Some(x), Some(y)) => { 32 | if x.borrow().val != y.borrow().val { 33 | return false; 34 | } 35 | 36 | let mut x_b = x.borrow_mut(); 37 | let mut y_b = y.borrow_mut(); 38 | return Solution::is_same_tree( 39 | x_b.left.take(), 40 | y_b.left.take(), 41 | ) && Solution::is_same_tree( 42 | x_b.right.take(), 43 | y_b.right.take(), 44 | ); 45 | } 46 | (Some(_), None) => return false, 47 | (None, Some(_)) => return false, 48 | (None, None) => return true, 49 | } 50 | return false; 51 | } 52 | } 53 | 54 | fn main() { 55 | let r1 = Some(Rc::new(RefCell::new(TreeNode::new(0)))); 56 | let r2 = Some(Rc::new(RefCell::new(TreeNode::new(0)))); 57 | println!("{}", Solution::is_same_tree(r1,r2)); 58 | } 59 | 60 | /* 61 | // leetcode 上的示例 62 | // Definition for a binary tree node. 63 | // #[derive(Debug, PartialEq, Eq)] 64 | // pub struct TreeNode { 65 | // pub val: i32, 66 | // pub left: Option>>, 67 | // pub right: Option>>, 68 | // } 69 | // 70 | // impl TreeNode { 71 | // #[inline] 72 | // pub fn new(val: i32) -> Self { 73 | // TreeNode { 74 | // val, 75 | // left: None, 76 | // right: None 77 | // } 78 | // } 79 | // } 80 | use std::rc::Rc; 81 | use std::cell::RefCell; 82 | impl Solution { 83 | pub fn is_same_tree(p: &mut Option>>, q: &mut Option>>) -> bool { 84 | if p.is_none() || q.is_none() { 85 | p.is_none() && q.is_none() 86 | } else { 87 | let mut left_subtree = p.as_mut().unwrap().borrow_mut(); 88 | let mut right_subtree = q.as_mut().unwrap().borrow_mut(); 89 | if left_subtree.val != right_subtree.val { 90 | return false; 91 | } 92 | if !Self::is_same_tree(&mut left_subtree.left, &mut right_subtree.left) { 93 | return false; 94 | } 95 | if !Self::is_same_tree(&mut left_subtree.right, &mut right_subtree.right) { 96 | return false; 97 | } 98 | 99 | true 100 | } 101 | } 102 | } 103 | */ -------------------------------------------------------------------------------- /S0101-symmetric-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0101-symmetric-tree" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" 9 | -------------------------------------------------------------------------------- /S0101-symmetric-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | 4 | // Definition for a binary tree node. 5 | // #[derive(Debug, PartialEq, Eq)] 6 | // pub struct TreeNode { 7 | // pub val: i32, 8 | // pub left: Option>>, 9 | // pub right: Option>>, 10 | // } 11 | // 12 | // impl TreeNode { 13 | // #[inline] 14 | // pub fn new(val: i32) -> Self { 15 | // TreeNode { 16 | // val, 17 | // left: None, 18 | // right: None 19 | // } 20 | // } 21 | // } 22 | use std::cell::RefCell; 23 | use std::rc::Rc; 24 | impl Solution { 25 | fn symmetric(l: Option>>, r: Option>>) -> bool { 26 | match (l.as_ref(), r.as_ref()) { 27 | (None, None) => return true, 28 | (Some(x), Some(y)) => { 29 | if x.borrow_mut().val != y.borrow_mut().val { 30 | return false; 31 | } 32 | let (mut x_b, mut y_b) = (x.borrow_mut(), y.borrow_mut()); 33 | // 左 = 右，右 = 左 34 | return Solution::symmetric( 35 | x_b.left.take(), 36 | y_b.right.take(), 37 | ) && Solution::symmetric( 38 | x_b.right.take(), 39 | y_b.left.take(), 40 | ); 41 | } 42 | (_, _) => return false, 43 | } 44 | } 45 | 46 | pub fn is_symmetric(root: Option>>) -> bool { 47 | if root.is_none() { 48 | return true; 49 | } 50 | 51 | let mut r_b = root.as_ref().unwrap().borrow_mut(); 52 | let (l, r) = (r_b.left.take(), r_b.right.take()); 53 | return Solution::symmetric(l, r); 54 | } 55 | } 56 | fn main() { 57 | let l = btree![1,2,2,3,4,4,3]; 58 | println!("{}", Solution::is_symmetric(l)); 59 | } 60 | 61 | 62 | /* 63 | use std::cell::RefCell; 64 | use std::rc::Rc; 65 | impl Solution { 66 | pub fn is_symmetric(root: Option>>) -> bool { 67 | Self::is_mirror(root.clone(), root) 68 | } 69 | 70 | fn is_mirror(t1: Option>>, t2: Option>>) -> bool { 71 | match (t1, t2) { 72 | (Some(t1), Some(t2)) => { 73 | t1.borrow().val == t2.borrow().val 74 | && Self::is_mirror(t1.borrow().left.clone(), t2.borrow().right.clone()) 75 | && Self::is_mirror(t1.borrow().right.clone(), t2.borrow().left.clone()) 76 | } 77 | (None, None) => true, 78 | _ => false, 79 | } 80 | } 81 | } 82 | */ -------------------------------------------------------------------------------- /S0104-maximum-depth-of-binary-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0104-maximum-depth-of-binary-tree" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0104-maximum-depth-of-binary-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | // Definition for a binary tree node. 3 | // #[derive(Debug, PartialEq, Eq)] 4 | pub struct TreeNode { 5 | pub val: i32, 6 | pub left: Option>>, 7 | pub right: Option>>, 8 | } 9 | 10 | impl TreeNode { 11 | #[inline] 12 | pub fn new(val: i32) -> Self { 13 | TreeNode { 14 | val, 15 | left: None, 16 | right: None 17 | } 18 | } 19 | } 20 | use std::rc::Rc; 21 | use std::cell::RefCell; 22 | impl Solution { 23 | pub fn max_depth(root: Option>>) -> i32 { 24 | let mut max_depth = 0; 25 | Solution::traverse(root, &mut max_depth, 0); 26 | return max_depth; 27 | } 28 | 29 | fn traverse(n:Option>>, max_depth : &mut i32, parent_depth : i32) { 30 | if n.is_none() { 31 | return 32 | } 33 | 34 | if parent_depth+1 > *max_depth { 35 | *max_depth = parent_depth +1; 36 | } 37 | 38 | let mut n_b = n.as_ref().unwrap().borrow_mut(); 39 | let (mut l, mut r) = (n_b.left.clone(), n_b.right.clone()); 40 | Solution::traverse(l, max_depth, parent_depth+1); 41 | Solution::traverse(r, max_depth, parent_depth+1); 42 | } 43 | } 44 | 45 | fn main() { 46 | println!("Hello, world!"); 47 | } 48 | 49 | 50 | /* 51 | use std::rc::Rc; 52 | use std::cell::RefCell; 53 | use std::cmp::max; 54 | impl Solution { 55 | pub fn max_depth(root: Option>>) -> i32 { 56 | max_depth_ref(&root) 57 | } 58 | } 59 | 60 | pub fn max_depth_ref(root: &Option>>) -> i32 { 61 | match root { 62 | Some(node) => { 63 | max( 64 | max_depth_ref(&node.borrow().left), 65 | max_depth_ref(&node.borrow().right), 66 | ) + 1 67 | } 68 | None => 0, 69 | } 70 | } 71 | */ -------------------------------------------------------------------------------- /S0105-construct-binary-tree-from-preorder-and-inorder-traversal/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0105-construct-binary-tree-from-preorder-and-inorder-traversal" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude= "^0.1" 9 | -------------------------------------------------------------------------------- /S0105-construct-binary-tree-from-preorder-and-inorder-traversal/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | // Definition for a binary tree node. 4 | // #[derive(Debug, PartialEq, Eq)] 5 | // pub struct TreeNode { 6 | // pub val: i32, 7 | // pub left: Option>>, 8 | // pub right: Option>>, 9 | // } 10 | // 11 | // impl TreeNode { 12 | // #[inline] 13 | // pub fn new(val: i32) -> Self { 14 | // TreeNode { 15 | // val, 16 | // left: None, 17 | // right: None 18 | // } 19 | // } 20 | // } 21 | use std::cell::RefCell; 22 | use std::rc::Rc; 23 | impl Solution { 24 | pub fn build_tree(preorder: Vec, inorder: Vec) -> Option>> { 25 | if preorder.len() == 0 { 26 | return None; 27 | } 28 | let head_val = preorder[0]; 29 | 30 | let pos = inorder.iter().position(|&v| v == head_val).unwrap(); 31 | let (left, right) = inorder.split_at(pos); 32 | let (left, right) = (left.to_vec(), right[1..].to_vec()); 33 | 34 | // preorder also need to split 35 | let (left_pre, right_pre) = ( 36 | preorder[1..=left.len()].to_vec(), 37 | preorder[(left.len() + 1)..].to_vec(), 38 | ); 39 | 40 | let left_tree = Solution::build_tree(left_pre, left); 41 | let right_tree = Solution::build_tree(right_pre, right); 42 | 43 | Some(Rc::new(RefCell::new(TreeNode { 44 | val: head_val, 45 | left: left_tree, 46 | right: right_tree, 47 | }))) 48 | } 49 | } 50 | 51 | fn main() { 52 | println!( 53 | "{:?}", 54 | Solution::build_tree(vec![3, 9, 20, 15, 7], vec![9, 3, 15, 20, 7]) 55 | ); 56 | } 57 | -------------------------------------------------------------------------------- /S0106-construct-binary-tree-from-inorder-and-postorder-traversal/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0106-construct-binary-tree-from-inorder-and-postorder-traversal" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" 9 | -------------------------------------------------------------------------------- /S0106-construct-binary-tree-from-inorder-and-postorder-traversal/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | // Definition for a binary tree node. 4 | // #[derive(Debug, PartialEq, Eq)] 5 | // pub struct TreeNode { 6 | // pub val: i32, 7 | // pub left: Option>>, 8 | // pub right: Option>>, 9 | // } 10 | // 11 | // impl TreeNode { 12 | // #[inline] 13 | // pub fn new(val: i32) -> Self { 14 | // TreeNode { 15 | // val, 16 | // left: None, 17 | // right: None 18 | // } 19 | // } 20 | // } 21 | use std::cell::RefCell; 22 | use std::rc::Rc; 23 | impl Solution { 24 | pub fn build_tree(inorder: Vec, postorder: Vec) -> Option>> { 25 | if postorder.len() == 0 { 26 | return None; 27 | } 28 | 29 | let head_val = postorder[postorder.len() - 1]; 30 | 31 | let pos = inorder.iter().position(|&x| x == head_val).unwrap(); 32 | let (left, right) = inorder.split_at(pos); 33 | let (left, right) = (left.to_vec(), right[1..].to_vec()); 34 | 35 | let (left_post, right_post) = ( 36 | postorder[0..left.len()].to_vec(), 37 | postorder[left.len()..postorder.len() - 1].to_vec(), 38 | ); 39 | //println!("{:?},{:?},{:?},{:?},{:?},{:?}", inorder,postorder,left,left_post, right,right_post); 40 | 41 | let (left_tree, right_tree) = ( 42 | Solution::build_tree(left, left_post), 43 | Solution::build_tree(right, right_post), 44 | ); 45 | //println!("left:{:?}, right:{:?}", left_tree, right_tree); 46 | 47 | Some(Rc::new(RefCell::new(TreeNode { 48 | val: head_val, 49 | left: left_tree, 50 | right: right_tree, 51 | }))) 52 | } 53 | } 54 | 55 | fn main() { 56 | println!( 57 | "{:?}", 58 | Solution::build_tree(vec![9, 3, 15, 20, 7], vec![9, 15, 7, 20, 3]) 59 | ); 60 | } 61 | -------------------------------------------------------------------------------- /S0114-flatten-binary-tree-to-linked-list/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0114-flatten-binary-tree-to-linked-list" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" 9 | -------------------------------------------------------------------------------- /S0114-flatten-binary-tree-to-linked-list/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | 4 | // Definition for a binary tree node. 5 | //#[derive(Debug, PartialEq, Eq)] 6 | //pub struct TreeNode { 7 | // pub val: i32, 8 | // pub left: Option>>, 9 | // pub right: Option>>, 10 | //} 11 | // 12 | //impl TreeNode { 13 | // #[inline] 14 | // pub fn new(val: i32) -> Self { 15 | // TreeNode { 16 | // val, 17 | // left: None, 18 | // right: None 19 | // } 20 | // } 21 | //} 22 | 23 | type Node = Option>>; 24 | 25 | use std::cell::RefCell; 26 | use std::rc::Rc; 27 | 28 | /* 29 | 学习大佬的写法 30 | impl Solution { 31 | pub fn flatten(root: &mut Node) { 32 | fn core(node: &mut Node, mut next: Node) -> Node { 33 | if let Some(node) = node { 34 | next = core(&mut node.borrow_mut().right, next); 35 | next = core(&mut node.borrow_mut().left, next); 36 | node.borrow_mut().right = next; 37 | node.borrow_mut().left = None; 38 | next = Some(node.clone()); 39 | } 40 | next 41 | } 42 | core(root, None); 43 | } 44 | } 45 | */ 46 | 47 | impl Solution { 48 | pub fn flatten(root: &mut Node) { 49 | if root.is_none() { 50 | return; 51 | }; 52 | 53 | let mut r = root.as_ref().unwrap().borrow_mut(); 54 | Solution::flatten(&mut r.left); 55 | Solution::flatten(&mut r.right); 56 | 57 | let left = r.left.take(); 58 | let right = r.right.take(); 59 | 60 | match (left.as_ref(), right.as_ref()) { 61 | (None, _) => { 62 | // take 消耗了 option，所以要赋值回去 63 | r.right = right; 64 | return; 65 | } 66 | (_, None) => { 67 | r.right = Some(Rc::clone(&left.unwrap())); 68 | return; 69 | } 70 | (Some(_), Some(_)) => { 71 | let (left, right) = (left.unwrap(), right.unwrap()); 72 | r.right = Some(Rc::clone(&left)); 73 | // 这里也可以不要 cursor 的 74 | let mut cursor = left; 75 | loop { 76 | let mut next; 77 | match cursor.borrow_mut().right { 78 | Some(ref node) => { 79 | next = Rc::clone(node); 80 | } 81 | None => { 82 | break; 83 | } 84 | } 85 | cursor = next; 86 | } 87 | 88 | cursor.borrow_mut().right = Some(Rc::clone(&right)); 89 | } 90 | } 91 | } 92 | } 93 | 94 | fn main() { 95 | let mut l = btree![1, 2, 5, 3, 4, null, 6]; 96 | println!("{:?}", l); 97 | Solution::flatten(&mut l); 98 | println!("{:?}", l); 99 | 100 | let mut l = btree![1, 2]; 101 | println!("{:?}", l); 102 | Solution::flatten(&mut l); 103 | println!("{:?}", l); 104 | } 105 | -------------------------------------------------------------------------------- /S0125-valid-palindrome/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0125-valid-palindrome" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0125-valid-palindrome/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | impl Solution { 3 | pub fn is_palindrome(s: String) -> bool { 4 | let s = s.as_bytes().to_ascii_lowercase(); 5 | let mut trimed: Vec = vec![]; 6 | for i in 0..s.len() { 7 | if s[i] >= 'a' as u8 && s[i] <= 'z' as u8 { 8 | trimed.push(s[i]); 9 | } 10 | if s[i] >= '0' as u8 && s[i] <= '9' as u8 { 11 | trimed.push(s[i]); 12 | } 13 | } 14 | 15 | for i in 0..(trimed.len() / 2) { 16 | if trimed[i] != trimed[trimed.len() - i - 1] { 17 | return false; 18 | } 19 | } 20 | true 21 | } 22 | } 23 | 24 | fn main() { 25 | assert_eq!( 26 | true, 27 | Solution::is_palindrome("A man, a plan, a canal: Panama".to_string()) 28 | ); 29 | } 30 | 31 | /* 32 | impl Solution { 33 | pub fn is_palindrome(s: String) -> bool { 34 | let s = s 35 | .bytes() 36 | .filter_map(|b| { 37 | if b.is_ascii_alphanumeric() { 38 | Some(b.to_ascii_lowercase()) 39 | } else { 40 | None 41 | } 42 | }) 43 | .collect::>(); 44 | for i in 0..s.len() / 2 { 45 | if s[i] != s[s.len() - i - 1] { 46 | return false; 47 | } 48 | } 49 | true 50 | } 51 | } 52 | */ 53 | -------------------------------------------------------------------------------- /S0128-longest-consecutive-sequence/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0128-longest-consecutive-sequence" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0128-longest-consecutive-sequence/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | use std::collections::HashMap; 4 | use std::collections::HashSet; 5 | 6 | #[derive(Clone, Debug)] 7 | struct Bounds { 8 | pub lower_bound: i32, 9 | pub upper_bound: i32, 10 | } 11 | 12 | impl Solution { 13 | pub fn longest_consecutive(nums: Vec) -> i32 { 14 | // 记录每个元素对应的上界、下界 15 | // 如果两个元素相连的话，那么这两个元素对应的上下界一定能连起来 16 | let mut bounds_m: HashMap = HashMap::new(); 17 | 18 | // 记录出现过的元素，如果元素之前出现过，没必要再处理了 19 | let mut record_m: HashSet = HashSet::new(); 20 | let mut max_len = 0; 21 | for num in nums { 22 | if record_m.contains(&num) { 23 | continue; 24 | } 25 | 26 | let left = num - 1; 27 | let right = num + 1; 28 | let mut new_bounds = Bounds { 29 | upper_bound: num, 30 | lower_bound: num, 31 | }; 32 | 33 | if bounds_m.contains_key(&left) { 34 | let left_bounds = bounds_m.get(&left).unwrap(); 35 | if left_bounds.upper_bound >= num { 36 | continue; 37 | } 38 | 39 | if left_bounds.upper_bound == left { 40 | // 可以合并 41 | new_bounds.lower_bound = left_bounds.lower_bound; 42 | bounds_m.remove(&left); 43 | } 44 | } 45 | 46 | if bounds_m.contains_key(&right) { 47 | let right_bounds = bounds_m.get(&right).unwrap(); 48 | if right_bounds.lower_bound <= num { 49 | continue; 50 | } 51 | 52 | if right_bounds.lower_bound == right { 53 | new_bounds.upper_bound = right_bounds.upper_bound; 54 | bounds_m.remove(&right); 55 | } 56 | } 57 | 58 | bounds_m.insert(new_bounds.lower_bound, new_bounds.clone()); 59 | bounds_m.insert(new_bounds.upper_bound, new_bounds.clone()); 60 | max_len = max_len.max(new_bounds.upper_bound - new_bounds.lower_bound + 1); 61 | record_m.insert(num); 62 | } 63 | 64 | max_len 65 | } 66 | } 67 | 68 | fn main() { 69 | dbg!(Solution::longest_consecutive(vec![100, 4, 200, 1, 3, 2])); 70 | } 71 | 72 | 73 | /* 74 | use std::collections::HashSet; 75 | impl Solution { 76 | pub fn longest_consecutive(nums: Vec) -> i32 { 77 | let mut set = nums.iter().cloned().collect::>(); 78 | let mut max_len = 0; 79 | for val in nums.into_iter() { 80 | if !set.contains(&val) 81 | { 82 | continue; 83 | } 84 | set.remove(&val); 85 | let mut prev = val - 1; 86 | let mut next = val + 1; 87 | while set.contains(&prev) { 88 | set.remove(&prev); 89 | prev -= 1; 90 | } 91 | while set.contains(&next) { 92 | set.remove(&next); 93 | next += 1; 94 | } 95 | max_len = max_len.max(next - prev - 1); 96 | } 97 | max_len 98 | } 99 | } 100 | */ -------------------------------------------------------------------------------- /S0144-binary-tree-preorder-traversal/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0144-binary-tree-preorder-traversal" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0144-binary-tree-preorder-traversal/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("Hello, world!"); 3 | } 4 | 5 | // Definition for a binary tree node. 6 | #[derive(Debug, PartialEq, Eq)] 7 | pub struct TreeNode { 8 | pub val: i32, 9 | pub left: Option>>, 10 | pub right: Option>>, 11 | } 12 | 13 | impl TreeNode { 14 | #[inline] 15 | pub fn new(val: i32) -> Self { 16 | TreeNode { 17 | val, 18 | left: None, 19 | right: None, 20 | } 21 | } 22 | } 23 | struct Solution; 24 | 25 | use std::cell::RefCell; 26 | use std::rc::Rc; 27 | impl Solution { 28 | pub fn preorder_traversal(root: Option>>) -> Vec { 29 | let mut res = vec![]; 30 | Solution::traverse(root, &mut |x: i32| res.push(x)); 31 | res 32 | } 33 | 34 | pub fn traverse(root: Option>>, consumer: &mut impl FnMut(i32)) { 35 | if root.is_none() { 36 | return; 37 | } 38 | let r_b = root.as_ref().unwrap().borrow_mut(); 39 | consumer(r_b.val); 40 | 41 | Solution::traverse(r_b.left.clone(), consumer); 42 | Solution::traverse(r_b.right.clone(), consumer); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /S0145-binary-tree-postorder-traversal/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0144-binary-tree-preorder-traversal" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0145-binary-tree-postorder-traversal/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("Hello, world!"); 3 | } 4 | 5 | // Definition for a binary tree node. 6 | #[derive(Debug, PartialEq, Eq)] 7 | pub struct TreeNode { 8 | pub val: i32, 9 | pub left: Option>>, 10 | pub right: Option>>, 11 | } 12 | 13 | impl TreeNode { 14 | #[inline] 15 | pub fn new(val: i32) -> Self { 16 | TreeNode { 17 | val, 18 | left: None, 19 | right: None, 20 | } 21 | } 22 | } 23 | struct Solution; 24 | 25 | use std::cell::RefCell; 26 | use std::rc::Rc; 27 | impl Solution { 28 | pub fn postorder_traversal(root: Option>>) -> Vec { 29 | let mut res = vec![]; 30 | Solution::traverse(root, &mut |x: i32| res.push(x)); 31 | res 32 | } 33 | 34 | pub fn traverse(root: Option>>, consumer: &mut impl FnMut(i32)) { 35 | if root.is_none() { 36 | return; 37 | } 38 | let r_b = root.as_ref().unwrap().borrow_mut(); 39 | 40 | Solution::traverse(r_b.left.clone(), consumer); 41 | Solution::traverse(r_b.right.clone(), consumer); 42 | consumer(r_b.val); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /S0150-evaluate-reverse-polish-notation/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0150-evaluate-reverse-polish-notation" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0150-evaluate-reverse-polish-notation/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn eval_rpn(tokens: Vec) -> i32 { 5 | let mut num_stack: Vec = vec![]; 6 | for token in tokens { 7 | match token.as_str() { 8 | "+" | "-" | "*" | "/" => { 9 | let rop: i32 = num_stack.pop().unwrap().parse().unwrap(); 10 | let lop: i32 = num_stack.pop().unwrap().parse().unwrap(); 11 | let result = match token.as_str() { 12 | "+" => lop + rop, 13 | "-" => lop - rop, 14 | "*" => lop * rop, 15 | "/" => lop / rop, 16 | _ => 0, 17 | }; 18 | num_stack.push(result.to_string()); 19 | } 20 | _ => { 21 | num_stack.push(token); 22 | } 23 | } 24 | } 25 | num_stack.pop().unwrap().parse().unwrap() 26 | } 27 | } 28 | 29 | fn main() { 30 | println!("{}", Solution::eval_rpn(vec!["2".to_string(), "1".to_string(), "+".to_string(), "3".to_string(), "*".to_string()])); 31 | println!("{}", Solution::eval_rpn(vec!["0".to_string(), "3".to_string(),"/".to_string()])) 32 | } 33 | 34 | /* 35 | impl Solution { 36 | pub fn eval_rpn(tokens: Vec) -> i32 { 37 | let mut nums = vec![]; 38 | for ref s in tokens { 39 | let s = s as &str; 40 | match s { 41 | "+" | "-" | "*" | "/" => { 42 | let (y, x) = (nums.pop().unwrap(), nums.pop().unwrap()); 43 | let ans = match s { 44 | "+" => x + y, 45 | "-" => x - y, 46 | "*" => x * y, 47 | "/" => x / y, 48 | _ => unreachable!(), 49 | }; 50 | nums.push(ans); 51 | }, 52 | _ => nums.push(s.parse::().unwrap()), 53 | } 54 | } 55 | nums[0] 56 | } 57 | } 58 | */ -------------------------------------------------------------------------------- /S0165-compare-version-numbers/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0165-compare-version-numbers" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /S0165-compare-version-numbers/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("Hello, world!"); 3 | } 4 | 5 | /* 6 | * @lc app=leetcode.cn id=165 lang=rust 7 | * 8 | * [165] 比较版本号 9 | */ 10 | impl Solution { 11 | pub fn compare_version(version1: String, version2: String) -> i32 { 12 | let (v1, v2) = ( 13 | version1 14 | .split(".") 15 | .map(|x| x.parse::().unwrap()) 16 | .collect::>(), 17 | version2 18 | .split(".") 19 | .map(|x| x.parse::().unwrap()) 20 | .collect::>(), 21 | ); 22 | for i in 0..(v1.len().max(v2.len())) { 23 | match (v1.get(i), v2.get(i)) { 24 | (Some(v1i), Some(v2i)) => { 25 | if v1i > v2i { 26 | return 1; 27 | } 28 | if v1i < v2i { 29 | return -1; 30 | } 31 | } 32 | (Some(v1i), None) => { 33 | if v1i > &0 { 34 | return 1; 35 | } 36 | } 37 | (None, Some(v2i)) => { 38 | if v2i > &0 { 39 | return -1; 40 | } 41 | } 42 | _ => {} 43 | } 44 | } 45 | 46 | 0 47 | } 48 | } 49 | 50 | -------------------------------------------------------------------------------- /S0179-largest-number/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0179" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0179-largest-number/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | use std::cmp::Ordering; 4 | impl Solution { 5 | pub fn largest_number(nums: Vec) -> String { 6 | let mut nums = nums; 7 | nums.sort_by(|a,b|{ 8 | Solution::cmp(a,b) 9 | }); 10 | let mut is_all_zero = true; 11 | let mut res = "".to_string(); 12 | for num in nums { 13 | if num > 0 { 14 | is_all_zero = false; 15 | } 16 | res = res + &num.to_string(); 17 | } 18 | 19 | if is_all_zero == true { 20 | return "0".to_string(); 21 | } 22 | 23 | return res; 24 | } 25 | 26 | fn cmp(a : &i32, b :&i32) -> Ordering { 27 | // a 和 b 小于 10 的时候，后面算出来的 pow 有问题，看一下怎么回事 28 | let mut a_pow = (10.0 as f64).powi((*a as f32).log(10.0) as i32+1) as i128; 29 | let mut b_pow = (10.0 as f64).powi((*b as f32).log(10.0) as i32+1) as i128; 30 | let (a,b) = (*a as i128,*b as i128); 31 | if a == 0 { a_pow = 10}; 32 | if b == 0 { b_pow = 10}; 33 | //println!("{},{},{},{},{},{}",a,b,a_pow,b_pow,a*b_pow+b, b*a_pow+a); 34 | if a * b_pow + b > b * a_pow + a { 35 | return Ordering::Less; 36 | } 37 | if a * b_pow + b < b * a_pow + a { 38 | return Ordering::Greater; 39 | } 40 | return Ordering::Equal; 41 | } 42 | } 43 | 44 | fn main() { 45 | println!("{}", Solution::largest_number(vec![10,2])); 46 | println!("{}", Solution::largest_number(vec![3,30,34,5,9])); 47 | println!("{}", Solution::largest_number(vec![999999998,999999997,999999999])); 48 | println!("{}", Solution::largest_number(vec![1,2,3,4,5,6,7,8,9,0])); 49 | } 50 | -------------------------------------------------------------------------------- /S0199-binary-tree-right-side-view/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0199-binary-tree-right-side-view" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" -------------------------------------------------------------------------------- /S0199-binary-tree-right-side-view/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | 4 | // Definition for a binary tree node. 5 | // #[derive(Debug, PartialEq, Eq)] 6 | // pub struct TreeNode { 7 | // pub val: i32, 8 | // pub left: Option>>, 9 | // pub right: Option>>, 10 | // } 11 | // 12 | // impl TreeNode { 13 | // #[inline] 14 | // pub fn new(val: i32) -> Self { 15 | // TreeNode { 16 | // val, 17 | // left: None, 18 | // right: None 19 | // } 20 | // } 21 | // } 22 | 23 | use std::cell::RefCell; 24 | use std::rc::Rc; 25 | impl Solution { 26 | pub fn right_side_view(root: Option>>) -> Vec { 27 | if root.is_none() { 28 | return vec![]; 29 | } 30 | 31 | let mut current_level = vec![root]; 32 | let mut res = vec![]; 33 | loop { 34 | let last_node = ¤t_level[current_level.len() - 1]; 35 | res.push(last_node.as_ref().unwrap().borrow_mut().val); 36 | 37 | let mut next_level = vec![]; 38 | for n in current_level { 39 | let mut n_r_b = n.as_ref().unwrap().borrow_mut(); 40 | if n_r_b.left.is_some() { 41 | next_level.push(n_r_b.left.take()); 42 | } 43 | if n_r_b.right.is_some() { 44 | next_level.push(n_r_b.right.take()); 45 | } 46 | } 47 | if next_level.len() == 0 { 48 | break; 49 | } 50 | current_level = next_level; 51 | } 52 | res 53 | } 54 | } 55 | fn main() { 56 | let mut b = btree![1, 2, 3, null, 5, null, 4]; 57 | println!("{:?}", Solution::right_side_view(b)); 58 | } 59 | -------------------------------------------------------------------------------- /S0203-remove-linked-list-elements/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0203-remove-linked-list-elements" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0203-remove-linked-list-elements/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("Hello, world!"); 3 | } 4 | 5 | // Definition for singly-linked list. 6 | #[derive(PartialEq, Eq, Debug)] 7 | pub struct ListNode { 8 | pub val: i32, 9 | pub next: Option> 10 | } 11 | 12 | impl ListNode { 13 | #[inline] 14 | fn new(val: i32) -> Self { 15 | ListNode { 16 | next: None, 17 | val 18 | } 19 | } 20 | } 21 | 22 | struct Solution; 23 | 24 | impl Solution { 25 | pub fn remove_elements(mut head: Option>, val: i32) -> Option> { 26 | while head.is_some() && head.as_ref().unwrap().val == val { 27 | head = head.unwrap().next; 28 | } 29 | if head.is_none() { 30 | return head 31 | } 32 | 33 | let mut cur = &mut head; 34 | while cur.as_ref().unwrap().next.is_some() { 35 | if cur.as_ref().unwrap().next.as_ref().unwrap().val == val { 36 | let next= std::mem::replace(&mut cur.as_mut().unwrap().next, None); 37 | std::mem::replace(&mut cur.as_mut().unwrap().next, next.unwrap().next); 38 | continue; 39 | } 40 | cur = &mut cur.as_mut().unwrap().next; 41 | } 42 | 43 | return head; 44 | } 45 | } 46 | 47 | /* 48 | use std::mem; 49 | impl Solution { 50 | pub fn remove_elements(mut head: Option>, val: i32) -> Option> { 51 | let mut cur = &mut head; 52 | while cur.is_some() { 53 | match cur.as_ref() { 54 | Some(node) if node.val == val => { 55 | let mut move_out = cur.take(); 56 | mem::swap(cur, &mut move_out.as_mut().unwrap().next); 57 | continue; 58 | } 59 | _ => {} 60 | } 61 | cur = &mut cur.as_mut().unwrap().next; 62 | } 63 | head 64 | } 65 | } 66 | */ 67 | 68 | /* 69 | 这个很优雅 70 | impl Solution { 71 | pub fn remove_elements(head: Option>, val: i32) -> Option> { 72 | let mut dummy = ListNode{val:0, next:head}; 73 | let mut p = &mut dummy; 74 | while let Some(q) = p.next.as_mut() { 75 | if q.val == val { 76 | p.next = q.next.take(); 77 | }else{ 78 | p = p.next.as_mut().unwrap(); 79 | } 80 | } 81 | 82 | dummy.next 83 | } 84 | } 85 | */ -------------------------------------------------------------------------------- /S0206-reverse-linked-list/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0206-reverse-linked-list" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="0.1" 9 | -------------------------------------------------------------------------------- /S0206-reverse-linked-list/src/main.rs: -------------------------------------------------------------------------------- 1 | use leetcode_prelude::*; 2 | fn main() { 3 | let l = linkedlist![1,2,3,4]; 4 | println!("{:?}", Solution::reverse_list(l)); 5 | } 6 | 7 | impl Solution { 8 | pub fn reverse_list(mut head: Option>) -> Option> { 9 | let cur = &mut head; 10 | let mut prev = None; 11 | while cur.is_some() { 12 | let mut cur_next = std::mem::replace(&mut cur.as_mut().unwrap().next, prev.take()); 13 | prev = cur.take(); 14 | std::mem::swap(&mut cur_next, cur); 15 | } 16 | 17 | prev 18 | } 19 | } 20 | struct Solution; 21 | 22 | /* 23 | impl Solution { 24 | pub fn reverse_list(head: Option>) -> Option> { 25 | let mut head = head; //move 26 | let mut new_head:Option> = None; 27 | loop { 28 | if head.is_none() { 29 | break; 30 | } 31 | let val = head.as_mut().unwrap().val; 32 | let mut new_node = ListNode::new(val); 33 | if new_head.is_some() { 34 | new_node.next = new_head; 35 | } 36 | new_head = Some(Box::new(new_node)); 37 | head = head.unwrap().next; 38 | } 39 | new_head 40 | } 41 | } 42 | */ -------------------------------------------------------------------------------- /S0222-count-complete-tree-nodes/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0222-count-complete-tree-nodes" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0222-count-complete-tree-nodes/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | // Definition for a binary tree node. 4 | #[derive(Debug, PartialEq, Eq)] 5 | pub struct TreeNode { 6 | pub val: i32, 7 | pub left: Option>>, 8 | pub right: Option>>, 9 | } 10 | 11 | impl TreeNode { 12 | #[inline] 13 | pub fn new(val: i32) -> Self { 14 | TreeNode { 15 | val, 16 | left: None, 17 | right: None 18 | } 19 | } 20 | } 21 | use std::rc::Rc; 22 | use std::cell::RefCell; 23 | impl Solution { 24 | pub fn count_nodes(mut root: Option>>) -> i32 { 25 | if root.is_none() { 26 | return 0; 27 | } 28 | let mut r_b = root.as_ref().unwrap().borrow_mut(); 29 | let (mut l, mut r ) = (r_b.left.take(), r_b.right.take()); 30 | return Solution::count_nodes(l) + Solution::count_nodes(r) + 1; 31 | } 32 | } 33 | 34 | fn main() { 35 | println!("Hello, world!"); 36 | } 37 | -------------------------------------------------------------------------------- /S0224-basic-calculator/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0224-basic-calculator" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0225-implement-stack-using-queues/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0225-implement-stack-using-queues" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0225-implement-stack-using-queues/src/main.rs: -------------------------------------------------------------------------------- 1 | struct MyStack { 2 | queue: LinkedList, 3 | } 4 | use std::collections::LinkedList; 5 | 6 | /** You can modify the type of `self` for your need. */ 7 | impl MyStack { 8 | /** Initialize your data structure here. */ 9 | fn new() -> Self { 10 | return MyStack { 11 | queue: LinkedList::new(), 12 | }; 13 | } 14 | /** Push element x onto stack. */ 15 | 16 | fn push(&mut self, x: i32) { 17 | self.queue.push_back(x); 18 | } 19 | 20 | /** Removes the element on top of the stack and returns that element. */ 21 | 22 | fn pop(&mut self) -> i32 { 23 | return self.queue.pop_back().unwrap(); 24 | } 25 | /** Get the top element. */ 26 | 27 | fn top(&mut self) -> i32 { 28 | let n = self.queue.pop_back().unwrap(); 29 | self.queue.push_back(n); 30 | return n; 31 | } 32 | /** Returns whether the stack is empty. */ 33 | 34 | fn empty(&self) -> bool { 35 | return self.queue.is_empty(); 36 | } 37 | } 38 | 39 | /** 40 | * Your MyStack object will be instantiated and called as such: 41 | * let obj = MyStack::new(); 42 | * obj.push(x); 43 | * let ret_2: i32 = obj.pop(); 44 | * let ret_3: i32 = obj.top(); 45 | * let ret_4: bool = obj.empty(); 46 | */ 47 | 48 | fn main() { 49 | println!("Hello, world!"); 50 | } 51 | -------------------------------------------------------------------------------- /S0230-kth-smallest-element-in-a-bst/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0230-kth-smallest-element-in-a-bst" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" 9 | -------------------------------------------------------------------------------- /S0230-kth-smallest-element-in-a-bst/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | // Definition for a binary tree node. 4 | 5 | use std::rc::Rc; 6 | use std::cell::RefCell; 7 | impl Solution { 8 | pub fn kth_smallest(root: Option>>, k: i32) -> i32 { 9 | let (mut cnt, mut res) = (0,0); 10 | Solution::mid_order(root,k, &mut cnt, &mut res); 11 | return res; 12 | } 13 | 14 | fn mid_order(n: Option>>, k:i32, cnt: &mut i32, res: &mut i32) { 15 | if n.is_none() { 16 | return 17 | } 18 | 19 | let mut n_b = n.as_ref().unwrap().borrow_mut(); 20 | 21 | 22 | Solution::mid_order(n_b.left.take(), k, cnt, res); 23 | 24 | *cnt += 1; 25 | if *cnt == k { 26 | *res = n_b.val; 27 | return 28 | } 29 | 30 | Solution::mid_order(n_b.right.take(), k, cnt, res); 31 | } 32 | } 33 | 34 | fn main() { 35 | let r = btree![3,1,4,null,2]; 36 | println!("{:?}", Solution::kth_smallest(r,1)); 37 | } 38 | -------------------------------------------------------------------------------- /S0334-increasing-triplet-subsequence/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0334-increasing-triplet-subsequence" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0334-increasing-triplet-subsequence/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn increasing_triplet(nums: Vec) -> bool { 5 | let (mut low, mut high) = (i32::max_value(), i32::max_value()); 6 | for num in nums { 7 | if num <= low { 8 | low = num; 9 | } else if num <= high { 10 | high = num; 11 | } else { 12 | return true 13 | } 14 | } 15 | 16 | false 17 | } 18 | } 19 | 20 | fn main() { 21 | println!("Hello, world!"); 22 | } 23 | -------------------------------------------------------------------------------- /S0349-intersection-of-two-arrays/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0349-intersection-of-two-arrays" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0349-intersection-of-two-arrays/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | use std::collections::HashSet; 4 | 5 | impl Solution { 6 | pub fn intersection(nums1: Vec, nums2: Vec) -> Vec { 7 | let mut set1 = HashSet::new(); 8 | let mut set2 = HashSet::new(); 9 | nums1 10 | .iter() 11 | .map(|n| { 12 | set1.insert(n); 13 | }) 14 | .for_each(drop); 15 | nums2 16 | .iter() 17 | .map(|n| { 18 | set2.insert(n); 19 | }) 20 | .for_each(drop); 21 | 22 | let mut res = vec![]; 23 | set2.into_iter() 24 | .map(|x| { 25 | if set1.contains(x) { 26 | res.push(*x); 27 | } 28 | }) 29 | .for_each(drop); 30 | return res; 31 | } 32 | } 33 | 34 | fn main() { 35 | let nums1 = vec![1, 2, 2, 1]; 36 | let nums2 = vec![2, 2]; 37 | println!("{:?}", Solution::intersection(nums1, nums2)); 38 | } 39 | -------------------------------------------------------------------------------- /S0350-intersection-of-two-arrays-ii/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0350-intersection-of-two-arrays-ii" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0350-intersection-of-two-arrays-ii/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | use std::collections::HashMap; 4 | impl Solution { 5 | fn collect_to_maps(nums: Vec) -> HashMap { 6 | let mut map = HashMap::new(); 7 | nums.iter() 8 | .map(|x| { 9 | if let Some(cnt) = map.get(x) { 10 | map.insert(*x, cnt + 1); 11 | } else { 12 | map.insert(*x, 1); 13 | } 14 | }) 15 | .for_each(drop); 16 | map 17 | } 18 | 19 | pub fn cintersect(nums1: Vec, nums2: Vec) -> Vec { 20 | let map1 = Solution::collect_to_maps(nums1); 21 | let map2 = Solution::collect_to_maps(nums2); 22 | 23 | let mut res = vec![]; 24 | map1.iter() 25 | .map(|(&num, cnt)| { 26 | let elem_cnt= *map2.get(&num).unwrap_or(&0).min(cnt); 27 | 28 | (0..elem_cnt).map(|_|{ 29 | res.push(num); 30 | }).for_each(drop); 31 | 32 | }) 33 | .for_each(drop); 34 | 35 | return res; 36 | } 37 | } 38 | 39 | fn main() { 40 | let (nums1, nums2) = (vec![1, 2, 2, 1], vec![2, 2]); 41 | println!("{:?}", Solution::cintersect(nums1, nums2)); 42 | 43 | let (nums1, nums2) = (vec![4, 9, 5], vec![9, 4, 9, 8, 4]); 44 | println!("{:?}", Solution::cintersect(nums1, nums2)); 45 | } 46 | -------------------------------------------------------------------------------- /S0398-random-pick-index/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0398-random-pick-index" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0398-random-pick-index/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashMap; 2 | struct Solution { 3 | // 因为这两个 map 都是在 new 内部生成的 4 | // 所以需要放在堆上 5 | idx_map: Box>>>, 6 | pick_map: Box>, 7 | } 8 | 9 | /** 10 | * `&self` means the method takes an immutable reference. 11 | * If you need a mutable reference, change it to `&mut self` instead. 12 | */ 13 | impl Solution { 14 | fn new(nums: Vec) -> Self { 15 | let mut idx_map: HashMap>> = HashMap::new(); 16 | let mut pick_map: HashMap = HashMap::new(); 17 | for (idx, num) in nums.iter().enumerate() { 18 | if pick_map.get(num).is_none() { 19 | pick_map.insert(*num, -1); 20 | let v = vec![idx]; 21 | idx_map.insert(*num, Box::new(v)); 22 | } else { 23 | // 这里的 clone 能优化掉么？ 24 | let mut v = idx_map.get(num).as_mut().unwrap().clone(); 25 | v.push(idx); 26 | idx_map.insert(*num, v); 27 | } 28 | } 29 | 30 | return Solution { 31 | idx_map: Box::new(idx_map), 32 | pick_map: Box::new(pick_map), 33 | }; 34 | } 35 | 36 | fn pick(&mut self, target: i32) -> i32 { 37 | let id_arr = self.idx_map.get(&target).unwrap(); 38 | let mut pick_pos = *(self.pick_map.get(&target).unwrap()); 39 | pick_pos += 1; 40 | self.pick_map.insert(target, pick_pos); 41 | if pick_pos >= id_arr.len() as i32 { 42 | pick_pos = 0; 43 | } 44 | self.pick_map.insert(target, pick_pos); 45 | 46 | return id_arr[pick_pos as usize] as i32; 47 | } 48 | } 49 | 50 | /** 51 | * Your Solution object will be instantiated and called as such: 52 | * let obj = Solution::new(nums); 53 | * let ret_1: i32 = obj.pick(target); 54 | */ 55 | 56 | fn main() { 57 | let nums = vec![1, 2, 3, 3, 3]; 58 | let mut obj = Solution::new(nums); 59 | println!("{}", obj.pick(3)); 60 | println!("{}", obj.pick(3)); 61 | println!("{}", obj.pick(3)); 62 | println!("{}", obj.pick(3)); 63 | println!("{}", obj.pick(3)); 64 | println!("{}", obj.pick(3)); 65 | println!("{}", obj.pick(3)); 66 | println!("{}", obj.pick(3)); 67 | println!("{}", obj.pick(3)); 68 | println!("{}", obj.pick(3)); 69 | println!("{}", obj.pick(3)); 70 | println!("{}", obj.pick(3)); 71 | println!("{}", obj.pick(3)); 72 | println!("{}", obj.pick(3)); 73 | println!("{}", obj.pick(3)); 74 | println!("{}", obj.pick(3)); 75 | println!("{}", obj.pick(3)); 76 | println!("{}", obj.pick(3)); 77 | println!("{}", obj.pick(3)); 78 | println!("{}", obj.pick(3)); 79 | println!("{}", obj.pick(3)); 80 | println!("{}", obj.pick(3)); 81 | println!("{}", obj.pick(3)); 82 | println!("{}", obj.pick(3)); 83 | println!("{}", obj.pick(3)); 84 | println!("{}", obj.pick(3)); 85 | println!("{}", obj.pick(3)); 86 | println!("{}", obj.pick(3)); 87 | println!("{}", obj.pick(3)); 88 | println!("{}", obj.pick(3)); 89 | println!("{}", obj.pick(3)); 90 | println!("{}", obj.pick(3)); 91 | } 92 | -------------------------------------------------------------------------------- /S0441-arranging-coins/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0441-arranging-coins" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0441-arranging-coins/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn arrange_coins(n: i32) -> i32 { 5 | if n <= 0 { 6 | return 0 7 | } 8 | let mut res = ((n as f64) * (2.0)).sqrt() as i128; 9 | if res * (res + 1) / 2 > n as i128 { 10 | return res as i32 - 1 11 | } 12 | res as i32 13 | } 14 | } 15 | 16 | fn main() { 17 | println!("{}", Solution::arrange_coins(8)); 18 | println!("{}", Solution::arrange_coins(1804289383)); 19 | } 20 | -------------------------------------------------------------------------------- /S0443-string-compression/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0443-string-compression" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0443-string-compression/readme.md: -------------------------------------------------------------------------------- 1 | ["?","?","?","0","0","^","^","g","g","?","`","v","^","^","$","$","4","4","z","c",";",";",";",";",";","@","@","@","@","K","l","l","~","~","~","[","[","t","t","?","V","I","<","i","i","i","i","i","o","o","o","o","7","8","o",":","z","t","t","t","K","w","d","$","$","$","$","$","A","5","5","2","m","m","m",",","Y","O","O","O","O","O","O","O","M","k","k","Y","@","@","@","_","_","c","c","c","E","`","`","'","e","e","e","<","F","`","`","`","&","&","K","L","z","&","\\","\\","\\","\\","\\","\\","@","b","Q",">","2","2","t",".","b","b","d","4","}","}","}","j","[","[","[","G","f","f","f","f","f","f","?","?","a","d","*","*","*","0","9","9","a","m","/","/","/","/","/","4","N","{","{","p","p","V","V","b","b","b",",",",",",","{","{","o","W","W",">",">",">",">",">",">",">","~","7","7","S","S","K","K","K","K","K","n","n","n","Z","d","B","B","B","B","B","B","B","f","o","V","j","}","}","&","&","&","&",",","p","p","t","^","^","^","j","j","d","d","d","d","d","d","C","C","C","C","C","C","P","P","x","x","f","f","G","G","8","8","8","+","?","3","i","i","}","}","7","Y","7","7","7","7","K","K","K","9","X","X","X","X","X","X","A","*","P","|","|","|",">",">",">","r","~","~","~","~","C","+","+","z","b","+","+",";","f","f"] 2 | 3 | 执行出错 4 | -------------------------------------------------------------------------------- /S0443-string-compression/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | use std::collections::HashMap; 4 | impl Solution { 5 | pub fn compress(chars: &mut Vec) -> i32 { 6 | if chars.len() == 1usize { 7 | return 1; 8 | } 9 | 10 | // O(1) 其实只要倒着遍历就行了，还是不写 O1 的了 11 | let mut char_counter = HashMap::new(); 12 | 13 | let c_c = chars.clone(); 14 | for c in c_c { 15 | let cnt = char_counter.get(&c).unwrap_or(&0); 16 | char_counter.insert(c, *cnt + 1); 17 | } 18 | 19 | let mut mark_cursor = 1usize; 20 | let mut iter_cursor = 0usize; 21 | let mut cur_char = chars[0].clone(); 22 | while iter_cursor < chars.len() { 23 | //println!('chars {:?}', chars); 24 | let cnt = char_counter.get(&cur_char).unwrap(); 25 | let cnt_str = (*cnt).to_string(); 26 | //println!('cnt_str{:?}', cnt_str); 27 | for i in 0..cnt_str.len() { 28 | chars[mark_cursor] = cnt_str.chars().nth(i).unwrap(); 29 | mark_cursor += 1; 30 | } 31 | if mark_cursor >= chars.len() { 32 | break; 33 | } 34 | iter_cursor = mark_cursor+1; 35 | // find next char 36 | while iter_cursor < chars.len() &&(chars[iter_cursor] == cur_char) { 37 | iter_cursor += 1; 38 | } 39 | //println!('cur_char:{}, iter_cursor:{}, mark_cursor:{}', cur_char, iter_cursor,mark_cursor); 40 | if iter_cursor == chars.len() { 41 | break; 42 | } 43 | chars[mark_cursor] = chars[iter_cursor]; 44 | cur_char = chars[mark_cursor]; 45 | mark_cursor += 1; 46 | //println!('cur_char:{}, mark_cursor:{}', cur_char, mark_cursor); 47 | } 48 | //println!('{:?}', chars); 49 | return mark_cursor as i32; 50 | } 51 | } 52 | 53 | fn main() { 54 | let mut v = vec!['a','a','b','b','c','c','c']; 55 | println!("{}", Solution::compress(&mut v)); 56 | let mut v = vec!['a', 'a']; 57 | println!("{}", Solution::compress(&mut v)); 58 | let mut v = vec!['a']; 59 | println!("{}", Solution::compress(&mut v)); 60 | let mut v = vec!['?','?','?','0','0','^','^','g','g','?','`','v','^','^','$','$','4','4','z','c',';',';',';',';',';','@','@','@','@','K','l','l','~','~','~','[','[','t','t','?','V','I','<','i','i','i','i','i','o','o','o','o','7','8','o',':','z','t','t','t','K','w','d','$','$','$','$','$','A','5','5','2','m','m','m',',','Y','O','O','O','O','O','O','O','M','k','k','Y','@','@','@','_','_','c','c','c','E','`','`','e','e','e','F']; 61 | println!("{}", Solution::compress(&mut v)); 62 | } 63 | -------------------------------------------------------------------------------- /S0448-find-all-numbers-disappeared-in-an-array/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0448-find-all-numbers-disappeared-in-an-array" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0448-find-all-numbers-disappeared-in-an-array/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | use std::collections::HashSet; 4 | impl Solution { 5 | // 用 set 反而更慢 6 | pub fn find_disappeared_numbers(nums: Vec) -> Vec { 7 | let mut set = HashSet::new(); 8 | let l = nums.len(); 9 | nums.into_iter() 10 | .map(|x| { 11 | set.insert(x); 12 | }) 13 | .collect::>(); 14 | 15 | let mut v = vec![]; 16 | 17 | (0..=l) 18 | .map(|x| { 19 | v.push(x as i32); 20 | }) 21 | .for_each(drop); 22 | 23 | let res = v 24 | .into_iter() 25 | .filter(|x| *x != 0 && !set.contains(x)) 26 | .collect(); 27 | return res; 28 | } 29 | 30 | // 下面这个 16ms 31 | pub fn find_disappeared_numbers2(nums: Vec) -> Vec { 32 | let mut v = vec![]; 33 | 34 | (0..=nums.len()) 35 | .map(|x| { 36 | v.push(x as i32); 37 | }) 38 | .for_each(drop); 39 | 40 | nums.iter() 41 | .map(|n| { 42 | v[*n as usize] = 0; 43 | }) 44 | .for_each(drop); 45 | 46 | let res = v.into_iter().filter(|x| *x != 0).collect(); 47 | return res; 48 | } 49 | } 50 | 51 | fn main() { 52 | let v = vec![4, 3, 2, 7, 8, 2, 3, 1]; 53 | println!("{:?}", Solution::find_disappeared_numbers(v)); 54 | } 55 | -------------------------------------------------------------------------------- /S0451-sort-characters-by-frequency/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0451-sort-characters-by-frequency" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0451-sort-characters-by-frequency/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | use std::cmp::Ordering; 4 | use std::collections::HashMap; 5 | impl Solution { 6 | pub fn frequency_sort(s: String) -> String { 7 | let mut char_cnt = HashMap::new(); 8 | s.bytes().for_each(|c| { 9 | char_cnt.entry(c).and_modify(|e| *e += 1).or_insert(1); 10 | }); 11 | 12 | let mut byte_arr = s.into_bytes(); 13 | byte_arr.sort_by(|x, y| { 14 | if char_cnt.get(x).unwrap_or(&0) > char_cnt.get(y).unwrap_or(&0) { 15 | return Ordering::Less; 16 | } 17 | if char_cnt.get(x).unwrap_or(&0) < char_cnt.get(y).unwrap_or(&0) { 18 | return Ordering::Greater; 19 | } 20 | return x.cmp(y); 21 | }); 22 | 23 | return String::from_utf8(byte_arr).unwrap(); 24 | } 25 | } 26 | 27 | fn main() { 28 | println!("{}", Solution::frequency_sort("abacd".to_string())); 29 | } 30 | -------------------------------------------------------------------------------- /S0485-max-consecutive-ones/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0485-max-consecutive-ones" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0485-max-consecutive-ones/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | 4 | impl Solution { 5 | pub fn find_max_consecutive_ones(nums: Vec) -> i32 { 6 | let mut max_counter = 0; 7 | let mut counter = 0; 8 | for n in nums { 9 | if n == 1 { 10 | counter += 1; 11 | } else { 12 | counter = 0; 13 | } 14 | 15 | if counter > max_counter { 16 | max_counter = counter; 17 | } 18 | } 19 | return max_counter; 20 | } 21 | } 22 | 23 | fn main() { 24 | println!("{}", Solution::find_max_consecutive_ones(vec![1,1,0,1,1,1])); 25 | } 26 | -------------------------------------------------------------------------------- /S0506-relative-ranks/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0506-relative-ranks" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0506-relative-ranks/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | use std::collections::HashMap; 4 | impl Solution { 5 | pub fn find_relative_ranks(nums: Vec) -> Vec { 6 | let mut map = HashMap::new(); 7 | let mut sorted= nums.clone(); 8 | sorted.sort_by(|a,b| b.cmp(a)); 9 | 10 | let rank_data = vec!["Gold Medal","Silver Medal","Bronze Medal"]; 11 | sorted.iter().enumerate().for_each(|(idx,n)|{ 12 | match idx { 13 | 0|1|2 => { 14 | map.insert(n, rank_data[idx].to_string()); 15 | }, 16 | _ => { 17 | map.insert(n, (idx+1).to_string()); 18 | }, 19 | } 20 | }); 21 | 22 | nums.iter().map(|x| { 23 | map.get(x).unwrap().clone() 24 | }).collect::>() 25 | } 26 | } 27 | 28 | fn main() { 29 | println!("Hello, world!"); 30 | } 31 | -------------------------------------------------------------------------------- /S0508-most-frequent-subtree-sum/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0508-most-frequent-subtree-sum" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude = "^0.1" 9 | 10 | -------------------------------------------------------------------------------- /S0508-most-frequent-subtree-sum/src/main.rs: -------------------------------------------------------------------------------- 1 | // Definition for a binary tree node. 2 | pub use leetcode_prelude::*; 3 | 4 | //#[derive(Debug, PartialEq, Eq)] 5 | //pub struct TreeNode { 6 | // pub val: i32, 7 | // pub left: Option>>, 8 | // pub right: Option>>, 9 | //} 10 | // 11 | //impl TreeNode { 12 | // #[inline] 13 | // pub fn new(val: i32) -> Self { 14 | // TreeNode { 15 | // val, 16 | // left: None, 17 | // right: None 18 | // } 19 | // } 20 | //} 21 | struct Solution; 22 | 23 | use std::collections::HashMap; 24 | use std::rc::Rc; 25 | use std::cell::RefCell; 26 | impl Solution { 27 | pub fn traverse_tree_and_get_sum(root: Option>>, val_counter: &mut HashMap) -> i32 { 28 | match root { 29 | Some(r) => { 30 | let mut root_b = r.as_ref().borrow_mut(); 31 | let l_val = Solution::traverse_tree_and_get_sum(root_b.left.take(), val_counter); 32 | let r_val = Solution::traverse_tree_and_get_sum(root_b.right.take(), val_counter); 33 | let res = root_b.val + l_val + r_val; 34 | let res_cnt = val_counter.get(&res).unwrap_or(&0) + 1; 35 | val_counter.insert(res,res_cnt); 36 | return res; 37 | }, 38 | None => return 0, 39 | } 40 | } 41 | 42 | pub fn find_frequent_tree_sum(root: Option>>) -> Vec { 43 | let mut val_count = HashMap::new(); 44 | Solution::traverse_tree_and_get_sum(root, &mut val_count); 45 | let mut max_cnt = 0; 46 | let mut res = vec![]; 47 | for (k,v) in val_count.iter() { 48 | if *v > max_cnt { 49 | max_cnt = *v; 50 | res = vec![]; 51 | res.push(*k); 52 | continue 53 | } 54 | if *v == max_cnt { 55 | res.push(*k); 56 | continue 57 | } 58 | } 59 | return res; 60 | } 61 | } 62 | 63 | fn main() { 64 | println!("{:?}", Solution::find_frequent_tree_sum(btree![5,2,3])); 65 | } 66 | -------------------------------------------------------------------------------- /S0513-find-bottom-left-tree-value/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0513-find-bottom-left-tree-value" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0513-find-bottom-left-tree-value/src/main.rs: -------------------------------------------------------------------------------- 1 | // Definition for a binary tree node. 2 | #[derive(Debug, PartialEq, Eq)] 3 | pub struct TreeNode { 4 | pub val: i32, 5 | pub left: Option>>, 6 | pub right: Option>>, 7 | } 8 | 9 | impl TreeNode { 10 | #[inline] 11 | pub fn new(val: i32) -> Self { 12 | TreeNode { 13 | val, 14 | left: None, 15 | right: None, 16 | } 17 | } 18 | } 19 | 20 | struct Solution; 21 | 22 | use std::cell::RefCell; 23 | use std::rc::Rc; 24 | impl Solution { 25 | pub fn find_bottom_left_value(root: Option>>) -> i32 { 26 | // 层序遍历 27 | let mut cur_level = vec![root]; 28 | loop { 29 | let first_node_of_this_line = cur_level[0].as_ref().unwrap().borrow().val; 30 | let mut next_level = vec![]; 31 | for n in cur_level { 32 | let mut n_b = n.as_ref().unwrap().borrow_mut(); 33 | if n_b.left.is_some() { 34 | next_level.push(n_b.left.take()); 35 | } 36 | if n_b.right.is_some() { 37 | next_level.push(n_b.right.take()); 38 | } 39 | } 40 | if next_level.len() == 0 { 41 | return first_node_of_this_line; 42 | } 43 | cur_level = next_level; 44 | } 45 | } 46 | } 47 | 48 | fn main() { 49 | let r = Some(Rc::new(RefCell::new(TreeNode::new(1)))); 50 | let x = r.as_ref().unwrap(); 51 | { 52 | x.borrow_mut().left = Some(Rc::new(RefCell::new(TreeNode::new(3)))); 53 | } 54 | { 55 | x.borrow_mut().right = Some(Rc::new(RefCell::new(TreeNode::new(2)))); 56 | } 57 | println!("{:?}", r); 58 | 59 | println!("{}", Solution::find_bottom_left_value(r)); 60 | } 61 | -------------------------------------------------------------------------------- /S0530-minimum-absolute-difference-in-bst/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0530-minimum-absolute-difference-in-bst" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" 9 | -------------------------------------------------------------------------------- /S0530-minimum-absolute-difference-in-bst/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | // Definition for a binary tree node. 4 | #[derive(Debug, PartialEq, Eq)] 5 | pub struct TreeNode { 6 | pub val: i32, 7 | pub left: Option>>, 8 | pub right: Option>>, 9 | } 10 | 11 | impl TreeNode { 12 | #[inline] 13 | pub fn new(val: i32) -> Self { 14 | TreeNode { 15 | val, 16 | left: None, 17 | right: None 18 | } 19 | } 20 | } 21 | use std::rc::Rc; 22 | use std::cell::RefCell; 23 | impl Solution { 24 | pub fn get_minimum_difference(root: Option>>) -> i32 { 25 | // 中序遍历 26 | let mut v:Vec = vec![]; 27 | Solution::mid_traversal(root, &mut v); 28 | let mut min_res = i32::max_value(); 29 | for i in 1..v.len() { 30 | if (v[i] - v[i-1]).abs() < min_res { 31 | min_res = (v[i] - v[i-1]).abs(); 32 | } 33 | } 34 | return min_res; 35 | } 36 | 37 | fn mid_traversal(node : Option>>, v: &mut Vec) { 38 | if node.is_none() { 39 | return; 40 | } 41 | 42 | // left 43 | let mut n_b = node.as_ref().unwrap().borrow_mut(); 44 | let (l,r) = (n_b.left.take(), n_b.right.take()); 45 | Solution::mid_traversal(l, v); 46 | // this 47 | v.push(n_b.val); 48 | // right 49 | Solution::mid_traversal(r, v); 50 | } 51 | } 52 | fn main() { 53 | println!("Hello, world!"); 54 | } 55 | -------------------------------------------------------------------------------- /S0617-merge-two-binary-trees/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0617-merge-two-binary-trees" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0617-merge-two-binary-trees/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | // Definition for a binary tree node. 4 | #[derive(Debug, PartialEq, Eq)] 5 | pub struct TreeNode { 6 | pub val: i32, 7 | pub left: Option>>, 8 | pub right: Option>>, 9 | } 10 | 11 | impl TreeNode { 12 | #[inline] 13 | pub fn new(val: i32) -> Self { 14 | TreeNode { 15 | val, 16 | left: None, 17 | right: None 18 | } 19 | } 20 | } 21 | use std::rc::Rc; 22 | use std::cell::RefCell; 23 | impl Solution { 24 | pub fn merge_trees(t1: Option>>, t2: Option>>) -> Option>> { 25 | match (t1, t2) { 26 | (None, None) => return None, 27 | (None, Some(n2)) => return Some(n2.clone()), 28 | (Some(n1),None) => return Some(n1.clone()), 29 | (Some(n1),Some(n2))=> { 30 | let v = n1.borrow_mut().val + n2.borrow_mut().val; 31 | let left_tree = Solution::merge_trees(n1.borrow_mut().left.clone(), n2.borrow_mut().left.clone()); 32 | let right_tree= Solution::merge_trees(n1.borrow_mut().right.clone(), n2.borrow_mut().right.clone()); 33 | return Some(Rc::new(RefCell::new(TreeNode{ 34 | val : v, 35 | left : left_tree, 36 | right : right_tree, 37 | }))); 38 | } 39 | } 40 | unreachable!() 41 | } 42 | } 43 | 44 | fn main() { 45 | println!("Hello, world!"); 46 | } 47 | -------------------------------------------------------------------------------- /S0637-average-of-levels-in-binary-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0637-average-of-levels-in-binary-tree" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude = "^0.1" 9 | -------------------------------------------------------------------------------- /S0637-average-of-levels-in-binary-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | use leetcode_prelude::*; 2 | struct Solution; 3 | // Definition for a binary tree node. 4 | // #[derive(Debug, PartialEq, Eq)] 5 | // pub struct TreeNode { 6 | // pub val: i32, 7 | // pub left: Option>>, 8 | // pub right: Option>>, 9 | // } 10 | // 11 | // impl TreeNode { 12 | // #[inline] 13 | // pub fn new(val: i32) -> Self { 14 | // TreeNode { 15 | // val, 16 | // left: None, 17 | // right: None 18 | // } 19 | // } 20 | // } 21 | use std::rc::Rc; 22 | use std::cell::RefCell; 23 | impl Solution { 24 | pub fn average_of_levels(root: Option>>) -> Vec { 25 | let mut res = vec![]; 26 | let mut cur_level = vec![root]; 27 | while cur_level.len() > 0 { 28 | let mut next_level = vec![]; 29 | let mut current_level_avg = 0f64; 30 | let mut current_level_sum = 0f64; 31 | for n in &cur_level { 32 | let mut n_b = n.as_ref().unwrap().borrow_mut(); 33 | current_level_sum += n_b.val as f64; 34 | let (mut l, mut r) = (n_b.left.take(), n_b.right.take()); 35 | if l.is_some() { 36 | next_level.push(l); 37 | } 38 | if r.is_some() { 39 | next_level.push(r); 40 | } 41 | } 42 | res.push(current_level_sum/(cur_level.len() as f64)); 43 | cur_level = next_level; 44 | } 45 | return res; 46 | } 47 | } 48 | fn main() { 49 | let r = btree![3,9,20,null,null,15,7]; 50 | println!("{:?}", Solution::average_of_levels(r)); 51 | } 52 | -------------------------------------------------------------------------------- /S0654-maximum-binary-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0654-maximum-binary-tree" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0654-maximum-binary-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | // Definition for a binary tree node. 2 | #[derive(Debug, PartialEq, Eq)] 3 | pub struct TreeNode { 4 | pub val: i32, 5 | pub left: Option>>, 6 | pub right: Option>>, 7 | } 8 | 9 | impl TreeNode { 10 | #[inline] 11 | pub fn new(val: i32) -> Self { 12 | TreeNode { 13 | val, 14 | left: None, 15 | right: None, 16 | } 17 | } 18 | } 19 | struct Solution; 20 | 21 | use std::cell::RefCell; 22 | use std::rc::Rc; 23 | impl Solution { 24 | pub fn construct_maximum_binary_tree(nums: Vec) -> Option>> { 25 | if nums.len() == 0 { 26 | return None; 27 | } 28 | 29 | // find the max index 30 | let (mut max_val, mut max_val_idx) = (nums[0], 0); 31 | for (idx, elem) in nums.iter().enumerate() { 32 | if *elem > max_val { 33 | max_val = *elem; 34 | max_val_idx = idx; 35 | } 36 | } 37 | //println!("max_val: {:?}, nums: {:?}", max_val, nums); 38 | 39 | // split arr 40 | let (left_vec, right_vec) = ( 41 | nums[0..max_val_idx].to_vec(), 42 | nums[max_val_idx + 1..].to_vec(), 43 | ); 44 | let (left_tree, right_tree) = ( 45 | Solution::construct_maximum_binary_tree(left_vec), 46 | Solution::construct_maximum_binary_tree(right_vec), 47 | ); 48 | 49 | let root = Some(Rc::new(RefCell::new(TreeNode::new(max_val)))); 50 | root.as_ref().unwrap().borrow_mut().left = left_tree; 51 | root.as_ref().unwrap().borrow_mut().right = right_tree; 52 | return root; 53 | } 54 | } 55 | 56 | fn main() { 57 | /* 58 | let mut v = vec![1,2,34,4]; 59 | let mut x = &v[1..3].to_vec(); 60 | println!("{:?}, {:?}",x,v); 61 | let mut z = v.split_at(2); 62 | println!("{:?}, {:?}",z,v); 63 | let zz = &v[4..].to_vec(); 64 | println!("{:?}, {:?}",zz,v); 65 | */ 66 | let v = vec![1, 5, 3, 2, 1]; 67 | let r = Solution::construct_maximum_binary_tree(v); 68 | println!("{:?}", r); 69 | } 70 | -------------------------------------------------------------------------------- /S0662-maximum-width-of-binary-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0662-maximum-width-of-binary-tree" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0662-maximum-width-of-binary-tree/src/lib.rs: -------------------------------------------------------------------------------- 1 | #![feature(proc_macro_hygiene)] 2 | 3 | use std::rc::Rc; 4 | use std::cell::RefCell; 5 | 6 | 7 | // Definition for singly-linked list. 8 | #[derive(PartialEq, Eq, Debug)] 9 | pub struct ListNode { 10 | pub val: i32, 11 | pub next: Option>, 12 | } 13 | 14 | impl ListNode { 15 | #[inline] 16 | fn new(val: i32) -> Self { 17 | ListNode { next: None, val } 18 | } 19 | } 20 | 21 | #[macro_export] 22 | macro_rules! linkedlist { 23 | () => { 24 | None 25 | }; 26 | ($($e:expr), *) => { 27 | { 28 | let mut head = Box::new($crate::ListNode::new(0)); 29 | let mut ref_head = &mut head; 30 | 31 | $( 32 | ref_head.next = Some(Box::new($crate::ListNode::new($e))); 33 | ref_head = ref_head.next.as_mut().unwrap(); 34 | )* 35 | 36 | let _ = ref_head; // 避免 `unused_assignments` 37 | head.next 38 | } 39 | }; 40 | } 41 | 42 | 43 | // Definition for a binary tree node. 44 | #[derive(Debug, PartialEq, Eq, Ord, PartialOrd)] 45 | pub struct TreeNode { 46 | pub val: i32, 47 | pub left: Option>>, 48 | pub right: Option>>, 49 | } 50 | 51 | impl TreeNode { 52 | #[inline] 53 | pub fn new(val: i32) -> Self { 54 | TreeNode { 55 | val, 56 | left: None, 57 | right: None, 58 | } 59 | } 60 | } 61 | 62 | // 想了想, 其实不要这个宏也行 63 | // 用 stringfiy! 全转成字符串就可以了... 64 | #[macro_export] 65 | macro_rules! null_to_none { 66 | (@start $($e:tt), *) => { 67 | { 68 | let mut ret: Vec> = vec![]; 69 | $crate::null_to_none![@next ret; $($e), *]; 70 | ret 71 | } 72 | }; 73 | (@next $vec:expr; null, $($tail:tt), *) => { 74 | $vec.push(None); 75 | $crate::null_to_none![@next $vec; $($tail), *]; 76 | }; 77 | (@next $vec:expr; $e:tt, $($tail:tt), *) => { 78 | $vec.push(Some($e)); 79 | $crate::null_to_none![@next $vec; $($tail), *]; 80 | }; 81 | (@next $vec:expr; null) => { 82 | $vec.push(None); 83 | }; 84 | (@next $vec:expr; $e:tt) => { 85 | $vec.push(Some($e)); 86 | }; 87 | ($($e:tt), *) => { 88 | $crate::null_to_none![@start $($e), *] 89 | }; 90 | } 91 | 92 | // 二叉树层序遍历初始化宏 93 | #[macro_export] 94 | macro_rules! btree { 95 | () => { 96 | None 97 | }; 98 | ($($e:tt), *) => { 99 | { 100 | let elems = $crate::null_to_none![$($e), *]; 101 | let head = Some($crate::Rc::new($crate::RefCell::new($crate::TreeNode::new(elems[0].unwrap())))); 102 | let mut nodes = std::collections::VecDeque::new(); 103 | nodes.push_back(head.as_ref().unwrap().clone()); 104 | 105 | for i in elems[1..].chunks(2) { 106 | let node = nodes.pop_front().unwrap(); 107 | if let Some(val) = i[0]{ 108 | node.borrow_mut().left = Some($crate::Rc::new($crate::RefCell::new($crate::TreeNode::new(val)))); 109 | nodes.push_back(node.borrow().left.as_ref().unwrap().clone()); 110 | } 111 | if i.len() > 1 { 112 | if let Some(val) = i[1] { 113 | node.borrow_mut().right = Some($crate::Rc::new($crate::RefCell::new($crate::TreeNode::new(val)))); 114 | nodes.push_back(node.borrow().right.as_ref().unwrap().clone()); 115 | } 116 | } 117 | } 118 | head 119 | } 120 | }; 121 | } 122 | 123 | #[macro_export] 124 | macro_rules! vec_string { 125 | ($($e:expr), *) => {vec![$($e.to_owned()), *]}; 126 | } 127 | 128 | -------------------------------------------------------------------------------- /S0662-maximum-width-of-binary-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | // Definition for a binary tree node. 2 | struct Solution; 3 | #[macro_export] 4 | macro_rules! btree { 5 | () => { 6 | None 7 | }; 8 | ($($e:tt), *) => { 9 | { 10 | let elems = $crate::null_to_none![$($e), *]; 11 | let head = Some($crate::Rc::new($crate::RefCell::new($crate::TreeNode::new(elems[0].unwrap())))); 12 | let mut nodes = std::collections::VecDeque::new(); 13 | nodes.push_back(head.as_ref().unwrap().clone()); 14 | 15 | for i in elems[1..].chunks(2) { 16 | let node = nodes.pop_front().unwrap(); 17 | if let Some(val) = i[0]{ 18 | node.borrow_mut().left = Some($crate::Rc::new($crate::RefCell::new($crate::TreeNode::new(val)))); 19 | nodes.push_back(node.borrow().left.as_ref().unwrap().clone()); 20 | } 21 | if i.len() > 1 { 22 | if let Some(val) = i[1] { 23 | node.borrow_mut().right = Some($crate::Rc::new($crate::RefCell::new($crate::TreeNode::new(val)))); 24 | nodes.push_back(node.borrow().right.as_ref().unwrap().clone()); 25 | } 26 | } 27 | } 28 | head 29 | } 30 | }; 31 | } 32 | #[macro_export] 33 | macro_rules! null_to_none { 34 | (@start $($e:tt), *) => { 35 | { 36 | let mut ret: Vec> = vec![]; 37 | $crate::null_to_none![@next ret; $($e), *]; 38 | ret 39 | } 40 | }; 41 | (@next $vec:expr; null, $($tail:tt), *) => { 42 | $vec.push(None); 43 | $crate::null_to_none![@next $vec; $($tail), *]; 44 | }; 45 | (@next $vec:expr; $e:tt, $($tail:tt), *) => { 46 | $vec.push(Some($e)); 47 | $crate::null_to_none![@next $vec; $($tail), *]; 48 | }; 49 | (@next $vec:expr; null) => { 50 | $vec.push(None); 51 | }; 52 | (@next $vec:expr; $e:tt) => { 53 | $vec.push(Some($e)); 54 | }; 55 | ($($e:tt), *) => { 56 | $crate::null_to_none![@start $($e), *] 57 | }; 58 | } 59 | 60 | #[derive(Debug, PartialEq, Eq)] 61 | pub struct TreeNode { 62 | pub val: i32, 63 | pub left: Option>>, 64 | pub right: Option>>, 65 | } 66 | 67 | impl TreeNode { 68 | #[inline] 69 | pub fn new(val: i32) -> Self { 70 | TreeNode { 71 | val, 72 | left: None, 73 | right: None, 74 | } 75 | } 76 | } 77 | 78 | use std::cell::RefCell; 79 | use std::rc::Rc; 80 | 81 | impl Solution { 82 | pub fn width_of_binary_tree(root: Option>>) -> i32 { 83 | // 层序遍历就行了 84 | let (mut cur_level, mut cur_level_idx) = (vec![root], vec![0]); 85 | let mut max_width = 0; 86 | loop { 87 | let (mut some_start, mut some_end) = (-1, -1); 88 | let (mut next_level, mut next_level_idx) = (vec![], vec![]); 89 | 90 | if cur_level.len() == 0 { 91 | return max_width; 92 | } 93 | 94 | for (idx, n) in cur_level.iter().enumerate() { 95 | let cur_node_idx = cur_level_idx[idx]; 96 | 97 | if some_start == -1 && n.is_some() { 98 | some_start = cur_node_idx; 99 | } 100 | if some_start != -1 && n.is_some() { 101 | some_end = cur_node_idx; 102 | } 103 | 104 | // 当前节点是 some 105 | // 需要把孩子节点和其索引推到下一层去 106 | if let Some(elem) = n { 107 | let mut e_b = elem.borrow_mut(); 108 | let (l, r) = (e_b.left.take(), e_b.right.take()); 109 | 110 | if l.is_some() { 111 | next_level.push(l); 112 | next_level_idx.push(cur_node_idx * 2); 113 | } 114 | 115 | if r.is_some() { 116 | next_level.push(r); 117 | next_level_idx.push(cur_node_idx * 2 + 1); 118 | } 119 | } 120 | 121 | if max_width < (some_end - some_start + 1) { 122 | max_width = some_end - some_start + 1; 123 | } 124 | } 125 | 126 | 127 | // 下一层初始化 128 | cur_level = next_level; 129 | cur_level_idx = next_level_idx; 130 | } 131 | } 132 | } 133 | 134 | fn main() { 135 | use crate::btree; 136 | use crate::TreeNode; 137 | let r = btree![ 138 | 1, 1, 1, 1, 1, 1, 1, null, null, null, 1, null, null, null, null, 2, 2, 2, 2, 2, 2, 2, 139 | null, 2, null, null, 2, null, 2 140 | ]; 141 | println!("{}", Solution::width_of_binary_tree(r)); 142 | } 143 | -------------------------------------------------------------------------------- /S0670-maximum-swap/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0670-maximum-swap" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0670-maximum-swap/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn maximum_swap(num: i32) -> i32 { 5 | let str = num.to_string(); 6 | let mut max = num; 7 | let mut b_arr: Vec = str.bytes().collect(); 8 | let l = b_arr.len(); 9 | for i in 0..l { 10 | for j in 0..l { 11 | if i == j { 12 | continue; 13 | } 14 | 15 | b_arr.swap(i,j); 16 | let cur_val = Solution::bytes_to_int(&b_arr); 17 | if cur_val > max { 18 | max = cur_val; 19 | } 20 | b_arr.swap(i,j); 21 | } 22 | } 23 | return max; 24 | } 25 | 26 | pub fn bytes_to_int(v: &Vec) -> i32 { 27 | let mut res: i32 = 0; 28 | for c in v { 29 | res = res * 10 + (c - ('0' as u8)) as i32; 30 | } 31 | return res; 32 | } 33 | } 34 | 35 | fn main() { 36 | println!("{}", Solution::maximum_swap(2378)); 37 | println!("{}", Solution::maximum_swap(9972)); 38 | println!("{}", Solution::maximum_swap(98368)); 39 | } 40 | -------------------------------------------------------------------------------- /S0671-second-minimum-node-in-a-binary-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0671-second-minimum-node-in-a-binary-tree" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0671-second-minimum-node-in-a-binary-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | // Definition for a binary tree node. 2 | #[derive(Debug, PartialEq, Eq)] 3 | pub struct TreeNode { 4 | pub val: i32, 5 | pub left: Option>>, 6 | pub right: Option>>, 7 | } 8 | 9 | impl TreeNode { 10 | #[inline] 11 | pub fn new(val: i32) -> Self { 12 | TreeNode { 13 | val, 14 | left: None, 15 | right: None 16 | } 17 | } 18 | } 19 | struct Solution; 20 | use std::rc::Rc; 21 | use std::cell::RefCell; 22 | impl Solution { 23 | pub fn find_second_minimum_value(mut root: Option>>) -> i32 { 24 | let mut v = vec![]; 25 | Solution::traverse_and_push_val_to_vec(&mut root, &mut v); 26 | v.sort(); 27 | if v.len() == 1 { 28 | return -1; 29 | } 30 | let (first, last) = (v[0],v[v.len()-1]); 31 | if first == last { 32 | return -1; 33 | } 34 | for n in &v { 35 | if *n != v[0] { 36 | return *n; 37 | } 38 | } 39 | return -1; 40 | } 41 | 42 | fn traverse_and_push_val_to_vec(n:&mut Option>>, vec:&mut Vec) { 43 | if n.is_none() { 44 | return 45 | } 46 | let mut n_b= n.as_ref().unwrap().borrow_mut(); 47 | vec.push(n_b.val); 48 | Solution::traverse_and_push_val_to_vec(&mut n_b.left,vec); 49 | Solution::traverse_and_push_val_to_vec(&mut n_b.right, vec); 50 | } 51 | } 52 | fn main() { 53 | println!("Hello, world!"); 54 | } 55 | -------------------------------------------------------------------------------- /S0680-valid-palindrome-ii/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0680-valid-palindrome-ii" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0680-valid-palindrome-ii/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | // 这个方案会超时 5 | pub fn valid_palindrome2(s: String) -> bool { 6 | for i in 0..s.len() { 7 | let mut s = s.clone(); 8 | s.remove(i); 9 | 10 | // reverse string，翻转字符串 11 | let s_rev = s.chars().rev().collect::(); 12 | if s_rev == s { 13 | return true; 14 | } 15 | } 16 | return false; 17 | } 18 | 19 | pub fn valid_palindrome(s: String) -> bool { 20 | if s.len() == 1 { 21 | return true; 22 | } 23 | 24 | let s = s.as_bytes(); 25 | let mut i = 0 as usize; 26 | let mut j = s.len() - 1 as usize; 27 | while i < j && s[i] == s[j] { 28 | i += 1; 29 | j -= 1; 30 | } 31 | //println!("i:{}, j:{}, s:{:?}", i, j, s); 32 | if i > j && s.len()%2== 1{ 33 | return false; 34 | } 35 | if i == j { 36 | return true; 37 | } 38 | 39 | //println!("i:{}, j:{}, s:{:?}", i, j, s); 40 | // 遇到不等于的情况，跳出了 while 循环 41 | // 要么去掉 i 要么去掉 j 42 | // 先跳过 i 来一遍 43 | { 44 | let (mut i, mut j )= (i+1,j); 45 | while i< j{ 46 | if s[i]!= s[j] { 47 | break 48 | } 49 | i = i+1; j = j-1; 50 | } 51 | if i >= j { 52 | return true; 53 | } 54 | } 55 | // 再跳过 j 来一遍 56 | { 57 | let (mut i, mut j )= (i,j-1); 58 | while i< j{ 59 | if s[i]!= s[j] { 60 | break 61 | } 62 | i = i+1; j = j-1; 63 | } 64 | if i >= j { 65 | return true; 66 | } 67 | } 68 | return false; 69 | } 70 | } 71 | 72 | fn main() { 73 | /*let mut s = "abcdefg".to_string(); 74 | println!("{}, {}", s.remove(0),s); 75 | println!("{}, {}", s.remove(0),s); 76 | */ 77 | println!("{}", Solution::valid_palindrome("aba".to_string())); 78 | println!("{}", Solution::valid_palindrome("abca".to_string())); 79 | println!("{}", Solution::valid_palindrome("bddb".to_string())); 80 | println!("{}", Solution::valid_palindrome("deeee".to_string())); 81 | println!("{}", Solution::valid_palindrome("cbbcc".to_string())); 82 | } 83 | -------------------------------------------------------------------------------- /S0709-to-lower-case/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0709" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0709-to-lower-case/src/main.rs: -------------------------------------------------------------------------------- 1 | 2 | struct Solution; 3 | impl Solution { 4 | pub fn to_lower_case(str: String) -> String { 5 | let mut res = String::new(); 6 | for c in str.chars() { 7 | res.push(c.to_ascii_lowercase()); 8 | } 9 | return res; 10 | } 11 | } 12 | 13 | fn main() { 14 | Solution::to_lower_case("aBbc".to_string()); 15 | } 16 | -------------------------------------------------------------------------------- /S0725-split-linked-list-in-parts/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0725-split-linked-list-in-parts" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" 9 | 10 | -------------------------------------------------------------------------------- /S0725-split-linked-list-in-parts/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | // Definition for singly-linked list. 4 | //#[derive(PartialEq, Eq, Debug)] 5 | //pub struct ListNode { 6 | // pub val: i32, 7 | // pub next: Option>, 8 | //} 9 | // 10 | //impl ListNode { 11 | // #[inline] 12 | // fn new(val: i32) -> Self { 13 | // ListNode { next: None, val } 14 | // } 15 | //} 16 | impl Solution { 17 | pub fn split_list_to_parts( 18 | mut root: Option>, 19 | k: i32, 20 | ) -> Vec>> { 21 | let mut res = vec![]; 22 | if root.is_none() { 23 | for _ in 0..k { 24 | res.push(None); 25 | } 26 | return res; 27 | } 28 | 29 | // 需要知道链表到底有多长 30 | let mut len = 0; 31 | let mut cursor = &mut root; 32 | loop { 33 | if cursor.is_none() { 34 | break; 35 | } 36 | 37 | len += 1; 38 | cursor = &mut cursor.as_mut().unwrap().next; 39 | } 40 | 41 | let every_vec_len = len / k; 42 | // 有这么多需要 every_vec_len + 1 的，剩下的全是 every_vec_len 长度 43 | let except_vec_count = len - every_vec_len * k; 44 | cursor = &mut root; 45 | for _ in 0..except_vec_count { 46 | let mut v = vec![]; 47 | for _ in 0..(every_vec_len + 1) { 48 | v.push(cursor.as_ref().unwrap().val); 49 | /* 50 | if let Some(c) = cursor { 51 | cursor = &mut c.next; 52 | } 53 | */ 54 | cursor = &mut cursor.as_mut().unwrap().next; 55 | } 56 | // build list from vec 57 | let l = Solution::build_list_from_vec(v); 58 | res.push(l); 59 | } 60 | loop { 61 | let mut v = vec![]; 62 | for _ in 0..(every_vec_len) { 63 | v.push(cursor.as_ref().unwrap().val); 64 | /*if let Some(c) = cursor { 65 | cursor = &mut c.next; 66 | }*/ 67 | cursor = &mut cursor.as_mut().unwrap().next; 68 | } 69 | // build list from vec 70 | let l = Solution::build_list_from_vec(v); 71 | res.push(l); 72 | if cursor.is_none() { 73 | break; 74 | } 75 | } 76 | while res.len() < k as usize { 77 | res.push(None); 78 | } 79 | return res; 80 | } 81 | 82 | fn build_list_from_vec(v: Vec) -> Option> { 83 | let mut dummy = Box::new(ListNode::new(0)); 84 | let mut cursor = &mut dummy; 85 | 86 | for num in v { 87 | cursor.next = Some(Box::new(ListNode::new(num))); 88 | cursor = cursor.next.as_mut().unwrap(); 89 | } 90 | dummy.next 91 | } 92 | } 93 | 94 | fn main() { 95 | let l = linkedlist![1, 2, 3]; 96 | let x = Solution::split_list_to_parts(l, 5); 97 | println!("{:?}", x); 98 | } 99 | -------------------------------------------------------------------------------- /S0748-shortest-completing-word/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0748-shortest-completing-word" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0748-shortest-completing-word/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | use std::collections::HashMap; 4 | impl Solution { 5 | pub fn shortest_completing_word(license_plate: String, words: Vec) -> String { 6 | let mut m = HashMap::new(); 7 | license_plate 8 | .chars() 9 | .map(|c| match c { 10 | 'a'..='z' | 'A'..='Z' => { 11 | let c = c.to_ascii_lowercase(); 12 | m.entry(c).and_modify(|e| *e += 1).or_insert(1); 13 | } 14 | _ => {} 15 | }) 16 | .for_each(drop); 17 | 18 | let mut res = "".to_string(); 19 | 'outer: for x in words { 20 | let mut char_cnt = HashMap::new(); 21 | x.chars() 22 | .map(|c| { 23 | char_cnt.entry(c).and_modify(|e| *e += 1).or_insert(1); 24 | }) 25 | .for_each(drop); 26 | 27 | for (x, y) in m.iter() { 28 | if char_cnt.get(x).unwrap_or(&0) < y { 29 | continue 'outer; 30 | } 31 | } 32 | 33 | if res.is_empty() || x.len() < res.len() { 34 | res = x.to_string(); 35 | } 36 | } 37 | 38 | return res.to_string(); 39 | } 40 | } 41 | 42 | fn main() { 43 | println!( 44 | "{:?}", 45 | Solution::shortest_completing_word( 46 | "1s3 PSt".to_string(), 47 | vec![ 48 | "step".to_string(), 49 | "steps".to_string(), 50 | "stripe".to_string(), 51 | "stepple".to_string() 52 | ] 53 | ) 54 | ); 55 | } 56 | -------------------------------------------------------------------------------- /S0771-jewels-and-stones/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0771" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0771-jewels-and-stones/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashSet; 2 | struct Solution; 3 | 4 | impl Solution { 5 | pub fn num_jewels_in_stones(j: String, s: String) -> i32 { 6 | let j = j.as_bytes(); 7 | let s = s.as_bytes(); 8 | let mut cnt = 0; 9 | let mut diamond_set = HashSet::new(); 10 | for c in j { 11 | diamond_set.insert(c); 12 | } 13 | for c in s { 14 | if diamond_set.contains(c) { 15 | cnt += 1; 16 | } 17 | } 18 | return cnt; 19 | } 20 | } 21 | 22 | fn main() { 23 | println!("{}", Solution::num_jewels_in_stones("aA".to_string(), "aAAbbbb".to_string())); 24 | println!("{}", Solution::num_jewels_in_stones("z".to_string(), "ZZ".to_string())); 25 | 26 | } 27 | -------------------------------------------------------------------------------- /S0789-escape-the-ghosts/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0789-escape-the-ghosts" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0789-escape-the-ghosts/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn escape_ghosts(ghosts: Vec>, target: Vec) -> bool { 5 | // 只要本体和目标的距离 < 任何一个 ghost 到目标的距离，就可以获胜 6 | // 否则的话 ghost 可以选择行动模式： 7 | // 1.先不管本体，直接走到终点 8 | // 2.这样不管本体怎么走，最终都没法获胜了 9 | let target_dist = target[0].abs() + target[1].abs(); 10 | let mut res = true; 11 | ghosts.iter().for_each(|g|{ 12 | if (g[0]-target[0]).abs() + (g[1]-target[1]).abs() < target_dist { 13 | res = false; 14 | } 15 | }); 16 | 17 | res 18 | } 19 | } 20 | 21 | fn main() { 22 | } 23 | -------------------------------------------------------------------------------- /S0817-linked-list-components/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0817-linked-list-components" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0817-linked-list-components/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | // Definition for singly-linked list. 3 | #[derive(PartialEq, Eq, Debug)] 4 | pub struct ListNode { 5 | pub val: i32, 6 | pub next: Option> 7 | } 8 | 9 | impl ListNode { 10 | #[inline] 11 | fn new(val: i32) -> Self { 12 | ListNode { 13 | next: None, 14 | val 15 | } 16 | } 17 | } 18 | use std::collections::HashSet; 19 | impl Solution { 20 | pub fn num_components(head: Option>, g: Vec) -> i32 { 21 | let mut cur = head; 22 | let mut passing_component = false; 23 | let set = g.iter().collect::>(); 24 | let mut res = 0; 25 | while cur.is_some() { 26 | if passing_component == false { 27 | if set.contains(&cur.as_ref().unwrap().val) { 28 | passing_component = true; 29 | } 30 | } else { 31 | if !set.contains(&cur.as_ref().unwrap().val) { 32 | passing_component = false; 33 | res += 1; 34 | } 35 | } 36 | cur = cur.unwrap().next; 37 | } 38 | 39 | if passing_component == true { 40 | return res + 1; 41 | } 42 | res 43 | } 44 | } 45 | 46 | fn main() { 47 | println!("Hello, world!"); 48 | } 49 | -------------------------------------------------------------------------------- /S0876-middle-of-the-linked-list/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0876-middle-of-the-linked-list" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0876-middle-of-the-linked-list/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | // Definition for singly-linked list. 3 | #[derive(PartialEq, Eq, Debug)] 4 | pub struct ListNode { 5 | pub val: i32, 6 | pub next: Option> 7 | } 8 | 9 | impl ListNode { 10 | #[inline] 11 | fn new(val: i32) -> Self { 12 | ListNode { 13 | next: None, 14 | val 15 | } 16 | } 17 | } 18 | impl Solution { 19 | pub fn middle_node(mut head: Option>) -> Option> { 20 | // 先遍历一遍计数 21 | let mut cnt = 0; 22 | let mut cur = &mut head; 23 | loop { 24 | if cur.is_none() { 25 | break; 26 | } 27 | cnt+=1; 28 | cur = &mut cur.as_mut().unwrap().next; 29 | } 30 | cur = &mut head; 31 | let mut i = 0; 32 | while i != cnt/2 { 33 | cur = &mut cur.as_mut().unwrap().next; 34 | i+=1; 35 | } 36 | return cur.take(); 37 | } 38 | } 39 | 40 | fn main() { 41 | println!("Hello, world!"); 42 | } 43 | -------------------------------------------------------------------------------- /S0877-stone-game/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0877-stone-game" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0877-stone-game/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | impl Solution { 3 | pub fn stone_game(piles: Vec) -> bool { 4 | return true 5 | } 6 | } 7 | 8 | fn main() { 9 | println!("Hello, world!"); 10 | } 11 | -------------------------------------------------------------------------------- /S0884-uncommon-words-from-two-sentences/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0884-uncommon-words-from-two-sentences" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0884-uncommon-words-from-two-sentences/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let res = Solution::uncommon_from_sentences("abc def".to_string(), "def aaa".to_string()); 3 | println!("{:?}", res); 4 | } 5 | 6 | struct Solution; 7 | 8 | use std::collections::HashMap; 9 | impl Solution { 10 | pub fn uncommon_from_sentences(a: String, b: String) -> Vec { 11 | let line = a + " " + b.as_str(); 12 | let word_arr = line.split(" ").collect::>(); 13 | 14 | let mut counter = HashMap::new(); 15 | word_arr.iter().for_each(|w| { 16 | counter.entry(w).and_modify(|e| *e += 1).or_insert(1); 17 | }); 18 | counter 19 | .iter() 20 | .filter(|(_, &c)| c == 1) 21 | .map(|(w, _)| w.to_string()) 22 | .collect::>() 23 | 24 | /* 合并为 filter_map 也可以 25 | counter 26 | .iter() 27 | .filter_map(|(w, &c)| if c == 1 { Some(w.to_string()) } else { None }) 28 | .collect::>() 29 | */ 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /S0889-construct-binary-tree-from-preorder-and-postorder-traversal/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0889-construct-binary-tree-from-preorder-and-postorder-traversal" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" 9 | -------------------------------------------------------------------------------- /S0889-construct-binary-tree-from-preorder-and-postorder-traversal/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | // Definition for a binary tree node. 4 | // #[derive(Debug, PartialEq, Eq)] 5 | // pub struct TreeNode { 6 | // pub val: i32, 7 | // pub left: Option>>, 8 | // pub right: Option>>, 9 | // } 10 | // 11 | // impl TreeNode { 12 | // #[inline] 13 | // pub fn new(val: i32) -> Self { 14 | // TreeNode { 15 | // val, 16 | // left: None, 17 | // right: None 18 | // } 19 | // } 20 | // } 21 | use std::cell::RefCell; 22 | use std::rc::Rc; 23 | impl Solution { 24 | pub fn construct_from_pre_post(pre: Vec, post: Vec) -> Option>> { 25 | if pre.len() == 0 { 26 | return None; 27 | } 28 | 29 | // root is pre[0] 30 | let (mut left_tree, mut right_tree) = (None, None); 31 | 32 | if pre.len() > 1 { 33 | let left_tree_root_val = pre[1]; 34 | let pos = post.iter().position(|x| *x == left_tree_root_val).unwrap(); 35 | let (left_post, right_post) = post.split_at(pos + 1); 36 | let (left_post, right_post) = ( 37 | left_post.to_vec(), 38 | right_post[..(right_post.len() - 1)].to_vec(), 39 | ); 40 | let (left_pre, right_pre) = ( 41 | pre[1..=left_post.len()].to_vec(), 42 | pre[(left_post.len() + 1)..].to_vec(), 43 | ); 44 | left_tree = Solution::construct_from_pre_post(left_pre, left_post); 45 | right_tree = Solution::construct_from_pre_post(right_pre, right_post); 46 | } 47 | 48 | // need to split the left and the right 49 | Some(Rc::new(RefCell::new(TreeNode { 50 | val: pre[0], 51 | left: left_tree, 52 | right: right_tree, 53 | }))) 54 | } 55 | } 56 | 57 | 58 | 59 | fn main() { 60 | println!("{:?}", Solution::construct_from_pre_post(vec![1,2,4,5,3,6,7], vec![4,5,2,6,7,3,1])); 61 | } 62 | -------------------------------------------------------------------------------- /S0897-increasing-order-search-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0897-increasing-order-search-tree" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" -------------------------------------------------------------------------------- /S0897-increasing-order-search-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | 4 | // Definition for a binary tree node. 5 | // #[derive(Debug, PartialEq, Eq)] 6 | // pub struct TreeNode { 7 | // pub val: i32, 8 | // pub left: Option>>, 9 | // pub right: Option>>, 10 | // } 11 | // 12 | // impl TreeNode { 13 | // #[inline] 14 | // pub fn new(val: i32) -> Self { 15 | // TreeNode { 16 | // val, 17 | // left: None, 18 | // right: None 19 | // } 20 | // } 21 | // } 22 | use std::rc::Rc; 23 | use std::cell::RefCell; 24 | impl Solution { 25 | pub fn increasing_bst(root: Option>>) -> Option>> { 26 | // mid order traversal 27 | let mut v = vec![]; 28 | Solution::traversal(root, &mut v); 29 | let dummy = Rc::new(RefCell::new(TreeNode::new(0))); 30 | let mut cursor = dummy.clone(); 31 | for num in v { 32 | let mut next = Rc::new(RefCell::new(TreeNode::new(num))); 33 | cursor.borrow_mut().right.replace(next.clone()); 34 | cursor = next.clone(); 35 | } 36 | return dummy.borrow_mut().right.take(); 37 | } 38 | 39 | fn traversal(n:Option>>,v : &mut Vec) { 40 | if n.is_none() { 41 | return; 42 | } 43 | 44 | let mut n_b = n.as_ref().unwrap().borrow_mut(); 45 | Solution::traversal(n_b.left.take(), v); 46 | v.push(n_b.val); 47 | Solution::traversal(n_b.right.take(),v); 48 | } 49 | } 50 | 51 | fn main() { 52 | let r = btree![5,3,6,2,4,null,8,1,null,null,null,7,9]; 53 | let x = Solution::increasing_bst(r); 54 | println!("{:?}", x); 55 | } 56 | -------------------------------------------------------------------------------- /S0901-online-stock-span/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0901-online-stock-span" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0901-online-stock-span/src/main.rs: -------------------------------------------------------------------------------- 1 | #[derive(Debug)] 2 | struct StockSpanner { 3 | v: Vec, 4 | } 5 | 6 | /** You can modify the type of `self` for your need. */ 7 | impl StockSpanner { 8 | fn new() -> Self { 9 | return StockSpanner { v: vec![] }; 10 | } 11 | 12 | fn next(&mut self, price: i32) -> i32 { 13 | let mut l = self.v.len(); 14 | let mut v = &mut self.v; 15 | 16 | let mut res = 1; 17 | for i in (0..l).rev() { 18 | if v[i] <= price { 19 | res += 1; 20 | } else { 21 | break; 22 | } 23 | } 24 | 25 | v.push(price); 26 | return res; 27 | } 28 | } 29 | 30 | /** 31 | * Your StockSpanner object will be instantiated and called as such: 32 | * let obj = StockSpanner::new(); 33 | * let ret_1: i32 = obj.next(price); 34 | */ 35 | 36 | fn main() { 37 | let mut s = StockSpanner::new(); 38 | println!("{}", s.next(100)); 39 | println!("{}", s.next(80)); 40 | println!("{}", s.next(60)); 41 | println!("{}", s.next(70)); 42 | println!("{}", s.next(60)); 43 | println!("{}", s.next(75)); 44 | println!("{}", s.next(85)); 45 | println!("{:?}", s); 46 | } 47 | -------------------------------------------------------------------------------- /S0908-smallest-range-i/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0908-smallest-range-i" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0908-smallest-range-i/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | impl Solution { 3 | pub fn smallest_range_i(a: Vec, k: i32) -> i32 { 4 | let (mut max, mut min) = (i32::min_value(), i32::max_value()); 5 | for num in a { 6 | if max < num { 7 | max = num; 8 | } 9 | if min > num { 10 | min = num; 11 | } 12 | } 13 | return (max-min - 2*k).max(0); 14 | } 15 | } 16 | 17 | fn main() { 18 | println!("Hello, world!"); 19 | } 20 | 21 | /* 22 | impl Solution { 23 | pub fn smallest_range_i(a: &mut Vec, k: i32) -> i32 { 24 | use std::cmp::{self}; 25 | 26 | let max = a.iter().cloned().max().unwrap_or(0); 27 | let min = a.iter().cloned().min().unwrap_or(0); 28 | 29 | cmp::max(max - min - 2 * k, 0) 30 | } 31 | } 32 | */ -------------------------------------------------------------------------------- /S0917-reverse-only-letters/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0917-reverse-only-letters" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0917-reverse-only-letters/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn reverse_only_letters(s: String) -> String { 5 | let mut char_arr = vec![]; 6 | let mut nonchar_arr = vec![]; 7 | s.bytes().for_each(|c| match c { 8 | b'a'..=b'z' | b'A'..=b'Z' => char_arr.push(c), 9 | _ => nonchar_arr.push(c), 10 | }); 11 | 12 | let mut char_iter = char_arr.iter().rev(); 13 | let mut nonchar_iter = nonchar_arr.iter(); 14 | let mut byte_arr = vec![]; 15 | s.chars().for_each(|c| match c { 16 | 'a'..='z' | 'A'..='Z' => byte_arr.push(char_iter.next().unwrap().clone()), 17 | _ => byte_arr.push(nonchar_iter.next().unwrap().clone()), 18 | }); 19 | 20 | String::from_utf8(byte_arr).unwrap() 21 | } 22 | } 23 | 24 | fn main() { 25 | println!("{}", Solution::reverse_only_letters("Test1ng-Leet=code-Q!".to_string())) 26 | } 27 | 28 | /* 29 | 30 | impl Solution { 31 | pub fn reverse_only_letters(s: String) -> String { 32 | if s.len()==0{ 33 | return "".to_string(); 34 | } 35 | let mut s = s.as_bytes().to_vec(); 36 | let mut result = String::new(); 37 | 38 | let mut i = 0; 39 | let mut j = s.len() -1; 40 | 41 | while i"] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0922-sort-array-by-parity-ii/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | impl Solution { 3 | pub fn sort_array_by_parity_ii(a: Vec) -> Vec { 4 | let mut res: Vec = vec![]; 5 | if a.len() == 0 { 6 | return res; 7 | } 8 | 9 | let mut odd_idx = 0; 10 | let mut even_idx = 0; 11 | 12 | while odd_idx < a.len() && a[odd_idx] % 2 == 0 { 13 | odd_idx += 1; 14 | } 15 | while even_idx < a.len() && a[even_idx] % 2 != 0 { 16 | even_idx += 1; 17 | } 18 | 19 | while odd_idx < a.len() && even_idx < a.len() { 20 | res.push(a[even_idx]); 21 | even_idx += 1; 22 | res.push(a[odd_idx]); 23 | odd_idx += 1; 24 | // find next even and odd 25 | while odd_idx < a.len() { 26 | if a[odd_idx] % 2 == 0 { 27 | odd_idx += 1; 28 | } else { 29 | break; 30 | } 31 | } 32 | while even_idx < a.len() { 33 | if a[even_idx] % 2 != 0 { 34 | even_idx += 1; 35 | } else { 36 | break; 37 | } 38 | } 39 | } 40 | 41 | return res; 42 | } 43 | } 44 | 45 | fn main() { 46 | let v = vec![1, 2, 3, 4, 5,6,7,8]; 47 | println!("{:?}", Solution::sort_array_by_parity_ii(v)); 48 | } 49 | -------------------------------------------------------------------------------- /S0923-3sum-with-multiplicity/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S923-3sum-with-multiplicity" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0925-long-pressed-name/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0925-long-pressed-name" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0925-long-pressed-name/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | impl Solution { 3 | pub fn is_long_pressed_name(name: String, typed: String) -> bool { 4 | if typed.len() < name.len() || name.chars().nth(0).unwrap() != typed.chars().nth(0).unwrap() 5 | { 6 | return false; 7 | } 8 | 9 | let mut idx = 0; 10 | for i in 0..name.len() { 11 | if idx >= typed.len() { 12 | return false; 13 | } 14 | 15 | let c1 = name.chars().nth(i).unwrap(); 16 | let c2 = typed.chars().nth(idx).unwrap(); 17 | 18 | if c1 == c2 { 19 | idx += 1; 20 | continue; 21 | } 22 | 23 | while typed.chars().nth(idx).unwrap() == c2 { 24 | idx += 1; 25 | if idx >= typed.len() { 26 | return false; 27 | } 28 | } 29 | if typed.chars().nth(idx).unwrap()!= c1 { 30 | return false; 31 | } 32 | idx += 1; 33 | } 34 | return true; 35 | } 36 | } 37 | 38 | fn main() { 39 | println!("{}", Solution::is_long_pressed_name("saeed".to_string(), "ssaaedd".to_string())); 40 | println!("{}", Solution::is_long_pressed_name("leelee".to_string(), "lleeelee".to_string())); 41 | println!("{}", Solution::is_long_pressed_name("laiden".to_string(), "laiden".to_string())); 42 | } 43 | -------------------------------------------------------------------------------- /S0929-unique-email-addresses/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0929" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0929-unique-email-addresses/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashSet; 2 | struct Solution; 3 | impl Solution { 4 | pub fn num_unique_emails(emails: Vec) -> i32 { 5 | let mut cnt_set = HashSet::new(); 6 | for m in emails { 7 | let name_and_domain:Vec<&str> = m.split('@').collect(); 8 | let (name, domain) = (name_and_domain[0], name_and_domain[1]); 9 | let name_without_dot = name.replace(".",""); 10 | let name_arr:Vec<&str> = name_without_dot .split('+').collect(); 11 | let name = name_arr[0]; 12 | let addr = vec![name, "@", domain].concat(); 13 | if cnt_set.contains(&addr) { 14 | continue; 15 | } else { 16 | cnt_set.insert(addr); 17 | } 18 | } 19 | return cnt_set.len() as i32; 20 | } 21 | } 22 | 23 | fn main() { 24 | let v = vec!["abc.efg@aaa.com".to_string(), "def+xxx@abc.com".to_string()]; 25 | println!("{}",Solution::num_unique_emails(v)); 26 | } 27 | -------------------------------------------------------------------------------- /S0938-range-sum-of-bst/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0938-range-sum-of-bst" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0938-range-sum-of-bst/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | // Definition for a binary tree node. 4 | #[derive(Debug, PartialEq, Eq)] 5 | pub struct TreeNode { 6 | pub val: i32, 7 | pub left: Option>>, 8 | pub right: Option>>, 9 | } 10 | 11 | impl TreeNode { 12 | #[inline] 13 | pub fn new(val: i32) -> Self { 14 | TreeNode { 15 | val, 16 | left: None, 17 | right: None, 18 | } 19 | } 20 | } 21 | use std::cell::RefCell; 22 | use std::rc::Rc; 23 | impl Solution { 24 | pub fn range_sum_bst(root: Option>>, l: i32, r: i32) -> i32 { 25 | if root.is_none() { 26 | return 0; 27 | } 28 | let mut r_b = root.as_ref().unwrap().borrow_mut(); 29 | if r_b.val > r { 30 | return Solution::range_sum_bst(r_b.left.take(), l, r); 31 | } 32 | if r_b.val < l { 33 | return Solution::range_sum_bst(r_b.right.take(), l, r); 34 | } 35 | return r_b.val 36 | + Solution::range_sum_bst(r_b.left.take(), l, r) 37 | + Solution::range_sum_bst(r_b.right.take(), l, r); 38 | } 39 | } 40 | 41 | fn main() { 42 | println!("Hello, world!"); 43 | } 44 | -------------------------------------------------------------------------------- /S0942-di-string-match/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0942-di-string-match" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0942-di-string-match/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | impl Solution { 3 | pub fn di_string_match(s: String) -> Vec { 4 | let v: Vec = (0..=s.len()).map(|x| x as i32).collect(); 5 | let (mut v_iter, mut v_rev_iter) = (v.iter(), v.iter().rev()); 6 | let mut res = vec![]; 7 | 8 | s.chars() 9 | .map(|c| match c { 10 | 'D' => res.push(*v_rev_iter.next().unwrap()), 11 | 'I' => res.push(*v_iter.next().unwrap()), 12 | _ => {} 13 | }) 14 | .for_each(drop); 15 | res.push(*v_iter.next().unwrap()); 16 | 17 | return res; 18 | } 19 | } 20 | 21 | fn main() { 22 | println!("{:?}", Solution::di_string_match("IDID".to_string())); 23 | } 24 | 25 | /* 26 | impl Solution { 27 | pub fn di_string_match(s: String) -> Vec { 28 | let mut a = 0; 29 | let mut b = s.len() as i32; 30 | let mut result:Vec = Vec::new(); 31 | 32 | for i in s.chars() { 33 | match i { 34 | 'I'=>{ 35 | result.push(a); 36 | a += 1; 37 | }, 38 | 'D'=>{ 39 | result.push(b); 40 | b -= 1; 41 | }, 42 | _ =>(), 43 | } 44 | } 45 | 46 | result.push(a); 47 | 48 | result 49 | 50 | 51 | } 52 | } 53 | */ 54 | -------------------------------------------------------------------------------- /S0946-validate-stack-sequences/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0946-validate-stack-sequences" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0946-validate-stack-sequences/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use std::collections::HashMap; 3 | 4 | impl Solution { 5 | pub fn validate_stack_sequences(pushed: Vec, popped: Vec) -> bool { 6 | let mut stack= vec![]; 7 | let mut cursor = 0; 8 | let mut cursor_pushed = 0; 9 | while cursor_pushed < pushed.len() { 10 | //println!("stack: {:?}, popped:{:?}, cursor:{}", stack,popped, cursor); 11 | if stack.len() == 0 { 12 | stack.push(pushed[cursor_pushed]); 13 | cursor_pushed+=1; 14 | continue; 15 | } 16 | if stack[stack.len()-1] != popped[cursor] { 17 | stack.push(pushed[cursor_pushed]); 18 | cursor_pushed+=1; 19 | continue; 20 | } 21 | // stack len > 0 and top = popped[cursor] 22 | stack.pop(); 23 | cursor+=1; 24 | } 25 | 26 | //println!("stack: {:?}, popped:{:?}, cursor:{}", stack,popped, cursor); 27 | for i in cursor..popped.len() { 28 | if stack.pop().unwrap() != popped[i] { 29 | return false; 30 | } 31 | } 32 | 33 | return true; 34 | } 35 | } 36 | 37 | fn main() { 38 | println!("{}", Solution::validate_stack_sequences(vec![1,2,3,4,5], vec![4,5,3,2,1])); 39 | } 40 | -------------------------------------------------------------------------------- /S0949-largest-time-for-given-digits/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0949-largest-time-for-given-digits" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0949-largest-time-for-given-digits/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | impl Solution { 3 | pub fn largest_time_from_digits(a: Vec) -> String { 4 | let mut res = "".to_string(); 5 | for i in 0..a.len() { 6 | for j in 0..a.len() { 7 | for k in 0..a.len() { 8 | for l in 0..a.len() { 9 | if i == j || i == k || i == l || j == k || j == l || k == l { 10 | continue; 11 | } 12 | let mut tmp = (a[i]).to_string(); 13 | tmp.push_str(&(a[j]).to_string()); 14 | tmp.push(':'); 15 | tmp.push_str(&(a[k]).to_string()); 16 | tmp.push_str(&(a[l]).to_string()); 17 | if a[i] > 2 { 18 | continue; 19 | } 20 | if a[i] == 2 { 21 | if a[j] >= 4 { 22 | continue; 23 | } 24 | } 25 | if a[k] >=6 { 26 | continue; 27 | } 28 | if tmp > res { 29 | res = tmp; 30 | } 31 | } 32 | } 33 | } 34 | } 35 | return res; 36 | } 37 | } 38 | 39 | fn main() { 40 | println!("{}", Solution::largest_time_from_digits(vec![1,2,3,4])); 41 | println!("{}", Solution::largest_time_from_digits(vec![5,5,5,5])); 42 | } 43 | -------------------------------------------------------------------------------- /S0951-flip-equivalent-binary-trees/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0951" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0951-flip-equivalent-binary-trees/src/main.rs: -------------------------------------------------------------------------------- 1 | // Definition for a binary tree node. 2 | #![feature(nll)] 3 | #[derive(Debug, PartialEq, Eq)] 4 | pub struct TreeNode { 5 | pub val: i32, 6 | pub left: Option>>, 7 | pub right: Option>>, 8 | } 9 | 10 | impl TreeNode { 11 | #[inline] 12 | pub fn new(val: i32) -> Self { 13 | TreeNode { 14 | val, 15 | left: None, 16 | right: None, 17 | } 18 | } 19 | } 20 | 21 | struct Solution; 22 | 23 | use std::cell::RefCell; 24 | use std::rc::Rc; 25 | impl Solution { 26 | pub fn flip_equiv( 27 | root1: Option>>, 28 | root2: Option>>, 29 | ) -> bool { 30 | match (&root1, &root2) { 31 | (Some(_), None) => return false, 32 | (None, Some(_)) => return false, 33 | (None, None) => return true, 34 | (Some(r1), Some(r2)) => { 35 | // 那么就要左左比较 36 | // 否则要右右比较 37 | if r1.borrow().val != r2.borrow().val { 38 | return false; 39 | } 40 | 41 | // 不用 take 怎么都过不了编译 42 | // 不信你试试 43 | let mut r1_b = r1.borrow_mut(); 44 | let mut r2_b = r2.borrow_mut(); 45 | let (r1_l, r1_r, r2_l, r2_r) = ( 46 | r1_b.left.take(), 47 | r1_b.right.take(), 48 | r2_b.left.take(), 49 | r2_b.right.take(), 50 | ); 51 | 52 | match (&r1_l, &r2_l) { 53 | (None, None) => { 54 | /* 55 | O O 56 | / \ / \ 57 | None Some/None None Some/None 58 | */ 59 | return Solution::flip_equiv(r1_l, r2_l) && Solution::flip_equiv(r1_r, r2_r) 60 | }, 61 | (Some(_), Some(_)) => { 62 | /* 63 | O O 64 | / \ / \ 65 | Some Some/None Some Some/None 66 | */ 67 | if r1_l.as_ref().unwrap().borrow().val == r2_l.as_ref().unwrap().borrow().val { 68 | return Solution::flip_equiv(r1_l, r2_l) && Solution::flip_equiv(r1_r, r2_r); 69 | } 70 | }, 71 | (_, _) => return Solution::flip_equiv(r1_l, r2_r) && Solution::flip_equiv(r1_r, r2_l), 72 | } 73 | 74 | // 这里理论上是 unreachable 75 | return false; 76 | } 77 | } 78 | } 79 | } 80 | 81 | fn main() { 82 | let r1 = Some(Rc::new(RefCell::new(TreeNode::new(0)))); 83 | let r2 = Some(Rc::new(RefCell::new(TreeNode::new(0)))); 84 | { 85 | let x = r1.as_ref().unwrap(); 86 | x.borrow_mut().left = Some(Rc::new(RefCell::new(TreeNode::new(1)))); 87 | } 88 | { 89 | let x = r2.as_ref().unwrap(); 90 | x.borrow_mut().left = Some(Rc::new(RefCell::new(TreeNode::new(1)))); 91 | } 92 | { 93 | println!("{:?}, {:?}", r1, r2); 94 | } 95 | println!("{}", Solution::flip_equiv(r1, r2)); 96 | } 97 | -------------------------------------------------------------------------------- /S0953-verifying-an-alien-dictionary/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S953" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0953-verifying-an-alien-dictionary/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashMap; 2 | 3 | struct Solution; 4 | 5 | impl Solution { 6 | pub fn is_alien_sorted(words: Vec, order: String) -> bool { 7 | let mut map : HashMap = HashMap::new(); 8 | let order = order.as_bytes(); 9 | for i in 0..order.len() { 10 | map.insert(order[i], i as i32); 11 | } 12 | 13 | for i in 1..(words.len()) { 14 | if !Solution::bigger_than(&words[i], &words[i-1], &map) { 15 | return false; 16 | } 17 | } 18 | return true; 19 | } 20 | 21 | fn bigger_than(a: &String, b: &String, dict: &HashMap) -> bool { 22 | let (a, b) = (a.as_bytes(), b.as_bytes()); 23 | let mut l = a.len(); 24 | if b.len() < a.len() { 25 | l = b.len(); 26 | } 27 | 28 | for idx in 0..l { 29 | if dict.get(&a[idx]) > dict.get(&b[idx]) { 30 | return true; 31 | } 32 | if dict.get(&a[idx]) < dict.get(&b[idx]) { 33 | return false; 34 | } 35 | // == continue 36 | } 37 | 38 | if a.len() > b.len() { 39 | return true; 40 | } 41 | return false; 42 | } 43 | } 44 | 45 | fn main() { 46 | assert_eq!(true, Solution::is_alien_sorted(vec!["hello".to_string(),"leetcode".to_string()], "hlabcdefgijkmnopqrstuvwxyz".to_string())); 47 | assert_eq!(false, Solution::is_alien_sorted(vec!["apple".to_string(),"app".to_string()], "abcdefghijklmnopqrstuvwxyz".to_string())); 48 | assert_eq!(false, Solution::is_alien_sorted( 49 | vec!["word".to_string(),"world".to_string(),"row".to_string()], 50 | "worldabcefghijkmnpqstuvxyz".to_string()) 51 | ); 52 | } 53 | -------------------------------------------------------------------------------- /S0958-check-completeness-of-a-binary-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0958" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0958-check-completeness-of-a-binary-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | // Definition for a binary tree node. 2 | 3 | #[derive(Debug, PartialEq, Eq)] 4 | pub struct TreeNode { 5 | pub val: i32, 6 | pub left: Option>>, 7 | pub right: Option>>, 8 | } 9 | 10 | impl TreeNode { 11 | #[inline] 12 | pub fn new(val: i32) -> Self { 13 | TreeNode { 14 | val, 15 | left: None, 16 | right: None, 17 | } 18 | } 19 | } 20 | 21 | use std::cell::RefCell; 22 | use std::rc::Rc; 23 | 24 | struct Solution; 25 | impl Solution { 26 | pub fn is_complete_tree(root: Option>>) -> bool { 27 | if root.is_none() { 28 | return true; 29 | } 30 | 31 | let mut cur_level: Vec>>> = vec![root]; 32 | 33 | loop { 34 | let mut next_level: Vec>>> = vec![]; 35 | let mut next_level_has_some = false; 36 | for (idx, elem) in cur_level.iter().enumerate() { 37 | match elem { 38 | Some(x) => { 39 | if idx > 0 && cur_level[idx-1].is_none() { 40 | return false; 41 | } 42 | let left = x.borrow_mut().left.take(); 43 | let right = x.borrow_mut().right.take(); 44 | if left.is_some()||right.is_some() { 45 | next_level_has_some = true; 46 | } 47 | 48 | next_level.push(left); 49 | next_level.push(right); 50 | } 51 | None => { 52 | if next_level.len() > 0 && next_level_has_some == true{ 53 | return false; 54 | } 55 | if idx == cur_level.len()-1 && next_level_has_some == false{ 56 | return true; 57 | } 58 | }, 59 | } 60 | } 61 | cur_level = next_level; 62 | //println!("{:?}", next_level); 63 | } 64 | return false; 65 | } 66 | } 67 | 68 | fn main() { 69 | let mut root = Some(Rc::new(RefCell::new(TreeNode::new(0)))); 70 | let res = Solution::is_complete_tree(root); 71 | println!("{}", res); 72 | let mut root = Some(Rc::new(RefCell::new(TreeNode::new(0)))); 73 | root.as_ref().unwrap().borrow_mut().right = Some(Rc::new(RefCell::new(TreeNode::new(0)))); 74 | let res = Solution::is_complete_tree(root); 75 | println!("{}", res); 76 | let mut root = Some(Rc::new(RefCell::new(TreeNode::new(0)))); 77 | root.as_ref().unwrap().borrow_mut().left= Some(Rc::new(RefCell::new(TreeNode::new(0)))); 78 | let res = Solution::is_complete_tree(root); 79 | println!("{}", res); 80 | } 81 | -------------------------------------------------------------------------------- /S0961-n-repeated-element-in-size-2n-array/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0961" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0961-n-repeated-element-in-size-2n-array/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashMap; 2 | 3 | struct Solution; 4 | 5 | impl Solution { 6 | pub fn repeated_n_times(a: Vec) -> i32 { 7 | let mut cnt_map = HashMap::new(); 8 | let must_match_cnt = (a.len() as i32)/2; 9 | 10 | for n in a { 11 | if let Some(c) = cnt_map.get(&n) { 12 | cnt_map.insert(n, c+1); 13 | } else { 14 | cnt_map.insert(n,1); 15 | } 16 | } 17 | 18 | for (k,cnt) in cnt_map { 19 | if cnt == must_match_cnt { 20 | return k; 21 | } 22 | } 23 | return 0; 24 | } 25 | } 26 | 27 | fn main() { 28 | assert_eq!(Solution::repeated_n_times(vec![1,2,3,3]), 3); 29 | assert_eq!(Solution::repeated_n_times(vec![2,1,2,5,3,2]), 2); 30 | assert_eq!(Solution::repeated_n_times(vec![5,1,5,2,5,3,5,4]), 5); 31 | } 32 | -------------------------------------------------------------------------------- /S0965-univalued-binary-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0965-univalued-binary-tree" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude = "^0.1" 9 | -------------------------------------------------------------------------------- /S0965-univalued-binary-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | use leetcode_prelude::*; 2 | struct Solution; 3 | // Definition for a binary tree node. 4 | // #[derive(Debug, PartialEq, Eq)] 5 | // pub struct TreeNode { 6 | // pub val: i32, 7 | // pub left: Option>>, 8 | // pub right: Option>>, 9 | // } 10 | // 11 | // impl TreeNode { 12 | // #[inline] 13 | // pub fn new(val: i32) -> Self { 14 | // TreeNode { 15 | // val, 16 | // left: None, 17 | // right: None 18 | // } 19 | // } 20 | // } 21 | use std::rc::Rc; 22 | use std::cell::RefCell; 23 | impl Solution { 24 | pub fn is_unival_tree(root: Option>>) -> bool { 25 | //println!("{:?}", root); 26 | if root.is_none() { 27 | return true; 28 | } 29 | let r_u = root.unwrap(); 30 | let mut r_b = r_u.borrow_mut(); 31 | 32 | if let Some(l) = r_b.left.take() { 33 | if l.borrow_mut().val != r_b.val { 34 | return false; 35 | } 36 | r_b.left = Some(l); 37 | } 38 | 39 | if let Some(r) = r_b.right.take() { 40 | if r.borrow_mut().val != r_b.val { 41 | return false; 42 | } 43 | r_b.right = Some(r); 44 | } 45 | return Solution::is_unival_tree(r_b.left.take()) && Solution::is_unival_tree(r_b.right.take()); 46 | } 47 | } 48 | 49 | fn main() { 50 | //let r = btree![1,2,3,4,null]; 51 | //println!("{}", Solution::is_unival_tree(r)); 52 | //let r = btree![1,1,1,1,1]; 53 | //println!("{}", Solution::is_unival_tree(r)); 54 | let r = btree![2,2,2,5,2]; 55 | println!("{}", Solution::is_unival_tree(r)); 56 | } 57 | -------------------------------------------------------------------------------- /S0966-vowel-spellchecker/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0966-vowel-spellchecker" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0966-vowel-spellchecker/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use std::collections::HashMap; 3 | 4 | impl Solution { 5 | pub fn spellchecker(wordlist: Vec, queries: Vec) -> Vec { 6 | let mut word_map = HashMap::new(); 7 | let mut word_lower_map = HashMap::new(); 8 | let mut replace_vowel_map = HashMap::new(); 9 | for w in wordlist.iter() { 10 | word_map.insert(w, w); 11 | if !word_lower_map.contains_key(&w.to_ascii_lowercase()) { 12 | word_lower_map.insert(w.to_ascii_lowercase(), w); 13 | } 14 | 15 | let s: String = w.to_ascii_lowercase() 16 | .chars() 17 | .map(|x| match x { 18 | 'a' | 'e' | 'i' | 'o' | 'u' => '?', 19 | _ => x, 20 | }) 21 | .collect::(); 22 | 23 | if !replace_vowel_map.contains_key(&s) { 24 | replace_vowel_map.insert(s, w); 25 | } 26 | } 27 | 28 | let res = queries 29 | .into_iter() 30 | .map(|w| { 31 | if word_map.contains_key(&w) { 32 | return word_map.get(&w).unwrap().to_string(); 33 | } 34 | let x = w.to_ascii_lowercase(); 35 | if word_lower_map.contains_key(&x) { 36 | return word_lower_map.get(&x).unwrap().to_string(); 37 | } 38 | let s: String = w.to_ascii_lowercase() 39 | .chars() 40 | .map(|x| match x { 41 | 'a' | 'e' | 'i' | 'o' | 'u' => '?', 42 | _ => x, 43 | }) 44 | .collect::(); 45 | if replace_vowel_map.contains_key(&s) { 46 | return replace_vowel_map.get(&s).unwrap().to_string(); 47 | } 48 | return "".to_string(); 49 | }) 50 | .collect::>(); 51 | //println!("{:?}", word_map); 52 | //println!("{:?}", word_lower_map); 53 | //println!("{:?}", replace_vowel_map); 54 | return res; 55 | } 56 | } 57 | 58 | fn main() { 59 | let mut a = vec!["KiTe", "kite", "hare", "Hare"]; 60 | let mut a = a 61 | .into_iter() 62 | .map(|w| w.to_string()) 63 | .collect::>(); 64 | let b = vec![ 65 | "kite", "Kite", "KiTe", "Hare", "HARE", "Hear", "hear", "keti", "keet", "keto", 66 | ]; 67 | let mut b = b 68 | .into_iter() 69 | .map(|w| w.to_string()) 70 | .collect::>(); 71 | println!("{:?}", Solution::spellchecker(a, b)); 72 | 73 | let mut a = vec!["v", "t", "k", "g", "n", "k", "u", "h", "m", "p"]; 74 | let mut a = a 75 | .into_iter() 76 | .map(|w| w.to_string()) 77 | .collect::>(); 78 | let b = vec!["n", "g", "k", "q", "m", "h", "x", "t", "p", "p"]; 79 | let mut b = b 80 | .into_iter() 81 | .map(|w| w.to_string()) 82 | .collect::>(); 83 | println!("{:?}", Solution::spellchecker(a, b)); 84 | } 85 | -------------------------------------------------------------------------------- /S0970-powerful-integers/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0970-powerful-integers" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0970-powerful-integers/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | use std::collections::HashSet; 4 | impl Solution { 5 | pub fn powerful_integers(x: i32, y: i32, bound: i32) -> Vec { 6 | let mut set = HashSet::new(); 7 | let (xb, yb) = ( 8 | ((bound as f64).log(x as f64) as i32).max(1), 9 | ((bound as f64).log(y as f64) as i32).max(1), 10 | ); 11 | 12 | (0..=xb) 13 | .map(|i| { 14 | (0..=yb) 15 | .map(|j| { 16 | let num = ((x as f64).powi(i) + (y as f64).powi(j)) as i32; 17 | if num <= bound && num > 0 { 18 | set.insert(num); 19 | } 20 | }) 21 | .for_each(drop); 22 | }) 23 | .for_each(drop); 24 | 25 | set.iter().map(|&num| num).collect() 26 | } 27 | } 28 | 29 | fn main() { 30 | println!("{:?}", Solution::powerful_integers(2, 3, 10)); 31 | println!("{:?}", Solution::powerful_integers(90, 90, 1000000)); 32 | println!("{:?}", Solution::powerful_integers(1, 2, 100)); 33 | } 34 | -------------------------------------------------------------------------------- /S0973-k-closest-points-to-origin/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0973-k-closest-points-to-origin" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0973-k-closest-points-to-origin/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | // 也可以用小顶堆来搞 5 | // binaryheap 6 | 7 | pub fn k_closest(points: Vec>, k: i32) -> Vec> { 8 | let mut points = points.clone(); 9 | points.sort_by(|a, b| { 10 | (a[0] * a[0] + a[1] * a[1]).cmp(&(b[0] * b[0] + b[1] * b[1])) 11 | }); 12 | 13 | return points[0..k as usize].to_vec(); 14 | } 15 | } 16 | 17 | fn main() { 18 | println!( 19 | "{:?}", 20 | Solution::k_closest(vec![vec![1, 3], vec![-2, 2]], 1) 21 | ); 22 | println!( 23 | "{:?}", 24 | Solution::k_closest(vec![vec![3, 3], vec![5, -1], vec![-2, 4]], 2) 25 | ); 26 | } 27 | -------------------------------------------------------------------------------- /S0976-largest-perimeter-triangle/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0976-largest-perimeter-triangle" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0976-largest-perimeter-triangle/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn largest_perimeter(a: Vec) -> i32 { 5 | let mut a = a.clone(); 6 | a.sort_by(|x, y| y.cmp(x)); 7 | //println!("{:?}", a); 8 | for i in 2..a.len() { 9 | if Solution::is_valid(a[i], a[i - 1], a[i - 2]) { 10 | return a[i] + a[i - 1] + a[i - 2]; 11 | } 12 | } 13 | 0 14 | } 15 | 16 | pub fn is_valid(a: i32, b: i32, c: i32) -> bool { 17 | if a + b > c && a + c > b && b + c > a { 18 | return true; 19 | } 20 | return false; 21 | } 22 | } 23 | 24 | fn main() { 25 | println!("{}", Solution::largest_perimeter(vec![2,1,2])); 26 | } 27 | -------------------------------------------------------------------------------- /S0977-squares-of-a-sorted-array/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0977-squares-of-a-sorted-array" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0977-squares-of-a-sorted-array/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | impl Solution { 3 | pub fn sorted_squares(a: Vec) -> Vec { 4 | let mut res = a.iter().map(|x|(*x)*(*x)).collect::>(); 5 | res.sort(); 6 | res 7 | } 8 | } 9 | 10 | fn main() { 11 | println!("Hello, world!"); 12 | } 13 | -------------------------------------------------------------------------------- /S0978-longest-turbulent-subarray/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0978-longest-turbulent-subarray" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0978-longest-turbulent-subarray/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn max_turbulence_size(a: Vec) -> i32 { 5 | if a.len() <= 1 { 6 | return a.len() as i32; 7 | } 8 | 9 | let (mut idx, mut max_len) = (1, 1); 10 | let mut cur_len = 1; 11 | while idx < (a.len() as i32) { 12 | if idx %2 != 0 { 13 | if a[idx as usize] < a[(idx-1) as usize] { 14 | cur_len += 1; 15 | } else { 16 | cur_len = 1; 17 | } 18 | } 19 | if idx %2 == 0 { 20 | if a[idx as usize] > a[(idx-1) as usize] { 21 | cur_len += 1; 22 | } else { 23 | cur_len = 1; 24 | } 25 | } 26 | max_len = max_len.max(cur_len); 27 | idx += 1; 28 | } 29 | 30 | let mut idx = 1; 31 | let mut cur_len = 1; 32 | while idx < (a.len() as i32) { 33 | if idx %2 == 0 { 34 | if a[idx as usize] < a[(idx-1) as usize] { 35 | cur_len += 1; 36 | } else { 37 | cur_len = 1; 38 | } 39 | } 40 | if idx %2 != 0 { 41 | if a[idx as usize] > a[(idx-1) as usize] { 42 | cur_len += 1; 43 | } else { 44 | cur_len = 1; 45 | } 46 | } 47 | max_len = max_len.max(cur_len); 48 | idx += 1; 49 | } 50 | max_len 51 | } 52 | } 53 | 54 | fn main() { 55 | println!("{}", Solution::max_turbulence_size(vec![0,1,1,0,1,0,1,1,0,0])); 56 | println!("{}", Solution::max_turbulence_size(vec![9,4,2,10,7,8,8,1,9])); 57 | } 58 | -------------------------------------------------------------------------------- /S0979-distribute-coins-in-binary-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0979-distribute-coins-in-binary-tree" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="^0.1" 9 | -------------------------------------------------------------------------------- /S0979-distribute-coins-in-binary-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | use leetcode_prelude::*; 3 | 4 | // Definition for a binary tree node. 5 | 6 | use std::cell::RefCell; 7 | use std::rc::Rc; 8 | impl Solution { 9 | pub fn distribute_coins(root: Option>>) -> i32 { 10 | let mut res = 0; 11 | Solution::dfs(root, &mut res); 12 | res 13 | } 14 | 15 | pub fn dfs(root: Option>>, res:&mut i32) -> i32 { 16 | if root.is_none() { 17 | return 0; 18 | } 19 | 20 | let r_u_b = root.as_ref().unwrap().borrow_mut(); 21 | let left_step_cnt = Solution::dfs(r_u_b.left.clone(), res); 22 | let right_step_cnt = Solution::dfs(r_u_b.right.clone(), res); 23 | //println!("{}, {}",left_step_cnt, right_step_cnt); 24 | *res += left_step_cnt.abs() + right_step_cnt.abs(); 25 | 26 | r_u_b.val - 1 + left_step_cnt + right_step_cnt 27 | } 28 | } 29 | 30 | fn main() { 31 | let r = btree![3,0,0]; 32 | //println!("{}", Solution::distribute_coins(r)); 33 | println!("{}", Solution::distribute_coins(btree![1,0,0,null,3])); 34 | } 35 | -------------------------------------------------------------------------------- /S0982-triples-with-bitwise-and-equal-to-zero/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0982-triples-with-bitwise-and-equal-to-zero" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | -------------------------------------------------------------------------------- /S0982-triples-with-bitwise-and-equal-to-zero/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("Hello, world!"); 3 | } 4 | 5 | struct Solution; 6 | impl Solution { 7 | pub fn count_triplets(a: Vec) -> i32 { 8 | let mut res = 0; 9 | (0..a.len()).for_each(|i| { 10 | (i..a.len()).for_each(|j| { 11 | let tmp = a[i] & a[j]; 12 | (j..a.len()).for_each(|k| { 13 | if tmp & a[k] == 0 { 14 | if i == j && j == k { 15 | res += 1; 16 | } else if i == j || j == k || i == k { 17 | res += 3; 18 | } else { 19 | res += 6; 20 | } 21 | } 22 | }) 23 | }) 24 | }); 25 | res 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /S0993-cousins-in-binary-tree/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S0993-cousins-in-binary-tree" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | [dependencies] 8 | leetcode_prelude="0.1" 9 | -------------------------------------------------------------------------------- /S0993-cousins-in-binary-tree/src/main.rs: -------------------------------------------------------------------------------- 1 | use leetcode_prelude::*; 2 | fn main() { 3 | let tree = btree![1,2,3,null,4,null,5]; 4 | println!("{}", Solution::is_cousins(tree, 5, 4)); 5 | let tree = btree![1,2,4,3]; 6 | println!("{}", Solution::is_cousins(tree, 3, 4)); 7 | let tree = btree![1,2,3,null, 4]; 8 | println!("{}", Solution::is_cousins(tree, 3, 2)); 9 | } 10 | 11 | 12 | struct Solution; 13 | 14 | use std::cell::RefCell; 15 | use std::rc::Rc; 16 | impl Solution { 17 | pub fn is_cousins(root: Option>>, x: i32, y: i32) -> bool { 18 | let x_idx = Solution::match_traverse(&root, 0, x); 19 | let y_idx = Solution::match_traverse(&root, 0, y); 20 | // 2^n + 0~n-1 21 | let (min, max) = (x_idx.min(y_idx), x_idx.max(y_idx)); 22 | //println!("{},{}", max,min); 23 | // 说明爹一样，不符合定义 24 | if max - min == 1 && max % 2 == 0 { 25 | return false 26 | } 27 | // 说明是同一个节点 28 | if max == min { 29 | return false 30 | } 31 | 32 | // 同一层的节点 log2 的取整结果一定是一样的 33 | return (((max+1) as f32).log2() as i32) == (((min+1) as f32).log2() as i32) 34 | } 35 | 36 | pub fn match_traverse(node: &Option>>, idx: i32, match_v: i32) -> i32 { 37 | if node.is_none() { 38 | return -1; 39 | } 40 | let n_u_b = node.as_ref().unwrap().borrow_mut(); 41 | // match !! 42 | if n_u_b.val == match_v { 43 | return idx; 44 | } 45 | 46 | // 叶子节点 47 | if n_u_b.left.is_none() && n_u_b.right.is_none() { 48 | return -1; 49 | } 50 | 51 | let left_idx= Solution::match_traverse(&n_u_b.left, idx * 2 + 1, match_v); 52 | let right_idx= Solution::match_traverse(&n_u_b.right, idx * 2 + 2, match_v); 53 | 54 | if left_idx != -1 { 55 | return left_idx; 56 | } 57 | 58 | return right_idx; 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /S1019-next-greater-node-in-linked-list/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S1019-next-greater-node-in-linked-list" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /S1019-next-greater-node-in-linked-list/readme.md: -------------------------------------------------------------------------------- 1 | 单调栈 2 | -------------------------------------------------------------------------------- /S1019-next-greater-node-in-linked-list/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("Hello, world!"); 3 | } 4 | 5 | /* 6 | * @lc app=leetcode.cn id=1019 lang=rust 7 | * 8 | * [1019] 链表中的下一个更大节点 9 | */ 10 | // Definition for singly-linked list. 11 | // #[derive(PartialEq, Eq, Clone, Debug)] 12 | // pub struct ListNode { 13 | // pub val: i32, 14 | // pub next: Option> 15 | // } 16 | // 17 | // impl ListNode { 18 | // #[inline] 19 | // fn new(val: i32) -> Self { 20 | // ListNode { 21 | // next: None, 22 | // val 23 | // } 24 | // } 25 | // } 26 | impl Solution { 27 | fn count_len(head: Option>) -> (i32, Vec) { 28 | let mut head = head; 29 | let mut cursor = &mut head; 30 | let mut cnt = 0; 31 | let mut v = vec![]; 32 | loop { 33 | match cursor { 34 | Some(e) => { 35 | cursor = &mut e.next; 36 | cnt += 1; 37 | v.push(e.val); 38 | } 39 | None => break, 40 | } 41 | } 42 | (cnt, v) 43 | } 44 | 45 | pub fn next_larger_nodes(head: Option>) -> Vec { 46 | let mut stack = vec![]; 47 | //let mut index_arr = vec![]; 48 | let (cnt, v) = Self::count_len(head); 49 | let mut res = vec![]; 50 | (0..cnt).for_each(|_| res.push(0)); 51 | for (idx, v) in v.iter().enumerate() { 52 | if stack.is_empty() { 53 | stack.push((v, idx)); 54 | continue; 55 | } 56 | 57 | while !stack.is_empty() && stack.last().unwrap().0 < v { 58 | let (_, i) = stack.pop().unwrap(); 59 | res[i] = *v; 60 | } 61 | stack.push((v, idx)); 62 | } 63 | res 64 | } 65 | } 66 | 67 | 68 | -------------------------------------------------------------------------------- /S1154-ordinal-number-of-date/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "description" 3 | version = "0.1.0" 4 | authors = ["xargin "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /S1154-ordinal-number-of-date/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("Hello, world!"); 3 | } 4 | 5 | /* 6 | * @lc app=leetcode.cn id=1154 lang=rust 7 | * 8 | * [1154] 一年中的第几天 9 | */ 10 | impl Solution { 11 | pub fn day_of_year(date: String) -> i32 { 12 | let day_for_normal = vec![31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; 13 | let day_for_leap = vec![31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; 14 | let ymd: Vec<&str> = date.split("-").collect(); 15 | let (y, m, d) = ( 16 | ymd[0].parse::().unwrap(), 17 | ymd[1].parse::().unwrap(), 18 | ymd[2].parse::().unwrap(), 19 | ); 20 | let mut should_use = day_for_normal; 21 | if Self::is_leap(y) { 22 | should_use = day_for_leap; 23 | } 24 | let mut res = 0; 25 | (0..m - 1).for_each(|i| { 26 | res += should_use[i as usize]; 27 | }); 28 | res + d 29 | } 30 | fn is_leap(y: i32) -> bool { 31 | (y % 4 == 0 && y % 100 != 0) || y % 400 == 0 32 | } 33 | } 34 | 35 | -------------------------------------------------------------------------------- /S1342-number-of-steps-to-reduce-a-number-to-zero/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S1342-number-of-steps-to-reduce-a-number-to-zero" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /S1342-number-of-steps-to-reduce-a-number-to-zero/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | dbg!(Solution::number_of_steps(14)); 3 | } 4 | 5 | struct Solution; 6 | 7 | impl Solution { 8 | pub fn number_of_steps (num: i32) -> i32 { 9 | (num.count_ones() * 2 - 1 + num.count_zeros() - num.leading_zeros()) as i32 10 | } 11 | } -------------------------------------------------------------------------------- /SORT/ms.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let mut a = vec![4,4,3,2,1]; 3 | ms(&mut a); 4 | println!("{:?}",a); 5 | } 6 | 7 | fn ms(arr: &mut Vec) { 8 | if arr.len() == 0 || arr.len() == 1 { 9 | return 10 | } 11 | 12 | let mid = arr.len()/2; 13 | let (l,r ) = arr.split_at_mut(mid); 14 | let (mut l, mut r) = (l.to_vec(), r.to_vec()); 15 | 16 | ms(&mut l); 17 | ms(&mut r); 18 | 19 | let (mut x,mut y, mut merged) = (0,0, vec![]); 20 | while x < l.len() && y < r.len() { 21 | if *l.get(x).unwrap() < *r.get(y).unwrap() { 22 | merged.push(*l.get(x).unwrap()); 23 | x += 1; 24 | } else { 25 | merged.push(*r.get(y).unwrap()); 26 | y+=1; 27 | } 28 | } 29 | while x < l.len() { 30 | merged.push(*l.get(x).unwrap()); 31 | x += 1; 32 | } 33 | while y < r.len() { 34 | merged.push(*r.get(y).unwrap()); 35 | y+=1; 36 | } 37 | 38 | std::mem::replace(arr, merged); 39 | } 40 | -------------------------------------------------------------------------------- /crack_interview/S17-19-missing-two-lcci/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "S17-19-missing-two-lcci" 3 | version = "0.1.0" 4 | authors = ["Xargin "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /crack_interview/S17-19-missing-two-lcci/src/main.rs: -------------------------------------------------------------------------------- 1 | struct Solution; 2 | 3 | impl Solution { 4 | pub fn missing_two(nums: Vec) -> Vec { 5 | let mut res = vec![]; 6 | (0..nums.len()).for_each(|i|{ 7 | if nums[i] == i as i32 + 2 && res.len() == 0 { 8 | res.push(nums[i] - 1); 9 | } 10 | if nums[i] == i as i32 + 3 && res.len() == 0 { 11 | res.push(nums[i] - 2); 12 | res.push(nums[i] - 1); 13 | } 14 | if nums[i] == i as i32 + 3 && res.len() == 1 { 15 | res.push(nums[i] - 1); 16 | } 17 | }); 18 | 19 | if res.len() == 0 { 20 | res.push(nums.len() as i32+1); 21 | res.push(nums.len() as i32+2); 22 | } 23 | if res.len() == 1 { 24 | res.push(nums.len() as i32 + 2); 25 | } 26 | res 27 | } 28 | } 29 | 30 | fn main() { 31 | dbg!(Solution::missing_two(vec![1])); 32 | dbg!(Solution::missing_two(vec![2, 3])); 33 | } 34 | 35 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | # Overview 2 | 3 | 听说 rust 写数据结构很难，做点知男而上的事情。 4 | 5 | ## Similar Repos in rust 6 | 7 | https://github.com/Aloxaf/LeetCode-Rust 8 | 9 | https://github.com/caibirdme/leetcode_rust 10 | 11 | https://github.com/aylei/leetcode-rust 12 | 13 | 14 | ## other language 15 | 16 | 之前已经写了 150+ 的 Go 版，如果不是闲得蛋疼，就不翻译了。除了数据结构题，其它尽量不做重叠部分。 17 | 18 | https://github.com/cch123/leetcode-go 19 | --------------------------------------------------------------------------------