From 4b0a6a01b051a4ebfbc17661d14cb23fe4f275fb Mon Sep 17 00:00:00 2001 From: Orangerot Date: Thu, 27 Jun 2024 11:30:16 +0200 Subject: [PATCH] Initial commit --- .gitignore | 16 ++++ _missing/Cargo.toml | 8 ++ _missing/src/main.rs | 37 +++++++++ a-number-after-a-double-reversal/Cargo.toml | 8 ++ a-number-after-a-double-reversal/src/main.rs | 11 +++ add-two-numbers/Cargo.toml | 8 ++ add-two-numbers/src/main.rs | 46 +++++++++++ buddy-strings/Cargo.toml | 8 ++ buddy-strings/src/main.rs | 31 +++++++ candy/Cargo.toml | 8 ++ candy/src/main.rs | 18 +++++ .../Cargo.toml | 8 ++ .../src/main.rs | 32 ++++++++ .../Cargo.toml | 8 ++ .../src/main.rs | 11 +++ check-if-it-is-a-straight-line/Cargo.toml | 8 ++ check-if-it-is-a-straight-line/src/main.rs | 37 +++++++++ .../Cargo.toml | 8 ++ .../src/main.rs | 13 +++ combination-sum-iv/Cargo.toml | 8 ++ combination-sum-iv/src/main.rs | 37 +++++++++ concatenation-of-array/Cargo.toml | 8 ++ concatenation-of-array/src/main.rs | 13 +++ contains-duplicate/Cargo.toml | 8 ++ contains-duplicate/src/main.rs | 10 +++ counting-bits/Cargo.toml | 8 ++ counting-bits/src/main.rs | 23 ++++++ .../Cargo.toml | 8 ++ .../src/main.rs | 22 +++++ design-hashmap/Cargo.toml | 8 ++ design-hashmap/src/main.rs | 43 ++++++++++ diagonal-traverse/Cargo.toml | 8 ++ diagonal-traverse/src/main.rs | 16 ++++ extra-characters-in-a-string/Cargo.toml | 8 ++ extra-characters-in-a-string/src/main.rs | 23 ++++++ .../Cargo.toml | 8 ++ .../src/main.rs | 17 ++++ .../Cargo.toml | 8 ++ .../src/main.rs | 11 +++ find-in-mountain-array/Cargo.toml | 8 ++ find-in-mountain-array/src/main.rs | 28 +++++++ .../Cargo.toml | 8 ++ .../src/main.rs | 17 ++++ find-the-difference-of-two-arrays/Cargo.toml | 9 +++ find-the-difference-of-two-arrays/src/main.rs | 25 ++++++ find-the-duplicate-number/Cargo.toml | 8 ++ find-the-duplicate-number/src/main.rs | 17 ++++ find-the-highest-altitude/Cargo.toml | 8 ++ find-the-highest-altitude/src/main.rs | 17 ++++ .../Cargo.toml | 8 ++ .../src/main.rs | 14 ++++ fizz-buzz/Cargo.toml | 8 ++ fizz-buzz/src/main.rs | 14 ++++ .../Cargo.toml | 8 ++ .../src/main.rs | 26 ++++++ increasing-order-search-tree/Cargo.toml | 8 ++ increasing-order-search-tree/src/main.rs | 33 ++++++++ k-th-symbol-in-grammar/Cargo.toml | 8 ++ k-th-symbol-in-grammar/src/main.rs | 28 +++++++ kth-largest-element-in-a-stream/Cargo.toml | 8 ++ kth-largest-element-in-a-stream/src/main.rs | 30 +++++++ length-of-last-word/Cargo.toml | 8 ++ length-of-last-word/src/main.rs | 10 +++ longest-common-prefix/Cargo.toml | 8 ++ longest-common-prefix/src/main.rs | 30 +++++++ majority-element-ii/Cargo.toml | 8 ++ majority-element-ii/src/main.rs | 28 +++++++ majority-element/Cargo.toml | 8 ++ majority-element/src/main.rs | 19 +++++ matrix-diagonal-sum/Cargo.toml | 8 ++ matrix-diagonal-sum/src/main.rs | 11 +++ median-of-two-sorted-arrays/Cargo.toml | 8 ++ median-of-two-sorted-arrays/src/main.rs | 23 ++++++ .../Cargo.toml | 8 ++ .../src/main.rs | 15 ++++ .../Cargo.toml | 8 ++ .../src/main.rs | 79 ++++++++++++++++++ .../Cargo.toml | 8 ++ .../src/main.rs | 39 +++++++++ .../src/main2.rs | 38 +++++++++ monotonic-array/Cargo.toml | 8 ++ monotonic-array/src/main.rs | 20 +++++ n-ary-tree-postorder-traversal/Cargo.toml | 8 ++ n-ary-tree-postorder-traversal/src/main.rs | 3 + next-greater-element-i/Cargo.toml | 8 ++ next-greater-element-i/src/main.rs | 17 ++++ .../Cargo.toml | 8 ++ .../src/main.rs | 29 +++++++ number-of-equivalent-domino-pairs/Cargo.toml | 8 ++ number-of-equivalent-domino-pairs/src/main.rs | 17 ++++ palindrome-number/Cargo.toml | 8 ++ palindrome-number/src/main.rs | 31 +++++++ pascals-triangle/Cargo.toml | 8 ++ pascals-triangle/src/main.rs | 32 ++++++++ plus-one/Cargo.toml | 8 ++ plus-one/src/main.rs | 21 +++++ .../Cargo.toml | 8 ++ .../src/main.rs | 14 ++++ .../Cargo.toml | 8 ++ .../src/main.rs | 31 +++++++ remove-duplicate-letters/Cargo.toml | 8 ++ remove-duplicate-letters/src/main.rs | 27 +++++++ .../Cargo.toml | 8 ++ .../src/main.rs | 11 +++ remove-element/Cargo.toml | 8 ++ remove-element/src/main.rs | 15 ++++ .../Cargo.toml | 8 ++ .../src/main.rs | 20 +++++ replace-all-digits-with-characters/Cargo.toml | 8 ++ .../src/main.rs | 20 +++++ reverse-integer/Cargo.toml | 8 ++ reverse-integer/src/main.rs | 12 +++ reverse-linked-list-ii/Cargo.toml | 8 ++ reverse-linked-list-ii/src/main.rs | 59 ++++++++++++++ reverse-string-ii/Cargo.toml | 8 ++ reverse-string-ii/src/main.rs | 21 +++++ reverse-words-in-a-string-iii/Cargo.toml | 8 ++ reverse-words-in-a-string-iii/src/main.rs | 12 +++ rotting-oranges-c/main.c | 62 ++++++++++++++ rotting-oranges/Cargo.toml | 8 ++ rotting-oranges/src/main.rs | 81 +++++++++++++++++++ rotting-oranges/src/main_2.rs | 80 ++++++++++++++++++ search-insert-position/Cargo.toml | 8 ++ search-insert-position/src/main.rs | 12 +++ shortest-distance-to-a-character/Cargo.toml | 8 ++ shortest-distance-to-a-character/src/main.rs | 3 + sort-array-by-parity/Cargo.toml | 8 ++ sort-array-by-parity/src/main.rs | 22 +++++ sort-the-matrix-diagonally/Cargo.toml | 8 ++ sort-the-matrix-diagonally/src/main.rs | 26 ++++++ sum-root-to-leaf-numbers/Cargo.toml | 8 ++ sum-root-to-leaf-numbers/src/main.rs | 40 +++++++++ two-sum/Cargo.toml | 8 ++ two-sum/src/main.rs | 28 +++++++ valid-palindrome/Cargo.toml | 8 ++ valid-palindrome/src/main.rs | 12 +++ valid-parentheses/Cargo.toml | 8 ++ valid-parentheses/src/main.rs | 39 +++++++++ 138 files changed, 2362 insertions(+) create mode 100644 .gitignore create mode 100644 _missing/Cargo.toml create mode 100644 _missing/src/main.rs create mode 100644 a-number-after-a-double-reversal/Cargo.toml create mode 100644 a-number-after-a-double-reversal/src/main.rs create mode 100644 add-two-numbers/Cargo.toml create mode 100644 add-two-numbers/src/main.rs create mode 100644 buddy-strings/Cargo.toml create mode 100644 buddy-strings/src/main.rs create mode 100644 candy/Cargo.toml create mode 100644 candy/src/main.rs create mode 100644 check-if-a-string-contains-all-binary-codes-of-size-k/Cargo.toml create mode 100644 check-if-a-string-contains-all-binary-codes-of-size-k/src/main.rs create mode 100644 check-if-all-as-appears-before-all-bs/Cargo.toml create mode 100644 check-if-all-as-appears-before-all-bs/src/main.rs create mode 100644 check-if-it-is-a-straight-line/Cargo.toml create mode 100644 check-if-it-is-a-straight-line/src/main.rs create mode 100644 check-if-two-string-arrays-are-equivalent/Cargo.toml create mode 100644 check-if-two-string-arrays-are-equivalent/src/main.rs create mode 100644 combination-sum-iv/Cargo.toml create mode 100644 combination-sum-iv/src/main.rs create mode 100644 concatenation-of-array/Cargo.toml create mode 100644 concatenation-of-array/src/main.rs create mode 100644 contains-duplicate/Cargo.toml create mode 100644 contains-duplicate/src/main.rs create mode 100644 counting-bits/Cargo.toml create mode 100644 counting-bits/src/main.rs create mode 100644 decrypt-string-from-alphabet-to-integer-mapping/Cargo.toml create mode 100644 decrypt-string-from-alphabet-to-integer-mapping/src/main.rs create mode 100644 design-hashmap/Cargo.toml create mode 100644 design-hashmap/src/main.rs create mode 100644 diagonal-traverse/Cargo.toml create mode 100644 diagonal-traverse/src/main.rs create mode 100644 extra-characters-in-a-string/Cargo.toml create mode 100644 extra-characters-in-a-string/src/main.rs create mode 100644 find-all-lonely-numbers-in-the-array/Cargo.toml create mode 100644 find-all-lonely-numbers-in-the-array/src/main.rs create mode 100644 find-first-palindromic-string-in-the-array/Cargo.toml create mode 100644 find-first-palindromic-string-in-the-array/src/main.rs create mode 100644 find-in-mountain-array/Cargo.toml create mode 100644 find-in-mountain-array/src/main.rs create mode 100644 find-smallest-letter-greater-than-target/Cargo.toml create mode 100644 find-smallest-letter-greater-than-target/src/main.rs create mode 100644 find-the-difference-of-two-arrays/Cargo.toml create mode 100644 find-the-difference-of-two-arrays/src/main.rs create mode 100644 find-the-duplicate-number/Cargo.toml create mode 100644 find-the-duplicate-number/src/main.rs create mode 100644 find-the-highest-altitude/Cargo.toml create mode 100644 find-the-highest-altitude/src/main.rs create mode 100644 find-the-index-of-the-first-occurrence-in-a-string/Cargo.toml create mode 100644 find-the-index-of-the-first-occurrence-in-a-string/src/main.rs create mode 100644 fizz-buzz/Cargo.toml create mode 100644 fizz-buzz/src/main.rs create mode 100644 group-the-people-given-the-group-size-they-belong-to/Cargo.toml create mode 100644 group-the-people-given-the-group-size-they-belong-to/src/main.rs create mode 100644 increasing-order-search-tree/Cargo.toml create mode 100644 increasing-order-search-tree/src/main.rs create mode 100644 k-th-symbol-in-grammar/Cargo.toml create mode 100644 k-th-symbol-in-grammar/src/main.rs create mode 100644 kth-largest-element-in-a-stream/Cargo.toml create mode 100644 kth-largest-element-in-a-stream/src/main.rs create mode 100644 length-of-last-word/Cargo.toml create mode 100644 length-of-last-word/src/main.rs create mode 100644 longest-common-prefix/Cargo.toml create mode 100644 longest-common-prefix/src/main.rs create mode 100644 majority-element-ii/Cargo.toml create mode 100644 majority-element-ii/src/main.rs create mode 100644 majority-element/Cargo.toml create mode 100644 majority-element/src/main.rs create mode 100644 matrix-diagonal-sum/Cargo.toml create mode 100644 matrix-diagonal-sum/src/main.rs create mode 100644 median-of-two-sorted-arrays/Cargo.toml create mode 100644 median-of-two-sorted-arrays/src/main.rs create mode 100644 minimum-changes-to-make-alternating-binary-string/Cargo.toml create mode 100644 minimum-changes-to-make-alternating-binary-string/src/main.rs create mode 100644 minimum-deletions-to-make-character-frequencies-unique/Cargo.toml create mode 100644 minimum-deletions-to-make-character-frequencies-unique/src/main.rs create mode 100644 minimum-operations-to-reduce-x-to-zero/Cargo.toml create mode 100644 minimum-operations-to-reduce-x-to-zero/src/main.rs create mode 100644 minimum-operations-to-reduce-x-to-zero/src/main2.rs create mode 100644 monotonic-array/Cargo.toml create mode 100644 monotonic-array/src/main.rs create mode 100644 n-ary-tree-postorder-traversal/Cargo.toml create mode 100644 n-ary-tree-postorder-traversal/src/main.rs create mode 100644 next-greater-element-i/Cargo.toml create mode 100644 next-greater-element-i/src/main.rs create mode 100644 number-of-different-integers-in-a-string/Cargo.toml create mode 100644 number-of-different-integers-in-a-string/src/main.rs create mode 100644 number-of-equivalent-domino-pairs/Cargo.toml create mode 100644 number-of-equivalent-domino-pairs/src/main.rs create mode 100644 palindrome-number/Cargo.toml create mode 100644 palindrome-number/src/main.rs create mode 100644 pascals-triangle/Cargo.toml create mode 100644 pascals-triangle/src/main.rs create mode 100644 plus-one/Cargo.toml create mode 100644 plus-one/src/main.rs create mode 100644 remove-all-occurrences-of-a-substring/Cargo.toml create mode 100644 remove-all-occurrences-of-a-substring/src/main.rs create mode 100644 remove-colored-pieces-if-both-neighbors-are-the-same-color/Cargo.toml create mode 100644 remove-colored-pieces-if-both-neighbors-are-the-same-color/src/main.rs create mode 100644 remove-duplicate-letters/Cargo.toml create mode 100644 remove-duplicate-letters/src/main.rs create mode 100644 remove-duplicates-from-sorted-array/Cargo.toml create mode 100644 remove-duplicates-from-sorted-array/src/main.rs create mode 100644 remove-element/Cargo.toml create mode 100644 remove-element/src/main.rs create mode 100644 remove-one-element-to-make-the-array-strictly-increasing/Cargo.toml create mode 100644 remove-one-element-to-make-the-array-strictly-increasing/src/main.rs create mode 100644 replace-all-digits-with-characters/Cargo.toml create mode 100644 replace-all-digits-with-characters/src/main.rs create mode 100644 reverse-integer/Cargo.toml create mode 100644 reverse-integer/src/main.rs create mode 100644 reverse-linked-list-ii/Cargo.toml create mode 100644 reverse-linked-list-ii/src/main.rs create mode 100644 reverse-string-ii/Cargo.toml create mode 100644 reverse-string-ii/src/main.rs create mode 100644 reverse-words-in-a-string-iii/Cargo.toml create mode 100644 reverse-words-in-a-string-iii/src/main.rs create mode 100644 rotting-oranges-c/main.c create mode 100644 rotting-oranges/Cargo.toml create mode 100644 rotting-oranges/src/main.rs create mode 100644 rotting-oranges/src/main_2.rs create mode 100644 search-insert-position/Cargo.toml create mode 100644 search-insert-position/src/main.rs create mode 100644 shortest-distance-to-a-character/Cargo.toml create mode 100644 shortest-distance-to-a-character/src/main.rs create mode 100644 sort-array-by-parity/Cargo.toml create mode 100644 sort-array-by-parity/src/main.rs create mode 100644 sort-the-matrix-diagonally/Cargo.toml create mode 100644 sort-the-matrix-diagonally/src/main.rs create mode 100644 sum-root-to-leaf-numbers/Cargo.toml create mode 100644 sum-root-to-leaf-numbers/src/main.rs create mode 100644 two-sum/Cargo.toml create mode 100644 two-sum/src/main.rs create mode 100644 valid-palindrome/Cargo.toml create mode 100644 valid-palindrome/src/main.rs create mode 100644 valid-parentheses/Cargo.toml create mode 100644 valid-parentheses/src/main.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5e1b333 --- /dev/null +++ b/.gitignore @@ -0,0 +1,16 @@ +# Generated by Cargo +# will have compiled files and executables +debug/ +target/ + +# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries +# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html +Cargo.lock + +# These are backup files generated by rustfmt +**/*.rs.bk + +# MSVC Windows builds of rustc generate these, which store debugging information +*.pdb + +main diff --git a/_missing/Cargo.toml b/_missing/Cargo.toml new file mode 100644 index 0000000..b3979a3 --- /dev/null +++ b/_missing/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/_missing/src/main.rs b/_missing/src/main.rs new file mode 100644 index 0000000..4d903d1 --- /dev/null +++ b/_missing/src/main.rs @@ -0,0 +1,37 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + (vec![100,4,200,1,3,2], 4), + (vec![0,3,7,2,5,8,4,6,0,1], 9) + ]; + + for test in tests { + println!("{:?} is {} should be {}", test.0, Solution::longest_consecutive(test.0.clone()), test.1); + } +} + + +struct Solution; + +impl Solution { + pub fn longest_consecutive(nums: Vec) -> i32 { + let mut s = nums.clone(); + s.sort(); + s.dedup(); + let mut longest = (nums.len() > 0) as i32; + let mut longest_old = 0; + + for i in s.windows(2) { + if &i[1] != &(&i[0] + 1) { + if longest > longest_old { + longest_old = longest; + } + longest = 1; + continue; + } + longest += 1; + } + + longest.max(longest_old) + } +} diff --git a/a-number-after-a-double-reversal/Cargo.toml b/a-number-after-a-double-reversal/Cargo.toml new file mode 100644 index 0000000..38924b9 --- /dev/null +++ b/a-number-after-a-double-reversal/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "a-number-after-a-double-reversal" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/a-number-after-a-double-reversal/src/main.rs b/a-number-after-a-double-reversal/src/main.rs new file mode 100644 index 0000000..7e7c9d1 --- /dev/null +++ b/a-number-after-a-double-reversal/src/main.rs @@ -0,0 +1,11 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn is_same_after_reversals(num: i32) -> bool { + num == 0 || num % 10 != 0 + } +} diff --git a/add-two-numbers/Cargo.toml b/add-two-numbers/Cargo.toml new file mode 100644 index 0000000..eee98ac --- /dev/null +++ b/add-two-numbers/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "add-two-numbers" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/add-two-numbers/src/main.rs b/add-two-numbers/src/main.rs new file mode 100644 index 0000000..3a9abe9 --- /dev/null +++ b/add-two-numbers/src/main.rs @@ -0,0 +1,46 @@ +fn main() { + println!("Hello, world!"); +} + +#[derive(PartialEq, Eq, Clone, Debug)] +pub struct ListNode { + pub val: i32, + pub next: Option> +} + +impl ListNode { + #[inline] + fn new(val: i32) -> Self { + ListNode { + next: None, + val + } + } +} +// Comprehensive 3ms Recursive + +struct Solution {} +impl Default for ListNode { + fn default() -> Self { + ListNode::new(0) + } +} + +impl Solution { + pub fn add_two_numbers(l1: Option>, l2: Option>) -> Option> { + Solution::add_two_numbers_with_carry(l1, l2, 0) + } + pub fn add_two_numbers_with_carry(l1: Option>, l2: Option>, carry: i32) -> Option> { + if l1.is_none() && l2.is_none() && carry == 0 {return None;} + let a = l1.unwrap_or_default(); + let b = l2.unwrap_or_default(); + let sum = a.val + b.val + carry; + + let result = ListNode { + val: sum % 10, + next: Solution::add_two_numbers_with_carry(a.next, b.next, sum / 10) + }; + Some(Box::new(result)) + } +} + diff --git a/buddy-strings/Cargo.toml b/buddy-strings/Cargo.toml new file mode 100644 index 0000000..c7ee668 --- /dev/null +++ b/buddy-strings/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "buddy-strings" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/buddy-strings/src/main.rs b/buddy-strings/src/main.rs new file mode 100644 index 0000000..dbc982c --- /dev/null +++ b/buddy-strings/src/main.rs @@ -0,0 +1,31 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + ("ab", "ba", true), + ("ab", "ab", false), + ("aa", "aa", true), + ("abcaa", "abcbb", false) + ]; + + for test in tests { + println!("{:?} {:?} is {} should be {}", test.0, test.1, + Solution::buddy_strings(test.0.clone().to_string(), test.1.clone().to_string()), + test.2); + } +} +struct Solution; + +use std::collections::HashMap; + +impl Solution { + pub fn buddy_strings(s: String, goal: String) -> bool { + let mut occurences_s = HashMap::new(); + let mut occurences_goal = HashMap::new(); + let similarities = s.chars().zip(goal.chars()).filter(|(a,b)| { + *occurences_s.entry(a.clone()).or_insert(1) += 1; + *occurences_goal.entry(b.clone()).or_insert(1) += 1; + a != b}) + .count(); + s.len() == goal.len() && occurences_s == occurences_goal && (similarities == 2 || (similarities == 0 && occurences_s.values().any(|&x| x > 2))) + } +} diff --git a/candy/Cargo.toml b/candy/Cargo.toml new file mode 100644 index 0000000..40dd834 --- /dev/null +++ b/candy/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "candy" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/candy/src/main.rs b/candy/src/main.rs new file mode 100644 index 0000000..e2fe56c --- /dev/null +++ b/candy/src/main.rs @@ -0,0 +1,18 @@ +fn main() { + println!("Hello, world!"); +} + + +struct Solution {} +impl Solution { + pub fn candy(ratings: Vec) -> i32 { + let result = Vec::with_capacity(ratings.len()); + + let mut candy = 1; + + while let Some(s)= ratings.iter().enumerate() + .fold(i32::MAX, |acc, (i,v)| if v < acc && {v}) + + result.iter().sum::() + } +} diff --git a/check-if-a-string-contains-all-binary-codes-of-size-k/Cargo.toml b/check-if-a-string-contains-all-binary-codes-of-size-k/Cargo.toml new file mode 100644 index 0000000..9086b45 --- /dev/null +++ b/check-if-a-string-contains-all-binary-codes-of-size-k/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "check-if-a-string-contains-all-binary-codes-of-size-k" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/check-if-a-string-contains-all-binary-codes-of-size-k/src/main.rs b/check-if-a-string-contains-all-binary-codes-of-size-k/src/main.rs new file mode 100644 index 0000000..028b32c --- /dev/null +++ b/check-if-a-string-contains-all-binary-codes-of-size-k/src/main.rs @@ -0,0 +1,32 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + ("00110110", 2, true), + ("0110", 1, true), + ("0110", 2, false), + ("00000000001011100", 3, true), + ("000011010111011001001111111001000100100100010100101100001101101101110001100100101111100111001001111001001010111010010101101001001110011100110101001001001000000110101001010011101100110110100010000", 7, false) + ]; + for (s, k, o) in tests { + let result = Solution::has_all_codes(s.to_string(),k); + println!("{s:?} with {k} is {result} should be {o}"); + } +} + +struct Solution; + +impl Solution { + pub fn has_all_codes(s: String, k: i32) -> bool { + // (00..=2_i32.pow(k as u32) -1).all(|x| s.contains(&format!("{x:00$b}", k as usize)))j + let mut m: u128 = 0; + let mut m = (0..) + for w in s.chars().collect::>().windows(k as usize) { + m |= 1 << i32::from_str_radix(&w.iter().collect::(), 2).unwrap(); + // println!("{m:b}"); + } + // println!("{m:b}"); + let h = 2_u128.pow(2_u32.pow(k as u32)) -1; + // println!("{h} {h:b}"); + m == h + } +} diff --git a/check-if-all-as-appears-before-all-bs/Cargo.toml b/check-if-all-as-appears-before-all-bs/Cargo.toml new file mode 100644 index 0000000..2442447 --- /dev/null +++ b/check-if-all-as-appears-before-all-bs/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "check-if-all-as-appears-before-all-bs" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/check-if-all-as-appears-before-all-bs/src/main.rs b/check-if-all-as-appears-before-all-bs/src/main.rs new file mode 100644 index 0000000..72ee26b --- /dev/null +++ b/check-if-all-as-appears-before-all-bs/src/main.rs @@ -0,0 +1,11 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn check_string(s: String) -> bool { + !s.chars().skip_while(|&x| x == 'a').any(|x| x == 'a') + } +} diff --git a/check-if-it-is-a-straight-line/Cargo.toml b/check-if-it-is-a-straight-line/Cargo.toml new file mode 100644 index 0000000..596a8f3 --- /dev/null +++ b/check-if-it-is-a-straight-line/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "check-if-it-is-a-straight-line" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/check-if-it-is-a-straight-line/src/main.rs b/check-if-it-is-a-straight-line/src/main.rs new file mode 100644 index 0000000..711e12e --- /dev/null +++ b/check-if-it-is-a-straight-line/src/main.rs @@ -0,0 +1,37 @@ +fn main() { + let tests = [ + (vec![[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]], true), + (vec![[1,1],[2,2],[3,4],[4,5],[5,6],[7,7]], false), + (vec![[0,0],[0,1],[0,-1]], true) + ]; + + for test in tests { + println!("{:?} is {} should be {}", + test.0, + check_straight_line(test.0.iter().map(|c| c.to_vec()).collect()), + test.1); + } +} + +pub fn check_straight_line(coordinates: Vec>) -> bool { + let base = get_lin_fn(coordinates[0].clone(), coordinates[1].clone()); + println!("{:?} base", base); + for c in 1..coordinates.len() { + let lin_fn = get_lin_fn(coordinates[0].clone(), coordinates[c].clone()); + println!("{} {:?}", c, lin_fn); + if lin_fn != base { + return false; + } + } + return true; +} + +pub fn get_lin_fn(a: Vec, b: Vec) -> (f32, f32) { + let mx = b[0] - a[0]; + let my = b[1] - a[1]; + let m = my as f32/mx as f32; + let b = a[1] as f32 - m*a[0] as f32; + + return (m,b); +} + diff --git a/check-if-two-string-arrays-are-equivalent/Cargo.toml b/check-if-two-string-arrays-are-equivalent/Cargo.toml new file mode 100644 index 0000000..1eaa37a --- /dev/null +++ b/check-if-two-string-arrays-are-equivalent/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "check-if-two-string-arrays-are-equivalent" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/check-if-two-string-arrays-are-equivalent/src/main.rs b/check-if-two-string-arrays-are-equivalent/src/main.rs new file mode 100644 index 0000000..6143793 --- /dev/null +++ b/check-if-two-string-arrays-are-equivalent/src/main.rs @@ -0,0 +1,13 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn array_strings_are_equal(word1: Vec, word2: Vec) -> bool { + //word1.iter_mut().reduce(|a, b| {a.push_str(b); a}).unwrap() == word2.iter_mut().reduce(|a, b| {a.push_str(b); a}).unwrap() + //word1.concat() == word2.concat() + word1.iter().flat_map(|x| x.chars()).eq(word2.iter().flat_map(|x| x.chars())) + } +} diff --git a/combination-sum-iv/Cargo.toml b/combination-sum-iv/Cargo.toml new file mode 100644 index 0000000..9eeae96 --- /dev/null +++ b/combination-sum-iv/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "combination-sum-iv" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/combination-sum-iv/src/main.rs b/combination-sum-iv/src/main.rs new file mode 100644 index 0000000..b0ee823 --- /dev/null +++ b/combination-sum-iv/src/main.rs @@ -0,0 +1,37 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + (vec![1,2,3], 4, 7), + // (vec![9], 3, 0), + (vec![2,1,3], 35, 1_132_436_852), + // (vec![10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240,250,260,270,280,290,300,310,320,330,340,350,360,370,380,390,400,410,420,430,440,450,460,470,480,490,500,510,520,530,540,550,560,570,580,590,600,610,620,630,640,650,660,670,680,690,700,710,720,730,740,750,760,770,780,790,800,810,820,830,840,850,860,870,880,890,900,910,920,930,940,950,960,970,980,990,111], 999, 2) + ]; + + for test in tests { + println!("{:?} {} is {} should be {}", + test.0, test.1, + Solution::combination_sum4(test.0.clone(), test.1), + test.2 + ); + } +} +struct Solution {} + + +impl Solution { + pub fn combination_sum4(nums: Vec, target: i32) -> i32 { + let mut cache = vec![0; target as usize]; + Solution::combination_sum4_from(&nums, 0, target, &mut cache) + } + + pub fn combination_sum4_from(nums: &Vec, from: i32, target: i32, cache: &mut Vec) -> i32 { + if from > target {return 0}; + if from == target {return 1}; + if cache[from as usize] > 0 {return cache[from as usize];} + + let result = nums.iter().rev().map(|x| Solution::combination_sum4_from(&nums, from + x, target, cache)).sum(); + cache[from as usize] = result; + println!("{:?}", cache); + result + } +} diff --git a/concatenation-of-array/Cargo.toml b/concatenation-of-array/Cargo.toml new file mode 100644 index 0000000..de3b44e --- /dev/null +++ b/concatenation-of-array/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "concatenation-of-array" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/concatenation-of-array/src/main.rs b/concatenation-of-array/src/main.rs new file mode 100644 index 0000000..f08a58d --- /dev/null +++ b/concatenation-of-array/src/main.rs @@ -0,0 +1,13 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn get_concatenation(nums: Vec) -> Vec { + let mut result = nums.clone(); + result.append(&mut nums.clone()); + result + } +} diff --git a/contains-duplicate/Cargo.toml b/contains-duplicate/Cargo.toml new file mode 100644 index 0000000..3fb9396 --- /dev/null +++ b/contains-duplicate/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "contains-duplicate" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/contains-duplicate/src/main.rs b/contains-duplicate/src/main.rs new file mode 100644 index 0000000..d067614 --- /dev/null +++ b/contains-duplicate/src/main.rs @@ -0,0 +1,10 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution {} +impl Solution { + pub fn contains_duplicate(nums: Vec) -> bool { + nums.iter(). + } +} diff --git a/counting-bits/Cargo.toml b/counting-bits/Cargo.toml new file mode 100644 index 0000000..6354b0d --- /dev/null +++ b/counting-bits/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "counting-bits" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/counting-bits/src/main.rs b/counting-bits/src/main.rs new file mode 100644 index 0000000..1203594 --- /dev/null +++ b/counting-bits/src/main.rs @@ -0,0 +1,23 @@ +fn main() { + let tests = [ + (2, vec![0,1,1]), + (5, vec![0,1,1,2,1,2]) + ]; + + for test in tests { + println!("{} is {:?} should be {:?}", test.0, count_bits(test.0), test.1); + } +} + +fn count_bits(n: i32) -> Vec { + let mut solution: Vec = Vec::new(); + for i in 0..=n { + let mut ones = 0; + for c in 0..32 { + ones += (1< String { + for i in 10..=26 { + let mut integer_str = i.to_string(); + integer_str.push_str("#"); + s = s.replace(&integer_str, &char::from_u32(96 + i).unwrap().to_string() ); + } + for i in 1..=9 { + let integer_str = i.to_string(); + s = s.replace(&integer_str, &char::from_u32(96 + i).unwrap().to_string() ); + } + let i = s.chars().rev(); + i.map(|x| if x == '#' {i.take()}) + s + } +} diff --git a/design-hashmap/Cargo.toml b/design-hashmap/Cargo.toml new file mode 100644 index 0000000..5f27b3e --- /dev/null +++ b/design-hashmap/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "design-hashmap" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/design-hashmap/src/main.rs b/design-hashmap/src/main.rs new file mode 100644 index 0000000..f35bd69 --- /dev/null +++ b/design-hashmap/src/main.rs @@ -0,0 +1,43 @@ +fn main() { + println!("Hello, world!"); + let mut a = MyHashMap::new(); + a.put(1,1); + a.put(2,2); + a.get(1); + a.get(3); + a.put(2,1); + a.get(2); + a.remove(2); + a.get(2); +} + +struct MyHashMap { + map: Vec<(i32,i32)> +} + +impl MyHashMap { + + fn new() -> Self { + MyHashMap { + map: Vec::new() + } + } + + fn put(&mut self, key: i32, value: i32) { + match self.map.iter_mut().find(|x| x.0 == key) { + Some(e) => e.1 = value, + None => self.map.push((key, value)) + }; + } + + fn get(&self, key: i32) -> i32 { + self.map.iter().find(|&x| x.0 == key).map(|x| x.1).unwrap_or(-1) + } + + fn remove(&mut self, key: i32) { + if let Some(e) = self.map.iter().position(|x| x.0 == key) { + self.map.swap_remove(e); + } + } +} + diff --git a/diagonal-traverse/Cargo.toml b/diagonal-traverse/Cargo.toml new file mode 100644 index 0000000..331f384 --- /dev/null +++ b/diagonal-traverse/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "diagonal-traverse" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/diagonal-traverse/src/main.rs b/diagonal-traverse/src/main.rs new file mode 100644 index 0000000..65f680b --- /dev/null +++ b/diagonal-traverse/src/main.rs @@ -0,0 +1,16 @@ +struct Solution; +impl Solution { + pub fn find_diagonal_order(mat: Vec>) -> Vec { + let mut solution: Vec = Vec::new(); + let x: usize = 0; + let y: usize = 0; + + solution.push(mat[x][y]); + + solution + } +} + +fn main() { + println!("Hello, world!"); +} diff --git a/extra-characters-in-a-string/Cargo.toml b/extra-characters-in-a-string/Cargo.toml new file mode 100644 index 0000000..7f2bfde --- /dev/null +++ b/extra-characters-in-a-string/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "extra-characters-in-a-string" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/extra-characters-in-a-string/src/main.rs b/extra-characters-in-a-string/src/main.rs new file mode 100644 index 0000000..f803964 --- /dev/null +++ b/extra-characters-in-a-string/src/main.rs @@ -0,0 +1,23 @@ +fn main() { + let tests = vec![ + ("leetscode", vec!["leet","code","leetcode"], 1), + ("sayhelloworld", vec!["hello","world"], 3), + ]; + + for test in tests { + let result = min_extra_char( + test.0.to_string(), + test.1.iter().map(|s| s.to_string()).collect() + ); + println!("{} has {} should be {}", test.0, result, test.2); + } +} + +fn min_extra_char(s: String, dictionary: Vec) -> i32 { + for i in 0..s.len() { + for w in dictionary { + s.starts_with(w); + } + } + 1 +} diff --git a/find-all-lonely-numbers-in-the-array/Cargo.toml b/find-all-lonely-numbers-in-the-array/Cargo.toml new file mode 100644 index 0000000..38ec185 --- /dev/null +++ b/find-all-lonely-numbers-in-the-array/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "find-all-lonely-numbers-in-the-array" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/find-all-lonely-numbers-in-the-array/src/main.rs b/find-all-lonely-numbers-in-the-array/src/main.rs new file mode 100644 index 0000000..1f1e6f9 --- /dev/null +++ b/find-all-lonely-numbers-in-the-array/src/main.rs @@ -0,0 +1,17 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn find_lonely(mut nums: Vec) -> Vec { + if nums.len() == 1 {return nums;} + + nums.sort(); + + let mut result: Vec = nums.windows(3).filter(|arr| (arr[0] - arr[1]).abs() > 1).flat_map(|arr| Vec::from(arr)).collect(); + result.dedup(); + result + } +} diff --git a/find-first-palindromic-string-in-the-array/Cargo.toml b/find-first-palindromic-string-in-the-array/Cargo.toml new file mode 100644 index 0000000..25fc001 --- /dev/null +++ b/find-first-palindromic-string-in-the-array/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "find-first-palindromic-string-in-the-array" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/find-first-palindromic-string-in-the-array/src/main.rs b/find-first-palindromic-string-in-the-array/src/main.rs new file mode 100644 index 0000000..cf3d386 --- /dev/null +++ b/find-first-palindromic-string-in-the-array/src/main.rs @@ -0,0 +1,11 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn first_palindrome(words: Vec) -> String { + words.iter().find(|&s| s.chars().take(s.len() / 2).eq(s.chars().rev().take(s.len() / 2))).map(|x| x.clone()).unwrap_or(String::new()) + } +} diff --git a/find-in-mountain-array/Cargo.toml b/find-in-mountain-array/Cargo.toml new file mode 100644 index 0000000..e29d001 --- /dev/null +++ b/find-in-mountain-array/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "find-in-mountain-array" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/find-in-mountain-array/src/main.rs b/find-in-mountain-array/src/main.rs new file mode 100644 index 0000000..4fd6d7c --- /dev/null +++ b/find-in-mountain-array/src/main.rs @@ -0,0 +1,28 @@ +fn main() { + println!("Hello, world!"); +} +/** + * // This is the MountainArray's API interface. + * // You should not implement it, or speculate about its implementation + * struct MountainArray; + * impl MountainArray { + * fn get(index:i32)->i32; + * fn length()->i32; + * }; + */ + +struct MountainArray; + +impl MountainArray { + fn get(self, index:i32)->i32; + fn length(self)->i32; +}; + +impl Solution { + pub fn find_in_mountain_array(target: i32, mountainArr: &MountainArray) -> i32 { + for i in 0..mountainArr.length() { + if mountainArr.get(i) == target {return i;} + } + -1 + } +} diff --git a/find-smallest-letter-greater-than-target/Cargo.toml b/find-smallest-letter-greater-than-target/Cargo.toml new file mode 100644 index 0000000..f5086d4 --- /dev/null +++ b/find-smallest-letter-greater-than-target/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "find-smallest-letter-greater-than-target" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/find-smallest-letter-greater-than-target/src/main.rs b/find-smallest-letter-greater-than-target/src/main.rs new file mode 100644 index 0000000..aa9944c --- /dev/null +++ b/find-smallest-letter-greater-than-target/src/main.rs @@ -0,0 +1,17 @@ +fn main() { + println!("Hello, world!"); +} + +pub fn next_greatest_letter(letters: Vec, target: char) -> char { + let mut smallest: char = '~'; + let first = letters[0]; + + for c in letters { + if c > target && c < smallest {smallest = c;} + } + if smallest == '~' { + return first; + } + + return smallest; +} diff --git a/find-the-difference-of-two-arrays/Cargo.toml b/find-the-difference-of-two-arrays/Cargo.toml new file mode 100644 index 0000000..d44a464 --- /dev/null +++ b/find-the-difference-of-two-arrays/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "find-the-difference-of-two-arrays" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +itertools = "0.9.0" diff --git a/find-the-difference-of-two-arrays/src/main.rs b/find-the-difference-of-two-arrays/src/main.rs new file mode 100644 index 0000000..a09cecb --- /dev/null +++ b/find-the-difference-of-two-arrays/src/main.rs @@ -0,0 +1,25 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution {} +impl Solution { + pub fn find_difference(nums1: Vec, nums2: Vec) -> Vec> { + let mut a: Vec = Vec::new(); + let mut b: Vec = Vec::new(); + + for i in nums1 { + if !nums2.contains(&i) && !nums1.contains(&i) { + a.push(i); + } + } + for i in nums2 { + if !nums2.contains(&i) && !nums1.contains(&i) { + b.push(i); + } + } + + vec![a,b] + + } +} diff --git a/find-the-duplicate-number/Cargo.toml b/find-the-duplicate-number/Cargo.toml new file mode 100644 index 0000000..2f23362 --- /dev/null +++ b/find-the-duplicate-number/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "find-the-duplicate-number" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/find-the-duplicate-number/src/main.rs b/find-the-duplicate-number/src/main.rs new file mode 100644 index 0000000..c86c542 --- /dev/null +++ b/find-the-duplicate-number/src/main.rs @@ -0,0 +1,17 @@ +fn main() { + println!("Hello, world!"); +} + + +struct Solution {} + +impl Solution { + pub fn find_duplicate(nums: Vec) -> i32 { + for i in 0..nums.len()-1 { + if nums[i+1..nums.len()].contains(&nums[i]) { + return nums[i]; + } + } + 0 + } +} diff --git a/find-the-highest-altitude/Cargo.toml b/find-the-highest-altitude/Cargo.toml new file mode 100644 index 0000000..648fce4 --- /dev/null +++ b/find-the-highest-altitude/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "find-the-highest-altitude" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/find-the-highest-altitude/src/main.rs b/find-the-highest-altitude/src/main.rs new file mode 100644 index 0000000..82fac4d --- /dev/null +++ b/find-the-highest-altitude/src/main.rs @@ -0,0 +1,17 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn largest_altitude(gain: Vec) -> i32 { + let mut altitude = 0; + let mut result = 0; + for x in gain { + altitude += x; + result = result.max(altitude); + } + result + } +} diff --git a/find-the-index-of-the-first-occurrence-in-a-string/Cargo.toml b/find-the-index-of-the-first-occurrence-in-a-string/Cargo.toml new file mode 100644 index 0000000..0badc0f --- /dev/null +++ b/find-the-index-of-the-first-occurrence-in-a-string/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "find-the-index-of-the-first-occurrence-in-a-string" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/find-the-index-of-the-first-occurrence-in-a-string/src/main.rs b/find-the-index-of-the-first-occurrence-in-a-string/src/main.rs new file mode 100644 index 0000000..51de786 --- /dev/null +++ b/find-the-index-of-the-first-occurrence-in-a-string/src/main.rs @@ -0,0 +1,14 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn str_str(haystack: String, needle: String) -> i32 { + match haystack.find(&needle) { + None => -1, + Some(e) => e as i32 + } + } +} diff --git a/fizz-buzz/Cargo.toml b/fizz-buzz/Cargo.toml new file mode 100644 index 0000000..0a2734e --- /dev/null +++ b/fizz-buzz/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "fizz-buzz" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/fizz-buzz/src/main.rs b/fizz-buzz/src/main.rs new file mode 100644 index 0000000..c6abf23 --- /dev/null +++ b/fizz-buzz/src/main.rs @@ -0,0 +1,14 @@ +fn main() { + println!("Hello, world!"); +} + +impl Solution { + pub fn fizz_buzz(n: i32) -> Vec { + (1..=n).map(|x| match x { + i if i % 3 == 0 && x % 5 == 0 => "FizzBuzz".to_string(), + i if i % 3 == 0 => "Fizz".to_string(), + i if i % 5 == 0 => "Buzz".to_string(), + i => i.to_string() + }).collect() + } +} diff --git a/group-the-people-given-the-group-size-they-belong-to/Cargo.toml b/group-the-people-given-the-group-size-they-belong-to/Cargo.toml new file mode 100644 index 0000000..5a9601f --- /dev/null +++ b/group-the-people-given-the-group-size-they-belong-to/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "group-the-people-given-the-group-size-they-belong-to" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/group-the-people-given-the-group-size-they-belong-to/src/main.rs b/group-the-people-given-the-group-size-they-belong-to/src/main.rs new file mode 100644 index 0000000..f380f39 --- /dev/null +++ b/group-the-people-given-the-group-size-they-belong-to/src/main.rs @@ -0,0 +1,26 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution {} +impl Solution { + pub fn group_the_people(group_sizes: Vec) -> Vec> { + let mut result: Vec> = Vec::new(); + + + for (i, size) in group_sizes.iter().enumerate() { + let group = result.iter_mut() + .find(|x| x.capacity() == *size as usize && x.len() != x.capacity()); + + match group { + Some(entry) => entry.push(i as i32), + None => { + let mut new_group = Vec::with_capacity(*size as usize); + new_group.push(i as i32); + result.push(new_group); + } + }; + } + result + } +} diff --git a/increasing-order-search-tree/Cargo.toml b/increasing-order-search-tree/Cargo.toml new file mode 100644 index 0000000..8dca9d6 --- /dev/null +++ b/increasing-order-search-tree/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "increasing-order-search-tree" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/increasing-order-search-tree/src/main.rs b/increasing-order-search-tree/src/main.rs new file mode 100644 index 0000000..8953101 --- /dev/null +++ b/increasing-order-search-tree/src/main.rs @@ -0,0 +1,33 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution {} + +// Definition for a binary tree node. +#[derive(Debug, PartialEq, Eq)] +pub struct TreeNode { + pub val: i32, + pub left: Option>>, + pub right: Option>>, +} + +impl TreeNode { + #[inline] + pub fn new(val: i32) -> Self { + TreeNode { + val, + left: None, + right: None + } + } +} +use std::rc::Rc; +use std::cell::RefCell; +impl Solution { + pub fn increasing_bst(root: Option>>) -> Option>> { + match root.unwrap().get_mut() { + TreeNode { val, left: None, right: None } => {root} + } + } +} diff --git a/k-th-symbol-in-grammar/Cargo.toml b/k-th-symbol-in-grammar/Cargo.toml new file mode 100644 index 0000000..4fccf4e --- /dev/null +++ b/k-th-symbol-in-grammar/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "k-th-symbol-in-grammar" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/k-th-symbol-in-grammar/src/main.rs b/k-th-symbol-in-grammar/src/main.rs new file mode 100644 index 0000000..5aaa24c --- /dev/null +++ b/k-th-symbol-in-grammar/src/main.rs @@ -0,0 +1,28 @@ +fn main() { + println!("Hello, world!"); + let tests = vec![ + (1,1,0), + (2,1,0), + (2,2,1), + (30, 434991989, 0) + ]; + for (n,k,o) in tests { + let result = Solution::kth_grammar(n,k); + println!("{n} {k} {result} {o}"); + } +} + +struct Solution; + +impl Solution { + pub fn kth_grammar(n: i32, k: i32) -> i32 { + let mut s: Vec = vec![false]; + for _ in 0..n { + s = s.iter().flat_map(|x| match x { + false => [false,true], + true => [true,false] + }).collect::>(); + } + s[(k - 1) as usize] as i32 + } +} diff --git a/kth-largest-element-in-a-stream/Cargo.toml b/kth-largest-element-in-a-stream/Cargo.toml new file mode 100644 index 0000000..b9f7f80 --- /dev/null +++ b/kth-largest-element-in-a-stream/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "kth-largest-element-in-a-stream" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/kth-largest-element-in-a-stream/src/main.rs b/kth-largest-element-in-a-stream/src/main.rs new file mode 100644 index 0000000..1a3d3ff --- /dev/null +++ b/kth-largest-element-in-a-stream/src/main.rs @@ -0,0 +1,30 @@ +fn main() { + println!("Hello, world!"); +} + + +struct KthLargest { + +} + + +/** + * `&self` means the method takes an immutable reference. + * If you need a mutable reference, change it to `&mut self` instead. + */ +impl KthLargest { + + fn new(k: i32, nums: Vec) -> Self { + + } + + fn add(&self, val: i32) -> i32 { + + } +} + +/** + * Your KthLargest object will be instantiated and called as such: + * let obj = KthLargest::new(k, nums); + * let ret_1: i32 = obj.add(val); + */ diff --git a/length-of-last-word/Cargo.toml b/length-of-last-word/Cargo.toml new file mode 100644 index 0000000..299ca49 --- /dev/null +++ b/length-of-last-word/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "length-of-last-word" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/length-of-last-word/src/main.rs b/length-of-last-word/src/main.rs new file mode 100644 index 0000000..d3e51ff --- /dev/null +++ b/length-of-last-word/src/main.rs @@ -0,0 +1,10 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution {} +impl Solution { + pub fn length_of_last_word(s: String) -> i32 { + s.split_whitespace().last().unwrap().len() as i32 + } +} diff --git a/longest-common-prefix/Cargo.toml b/longest-common-prefix/Cargo.toml new file mode 100644 index 0000000..91d0dc9 --- /dev/null +++ b/longest-common-prefix/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "longest-common-prefix" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/longest-common-prefix/src/main.rs b/longest-common-prefix/src/main.rs new file mode 100644 index 0000000..9e573c1 --- /dev/null +++ b/longest-common-prefix/src/main.rs @@ -0,0 +1,30 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + (vec!["flower","flow","flight"], "fl"), + (vec!["dog","racecar","car"], "") + ]; + + for test in tests { + println!("{:?} is {} should be {}", test.0, + Solution::longest_common_prefix(test.0.iter().map(|s| s.to_string()).collect()), + test.1); + } +} + +struct Solution {} +impl Solution { + pub fn longest_common_prefix(strs: Vec) -> String { + let mut index = 0; + let mut c = String::new(); + loop { + for s in strs { + let prefix = s.chars().nth(index); + if prefix.is_none() {return c;} + } + break; + } + "".to_string() + } +} + diff --git a/majority-element-ii/Cargo.toml b/majority-element-ii/Cargo.toml new file mode 100644 index 0000000..71a2fbe --- /dev/null +++ b/majority-element-ii/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "majority-element-ii" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/majority-element-ii/src/main.rs b/majority-element-ii/src/main.rs new file mode 100644 index 0000000..34872a4 --- /dev/null +++ b/majority-element-ii/src/main.rs @@ -0,0 +1,28 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + vec![3,2,3], + vec![1], + vec![1,2] + ]; + + for test in tests { + let result = Solution::majority_element(test.clone()); + println!("{test:?} is {result:?}"); + } +} + +struct Solution; + +use std::collections::HashMap; + +impl Solution { + pub fn majority_element(nums: Vec) -> Vec { + let mut occurance: HashMap<&i32, i32> = HashMap::new(); + + for num in &nums { + occurance.entry(num).and_modify(|x| {*x += 1}).or_insert(0); + } + occurance.iter().filter(|(_, &occ)| occ >= nums.len() as i32 / 3).map(|(&&num,_)| num).collect() + } +} diff --git a/majority-element/Cargo.toml b/majority-element/Cargo.toml new file mode 100644 index 0000000..8930310 --- /dev/null +++ b/majority-element/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "majority-element" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/majority-element/src/main.rs b/majority-element/src/main.rs new file mode 100644 index 0000000..f6757e0 --- /dev/null +++ b/majority-element/src/main.rs @@ -0,0 +1,19 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +use std::collections::HashMap; + +impl Solution { + pub fn majority_element(nums: Vec) -> i32 { + let mut table = HashMap::new(); + + for num in nums { + *table.entry(num).or_insert(1) += 1; + } + + *table.iter().reduce(|a,b| if a.1 > b.1 {a} else {b}).unwrap().0 + } +} diff --git a/matrix-diagonal-sum/Cargo.toml b/matrix-diagonal-sum/Cargo.toml new file mode 100644 index 0000000..b0abc38 --- /dev/null +++ b/matrix-diagonal-sum/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "matrix-diagonal-sum" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/matrix-diagonal-sum/src/main.rs b/matrix-diagonal-sum/src/main.rs new file mode 100644 index 0000000..8ee95a0 --- /dev/null +++ b/matrix-diagonal-sum/src/main.rs @@ -0,0 +1,11 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution {} +impl Solution { + pub fn diagonal_sum(mat: Vec>) -> i32 { + mat.iter().enumerate() + .fold(0, |acc, (i, row)| acc + row[i] + if i != row.len()-1 -i {row[row.len()-1 -i]} else {0}) + } +} diff --git a/median-of-two-sorted-arrays/Cargo.toml b/median-of-two-sorted-arrays/Cargo.toml new file mode 100644 index 0000000..58b9f7b --- /dev/null +++ b/median-of-two-sorted-arrays/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "median-of-two-sorted-arrays" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/median-of-two-sorted-arrays/src/main.rs b/median-of-two-sorted-arrays/src/main.rs new file mode 100644 index 0000000..a8557aa --- /dev/null +++ b/median-of-two-sorted-arrays/src/main.rs @@ -0,0 +1,23 @@ +fn main() { + println!("Hello, world!"); + let tests = vec![ + (vec![1,3], vec![2], 2.0), + (vec![1,2], vec![3,4], 2.5) + ]; + for test in tests { + println!("{:?}{:?} is {} should be {}", test.0, test.1, + Solution::find_median_sorted_arrays(test.0.clone(), test.1.clone()), test.2); + } +} + +struct Solution {} +impl Solution { + pub fn find_median_sorted_arrays(nums1: Vec, nums2: Vec) -> f64 { + let mut a = nums1.clone(); + a.append(&mut nums2.clone()); + a.sort(); + let median = a.get((a.len() / 2)-1..((a.len() + 1)/2)).unwrap(); + println!("{:?}", median); + (median.iter().sum::() as f64) / (median.len() as f64) + } +} diff --git a/minimum-changes-to-make-alternating-binary-string/Cargo.toml b/minimum-changes-to-make-alternating-binary-string/Cargo.toml new file mode 100644 index 0000000..01c4446 --- /dev/null +++ b/minimum-changes-to-make-alternating-binary-string/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "minimum-changes-to-make-alternating-binary-string" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/minimum-changes-to-make-alternating-binary-string/src/main.rs b/minimum-changes-to-make-alternating-binary-string/src/main.rs new file mode 100644 index 0000000..369635d --- /dev/null +++ b/minimum-changes-to-make-alternating-binary-string/src/main.rs @@ -0,0 +1,15 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn min_operations(s: String) -> i32 { + let a: Vec<_> = s.chars().collect(); + i32::min( + a.chunks(2).map(|x| match x { ['0','1'] | ['0'] => 0, ['1', '0'] => 2, _ => 1 }).sum(), + a.chunks(2).map(|x| match x { ['1','0'] | ['1'] => 0, ['0', '1'] => 2, _ => 1 }).sum() + ) + } +} diff --git a/minimum-deletions-to-make-character-frequencies-unique/Cargo.toml b/minimum-deletions-to-make-character-frequencies-unique/Cargo.toml new file mode 100644 index 0000000..d098b5a --- /dev/null +++ b/minimum-deletions-to-make-character-frequencies-unique/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "minimum-deletions-to-make-character-frequencies-unique" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/minimum-deletions-to-make-character-frequencies-unique/src/main.rs b/minimum-deletions-to-make-character-frequencies-unique/src/main.rs new file mode 100644 index 0000000..1ca58f3 --- /dev/null +++ b/minimum-deletions-to-make-character-frequencies-unique/src/main.rs @@ -0,0 +1,79 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + ("aab", 0), + ("aaabbbcc", 2), + ("ceabaacb", 2), + ("accdcdadddbaadbc", 1), + ("abcabc", 3), + ("bbcebab",2) + ]; + + for test in tests { + println!("{:?} is {} should be {}", + test.0, + Solution::min_deletions(test.0.to_string()), + test.1 + ); + } +} + + +struct Solution {} + +use std::collections::HashMap; + +impl Solution { + pub fn min_deletions(s: String) -> i32 { + // aaabbbcc => a: 3, b: 3, c: 2 + let mut char_occurance = HashMap::new(); + + for c in s.chars() { + char_occurance.entry(c).and_modify(|x| *x += 1).or_insert(1); + } + + // 2, 3, 3 + let mut occurences: Vec = char_occurance.values().cloned().collect(); + occurences.sort(); + + // 2: 1, 3: 2 + let mut occurence_occurences = HashMap::new(); + // println!("{:?}", occurences); + for i in occurences { + occurence_occurences.entry(i).and_modify(|x| *x += 1).or_insert(1); + } + + let a = occurence_occurences.iter().collect::>(); + // println!("{:?}", a); + + // 3 + let mut needs_change = Vec::new(); + for (key, val) in occurence_occurences.iter() { + if *val > 1 { + needs_change.push(*key); + } + } + + let mut changes = 0; + for key in needs_change.iter() { + let mut val = occurence_occurences.get(&key).unwrap().clone(); + while val > 1 { + for i in (0..*key).rev() { + let occ = occurence_occurences.get(&i); + if occ.is_none() { + val += -1; + changes += key - i; + if i > 0 { + occurence_occurences.insert(i, key-i); + } + break; + } + } + } + + } + // println!("{occurence_occurences:?}"); + changes + } +} + diff --git a/minimum-operations-to-reduce-x-to-zero/Cargo.toml b/minimum-operations-to-reduce-x-to-zero/Cargo.toml new file mode 100644 index 0000000..0630adf --- /dev/null +++ b/minimum-operations-to-reduce-x-to-zero/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "minimum-operations-to-reduce-x-to-zero" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/minimum-operations-to-reduce-x-to-zero/src/main.rs b/minimum-operations-to-reduce-x-to-zero/src/main.rs new file mode 100644 index 0000000..55ee894 --- /dev/null +++ b/minimum-operations-to-reduce-x-to-zero/src/main.rs @@ -0,0 +1,39 @@ +use std::cmp::min; + + +struct Solution; +impl Solution { + pub fn min_operations(nums: Vec, x: i32) -> i32 { + Self::min_operations_slice(&nums[..], x) + } + + pub fn min_operations_slice(nums: &[i32], x: i32) -> i32 { + if x == 0 {return 0;} + if x < 0 || nums.is_empty() {return -1;} + + match ( + Self::min_operations_slice(&nums[..nums.len() - 1], x - &nums[nums.len() - 1]), + Self::min_operations_slice(&nums[1..], x - &nums[0]) + ) { + (-1, -1) => -1, + (x,-1) | (-1, x) => x+1, + (x, y) => min(x,y)+1, + } + } +} + +fn main() { + + let tests = vec![ + (vec![1,1,4,2,3], 5, 2), + (vec![5,6,7,8,9], 4, -1), + (vec![3,2,20,1,1,3], 10, 5), + (vec![1,1], 3, -1), + (vec![1241,8769,9151,3211,2314,8007,3713,5835,2176,8227,5251,9229,904,1899,5513,7878,8663,3804,2685,3501,1204,9742,2578,8849,1120,4687,5902,9929,6769,8171,5150,1343,9619,3973,3273,6427,47,8701,2741,7402,1412,2223,8152,805,6726,9128,2794,7137,6725,4279,7200,5582,9583,7443,6573,7221,1423,4859,2608,3772,7437,2581,975,3893,9172,3,3113,2978,9300,6029,4958,229,4630,653,1421,5512,5392,7287,8643,4495,2640,8047,7268,3878,6010,8070,7560,8931,76,6502,5952,4871,5986,4935,3015,8263,7497,8153,384,1136], 894887480, 0) + ]; + + for (nums, x, out) in tests { + let result = Solution::min_operations(nums.clone(), x); + println!("{nums:?} {x} is {result} should be {out}"); + } +} diff --git a/minimum-operations-to-reduce-x-to-zero/src/main2.rs b/minimum-operations-to-reduce-x-to-zero/src/main2.rs new file mode 100644 index 0000000..1ab02ab --- /dev/null +++ b/minimum-operations-to-reduce-x-to-zero/src/main2.rs @@ -0,0 +1,38 @@ +use std::cmp::min; + +struct Solution; +impl Solution { + pub fn min_operations(nums: Vec, x: i32) -> i32 { + Self::min_operations_slice(&nums[..], x).unwrap_or(-1) + } + + pub fn min_operations_slice(nums: &[i32], x: i32) -> Option { + if x < 0 || nums.is_empty() {return None;} + if x == 0 {return Some(0);} + + match ( + Self::min_operations_slice(&nums[..nums.len() - 1], x - &nums[nums.len() - 1]), + Self::min_operations_slice(&nums[1..], x - &nums[0]) + ) { + (None, None) => None, + (Some(x), Some(y)) => Some(min(x,y)+1), + (Some(x),None) | (None, Some(x)) => Some(x+1) + } + } +} + +fn main() { + + let tests = vec![ + (vec![1,1,4,2,3], 5, 2), + (vec![5,6,7,8,9], 4, -1), + (vec![3,2,20,1,1,3], 10, 5), + (vec![1,1], 3, -1), + (vec![1241,8769,9151,3211,2314,8007,3713,5835,2176,8227,5251,9229,904,1899,5513,7878,8663,3804,2685,3501,1204,9742,2578,8849,1120,4687,5902,9929,6769,8171,5150,1343,9619,3973,3273,6427,47,8701,2741,7402,1412,2223,8152,805,6726,9128,2794,7137,6725,4279,7200,5582,9583,7443,6573,7221,1423,4859,2608,3772,7437,2581,975,3893,9172,3,3113,2978,9300,6029,4958,229,4630,653,1421,5512,5392,7287,8643,4495,2640,8047,7268,3878,6010,8070,7560,8931,76,6502,5952,4871,5986,4935,3015,8263,7497,8153,384,1136], 894887480, 0) + ]; + + for (nums, x, out) in tests { + let result = Solution::min_operations(nums.clone(), x); + println!("{nums:?} {x} is {result} should be {out}"); + } +} diff --git a/monotonic-array/Cargo.toml b/monotonic-array/Cargo.toml new file mode 100644 index 0000000..d8244c5 --- /dev/null +++ b/monotonic-array/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "monotonic-array" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/monotonic-array/src/main.rs b/monotonic-array/src/main.rs new file mode 100644 index 0000000..eeb1b2e --- /dev/null +++ b/monotonic-array/src/main.rs @@ -0,0 +1,20 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + (vec![1,2,2,3],true), + (vec![6,5,4,4],true), + (vec![1,3,2], false) + ]; + + for test in tests { + println!("{:?} is {} should be {}", test.0, Solution::is_monotonic(test.0.clone()), + test.1); + } +} +struct Solution; +impl Solution { + pub fn is_monotonic(nums: Vec) -> bool { + nums.windows(2).all(|x| x[0] >= x[1]) || + nums.windows(2).all(|x| x[0] <= x[1]) + } +} diff --git a/n-ary-tree-postorder-traversal/Cargo.toml b/n-ary-tree-postorder-traversal/Cargo.toml new file mode 100644 index 0000000..b7cc953 --- /dev/null +++ b/n-ary-tree-postorder-traversal/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "n-ary-tree-postorder-traversal" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/n-ary-tree-postorder-traversal/src/main.rs b/n-ary-tree-postorder-traversal/src/main.rs new file mode 100644 index 0000000..e7a11a9 --- /dev/null +++ b/n-ary-tree-postorder-traversal/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + println!("Hello, world!"); +} diff --git a/next-greater-element-i/Cargo.toml b/next-greater-element-i/Cargo.toml new file mode 100644 index 0000000..406d4ef --- /dev/null +++ b/next-greater-element-i/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "next-greater-element-i" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/next-greater-element-i/src/main.rs b/next-greater-element-i/src/main.rs new file mode 100644 index 0000000..84ab40c --- /dev/null +++ b/next-greater-element-i/src/main.rs @@ -0,0 +1,17 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution {} + +impl Solution { + pub fn next_greater_element(nums1: Vec, nums2: Vec) -> Vec { + let mut result = nums1.clone(); + for i in result.iter_mut() { + nums2.iter().position(|&x| x == *i); + } + + + result + } +} diff --git a/number-of-different-integers-in-a-string/Cargo.toml b/number-of-different-integers-in-a-string/Cargo.toml new file mode 100644 index 0000000..aca88ce --- /dev/null +++ b/number-of-different-integers-in-a-string/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "number-of-different-integers-in-a-string" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/number-of-different-integers-in-a-string/src/main.rs b/number-of-different-integers-in-a-string/src/main.rs new file mode 100644 index 0000000..5a8256e --- /dev/null +++ b/number-of-different-integers-in-a-string/src/main.rs @@ -0,0 +1,29 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + ("a123bc34d8ef34", 3), + ("leet1234code234", 2), + ("a1b01c001", 1), + ("035985750011523523129774573439111590559325a1554234973", 2) + ]; + for test in tests { + println!("{:?} is {} should be {}", test.0, + Solution::num_different_integers(test.0.to_string()), test.1); + } +} + +struct Solution; + +use std::collections::HashSet; + +impl Solution { + pub fn num_different_integers(word: String) -> i32 { + let result = unsafe { word.as_bytes() }.split(u8::is_ascii_alphabetic) + .filter(|x| !x.is_empty()) + .map(|mut x| {while x.starts_with(b"0") {x = x.strip_prefix(b"0").unwrap(); } x}) + // .map(|x| x.iter().rev().enumerate().fold(0, |acc, (i,&v)| acc + (v as u32 -48) * 10_u32.pow(i as u32))) + .collect::>(); + println!("{result:?}"); + result.len() as i32 + } +} diff --git a/number-of-equivalent-domino-pairs/Cargo.toml b/number-of-equivalent-domino-pairs/Cargo.toml new file mode 100644 index 0000000..b0cfcd7 --- /dev/null +++ b/number-of-equivalent-domino-pairs/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "number-of-equivalent-domino-pairs" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/number-of-equivalent-domino-pairs/src/main.rs b/number-of-equivalent-domino-pairs/src/main.rs new file mode 100644 index 0000000..ff16907 --- /dev/null +++ b/number-of-equivalent-domino-pairs/src/main.rs @@ -0,0 +1,17 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn num_equiv_domino_pairs(dominoes: Vec>) -> i32 { + let mut map = [0;100]; + for d in dominoes { + if let [i,j] = d[..] { + map[(i.max(j) * 10 + i.min(j)) as usize] += 1; + } + } + map.iter().filter(|&&x| x > 1).map(|&x| (x *(x-1))/2).sum::() + } +} diff --git a/palindrome-number/Cargo.toml b/palindrome-number/Cargo.toml new file mode 100644 index 0000000..dd3c2d3 --- /dev/null +++ b/palindrome-number/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "palindrome-number" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/palindrome-number/src/main.rs b/palindrome-number/src/main.rs new file mode 100644 index 0000000..1e0d6d1 --- /dev/null +++ b/palindrome-number/src/main.rs @@ -0,0 +1,31 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + (121, true), + (-121, false), + (10, false), + (1410110141, true) + ]; + for test in tests { + println!("{} is {} should be {}", test.0, Solution::is_palindrome(test.0), test.1); + } +} + + +struct Solution {} +impl Solution { + pub fn is_palindrome(x: i32) -> bool { + if x < 0 {return false;} + let len = (x as f32).log10() as usize; + //println!("{} {}", len, (len+1)/2); + for i in 0..(len+1)/2 { + if (x as u32 / 10_u32.pow(i as u32)) % 10 != (x as u32 / 10_u32.pow((len - i) as u32)) % 10 { + return false; + } + } + true + } + pub fn get(x: i32, i: usize) -> u32 { + (x as u32 / 10_u32.pow(i as u32)) % 10 + } +} diff --git a/pascals-triangle/Cargo.toml b/pascals-triangle/Cargo.toml new file mode 100644 index 0000000..99cb41f --- /dev/null +++ b/pascals-triangle/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "pascals-triangle" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/pascals-triangle/src/main.rs b/pascals-triangle/src/main.rs new file mode 100644 index 0000000..7755650 --- /dev/null +++ b/pascals-triangle/src/main.rs @@ -0,0 +1,32 @@ +fn main() { + println!("Hello, world!"); + let tests = vec![ + (5, vec![ + vec![1],vec![1,1],vec![1,2,1],vec![1,3,3,1],vec![1,4,6,4,1] + ]), + (1, vec![vec![1]]) + ]; + + for test in tests { + println!("{} is {:?} should be {:?}", test.0, Solution::generate(test.0), test.1); + } +} + +struct Solution {} +impl Solution { + pub fn generate(num_rows: i32) -> Vec> { + let mut rows = Vec::with_capacity(num_rows as usize); + rows.push(vec![1]); + for i in 1..num_rows { + let mut row: Vec = Vec::with_capacity((i+1) as usize); + for ii in 0..=i { + let above = &rows[(i-1) as usize]; + row.push(if ii == 0 || i == ii {1} else {above[(ii-1) as usize] + above[ii as usize]}); + } + rows.push(row); + } + + rows + } +} + diff --git a/plus-one/Cargo.toml b/plus-one/Cargo.toml new file mode 100644 index 0000000..d912d93 --- /dev/null +++ b/plus-one/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "plus-one" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/plus-one/src/main.rs b/plus-one/src/main.rs new file mode 100644 index 0000000..7fdef54 --- /dev/null +++ b/plus-one/src/main.rs @@ -0,0 +1,21 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution {} +impl Solution { + pub fn plus_one(digits: Vec) -> Vec { + let mut result = Vec::with_capacity(digits.len()+1); + let mut carry = 1; + for i in digits.iter().rev() { + let sum = *i + carry; + result.push(sum % 10); + carry = sum / 10; + } + if carry > 0 { + result.push(carry); + } + result.reverse(); + result + } +} diff --git a/remove-all-occurrences-of-a-substring/Cargo.toml b/remove-all-occurrences-of-a-substring/Cargo.toml new file mode 100644 index 0000000..d872dcc --- /dev/null +++ b/remove-all-occurrences-of-a-substring/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "remove-all-occurrences-of-a-substring" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/remove-all-occurrences-of-a-substring/src/main.rs b/remove-all-occurrences-of-a-substring/src/main.rs new file mode 100644 index 0000000..8e1e181 --- /dev/null +++ b/remove-all-occurrences-of-a-substring/src/main.rs @@ -0,0 +1,14 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn remove_occurrences(mut s: String, part: String) -> String { + while s.contains(&part) { + s = s.replacen(&part, "", 1); + } + s + } +} diff --git a/remove-colored-pieces-if-both-neighbors-are-the-same-color/Cargo.toml b/remove-colored-pieces-if-both-neighbors-are-the-same-color/Cargo.toml new file mode 100644 index 0000000..30239ca --- /dev/null +++ b/remove-colored-pieces-if-both-neighbors-are-the-same-color/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "remove-colored-pieces-if-both-neighbors-are-the-same-color" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/remove-colored-pieces-if-both-neighbors-are-the-same-color/src/main.rs b/remove-colored-pieces-if-both-neighbors-are-the-same-color/src/main.rs new file mode 100644 index 0000000..298c43d --- /dev/null +++ b/remove-colored-pieces-if-both-neighbors-are-the-same-color/src/main.rs @@ -0,0 +1,31 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + ("AAABABB", true), + ("AA", false), + ("ABBBBBBBAAA", false), + ("AAAABBBB", false) + ]; + for (input, output) in tests { + let result = Solution::winner_of_game(input.to_string()); + println!("{input:?} is {result} should be {output:?}"); + } +} + +struct Solution; + +impl Solution { + pub fn winner_of_game(mut colors: String) -> bool { + if colors.len() < 3 {return false;} + let mut is_alice_turn = true; + while ((is_alice_turn && colors.contains("AAA")) || (!is_alice_turn) && colors.contains("BBB")) { + if is_alice_turn { + colors = colors.replacen("AAA", "AA", 1); + } else { + colors = colors.replacen("BBB", "BB", 1); + } + is_alice_turn = !is_alice_turn + } + !is_alice_turn + } +} diff --git a/remove-duplicate-letters/Cargo.toml b/remove-duplicate-letters/Cargo.toml new file mode 100644 index 0000000..65fc799 --- /dev/null +++ b/remove-duplicate-letters/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "remove-duplicate-letters" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/remove-duplicate-letters/src/main.rs b/remove-duplicate-letters/src/main.rs new file mode 100644 index 0000000..9cc7296 --- /dev/null +++ b/remove-duplicate-letters/src/main.rs @@ -0,0 +1,27 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + ("bcabc", "abc"), + ("cbacdcbc", "acdb") + ]; + + for test in tests { + println!("{:?} is {:?} should be {:?}", test.0, + Solution::remove_duplicate_letters(test.0.to_string()), test.1); + } +} + +struct Solution; + +impl Solution { + pub fn remove_duplicate_letters(s: String) -> String { + let mut a: Vec = Vec::with_capacity(s.len()); + let start = s.chars().enumerate().reduce(|a,b| if a.1 < b.1 {a} else {b}); + for c in s.chars().skip(start.unwrap().0) { + if a.last().is_none() || c > *a.last().unwrap() { + a.push(c); + } + } + a.iter().collect::() + } +} diff --git a/remove-duplicates-from-sorted-array/Cargo.toml b/remove-duplicates-from-sorted-array/Cargo.toml new file mode 100644 index 0000000..8d10bd5 --- /dev/null +++ b/remove-duplicates-from-sorted-array/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "remove-duplicates-from-sorted-array" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/remove-duplicates-from-sorted-array/src/main.rs b/remove-duplicates-from-sorted-array/src/main.rs new file mode 100644 index 0000000..2838a46 --- /dev/null +++ b/remove-duplicates-from-sorted-array/src/main.rs @@ -0,0 +1,11 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution {} +impl Solution { + pub fn remove_duplicates(nums: &mut Vec) -> i32 { + nums.dedup(); + nums.len() as i32 + } +} diff --git a/remove-element/Cargo.toml b/remove-element/Cargo.toml new file mode 100644 index 0000000..c4f2338 --- /dev/null +++ b/remove-element/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "remove-element" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/remove-element/src/main.rs b/remove-element/src/main.rs new file mode 100644 index 0000000..807cd97 --- /dev/null +++ b/remove-element/src/main.rs @@ -0,0 +1,15 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn remove_element(nums: &mut Vec, val: i32) -> i32 { + let elements: Vec<_> = nums.iter().enumerate().filter(|(_,&num)| num == val).map(|(i,_)| i).collect(); + for i in &elements { + nums.remove(*i); + } + elements.len() as i32 + } +} diff --git a/remove-one-element-to-make-the-array-strictly-increasing/Cargo.toml b/remove-one-element-to-make-the-array-strictly-increasing/Cargo.toml new file mode 100644 index 0000000..ccf1b7c --- /dev/null +++ b/remove-one-element-to-make-the-array-strictly-increasing/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "remove-one-element-to-make-the-array-strictly-increasing" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/remove-one-element-to-make-the-array-strictly-increasing/src/main.rs b/remove-one-element-to-make-the-array-strictly-increasing/src/main.rs new file mode 100644 index 0000000..d9f5304 --- /dev/null +++ b/remove-one-element-to-make-the-array-strictly-increasing/src/main.rs @@ -0,0 +1,20 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + (vec![1,2,10,5,7], true), + (vec![2,3,1,2], false), + (vec![1,1,1], false) + ]; + for test in tests { + println!("{:?} is {} should be {}", test.0, Solution::can_be_increasing(test.0.clone()), + test.1); + } +} + +struct Solution; + +impl Solution { + pub fn can_be_increasing(nums: Vec) -> bool { + nums.windows(2).filter(|x| x[0] < x[1]).count() + 2 == nums.len() + } +} diff --git a/replace-all-digits-with-characters/Cargo.toml b/replace-all-digits-with-characters/Cargo.toml new file mode 100644 index 0000000..ec8606e --- /dev/null +++ b/replace-all-digits-with-characters/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "replace-all-digits-with-characters" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/replace-all-digits-with-characters/src/main.rs b/replace-all-digits-with-characters/src/main.rs new file mode 100644 index 0000000..881d15a --- /dev/null +++ b/replace-all-digits-with-characters/src/main.rs @@ -0,0 +1,20 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + ("a1c1e1", "abcdef"), + ("a1b2c3d4e", "abbdcfdhe") + ]; + for (input, output) in tests { + let result = Solution::replace_digits(input.to_string()); + println!("{input:?} is {result:?} should be {output:?}"); + } +} + +struct Solution; + +impl Solution { + pub fn replace_digits(mut s: String) -> String { + unsafe {s.as_bytes_mut()}.chunks_exact_mut(2).for_each(|x| x[1] = x[0] + x[1] - b'0'); + s + } +} diff --git a/reverse-integer/Cargo.toml b/reverse-integer/Cargo.toml new file mode 100644 index 0000000..c6ea71f --- /dev/null +++ b/reverse-integer/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "reverse-integer" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/reverse-integer/src/main.rs b/reverse-integer/src/main.rs new file mode 100644 index 0000000..acb54a6 --- /dev/null +++ b/reverse-integer/src/main.rs @@ -0,0 +1,12 @@ +fn main() { + println!("Hello, world!"); +} + + +struct Solution; + +impl Solution { + pub fn reverse(x: i32) -> i32 { + x.abs().to_string().chars().rev().collect::().parse::().unwrap_or(0) * x.signum() + } +} diff --git a/reverse-linked-list-ii/Cargo.toml b/reverse-linked-list-ii/Cargo.toml new file mode 100644 index 0000000..d8764c6 --- /dev/null +++ b/reverse-linked-list-ii/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "reverse-linked-list-ii" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/reverse-linked-list-ii/src/main.rs b/reverse-linked-list-ii/src/main.rs new file mode 100644 index 0000000..20790aa --- /dev/null +++ b/reverse-linked-list-ii/src/main.rs @@ -0,0 +1,59 @@ +fn main() { + let tests = [ + (vec![1,2,3,4,5], 2, 4, vec![1,4,3,2,5]), + (vec![5], 1, 1, vec![5]) + ]; + + for test in tests { + let a = ListNode::new_from_vec(test.0.clone()); + println!("{:?} is {:?} should be {:?}", test.0, Solution::reverse_between(a, test.1, test.2).unwrap().to_vec(), test.3); + } + +} + +#[derive(PartialEq, Eq, Clone, Debug)] +pub struct ListNode { + pub val: i32, + pub next: Option> +} + +impl ListNode { + #[inline] + fn new(val: i32) -> Self { + ListNode { + next: None, + val + } + } +} + +impl ListNode { + fn new_from_vec(val: Vec) -> Option> { + let mut first = ListNode::new(val[0]); + if val.len() > 1 { + let slice = &val[1..val.len()]; + first.next = Self::new_from_vec(slice.to_vec()); + } + Some(Box::new(first)) + } + pub fn to_vec(&self) -> Vec { + let mut v = Vec::new(); + + let mut a = Some(Box::new(self.to_owned())); + while a.is_some() { + let t = a.unwrap(); + v.push(t.val); + a = t.next; + } + v + } +} +struct Solution {} +impl Solution { + pub fn reverse_between(head: Option>, left: i32, right: i32) -> Option> { + let v = &mut head.unwrap().to_vec(); + v[((left-1) as usize)..(right as usize)].reverse(); + + ListNode::new_from_vec( v.to_vec() ) + } +} diff --git a/reverse-string-ii/Cargo.toml b/reverse-string-ii/Cargo.toml new file mode 100644 index 0000000..10128f6 --- /dev/null +++ b/reverse-string-ii/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "reverse-string-ii" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/reverse-string-ii/src/main.rs b/reverse-string-ii/src/main.rs new file mode 100644 index 0000000..883f24f --- /dev/null +++ b/reverse-string-ii/src/main.rs @@ -0,0 +1,21 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + ("abcdefg", 2, "bacdfeg"), + ("abcd", 2, "bacd") + ]; + + for test in tests { + println!("{:?} {} is {:?} should be {:?}", test.0, test.1, + Solution::reverse_str(test.0.to_string(), test.1), test.2); + } +} + +struct Solution; + +impl Solution { + pub fn reverse_str(mut s: String, k: i32) -> String { + unsafe { s.as_bytes_mut() }.chunks_mut(k as usize).step_by(2).for_each(|x| x.reverse()); + s + } +} diff --git a/reverse-words-in-a-string-iii/Cargo.toml b/reverse-words-in-a-string-iii/Cargo.toml new file mode 100644 index 0000000..b5d5baf --- /dev/null +++ b/reverse-words-in-a-string-iii/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "reverse-words-in-a-string-iii" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/reverse-words-in-a-string-iii/src/main.rs b/reverse-words-in-a-string-iii/src/main.rs new file mode 100644 index 0000000..473b428 --- /dev/null +++ b/reverse-words-in-a-string-iii/src/main.rs @@ -0,0 +1,12 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn reverse_words(mut s: String) -> String { + unsafe {s.as_bytes_mut() }.split_mut(|&x| x == b' ').for_each(|x| x.reverse()); + s + } +} diff --git a/rotting-oranges-c/main.c b/rotting-oranges-c/main.c new file mode 100644 index 0000000..f1a4caf --- /dev/null +++ b/rotting-oranges-c/main.c @@ -0,0 +1,62 @@ +#include +#include +#include +#include + +#define MIN(a,b) (((a)<(b))?(a):(b)) +#define MAX(a,b) (((a)>(b))?(a):(b)) + +int orangesRotting(int** grid, int gridSize, int* gridColSize) { + int *grid2 = malloc(sizeof(int) * gridSize * *gridColSize); + memcpy(grid2, *grid, sizeof(int) * gridSize * *gridColSize); + printf("%d %d\n", gridSize, *gridColSize); + + for (int minutes = 0;; minutes++) { + for (int x = 0; x < gridSize; x++) { + for (int y = 0; y < *gridColSize; y++) { + printf("%d ", (*grid)[x * gridSize + y]); + if ( (*grid)[x * gridSize + y] != 2 ) continue; + + for (int dx = MAX(x-1,0); dx < MIN(x+2, gridSize); dx++) + if ((*grid)[dx * gridSize + y] == 1) (grid2)[dx * gridSize + y] = 2; + for (int dy = MAX(y-1, 0); dy < MIN(y+2, *gridColSize); dy++) + if ((*grid)[x * gridSize + dy] == 1) (grid2)[x * gridSize + dy] = 2; + } + printf("\n"); + } + + int finished = 1; + int same = 1; + for (size_t i = 0; i < gridSize * *gridColSize; i++) { + if ((*grid)[i] == 1) finished = 0; + same &= (*grid)[i] == grid2[i]; + } + + if (finished) return minutes; + + if (same) return -1; + int *temp = *grid; + *grid = grid2; + grid2 = temp; + memcpy(grid2, *grid, sizeof(int) * gridSize * *gridColSize); + } + + return 0; +} + +int main() { + int *test1 = malloc(sizeof(int) * 3 * 3); + int test[] = {2,1,1,1,1,0,0,1,1}; + memcpy(test1, test, sizeof(int) * 3 * 3); + + int gridColSize = 3; + + int result = orangesRotting(&test1, 3, &gridColSize); + + printf("is %d expeceted %d\n", result, 4); + + assert(result == 4); +} + + + diff --git a/rotting-oranges/Cargo.toml b/rotting-oranges/Cargo.toml new file mode 100644 index 0000000..5202e07 --- /dev/null +++ b/rotting-oranges/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "rotting-oranges" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/rotting-oranges/src/main.rs b/rotting-oranges/src/main.rs new file mode 100644 index 0000000..a975aa1 --- /dev/null +++ b/rotting-oranges/src/main.rs @@ -0,0 +1,81 @@ +fn main() { + let tests: Vec>> = vec![ + vec![ + vec![2,1,1], + vec![1,1,0], + vec![0,1,1] + ], + vec![ + vec![2,1,1], + vec![0,1,1], + vec![1,0,1] + ], + vec![ + vec![0,2] + ], + vec![ + vec![1,2] + ] + ]; + let outputs = [4,-1,0,1]; + for (n, test) in tests.iter().enumerate() { + let c: Vec> = test.to_vec(); + let result = oranges_rotting(c); + println!("test {} result {} should be {}", n, result, outputs[n]); + } +} + + +fn oranges_rotting(grid: Vec>) -> i32 { + let mut grid1 = grid.clone(); + let mut grid2 = grid1.clone(); + + let mut minutes: i32 = -1; + let mut some_fresh: bool = true; + let mut some_different: bool; + while some_fresh { + some_fresh = false; + some_different = false; + + // println!("Minute {}", minutes); + + for (x, row) in grid1.iter().enumerate() { + for (y, col) in row.iter().enumerate() { + some_fresh |= *col == 1; + if *col != 2 {continue;} + let r: [i32; 3] = [-1,0,1]; + for ix in r { + for iy in r { + if ix.abs() == iy.abs() {continue;} + let field: &mut i32 = &mut grid2[ + (x as i32 + ix).clamp(0,grid.len() as i32 -1) as usize + ][ + (y as i32 + iy).clamp(0,grid[0].len() as i32 -1) as usize + ]; + if *field == 1 { + some_different = true; + *field = 2; + } + } + } + } + // println!("{:?} {:?}", row, grid2[x]); + } + // for (x, row) in grid1.iter().enumerate() { + // for (y, col) in row.iter().enumerate() { + // some_different |= grid1[x][y] != grid2[x][y]; + // } + // } + + if !some_different && some_fresh { + // println!("impossible"); + return -1; + } + + grid1 = grid2; + grid2 = grid1.clone(); + minutes += 1; + } + return minutes; +} + diff --git a/rotting-oranges/src/main_2.rs b/rotting-oranges/src/main_2.rs new file mode 100644 index 0000000..6e806a7 --- /dev/null +++ b/rotting-oranges/src/main_2.rs @@ -0,0 +1,80 @@ +fn main() { + let tests: Vec>> = vec![ + vec![ + vec![2,1,1], + vec![1,1,0], + vec![0,1,1] + ], + vec![ + vec![2,1,1], + vec![0,1,1], + vec![1,0,1] + ], + vec![ + vec![0,2] + ], + vec![ + vec![1,2] + ] + ]; + let outputs = [4,-1,0,1]; + for (n, test) in tests.iter().enumerate() { + let c: Vec> = test.to_vec(); + let result = oranges_rotting(c); + println!("test {} result {} should be {}", n, result, outputs[n]); + } +} + + +fn oranges_rotting(grid: Vec>) -> i32 { + let mut grid1 = grid.clone(); + let mut grid2 = grid1.clone(); + + let mut minutes: i32 = -1; + let mut some_fresh: bool = true; + let mut some_different: bool; + while some_fresh { + some_fresh = false; + some_different = false; + + println!("Minute {}", minutes); + + for (x, row) in grid1.iter().enumerate() { + for (y, col) in row.iter().enumerate() { + some_fresh |= *col == 1; + if *col != 2 {continue;} + let r: [i32; 3] = [-1,0,1]; + for ix in r { + for iy in r { + if ix.abs() == iy.abs() {continue;} + let field: &mut i32 = &mut grid2[ + (x as i32 + ix).clamp(0,grid.len() as i32 -1) as usize + ][ + (y as i32 + iy).clamp(0,grid[0].len() as i32 -1) as usize + ]; + if *field == 1 { + *field = 2; + } + } + } + } + println!("{:?} {:?}", row, grid2[x]); + } + for (x, row) in grid1.iter().enumerate() { + for (y, col) in row.iter().enumerate() { + some_different |= grid1[x][y] != grid2[x][y]; + } + } + + if !some_different && some_fresh { + println!("impossible"); + return -1; + } + + grid1 = grid2; + grid2 = grid1.clone(); + minutes += 1; + } + return minutes; +} + diff --git a/search-insert-position/Cargo.toml b/search-insert-position/Cargo.toml new file mode 100644 index 0000000..a4b2727 --- /dev/null +++ b/search-insert-position/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "search-insert-position" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/search-insert-position/src/main.rs b/search-insert-position/src/main.rs new file mode 100644 index 0000000..50ad333 --- /dev/null +++ b/search-insert-position/src/main.rs @@ -0,0 +1,12 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution {} +impl Solution { + pub fn search_insert(nums: Vec, target: i32) -> i32 { + nums.partition_point(|&x| x < target) as i32 + // nums.binary_search(&target).unwrap_or_else(|x| x) as i32 + + } +} diff --git a/shortest-distance-to-a-character/Cargo.toml b/shortest-distance-to-a-character/Cargo.toml new file mode 100644 index 0000000..ce28cb0 --- /dev/null +++ b/shortest-distance-to-a-character/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "shortest-distance-to-a-character" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/shortest-distance-to-a-character/src/main.rs b/shortest-distance-to-a-character/src/main.rs new file mode 100644 index 0000000..e7a11a9 --- /dev/null +++ b/shortest-distance-to-a-character/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + println!("Hello, world!"); +} diff --git a/sort-array-by-parity/Cargo.toml b/sort-array-by-parity/Cargo.toml new file mode 100644 index 0000000..c67befb --- /dev/null +++ b/sort-array-by-parity/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "sort-array-by-parity" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/sort-array-by-parity/src/main.rs b/sort-array-by-parity/src/main.rs new file mode 100644 index 0000000..6deb88d --- /dev/null +++ b/sort-array-by-parity/src/main.rs @@ -0,0 +1,22 @@ +fn main() { + println!("Hello, world!"); + + let tests = [ + vec![3,1,2,4], + vec![0] + ]; + + for test in tests { + println!("{:?} {:?}", test, Solution::sort_array_by_parity(test.clone())); + } +} + +struct Solution; + +impl Solution { + pub fn sort_array_by_parity(nums: Vec) -> Vec { + let mut result = nums.clone(); + result.sort_by_key(|x| x % 2); + result + } +} diff --git a/sort-the-matrix-diagonally/Cargo.toml b/sort-the-matrix-diagonally/Cargo.toml new file mode 100644 index 0000000..8e05371 --- /dev/null +++ b/sort-the-matrix-diagonally/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "sort-the-matrix-diagonally" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/sort-the-matrix-diagonally/src/main.rs b/sort-the-matrix-diagonally/src/main.rs new file mode 100644 index 0000000..fa8d7e8 --- /dev/null +++ b/sort-the-matrix-diagonally/src/main.rs @@ -0,0 +1,26 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +use std::collections::HashMap; + +impl Solution { + pub fn diagonal_sort(mut mat: Vec>) -> Vec> { + let mut a = HashMap::new(); + + for (i, row) in mat.iter().enumerate() { + for (ii, value) in row.iter().enumerate() { + a.entry(i-ii).and_modify(|x: &mut Vec<&i32>| {x.push(value)}).or_insert(vec![value]); + } + } + + for i in a.values_mut() { + i.sort(); + println!("{i:?}"); + } + + mat + } +} diff --git a/sum-root-to-leaf-numbers/Cargo.toml b/sum-root-to-leaf-numbers/Cargo.toml new file mode 100644 index 0000000..5d43227 --- /dev/null +++ b/sum-root-to-leaf-numbers/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "sum-root-to-leaf-numbers" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/sum-root-to-leaf-numbers/src/main.rs b/sum-root-to-leaf-numbers/src/main.rs new file mode 100644 index 0000000..57254ce --- /dev/null +++ b/sum-root-to-leaf-numbers/src/main.rs @@ -0,0 +1,40 @@ +// Definition for a binary tree node. +#[derive(Debug, PartialEq, Eq)] +pub struct TreeNode { + pub val: i32, + pub left: Option>>, + pub right: Option>>, +} + +impl TreeNode { + #[inline] + pub fn new(val: i32) -> Self { + TreeNode { + val, + left: None, + right: None + } + } +} +use std::rc::Rc; +use std::cell::RefCell; + +struct Solution; +impl Solution { + pub fn sum_numbers(root: Option>>) -> i32 { + Solution::sum_numbers_before(root, 0) + } + pub fn sum_numbers_before(root: Option>>, before: i32) -> i32 { + let Some(node) = root else {return 0;}; + let n = &node.borrow(); + let mut sum = 0; + if n.left.is_some() {sum += Solution::sum_numbers_before(n.left.clone(), before * 10 + n.val);} + if n.right.is_some() {sum += Solution::sum_numbers_before(n.right.clone(), before * 10 + n.val);} + sum + } +} + + +fn main() { + println!("Hello, world!"); +} diff --git a/two-sum/Cargo.toml b/two-sum/Cargo.toml new file mode 100644 index 0000000..540b825 --- /dev/null +++ b/two-sum/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "two-sum" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/two-sum/src/main.rs b/two-sum/src/main.rs new file mode 100644 index 0000000..8b18400 --- /dev/null +++ b/two-sum/src/main.rs @@ -0,0 +1,28 @@ +fn main() { + println!("Hello, world!"); + let tests = [ + (vec![2,7,11,15], 9, vec![0,1]), + (vec![3,2,4], 6, vec![1,2]), + (vec![3,3], 6, vec![0,1]) + ]; + + for test in tests { + println!("{:?} at {} is {:?} should be {:?}", + test.0, + test.1, + two_sum(test.0.clone(), test.1), + test.2 + ); + } +} + +pub fn two_sum(nums: Vec, target: i32) -> Vec { + for i in 0..nums.len()-1 { + for ii in i+1..nums.len() { + if nums[i] + nums[ii] == target { + return vec![i as i32, ii as i32]; + } + } + } + return vec![0,0]; +} diff --git a/valid-palindrome/Cargo.toml b/valid-palindrome/Cargo.toml new file mode 100644 index 0000000..70e5242 --- /dev/null +++ b/valid-palindrome/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "valid-palindrome" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/valid-palindrome/src/main.rs b/valid-palindrome/src/main.rs new file mode 100644 index 0000000..e9ad1d4 --- /dev/null +++ b/valid-palindrome/src/main.rs @@ -0,0 +1,12 @@ +fn main() { + println!("Hello, world!"); +} + +struct Solution; + +impl Solution { + pub fn is_palindrome(mut s: String) -> bool { + let str: Vec = unsafe { s.as_bytes_mut() }.iter_mut().filter(|x| x.is_ascii_alphanumeric()).map(|x| x.to_ascii_lowercase()).collect(); + str.iter().take(str.len() / 2).eq(str.iter().rev().take(str.len() / 2)) + } +} diff --git a/valid-parentheses/Cargo.toml b/valid-parentheses/Cargo.toml new file mode 100644 index 0000000..7b14741 --- /dev/null +++ b/valid-parentheses/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "valid-parentheses" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/valid-parentheses/src/main.rs b/valid-parentheses/src/main.rs new file mode 100644 index 0000000..5ee7e96 --- /dev/null +++ b/valid-parentheses/src/main.rs @@ -0,0 +1,39 @@ +fn main() { + let tests = vec![ + ("()", true), + ("()[]{}", true), + ("([", false) + ]; + + for test in tests { + println!("{} is {} should be {}", test.0, is_valid(test.0.to_string()).to_string(), test.1) + } +} + +fn is_valid(s: String) -> bool { + + let mut stack: Vec = vec![]; + + for c in s.chars() { + match c { + '[' | '(' | '{' => stack.push(c), + ']' | ')' | '}' => { + match stack.pop() { + Some(head) => if lookup(head).unwrap() != c {return false;}, + None => return false + } + } + _ => {} + } + } + return stack.is_empty(); +} + +fn lookup(c: char) -> Option { + match c { + '[' => Some(']'), + '(' => Some(')'), + '{' => Some('}'), + _ => None + } +}