From dfe80b959f12e0e03b76887681d8ffc058eb9d8d Mon Sep 17 00:00:00 2001 From: taro <34352544+tarolling@users.noreply.github.com> Date: Sat, 23 Nov 2024 19:32:18 -0600 Subject: [PATCH 1/5] Create pull_request_template.md --- .github/pull_request_template.md | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 .github/pull_request_template.md diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 0000000..8413f29 --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,7 @@ +Fixes # . + +Changes proposed in this pull request: + + * + * + * From fffa716112f51e4a6dba1f5516ef15289b5b47e2 Mon Sep 17 00:00:00 2001 From: tarolling Date: Sat, 23 Nov 2024 19:40:28 -0600 Subject: [PATCH 2/5] add publish workflow --- .github/workflows/publish.yml | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 .github/workflows/publish.yml diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..f482ee1 --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,22 @@ +name: Publish to crates.io + +on: + push: + branches: + - main + +env: + CARGO_TERM_COLOR: always + +jobs: + publish: + name: Rust project - latest + runs-on: ubuntu-latest + strategy: + matrix: + toolchain: + - stable + steps: + - uses: actions/checkout@v4 + - run: rustup update ${{ matrix.toolchain }} && rustup default ${{ matrix.toolchain }} + - run: cargo publish --verbose From 0ef8aecb9b2b9a79fe7f6bc5ff72140ae93643ee Mon Sep 17 00:00:00 2001 From: taro <34352544+tarolling@users.noreply.github.com> Date: Sun, 24 Nov 2024 00:20:54 -0600 Subject: [PATCH 3/5] Create CONTRIBUTING.md --- .github/CONTRIBUTING.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 .github/CONTRIBUTING.md diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 0000000..5dc007c --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,14 @@ +# How to Contribute + +If you want to implement new methods, follow this general format. + +- Method names must match the LeetCode problem name in snake case, e.g. Two Sum -> two_sum +- Method definitions must match the LeetCode definitions provided, types and all (excluding externally defined types like ListNode) +- Test names must be named the same, prefixed with `test_` +- Test cases must match the test cases given by LeetCode + +Below are features/documentation that may be implemented in future release, but are not deemed a priority as of now. + +- Method documentation +- Assertions to validate method inputs +- Extensive test cases/full code coverage From f21a7ed0d41f7f23e78cbec9c5976c0451946566 Mon Sep 17 00:00:00 2001 From: tarolling Date: Sun, 24 Nov 2024 18:41:34 -0600 Subject: [PATCH 4/5] add 10 mediums --- Cargo.toml | 2 +- README.md | 1 + src/easy.rs | 64 +++----- src/medium.rs | 209 ++++++++++++++++++++++++ src/utils.rs | 2 +- tests/easy_tests.rs | 365 +++++++++++++++++++++--------------------- tests/medium_tests.rs | 182 +++++++++++++++++++++ 7 files changed, 600 insertions(+), 225 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index d8a1ef2..5b61db0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "rsleetcode" -version = "0.0.2" +version = "0.0.3" edition = "2021" repository = "https://github.com/LeetCode-Packages/Rust" license-file = "LICENSE" diff --git a/README.md b/README.md index fe6ee55..c6ea70f 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,3 @@ # Rust + Implementations of LeetCode problem solutions in Rust. diff --git a/src/easy.rs b/src/easy.rs index 7c34a18..a453651 100644 --- a/src/easy.rs +++ b/src/easy.rs @@ -1,4 +1,4 @@ -use super::utils; +use super::utils::*; use std::cell::RefCell; use std::rc::Rc; @@ -103,20 +103,20 @@ pub fn valid_parentheses(s: String) -> bool { } pub fn merge_two_sorted_lists( - list1: Option>, - list2: Option>, -) -> Option> { + list1: Option>, + list2: Option>, +) -> Option> { match (list1, list2) { (None, None) => None, (Some(n), None) | (None, Some(n)) => Some(n), (Some(list1), Some(list2)) => { if list1.val >= list2.val { - Some(Box::new(utils::ListNode { + Some(Box::new(ListNode { val: list2.val, next: merge_two_sorted_lists(Some(list1), list2.next), })) } else { - Some(Box::new(utils::ListNode { + Some(Box::new(ListNode { val: list1.val, next: merge_two_sorted_lists(list1.next, Some(list2)), })) @@ -221,9 +221,7 @@ pub fn climbing_stairs(n: i32) -> i32 { (0..n).fold((1, 0), |(res, prev), _| (res + prev, res)).0 } -pub fn remove_duplicates_from_sorted_list( - head: Option>, -) -> Option> { +pub fn remove_duplicates_from_sorted_list(head: Option>) -> Option> { head.map(|mut ln| { let mut cur = ln.as_mut(); while let Some(next) = cur.next.as_mut() { @@ -250,9 +248,9 @@ pub fn merge_sorted_array(nums1: &mut Vec, m: i32, nums2: &mut Vec, n: } } -pub fn binary_tree_inorder_traversal(root: Option>>) -> Vec { +pub fn binary_tree_inorder_traversal(root: Option>>) -> Vec { let mut curr = root; - let mut stack = Vec::>>::new(); + let mut stack = Vec::>>::new(); let mut res = vec![]; while curr.is_some() || !stack.is_empty() { @@ -270,14 +268,11 @@ pub fn binary_tree_inorder_traversal(root: Option>>) res } -pub fn same_tree( - p: Option>>, - q: Option>>, -) -> bool { +pub fn same_tree(p: Option>>, q: Option>>) -> bool { p == q } -pub fn symmetric_tree(root: Option>>) -> bool { +pub fn symmetric_tree(root: Option>>) -> bool { if root.is_none() { return true; } @@ -301,7 +296,7 @@ pub fn symmetric_tree(root: Option>>) -> bool { true } -pub fn maximum_depth_of_binary_tree(root: Option>>) -> i32 { +pub fn maximum_depth_of_binary_tree(root: Option>>) -> i32 { if root.is_none() { return 0; } @@ -322,16 +317,14 @@ pub fn maximum_depth_of_binary_tree(root: Option>>) max_depth } -pub fn convert_sorted_array_to_binary_search_tree( - nums: Vec, -) -> Option>> { +pub fn convert_sorted_array_to_binary_search_tree(nums: Vec) -> Option>> { let n = nums.len(); match n { 0 => None, _ => { let m = n / 2; - let mut node = utils::TreeNode::new(nums[m]); + let mut node = TreeNode::new(nums[m]); node.left = convert_sorted_array_to_binary_search_tree(nums[..m].to_vec()); node.right = convert_sorted_array_to_binary_search_tree(nums[m + 1..].to_vec()); @@ -340,7 +333,7 @@ pub fn convert_sorted_array_to_binary_search_tree( } } -pub fn balanced_binary_tree(root: Option>>) -> bool { +pub fn balanced_binary_tree(root: Option>>) -> bool { let mut dstack = Vec::new(); let mut stack = Vec::new(); stack.push((1 as i32, 0 as i32, false, false, root)); @@ -379,7 +372,7 @@ pub fn balanced_binary_tree(root: Option>>) -> bool return true; } -pub fn minimum_depth_of_binary_tree(root: Option>>) -> i32 { +pub fn minimum_depth_of_binary_tree(root: Option>>) -> i32 { match root { Some(node) => { let left = minimum_depth_of_binary_tree(node.as_ref().borrow().left.clone()); @@ -393,14 +386,14 @@ pub fn minimum_depth_of_binary_tree(root: Option>>) } } -pub fn path_sum(root: Option>>, target_sum: i32) -> bool { +pub fn path_sum(root: Option>>, target_sum: i32) -> bool { root.map_or(false, |root| match &*root.borrow() { - &utils::TreeNode { + &TreeNode { val, left: None, right: None, } => val == target_sum, - &utils::TreeNode { + &TreeNode { val, ref left, ref right, @@ -430,11 +423,11 @@ pub fn single_number(nums: Vec) -> i32 { // Linked List Cycle - not possible with current ListNode definition -pub fn binary_tree_preorder_traversal(root: Option>>) -> Vec { +pub fn binary_tree_preorder_traversal(root: Option>>) -> Vec { todo!(); } -pub fn binary_tree_postorder_traversal(root: Option>>) -> Vec { +pub fn binary_tree_postorder_traversal(root: Option>>) -> Vec { todo!(); } @@ -470,10 +463,7 @@ pub fn happy_number(n: i32) -> bool { todo!(); } -pub fn remove_linked_list_elements( - head: Option>, - val: i32, -) -> Option> { +pub fn remove_linked_list_elements(head: Option>, val: i32) -> Option> { todo!(); } @@ -481,7 +471,7 @@ pub fn isomorphic_strings(s: String, t: String) -> bool { todo!(); } -pub fn reverse_linked_list(head: Option>) -> Option> { +pub fn reverse_linked_list(head: Option>) -> Option> { todo!(); } @@ -493,15 +483,13 @@ pub fn contains_duplicate_ii(nums: Vec, k: i32) -> bool { todo!(); } -pub fn count_complete_tree_nodes(root: Option>>) -> i32 { +pub fn count_complete_tree_nodes(root: Option>>) -> i32 { todo!(); } // Implement Stack using Queues - not applicable -pub fn invert_binary_tree( - root: Option>>, -) -> Option>> { +pub fn invert_binary_tree(root: Option>>) -> Option>> { todo!(); } @@ -515,7 +503,7 @@ pub fn power_of_two(n: i32) -> bool { // Implement Queue using Stacks - not applicable -pub fn palindrome_linked_list(head: Option>) -> bool { +pub fn palindrome_linked_list(head: Option>) -> bool { todo!(); } diff --git a/src/medium.rs b/src/medium.rs index e69de29..f752b72 100644 --- a/src/medium.rs +++ b/src/medium.rs @@ -0,0 +1,209 @@ +use super::utils::*; + +/// https://leetcode.com/problems/add-two-numbers/ +pub fn add_two_numbers( + l1: Option>, + l2: Option>, +) -> Option> { + match (l1, l2) { + (None, None) => None, + (Some(n), None) | (None, Some(n)) => Some(n), + (Some(n1), Some(n2)) => { + let sum = n1.val + n2.val; + if sum < 10 { + Some(Box::new(ListNode { + val: sum, + next: add_two_numbers(n1.next, n2.next), + })) + } else { + let carry = Some(Box::new(ListNode::new(1))); + Some(Box::new(ListNode { + val: sum - 10, + next: add_two_numbers(add_two_numbers(carry, n1.next), n2.next), + })) + } + } + } +} + +/// https://leetcode.com/problems/longest-substring-without-repeating-characters/ +pub fn longest_substring_without_repeating_characters(s: String) -> i32 { + let mut max_len: usize = 0; + let mut pos: [usize; 128] = [0; 128]; + let mut start: usize = 0; + + for (end, ch) in s.chars().enumerate() { + start = start.max(pos[ch as usize]); + max_len = max_len.max(end - start + 1); + pos[ch as usize] = end + 1; + } + return max_len as i32; +} + +/// https://leetcode.com/problems/longest-palindromic-substring/ +pub fn longest_palindromic_substring(s: String) -> String { + fn is_palidrome(s: &[u8]) -> bool { + s.iter().zip(s.iter().rev()).all(|(l, r)| l == r) + } + + for size in (1..=s.len()).rev() { + match s + .as_bytes() + .windows(size) + .find(|substr| is_palidrome(substr)) + { + Some(pal) => return String::from_utf8(pal.to_vec()).unwrap(), + None => continue, + } + } + "".to_string() +} + +/// https://leetcode.com/problems/zigzag-conversion/ +pub fn zigzag_conversion(s: String, num_rows: i32) -> String { + let mut zigzags: Vec<_> = (0..num_rows) + .chain((1..num_rows - 1).rev()) + .cycle() + .zip(s.chars()) + .collect(); + zigzags.sort_by_key(|&(row, _)| row); + zigzags.into_iter().map(|(_, c)| c).collect() +} + +/// https://leetcode.com/problems/reverse-integer/ +pub fn reverse_integer(x: i32) -> i32 { + let mut res: i32 = 0; + let mut cur: i32 = x; + + while cur != 0 { + match res.checked_mul(10) { + None => return 0, + Some(tmp) => match tmp.checked_add(cur % 10) { + None => return 0, + Some(fine) => { + res = fine; + } + }, + } + cur = cur / 10; + } + res +} + +/// https://leetcode.com/problems/string-to-integer-atoi/ +pub fn string_to_integer_atoi(s: String) -> i32 { + let s = s.trim_start(); + let (s, sign) = match s.strip_prefix('-') { + Some(s) => (s, -1), + None => (s.strip_prefix('+').unwrap_or(s), 1), + }; + s.chars() + .map(|c| c.to_digit(10)) + .take_while(Option::is_some) + .flatten() + .fold(0, |acc, digit| { + acc.saturating_mul(10).saturating_add(sign * digit as i32) + }) +} + +/// https://leetcode.com/problems/container-with-most-water/ +pub fn container_with_most_water(height: Vec) -> i32 { + let mut result = 0; + let mut iter = height.iter().enumerate(); + let mut p1 = iter.next(); + let mut p2 = iter.next_back(); + while let (Some((i, h1)), Some((j, h2))) = (p1, p2) { + result = result.max(h1.min(h2) * (j - i) as i32); + if h1 < h2 { + p1 = iter.next(); + } else { + p2 = iter.next_back(); + } + } + result +} + +/// https://leetcode.com/problems/integer-to-roman/ +pub fn integer_to_roman(num: i32) -> String { + const ONES: [&str; 10] = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"]; + const TENS: [&str; 10] = ["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"]; + const CENT: [&str; 10] = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"]; + const MILS: [&str; 4] = ["", "M", "MM", "MMM"]; + + format!( + "{}{}{}{}", + MILS[(num / 1000 % 10) as usize], + CENT[(num / 100 % 10) as usize], + TENS[(num / 10 % 10) as usize], + ONES[(num % 10) as usize] + ) +} + +/// https://leetcode.com/problems/3sum/ +pub fn three_sum(nums: Vec) -> Vec> { + let max = nums.len(); + let mut wnums = nums.clone(); + wnums.sort(); + let mut result: Vec> = Vec::new(); + for i in 0..max { + if i > 0 && wnums[i] == wnums[i - 1] { + continue; + } + let mut j = i + 1; + let mut k = max - 1; + while j < k { + let sum = wnums[i] + wnums[j] + wnums[k]; + if sum == 0 { + result.push(vec![wnums[i], wnums[j], wnums[k]]); + j += 1; + k -= 1; + while j < k && wnums[j] == wnums[j - 1] { + j += 1 + } + while j < k && wnums[k] == wnums[k + 1] { + k -= 1 + } + } else { + if sum < 0 { + j += 1 + } else { + k -= 1 + } + } + } + } + result +} + +/// https://leetcode.com/problems/3sum-closest/ +pub fn three_sum_closest(nums: Vec, target: i32) -> i32 { + let mut arr: Vec = nums.clone(); + arr.sort(); + let n: usize = arr.len(); + let mut min_diff: i32 = i32::MAX; + let mut min_sum: i32 = i32::MAX; + for i in 0..n - 2 { + let mut j = i + 1; + let mut k = n - 1; + while k > j { + let _sum = arr[i] + arr[j] + arr[k]; + let _diff = _sum - target; + if _diff == 0 { + return _sum; + } else if _diff < 0 { + if min_diff > { -_diff } { + min_diff = -_diff; + min_sum = _sum; + } + j += 1; + } else { + if min_diff > _diff { + min_diff = _diff; + min_sum = _sum; + } + k -= 1; + } + } + } + min_sum +} diff --git a/src/utils.rs b/src/utils.rs index 9fcbc57..252832d 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -9,7 +9,7 @@ pub struct ListNode { impl ListNode { #[inline] - fn new(val: i32) -> Self { + pub fn new(val: i32) -> Self { ListNode { next: None, val } } } diff --git a/tests/easy_tests.rs b/tests/easy_tests.rs index 3c03a4f..b71f2ef 100644 --- a/tests/easy_tests.rs +++ b/tests/easy_tests.rs @@ -1,32 +1,33 @@ use std::{cell::RefCell, rc::Rc}; -use rsleetcode::{easy, utils}; +use rsleetcode::easy::*; +use rsleetcode::utils::*; #[test] fn test_two_sum() { - assert_eq!(easy::two_sum(vec![2, 7, 11, 15], 9), vec![0, 1]); - assert_eq!(easy::two_sum(vec![3, 2, 4], 6), vec![1, 2]); - assert_eq!(easy::two_sum(vec![3, 3], 6), vec![0, 1]); + assert_eq!(two_sum(vec![2, 7, 11, 15], 9), vec![0, 1]); + assert_eq!(two_sum(vec![3, 2, 4], 6), vec![1, 2]); + assert_eq!(two_sum(vec![3, 3], 6), vec![0, 1]); } #[test] fn test_palindrome_number() { - assert!(easy::palindrome_number(121)); - assert!(!easy::palindrome_number(-121)); - assert!(!easy::palindrome_number(10)); + assert!(palindrome_number(121)); + assert!(!palindrome_number(-121)); + assert!(!palindrome_number(10)); } #[test] fn test_roman_to_integer() { - assert_eq!(easy::roman_to_integer("III".to_string()), 3); - assert_eq!(easy::roman_to_integer("LVIII".to_string()), 58); - assert_eq!(easy::roman_to_integer("MCMXCIV".to_string()), 1994); + assert_eq!(roman_to_integer("III".to_string()), 3); + assert_eq!(roman_to_integer("LVIII".to_string()), 58); + assert_eq!(roman_to_integer("MCMXCIV".to_string()), 1994); } #[test] fn test_longest_common_prefix() { assert_eq!( - easy::longest_common_prefix(vec![ + longest_common_prefix(vec![ "flower".to_string(), "flow".to_string(), "flight".to_string() @@ -34,7 +35,7 @@ fn test_longest_common_prefix() { "fl".to_string() ); assert_eq!( - easy::longest_common_prefix(vec![ + longest_common_prefix(vec![ "dog".to_string(), "racecar".to_string(), "car".to_string() @@ -45,64 +46,64 @@ fn test_longest_common_prefix() { #[test] fn test_valid_parentheses() { - assert!(easy::valid_parentheses("()".to_string())); - assert!(easy::valid_parentheses("()[]{}".to_string())); - assert!(!easy::valid_parentheses("(]".to_string())); - assert!(easy::valid_parentheses("([])".to_string())); + assert!(valid_parentheses("()".to_string())); + assert!(valid_parentheses("()[]{}".to_string())); + assert!(!valid_parentheses("(]".to_string())); + assert!(valid_parentheses("([])".to_string())); } #[test] fn test_merge_two_sorted_lists() { - let list1 = Some(Box::new(utils::ListNode { + let list1 = Some(Box::new(ListNode { val: 1, - next: Some(Box::new(utils::ListNode { + next: Some(Box::new(ListNode { val: 2, - next: Some(Box::new(utils::ListNode { val: 4, next: None })), + next: Some(Box::new(ListNode { val: 4, next: None })), })), })); - let list2 = Some(Box::new(utils::ListNode { + let list2 = Some(Box::new(ListNode { val: 1, - next: Some(Box::new(utils::ListNode { + next: Some(Box::new(ListNode { val: 3, - next: Some(Box::new(utils::ListNode { val: 4, next: None })), + next: Some(Box::new(ListNode { val: 4, next: None })), })), })); - let sol = Some(Box::new(utils::ListNode { + let sol = Some(Box::new(ListNode { val: 1, - next: Some(Box::new(utils::ListNode { + next: Some(Box::new(ListNode { val: 1, - next: Some(Box::new(utils::ListNode { + next: Some(Box::new(ListNode { val: 2, - next: Some(Box::new(utils::ListNode { + next: Some(Box::new(ListNode { val: 3, - next: Some(Box::new(utils::ListNode { + next: Some(Box::new(ListNode { val: 4, - next: Some(Box::new(utils::ListNode { val: 4, next: None })), + next: Some(Box::new(ListNode { val: 4, next: None })), })), })), })), })), })); - assert_eq!(easy::merge_two_sorted_lists(list1, list2), sol); - assert_eq!(easy::merge_two_sorted_lists(None, None), None); + assert_eq!(merge_two_sorted_lists(list1, list2), sol); + assert_eq!(merge_two_sorted_lists(None, None), None); assert_eq!( - easy::merge_two_sorted_lists(None, Some(Box::new(utils::ListNode { val: 0, next: None }))), - Some(Box::new(utils::ListNode { val: 0, next: None })) + merge_two_sorted_lists(None, Some(Box::new(ListNode { val: 0, next: None }))), + Some(Box::new(ListNode { val: 0, next: None })) ); } #[test] fn test_remove_duplicates_from_sorted_array() { let sorted_array = &mut vec![1, 1, 2]; - assert_eq!(easy::remove_duplicates_from_sorted_array(sorted_array), 2); + assert_eq!(remove_duplicates_from_sorted_array(sorted_array), 2); assert_eq!(sorted_array[0], 1); assert_eq!(sorted_array[1], 2); let sorted_array = &mut vec![0, 0, 1, 1, 1, 2, 2, 3, 3, 4]; - assert_eq!(easy::remove_duplicates_from_sorted_array(sorted_array), 5); + assert_eq!(remove_duplicates_from_sorted_array(sorted_array), 5); assert_eq!(sorted_array[0], 0); assert_eq!(sorted_array[1], 1); assert_eq!(sorted_array[2], 2); @@ -113,26 +114,26 @@ fn test_remove_duplicates_from_sorted_array() { #[test] fn test_remove_element() { let nums = &mut vec![3, 2, 2, 3]; - assert_eq!(easy::remove_element(nums, 3), 2); + assert_eq!(remove_element(nums, 3), 2); assert_eq!(nums[0], 2); assert_eq!(nums[1], 2); let nums = &mut vec![0, 1, 2, 2, 3, 0, 4, 2]; - assert_eq!(easy::remove_element(nums, 2), 5); + assert_eq!(remove_element(nums, 2), 5); assert_eq!(nums[..5].sort(), vec![0, 1, 3, 0, 4].sort()); } #[test] fn test_find_the_index_of_the_first_occurrence_in_a_string() { assert_eq!( - easy::find_the_index_of_the_first_occurrence_in_a_string( + find_the_index_of_the_first_occurrence_in_a_string( "sadbutsad".to_string(), "sad".to_string() ), 0 ); assert_eq!( - easy::find_the_index_of_the_first_occurrence_in_a_string( + find_the_index_of_the_first_occurrence_in_a_string( "leetcode".to_string(), "leeto".to_string() ), @@ -142,90 +143,87 @@ fn test_find_the_index_of_the_first_occurrence_in_a_string() { #[test] fn test_search_insert_position() { - assert_eq!(easy::search_insert_position(vec![1, 3, 5, 6], 5), 2); - assert_eq!(easy::search_insert_position(vec![1, 3, 5, 6], 2), 1); - assert_eq!(easy::search_insert_position(vec![1, 3, 5, 6], 7), 4); + assert_eq!(search_insert_position(vec![1, 3, 5, 6], 5), 2); + assert_eq!(search_insert_position(vec![1, 3, 5, 6], 2), 1); + assert_eq!(search_insert_position(vec![1, 3, 5, 6], 7), 4); } #[test] fn test_length_of_last_word() { - assert_eq!(easy::length_of_last_word("Hello World".to_string()), 5); + assert_eq!(length_of_last_word("Hello World".to_string()), 5); assert_eq!( - easy::length_of_last_word(" fly me to the moon ".to_string()), + length_of_last_word(" fly me to the moon ".to_string()), 4 ); - assert_eq!( - easy::length_of_last_word("luffy is still joyboy".to_string()), - 6 - ); + assert_eq!(length_of_last_word("luffy is still joyboy".to_string()), 6); } #[test] fn test_plus_one() { - assert_eq!(easy::plus_one(vec![1, 2, 3]), vec![1, 2, 4]); - assert_eq!(easy::plus_one(vec![4, 3, 2, 1]), vec![4, 3, 2, 2]); - assert_eq!(easy::plus_one(vec![9]), vec![1, 0]); + assert_eq!(plus_one(vec![1, 2, 3]), vec![1, 2, 4]); + assert_eq!(plus_one(vec![4, 3, 2, 1]), vec![4, 3, 2, 2]); + assert_eq!(plus_one(vec![9]), vec![1, 0]); } #[test] fn test_add_binary() { assert_eq!( - easy::add_binary("11".to_string(), "1".to_string()), + add_binary("11".to_string(), "1".to_string()), "100".to_string() ); assert_eq!( - easy::add_binary("1010".to_string(), "1011".to_string()), + add_binary("1010".to_string(), "1011".to_string()), "10101".to_string() ); } #[test] fn test_sqrt_x() { - assert_eq!(easy::sqrt_x(4), 2); - assert_eq!(easy::sqrt_x(8), 2); + assert_eq!(sqrt_x(4), 2); + assert_eq!(sqrt_x(8), 2); } #[test] fn test_climbing_stairs() { - assert_eq!(easy::climbing_stairs(2), 2); - assert_eq!(easy::climbing_stairs(3), 3); + assert_eq!(climbing_stairs(2), 2); + assert_eq!(climbing_stairs(3), 3); } #[test] fn test_remove_duplicates_from_sorted_list() { assert_eq!( - easy::remove_duplicates_from_sorted_list(Some(Box::new(utils::ListNode { + remove_duplicates_from_sorted_list(Some(Box::new(ListNode { val: 1, - next: Some(Box::new(utils::ListNode { + next: Some(Box::new(ListNode { val: 1, - next: Some(Box::new(utils::ListNode { val: 2, next: None })) + next: Some(Box::new(ListNode { val: 2, next: None })) })) }))), - Some(Box::new(utils::ListNode { + Some(Box::new(ListNode { val: 1, - next: Some(Box::new(utils::ListNode { val: 2, next: None })) + next: Some(Box::new(ListNode { val: 2, next: None })) })) ); assert_eq!( - easy::remove_duplicates_from_sorted_list(Some(Box::new(utils::ListNode { + remove_duplicates_from_sorted_list(Some(Box::new(ListNode { val: 1, - next: Some(Box::new(utils::ListNode { + next: Some(Box::new(ListNode { val: 1, - next: Some(Box::new(utils::ListNode { + next: Some(Box::new(ListNode { val: 2, - next: Some(Box::new(utils::ListNode { + next: Some(Box::new(ListNode { val: 3, - next: Some(Box::new(utils::ListNode { val: 3, next: None })) + next: Some(Box::new(ListNode { val: 3, next: None })) })) })) })) }))), - Some(Box::new(utils::ListNode { + Some(Box::new(ListNode { val: 1, - next: Some(Box::new(utils::ListNode { + next: Some(Box::new(ListNode { val: 2, - next: Some(Box::new(utils::ListNode { val: 3, next: None })) + next: Some(Box::new(ListNode { val: 3, next: None })) })) })) ); @@ -235,7 +233,7 @@ fn test_remove_duplicates_from_sorted_list() { fn test_merge_sorted_array() { let nums1 = &mut vec![1, 2, 3, 0, 0, 0]; let nums2 = &mut vec![2, 5, 6]; - easy::merge_sorted_array(nums1, 3, nums2, 3); + merge_sorted_array(nums1, 3, nums2, 3); assert_eq!(nums1[0], 1); assert_eq!(nums1[1], 2); assert_eq!(nums1[2], 2); @@ -245,23 +243,23 @@ fn test_merge_sorted_array() { let nums1 = &mut vec![1]; let nums2 = &mut vec![]; - easy::merge_sorted_array(nums1, 1, nums2, 0); + merge_sorted_array(nums1, 1, nums2, 0); assert_eq!(nums1[0], 1); let nums1 = &mut vec![0]; let nums2 = &mut vec![1]; - easy::merge_sorted_array(nums1, 0, nums2, 1); + merge_sorted_array(nums1, 0, nums2, 1); assert_eq!(nums1[0], 1); } #[test] fn test_binary_tree_inorder_traversal() { - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 1, left: None, - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 2, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 3, left: None, right: None, @@ -269,37 +267,37 @@ fn test_binary_tree_inorder_traversal() { right: None, }))), }))); - assert_eq!(easy::binary_tree_inorder_traversal(root), vec![1, 3, 2]); + assert_eq!(binary_tree_inorder_traversal(root), vec![1, 3, 2]); - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 1, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 2, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 4, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 5, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 6, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 7, left: None, right: None, }))), }))), }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 3, left: None, - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 8, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 9, left: None, right: None, @@ -309,210 +307,210 @@ fn test_binary_tree_inorder_traversal() { }))), }))); assert_eq!( - easy::binary_tree_inorder_traversal(root), + binary_tree_inorder_traversal(root), vec![4, 2, 6, 5, 7, 1, 3, 9, 8] ); let root = None; - assert_eq!(easy::binary_tree_inorder_traversal(root), vec![]); + assert_eq!(binary_tree_inorder_traversal(root), vec![]); - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 1, left: None, right: None, }))); - assert_eq!(easy::binary_tree_inorder_traversal(root), vec![1]); + assert_eq!(binary_tree_inorder_traversal(root), vec![1]); } #[test] fn test_same_tree() { - let p = Some(Rc::new(RefCell::new(utils::TreeNode { + let p = Some(Rc::new(RefCell::new(TreeNode { val: 1, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 3, left: None, right: None, }))), }))); - let q = Some(Rc::new(RefCell::new(utils::TreeNode { + let q = Some(Rc::new(RefCell::new(TreeNode { val: 1, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 3, left: None, right: None, }))), }))); - assert!(easy::same_tree(p, q)); + assert!(same_tree(p, q)); - let p = Some(Rc::new(RefCell::new(utils::TreeNode { + let p = Some(Rc::new(RefCell::new(TreeNode { val: 1, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, right: None, }))), right: None, }))); - let q = Some(Rc::new(RefCell::new(utils::TreeNode { + let q = Some(Rc::new(RefCell::new(TreeNode { val: 1, left: None, - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, right: None, }))), }))); - assert!(!easy::same_tree(p, q)); + assert!(!same_tree(p, q)); - let p = Some(Rc::new(RefCell::new(utils::TreeNode { + let p = Some(Rc::new(RefCell::new(TreeNode { val: 1, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 1, left: None, right: None, }))), }))); - let q = Some(Rc::new(RefCell::new(utils::TreeNode { + let q = Some(Rc::new(RefCell::new(TreeNode { val: 1, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 1, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, right: None, }))), }))); - assert!(!easy::same_tree(p, q)); + assert!(!same_tree(p, q)); } #[test] fn test_symmetric_tree() { - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 1, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 2, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 3, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 4, left: None, right: None, }))), }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 2, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 4, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 3, left: None, right: None, }))), }))), }))); - assert!(easy::symmetric_tree(root)); + assert!(symmetric_tree(root)); - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 1, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 3, left: None, right: None, }))), }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 3, left: None, right: None, }))), }))), }))); - assert!(!easy::symmetric_tree(root)); + assert!(!symmetric_tree(root)); } #[test] fn test_maximum_depth_of_binary_tree() { - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 3, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 9, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 20, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 15, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 7, left: None, right: None, }))), }))), }))); - assert_eq!(easy::maximum_depth_of_binary_tree(root), 3); + assert_eq!(maximum_depth_of_binary_tree(root), 3); - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 1, left: None, - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, right: None, }))), }))); - assert_eq!(easy::maximum_depth_of_binary_tree(root), 2); + assert_eq!(maximum_depth_of_binary_tree(root), 2); } #[test] fn test_convert_sorted_array_to_binary_search_tree() { - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 0, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: -3, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: -10, left: None, right: None, }))), right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 9, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 5, left: None, right: None, @@ -521,123 +519,120 @@ fn test_convert_sorted_array_to_binary_search_tree() { }))), }))); assert_eq!( - easy::convert_sorted_array_to_binary_search_tree(vec![-10, -3, 0, 5, 9]), + convert_sorted_array_to_binary_search_tree(vec![-10, -3, 0, 5, 9]), root ); - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 3, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 1, left: None, right: None, }))), right: None, }))); - assert_eq!( - easy::convert_sorted_array_to_binary_search_tree(vec![1, 3]), - root - ); + assert_eq!(convert_sorted_array_to_binary_search_tree(vec![1, 3]), root); } #[test] fn test_balanced_binary_tree() { - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 3, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 9, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 20, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 15, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 7, left: None, right: None, }))), }))), }))); - assert!(easy::balanced_binary_tree(root)); + assert!(balanced_binary_tree(root)); - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 1, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 2, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 3, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 4, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 4, left: None, right: None, }))), }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 3, left: None, right: None, }))), }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, right: None, }))), }))); - assert!(!easy::balanced_binary_tree(root)); + assert!(!balanced_binary_tree(root)); let root = None; - assert!(easy::balanced_binary_tree(root)); + assert!(balanced_binary_tree(root)); } #[test] fn test_minimum_depth_of_binary_tree() { - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 3, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 9, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 20, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 15, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 7, left: None, right: None, }))), }))), }))); - assert_eq!(easy::minimum_depth_of_binary_tree(root), 2); + assert_eq!(minimum_depth_of_binary_tree(root), 2); - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 3, left: None, - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 4, left: None, - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 5, left: None, - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 6, left: None, right: None, @@ -646,23 +641,23 @@ fn test_minimum_depth_of_binary_tree() { }))), }))), }))); - assert_eq!(easy::minimum_depth_of_binary_tree(root), 5); + assert_eq!(minimum_depth_of_binary_tree(root), 5); } #[test] fn test_path_sum() { - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 5, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 4, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 11, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 7, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, right: None, @@ -670,17 +665,17 @@ fn test_path_sum() { }))), right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 8, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 13, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 4, left: None, - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 1, left: None, right: None, @@ -688,23 +683,23 @@ fn test_path_sum() { }))), }))), }))); - assert!(easy::path_sum(root, 22)); + assert!(path_sum(root, 22)); - let root = Some(Rc::new(RefCell::new(utils::TreeNode { + let root = Some(Rc::new(RefCell::new(TreeNode { val: 1, - left: Some(Rc::new(RefCell::new(utils::TreeNode { + left: Some(Rc::new(RefCell::new(TreeNode { val: 2, left: None, right: None, }))), - right: Some(Rc::new(RefCell::new(utils::TreeNode { + right: Some(Rc::new(RefCell::new(TreeNode { val: 3, left: None, right: None, }))), }))); - assert!(!easy::path_sum(root, 5)); + assert!(!path_sum(root, 5)); let root = None; - assert!(!easy::path_sum(root, 0)); + assert!(!path_sum(root, 0)); } diff --git a/tests/medium_tests.rs b/tests/medium_tests.rs index e69de29..36a2750 100644 --- a/tests/medium_tests.rs +++ b/tests/medium_tests.rs @@ -0,0 +1,182 @@ +use rsleetcode::medium::*; +use rsleetcode::utils::*; + +#[test] +fn test_add_two_numbers() { + assert_eq!( + add_two_numbers( + Some(Box::new(ListNode { + val: 2, + next: Some(Box::new(ListNode { + val: 4, + next: Some(Box::new(ListNode { val: 3, next: None })) + })) + })), + Some(Box::new(ListNode { + val: 5, + next: Some(Box::new(ListNode { + val: 6, + next: Some(Box::new(ListNode { val: 4, next: None })) + })) + })) + ), + Some(Box::new(ListNode { + val: 7, + next: Some(Box::new(ListNode { + val: 0, + next: Some(Box::new(ListNode { val: 8, next: None })) + })) + })) + ); + assert_eq!( + add_two_numbers( + Some(Box::new(ListNode { val: 0, next: None })), + Some(Box::new(ListNode { val: 0, next: None })) + ), + Some(Box::new(ListNode { val: 0, next: None })) + ); + assert_eq!( + add_two_numbers( + Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { val: 9, next: None })) + })) + })) + })) + })) + })) + })), + Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { val: 9, next: None })) + })) + })) + })) + ), + Some(Box::new(ListNode { + val: 8, + next: Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { + val: 9, + next: Some(Box::new(ListNode { + val: 0, + next: Some(Box::new(ListNode { + val: 0, + next: Some(Box::new(ListNode { + val: 0, + next: Some(Box::new(ListNode { val: 1, next: None })) + })) + })) + })) + })) + })) + })) + })) + ); +} + +#[test] +fn test_longest_substring_without_repeating_characters() { + assert_eq!( + longest_substring_without_repeating_characters("abcabcbb".to_string()), + 3 + ); + assert_eq!( + longest_substring_without_repeating_characters("bbbbb".to_string()), + 1 + ); + assert_eq!( + longest_substring_without_repeating_characters("pwwkew".to_string()), + 3 + ); +} + +#[test] +fn test_longest_palindromic_substring() { + assert_eq!( + longest_palindromic_substring("babad".to_string()), + "bab".to_string() + ); + assert_eq!( + longest_palindromic_substring("cbbd".to_string()), + "bb".to_string() + ); +} + +#[test] +fn test_zigzag_conversion() { + assert_eq!( + zigzag_conversion("PAYPALISHIRING".to_string(), 3), + "PAHNAPLSIIGYIR".to_string() + ); + assert_eq!( + zigzag_conversion("PAYPALISHIRING".to_string(), 4), + "PINALSIGYAHRPI".to_string() + ); + assert_eq!(zigzag_conversion("A".to_string(), 1), "A".to_string()); +} + +#[test] +fn test_reverse_integer() { + assert_eq!(reverse_integer(123), 321); + assert_eq!(reverse_integer(-123), -321); + assert_eq!(reverse_integer(120), 21); +} + +#[test] +fn test_string_to_integer_atoi() { + assert_eq!(string_to_integer_atoi("42".to_string()), 42); + assert_eq!(string_to_integer_atoi(" -042".to_string()), -42); + assert_eq!(string_to_integer_atoi("1337c0d3".to_string()), 1337); + assert_eq!(string_to_integer_atoi("0-1".to_string()), 0); + assert_eq!(string_to_integer_atoi("words and 987".to_string()), 0); +} + +#[test] +fn test_container_with_most_water() { + assert_eq!( + container_with_most_water(vec![1, 8, 6, 2, 5, 4, 8, 3, 7]), + 49 + ); + assert_eq!(container_with_most_water(vec![1, 1]), 1); +} + +#[test] +fn test_integer_to_roman() { + assert_eq!(integer_to_roman(3749), "MMMDCCXLIX".to_string()); + assert_eq!(integer_to_roman(58), "LVIII".to_string()); + assert_eq!(integer_to_roman(1994), "MCMXCIV".to_string()); +} + +#[test] +fn test_three_sum() { + assert_eq!( + three_sum(vec![-1, 0, 1, 2, -1, -4]), + vec![vec![-1, -1, 2], vec![-1, 0, 1]] + ); + assert_eq!(three_sum(vec![0, 1, 1]), vec![vec![0; 0]; 0]); + assert_eq!(three_sum(vec![0, 0, 0]), vec![vec![0, 0, 0]]); +} + +#[test] +fn test_three_sum_closest() { + assert_eq!(three_sum_closest(vec![-1, 2, 1, -4], 1), 2); + assert_eq!(three_sum_closest(vec![0, 0, 0], 1), 0); +} From ce4682c7f96b3ce8af25f9c6fd50029156f30b3c Mon Sep 17 00:00:00 2001 From: tarolling Date: Sun, 24 Nov 2024 18:43:30 -0600 Subject: [PATCH 5/5] change ci runs --- .github/workflows/ci.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 9b32549..a384b82 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -2,7 +2,11 @@ name: Cargo Build & Test on: push: + branches: + - main pull_request: + branches: + - main env: CARGO_TERM_COLOR: always