From 51d935d06be6690059708b256acb2258d9b1209b Mon Sep 17 00:00:00 2001 From: timeshifter Date: Fri, 4 Sep 2026 15:56:45 +0200 Subject: [PATCH] add initial data --- 0005-longest-palindromic-substring/Cargo.lock | 7 ++ 0005-longest-palindromic-substring/Cargo.toml | 6 ++ .../src/main.rs | 64 +++++++++++++ 0006-zigzag-conversion/Cargo.lock | 7 ++ 0006-zigzag-conversion/Cargo.toml | 6 ++ 0006-zigzag-conversion/src/main.rs | 53 +++++++++++ 0007-reverse-integer/Cargo.lock | 7 ++ 0007-reverse-integer/Cargo.toml | 6 ++ 0007-reverse-integer/src/main.rs | 43 +++++++++ 0008-string-to-integer-atoi/Cargo.lock | 7 ++ 0008-string-to-integer-atoi/Cargo.toml | 6 ++ 0008-string-to-integer-atoi/src/main.rs | 94 +++++++++++++++++++ 0011-container-with-most-water/Cargo.lock | 7 ++ 0011-container-with-most-water/Cargo.toml | 6 ++ 0011-container-with-most-water/src/main.rs | 37 ++++++++ 0012-integer-to-roman/Cargo.lock | 7 ++ 0012-integer-to-roman/Cargo.toml | 6 ++ 0012-integer-to-roman/src/main.rs | 54 +++++++++++ 0013-roman-to-integer/Cargo.lock | 7 ++ 0013-roman-to-integer/Cargo.toml | 6 ++ 0013-roman-to-integer/src/main.rs | 59 ++++++++++++ 0015-3sum/Cargo.lock | 7 ++ 0015-3sum/Cargo.toml | 6 ++ 0015-3sum/src/main.rs | 88 +++++++++++++++++ .../Cargo.lock | 7 ++ .../Cargo.toml | 6 ++ .../src/main.rs | 66 +++++++++++++ .../Cargo.lock | 7 ++ .../Cargo.toml | 6 ++ .../src/main.rs | 45 +++++++++ 0020-valid-parentheses/Cargo.lock | 7 ++ 0020-valid-parentheses/Cargo.toml | 6 ++ 0020-valid-parentheses/src/main.rs | 64 +++++++++++++ add-two-numbers/Cargo.lock | 7 ++ add-two-numbers/Cargo.toml | 6 ++ add-two-numbers/src/main.rs | 77 +++++++++++++++ .../Cargo.lock | 7 ++ .../Cargo.toml | 6 ++ .../src/main.rs | 20 ++++ length-of-last-word/Cargo.lock | 7 ++ length-of-last-word/Cargo.toml | 6 ++ length-of-last-word/src/main.rs | 7 ++ longest-common-prefix/Cargo.lock | 7 ++ longest-common-prefix/Cargo.toml | 6 ++ longest-common-prefix/src/main.rs | 28 ++++++ .../Cargo.lock | 7 ++ .../Cargo.toml | 6 ++ .../src/main.rs | 58 ++++++++++++ palindrome-number/Cargo.lock | 7 ++ palindrome-number/Cargo.toml | 6 ++ palindrome-number/src/main.rs | 20 ++++ .../Cargo.lock | 7 ++ .../Cargo.toml | 6 ++ .../src/main.rs | 32 +++++++ remove-element/Cargo.lock | 7 ++ remove-element/Cargo.toml | 6 ++ remove-element/src/main.rs | 29 ++++++ search-insert-position/Cargo.lock | 7 ++ search-insert-position/Cargo.toml | 6 ++ search-insert-position/src/main.rs | 19 ++++ two-sum/Cargo.lock | 7 ++ two-sum/Cargo.toml | 6 ++ two-sum/src/main.rs | 45 +++++++++ valid-parentheses/Cargo.lock | 7 ++ valid-parentheses/Cargo.toml | 6 ++ valid-parentheses/src/main.rs | 41 ++++++++ 66 files changed, 1329 insertions(+) create mode 100644 0005-longest-palindromic-substring/Cargo.lock create mode 100644 0005-longest-palindromic-substring/Cargo.toml create mode 100644 0005-longest-palindromic-substring/src/main.rs create mode 100644 0006-zigzag-conversion/Cargo.lock create mode 100644 0006-zigzag-conversion/Cargo.toml create mode 100644 0006-zigzag-conversion/src/main.rs create mode 100644 0007-reverse-integer/Cargo.lock create mode 100644 0007-reverse-integer/Cargo.toml create mode 100644 0007-reverse-integer/src/main.rs create mode 100644 0008-string-to-integer-atoi/Cargo.lock create mode 100644 0008-string-to-integer-atoi/Cargo.toml create mode 100644 0008-string-to-integer-atoi/src/main.rs create mode 100644 0011-container-with-most-water/Cargo.lock create mode 100644 0011-container-with-most-water/Cargo.toml create mode 100644 0011-container-with-most-water/src/main.rs create mode 100644 0012-integer-to-roman/Cargo.lock create mode 100644 0012-integer-to-roman/Cargo.toml create mode 100644 0012-integer-to-roman/src/main.rs create mode 100644 0013-roman-to-integer/Cargo.lock create mode 100644 0013-roman-to-integer/Cargo.toml create mode 100644 0013-roman-to-integer/src/main.rs create mode 100644 0015-3sum/Cargo.lock create mode 100644 0015-3sum/Cargo.toml create mode 100644 0015-3sum/src/main.rs create mode 100644 0017-letter-combinations-of-a-phone-number/Cargo.lock create mode 100644 0017-letter-combinations-of-a-phone-number/Cargo.toml create mode 100644 0017-letter-combinations-of-a-phone-number/src/main.rs create mode 100644 0019-remove-nth-node-from-end-of-list/Cargo.lock create mode 100644 0019-remove-nth-node-from-end-of-list/Cargo.toml create mode 100644 0019-remove-nth-node-from-end-of-list/src/main.rs create mode 100644 0020-valid-parentheses/Cargo.lock create mode 100644 0020-valid-parentheses/Cargo.toml create mode 100644 0020-valid-parentheses/src/main.rs create mode 100644 add-two-numbers/Cargo.lock create mode 100644 add-two-numbers/Cargo.toml create mode 100644 add-two-numbers/src/main.rs create mode 100644 find-the-index-of-the-first-occurrence-in-a-string/Cargo.lock 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 length-of-last-word/Cargo.lock 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.lock create mode 100644 longest-common-prefix/Cargo.toml create mode 100644 longest-common-prefix/src/main.rs create mode 100644 longest-substring-without-repeating-characters/Cargo.lock create mode 100644 longest-substring-without-repeating-characters/Cargo.toml create mode 100644 longest-substring-without-repeating-characters/src/main.rs create mode 100644 palindrome-number/Cargo.lock create mode 100644 palindrome-number/Cargo.toml create mode 100644 palindrome-number/src/main.rs create mode 100644 remove-duplicates-from-sorted-array/Cargo.lock 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.lock create mode 100644 remove-element/Cargo.toml create mode 100644 remove-element/src/main.rs create mode 100644 search-insert-position/Cargo.lock create mode 100644 search-insert-position/Cargo.toml create mode 100644 search-insert-position/src/main.rs create mode 100644 two-sum/Cargo.lock create mode 100644 two-sum/Cargo.toml create mode 100644 two-sum/src/main.rs create mode 100644 valid-parentheses/Cargo.lock create mode 100644 valid-parentheses/Cargo.toml create mode 100644 valid-parentheses/src/main.rs diff --git a/0005-longest-palindromic-substring/Cargo.lock b/0005-longest-palindromic-substring/Cargo.lock new file mode 100644 index 0000000..8779c0d --- /dev/null +++ b/0005-longest-palindromic-substring/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "leetcode" +version = "0.1.0" diff --git a/0005-longest-palindromic-substring/Cargo.toml b/0005-longest-palindromic-substring/Cargo.toml new file mode 100644 index 0000000..884c0d3 --- /dev/null +++ b/0005-longest-palindromic-substring/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/0005-longest-palindromic-substring/src/main.rs b/0005-longest-palindromic-substring/src/main.rs new file mode 100644 index 0000000..5b98768 --- /dev/null +++ b/0005-longest-palindromic-substring/src/main.rs @@ -0,0 +1,64 @@ +fn main() { + println!("Hello, world!"); +} + +pub fn longest_palindrome(s: String) -> String { + let mut best = Vec::with_capacity(s.len()); + + let bytes = s.as_bytes(); + + for center in 0..bytes.len() { + for (mut left_idx, mut right_idx) in [(center, center), (center, center + 1)] { + expand(bytes, &mut left_idx, &mut right_idx); + + if right_idx - left_idx > best.len() { + best = bytes[left_idx..right_idx].into(); + } + } + } + String::from_utf8(best).unwrap() +} + +fn expand(bytes: &[u8], left_idx: &mut usize, right_idx: &mut usize) { + loop { + if bytes.get(*right_idx).is_none_or(|&r| bytes[*left_idx] != r) { + *left_idx += 1; + return; + } + match left_idx.checked_sub(1) { + Some(new_left) => *left_idx = new_left, + None => { + *right_idx += 1; + return; + } + } + *right_idx += 1; + } +} + +#[cfg(test)] +mod tests { + use crate::longest_palindrome; + + #[test] + fn test_1() { + assert!( + ["aba".to_string(), "bab".to_string()] + .contains(&longest_palindrome("babad".to_string())) + ); + } + #[test] + fn test_2() { + assert_eq!(longest_palindrome("cbbd".to_string()), "bb".to_string()); + } + + #[test] + fn test_3() { + assert_eq!(longest_palindrome("whdqcudjpisufnrtsyupwtnnbsvfptrcgvobbjglmpynebblpigaflpbezjvjgbmofejyjssdhbgghgrhzuplbeptpaecfdanhlylgusptlgobkqnulxvnwuzwauewcplnvcwowmbxxnhsdmgxtvbfgnuqdpxennqglgmspbagvmjcmzmbsuacxlqfxjggrwsnbblnnwisvmpwwhomyjylbtedzrptejjsaiqzprnadkjxeqfdpkddmbzokkegtypxaafodjdwirynzurzkjzrkufsokhcdkajwmqvhcbzcnysrbsfxhfvtodqabvbuosxtonbpmgoemcgkudandrioncjigbyizekiakmrfjvezuzddjxqyevyenuebfwugqelxwpirsoyixowcmtgosuggrkdciehktojageynqkazsqxraimeopcsjxcdtzhlbvtlvzytgblwkmbfwmggrkpioeofkrmfdgfwknrbaimhefpzckrzwdvddhdqujffwvtvfyjlimkljrsnnhudyejcrtrwvtsbkxaplchgbikscfcbhovlepdojmqybzhbiionyjxqsmquehkhzdiawfxunguhqhkxqdiiwsbuhosebxrpcstpklukjcsnnzpbylzaoyrmyjatuovmaqiwfdfwyhugbeehdzeozdrvcvghekusiahfxhlzclhbegdnvkzeoafodnqbtanfwixjzirnoaiqamjgkcapeopbzbgtxsjhqurbpbuduqjziznblrhxbydxsmtjdfeepntijqpkuwmqezkhnkwbvwgnkxmkyhlbfuwaslmjzlhocsgtoujabbexvxweigplmlewumcone".to_string()), "wfdfw".to_string()); + } + + #[test] + fn test_4() { + assert_eq!(longest_palindrome("a".to_string()), "a".to_string()); + } +} diff --git a/0006-zigzag-conversion/Cargo.lock b/0006-zigzag-conversion/Cargo.lock new file mode 100644 index 0000000..8779c0d --- /dev/null +++ b/0006-zigzag-conversion/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "leetcode" +version = "0.1.0" diff --git a/0006-zigzag-conversion/Cargo.toml b/0006-zigzag-conversion/Cargo.toml new file mode 100644 index 0000000..884c0d3 --- /dev/null +++ b/0006-zigzag-conversion/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/0006-zigzag-conversion/src/main.rs b/0006-zigzag-conversion/src/main.rs new file mode 100644 index 0000000..c373589 --- /dev/null +++ b/0006-zigzag-conversion/src/main.rs @@ -0,0 +1,53 @@ +fn main() { + println!("Hello, world!"); +} + +pub fn convert(s: String, num_rows: i32) -> String { + let bytes = s.as_bytes(); + let mut result = vec![vec![]; num_rows as usize]; + + for (idx, byte) in bytes.iter().enumerate() { + let row = if num_rows == 1 { + 0 + } else { + let cycle_pos = idx % (2 * (num_rows - 1)) as usize; + if cycle_pos < num_rows as usize - 1 { + cycle_pos + } else { + 2 * (num_rows as usize - 1) - cycle_pos + } + }; + + result[row].push(*byte); + } + + result.into_iter().flatten().map(|b| b as char).collect() +} + +#[cfg(test)] +mod tests { + use super::convert; + + #[test] + fn test_1() { + assert_eq!( + convert("PAYPALISHIRING".to_string(), 3), + "PAHNAPLSIIGYIR".to_string() + ); + } + #[test] + fn test_2() { + assert_eq!( + convert("PAYPALISHIRING".to_string(), 4), + "PINALSIGYAHRPI".to_string() + ); + } + #[test] + fn test_3() { + assert_eq!(convert("A".to_string(), 1), "A".to_string()); + } + #[test] + fn test_4() { + assert_eq!(convert("AB".to_string(), 1), "AB".to_string()); + } +} diff --git a/0007-reverse-integer/Cargo.lock b/0007-reverse-integer/Cargo.lock new file mode 100644 index 0000000..8779c0d --- /dev/null +++ b/0007-reverse-integer/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "leetcode" +version = "0.1.0" diff --git a/0007-reverse-integer/Cargo.toml b/0007-reverse-integer/Cargo.toml new file mode 100644 index 0000000..884c0d3 --- /dev/null +++ b/0007-reverse-integer/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/0007-reverse-integer/src/main.rs b/0007-reverse-integer/src/main.rs new file mode 100644 index 0000000..219ded3 --- /dev/null +++ b/0007-reverse-integer/src/main.rs @@ -0,0 +1,43 @@ +fn main() { + println!("Hello, world!"); +} + +fn try_reverse(x: i32) -> Option { + let mut i = x; + let mut result: i32 = 0; + + while i != 0 { + let digit = i % 10; + result = result.checked_mul(10)?.checked_add(digit)?; + + i /= 10; + } + + Some(result) +} + +pub fn reverse(x: i32) -> i32 { + try_reverse(x).unwrap_or(0) +} + +#[cfg(test)] +mod tests { + use crate::reverse; + + #[test] + fn test_1() { + assert_eq!(reverse(123), 321); + } + #[test] + fn test_2() { + assert_eq!(reverse(-123), -321); + } + #[test] + fn test_3() { + assert_eq!(reverse(120), 21); + } + #[test] + fn test_4() { + assert_eq!(reverse(1534236469), 0); + } +} diff --git a/0008-string-to-integer-atoi/Cargo.lock b/0008-string-to-integer-atoi/Cargo.lock new file mode 100644 index 0000000..8779c0d --- /dev/null +++ b/0008-string-to-integer-atoi/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "leetcode" +version = "0.1.0" diff --git a/0008-string-to-integer-atoi/Cargo.toml b/0008-string-to-integer-atoi/Cargo.toml new file mode 100644 index 0000000..884c0d3 --- /dev/null +++ b/0008-string-to-integer-atoi/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/0008-string-to-integer-atoi/src/main.rs b/0008-string-to-integer-atoi/src/main.rs new file mode 100644 index 0000000..33dce8c --- /dev/null +++ b/0008-string-to-integer-atoi/src/main.rs @@ -0,0 +1,94 @@ +fn main() { + println!("Hello, world!"); +} +pub fn my_atoi(s: String) -> i32 { + let mut chars = s.trim().chars().peekable(); + + let is_negative = match chars.peek() { + Some(&'+') => { + chars.next(); + false + } + Some(&'-') => { + chars.next(); + true + } + _ => false, + }; + + let mut accum: i64 = 0; + for c in chars { + let Some(digit) = c.to_digit(10) else { + break; + }; + accum = accum * 10 - digit as i64; + accum = accum.max(i32::MIN as i64); + } + + if is_negative { + accum as i32 + } else { + (-accum).min(i32::MAX as i64) as i32 + } +} + +#[cfg(test)] +mod tests { + use crate::my_atoi; + + #[test] + fn test_1() { + assert_eq!(my_atoi("42".to_string()), 42); + } + + #[test] + fn test_2() { + assert_eq!(my_atoi(" -042".to_string()), -42); + } + + #[test] + fn test_3() { + assert_eq!(my_atoi("1337c0d3".to_string()), 1337); + } + + #[test] + fn test_4() { + assert_eq!(my_atoi("0-1".to_string()), 0); + } + + #[test] + fn test_5() { + assert_eq!(my_atoi("words and 987".to_string()), 0); + } + + #[test] + fn test_6() { + assert_eq!(my_atoi((i32::MAX as i64 + 1).to_string()), i32::MAX); + } + + #[test] + fn test_7() { + assert_eq!(my_atoi((i32::MAX).to_string()), i32::MAX); + } + + #[test] + fn test_8() { + assert_eq!(my_atoi("9223372036854775808".to_string()), i32::MAX); + } + + #[test] + fn test_9() { + assert_eq!( + my_atoi("1234567890123456789012345678901234567890".to_string()), + i32::MAX + ); + } + + #[test] + fn test_10() { + assert_eq!( + my_atoi("10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000522545459".to_string()), + i32::MAX + ); + } +} diff --git a/0011-container-with-most-water/Cargo.lock b/0011-container-with-most-water/Cargo.lock new file mode 100644 index 0000000..8779c0d --- /dev/null +++ b/0011-container-with-most-water/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "leetcode" +version = "0.1.0" diff --git a/0011-container-with-most-water/Cargo.toml b/0011-container-with-most-water/Cargo.toml new file mode 100644 index 0000000..884c0d3 --- /dev/null +++ b/0011-container-with-most-water/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/0011-container-with-most-water/src/main.rs b/0011-container-with-most-water/src/main.rs new file mode 100644 index 0000000..7629db1 --- /dev/null +++ b/0011-container-with-most-water/src/main.rs @@ -0,0 +1,37 @@ +fn main() { + println!("Hello, world!"); +} + +pub fn max_area(height: Vec) -> i32 { + let mut best = 0; + + let mut left = 0; + let mut right = height.len() - 1; + + while left != right { + let area = height[left].min(height[right]) * (right - left) as i32; + best = best.max(area); + if height[left] < height[right] { + left += 1; + } else { + right -= 1; + } + } + + best +} + +#[cfg(test)] +mod tests { + use crate::max_area; + + #[test] + fn test_1() { + assert_eq!(max_area(vec![1, 8, 6, 2, 5, 4, 8, 3, 7]), 49); + } + + #[test] + fn test_2() { + assert_eq!(max_area(vec![1, 1]), 1); + } +} diff --git a/0012-integer-to-roman/Cargo.lock b/0012-integer-to-roman/Cargo.lock new file mode 100644 index 0000000..8779c0d --- /dev/null +++ b/0012-integer-to-roman/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "leetcode" +version = "0.1.0" diff --git a/0012-integer-to-roman/Cargo.toml b/0012-integer-to-roman/Cargo.toml new file mode 100644 index 0000000..884c0d3 --- /dev/null +++ b/0012-integer-to-roman/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/0012-integer-to-roman/src/main.rs b/0012-integer-to-roman/src/main.rs new file mode 100644 index 0000000..f11fd60 --- /dev/null +++ b/0012-integer-to-roman/src/main.rs @@ -0,0 +1,54 @@ +static ROMAN_VALUES: [(i32, &str); 13] = [ + (1000, "M"), + (900, "CM"), + (500, "D"), + (400, "CD"), + (100, "C"), + (90, "XC"), + (50, "L"), + (40, "XL"), + (10, "X"), + (9, "IX"), + (5, "V"), + (4, "IV"), + (1, "I"), +]; + +pub fn int_to_roman(num: i32) -> String { + let mut num = num; + + let mut buf = String::new(); + + for (subtrahend, letters) in ROMAN_VALUES { + while let Some(n) = num.checked_sub(subtrahend) + && n >= 0 + { + num = n; + buf.push_str(letters); + } + } + + buf +} + +fn main() {} + +#[cfg(test)] +mod tests { + use crate::int_to_roman; + + #[test] + fn test_1() { + assert_eq!(int_to_roman(3749), "MMMDCCXLIX"); + } + + #[test] + fn test_2() { + assert_eq!(int_to_roman(58), "LVIII"); + } + + #[test] + fn test_3() { + assert_eq!(int_to_roman(1994), "MCMXCIV"); + } +} diff --git a/0013-roman-to-integer/Cargo.lock b/0013-roman-to-integer/Cargo.lock new file mode 100644 index 0000000..8779c0d --- /dev/null +++ b/0013-roman-to-integer/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "leetcode" +version = "0.1.0" diff --git a/0013-roman-to-integer/Cargo.toml b/0013-roman-to-integer/Cargo.toml new file mode 100644 index 0000000..884c0d3 --- /dev/null +++ b/0013-roman-to-integer/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/0013-roman-to-integer/src/main.rs b/0013-roman-to-integer/src/main.rs new file mode 100644 index 0000000..0edfa09 --- /dev/null +++ b/0013-roman-to-integer/src/main.rs @@ -0,0 +1,59 @@ +static ROMAN_VALUES: [(i32, &str); 13] = [ + (1, "I"), + (4, "IV"), + (5, "V"), + (9, "IX"), + (10, "X"), + (40, "XL"), + (50, "L"), + (90, "XC"), + (100, "C"), + (400, "CD"), + (500, "D"), + (900, "CM"), + (1000, "M"), +]; + +pub fn roman_to_int(s: String) -> i32 { + let mut s = s; + + let mut result = 0; + + for (num, letters) in ROMAN_VALUES { + loop { + let left = s.len().saturating_sub(letters.len()); + let part = &s[left..]; + + if part == letters { + result += num; + s.truncate(left); + } else { + break; + } + } + } + + result +} + +fn main() {} + +#[cfg(test)] +mod tests { + use crate::roman_to_int; + + #[test] + fn test_1() { + assert_eq!(roman_to_int("MMMDCCXLIX".to_string()), 3749); + } + + #[test] + fn test_2() { + assert_eq!(roman_to_int("LVIII".to_string()), 58); + } + + #[test] + fn test_3() { + assert_eq!(roman_to_int("MCMXCIV".to_string()), 1994); + } +} diff --git a/0015-3sum/Cargo.lock b/0015-3sum/Cargo.lock new file mode 100644 index 0000000..8779c0d --- /dev/null +++ b/0015-3sum/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "leetcode" +version = "0.1.0" diff --git a/0015-3sum/Cargo.toml b/0015-3sum/Cargo.toml new file mode 100644 index 0000000..884c0d3 --- /dev/null +++ b/0015-3sum/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/0015-3sum/src/main.rs b/0015-3sum/src/main.rs new file mode 100644 index 0000000..0f41e51 --- /dev/null +++ b/0015-3sum/src/main.rs @@ -0,0 +1,88 @@ +fn main() { + println!("Hello, world!"); +} + +pub fn three_sum(nums: Vec) -> Vec> { + let mut result = vec![]; + + if nums.len() < 3 { + return result; + } + + let mut nums: Vec<_> = nums; + nums.sort_unstable(); + + for idx in 0..nums.len() - 1 { + let first = nums[idx]; + + if first > 0 { + // no more negative numbers left, so we are done + break; + } + + if idx > 0 && first == nums[idx - 1] { + // we already scanned for this number + continue; + } + let mut left = idx + 1; + let mut right = nums.len() - 1; + + while left < right { + let sum = first + nums[left] + nums[right]; + if sum == 0 { + let entry = vec![first, nums[left], nums[right]]; + result.push(entry); + + // skip identical numbers that would lead to the same combinations + while nums[left + 1] == nums[left] && left < nums.len() - 2 { + left += 1; + } + + while nums[right - 1] == nums[right] && right > 1 { + right -= 1; + } + } + if sum <= 0 { + left += 1; + } else { + right -= 1; + } + } + } + + result +} + +#[cfg(test)] +mod tests { + use crate::three_sum; + + #[test] + fn test_1() { + let sums = three_sum(vec![-1, 0, 1, 2, -1, -4]); + + assert_eq!(sums.len(), 2); + assert!(sums.contains(&vec![-1, -1, 2])); + assert!(sums.contains(&vec![-1, 0, 1])); + } + + #[test] + fn test_2() { + let sums = three_sum(vec![0, 1, 1]); + assert_eq!(sums, Vec::>::new()); + } + + #[test] + fn test_3() { + let sums = three_sum(vec![0, 0, 0]); + assert_eq!(sums, vec![vec![0, 0, 0]]); + } + + #[test] + fn test_4() { + let sums = three_sum(vec![ + 2, -3, 0, -2, -5, -5, -4, 1, 2, -2, 2, 0, 2, -4, 5, 5, -10, + ]); + assert_eq!(sums.len(), 6); + } +} diff --git a/0017-letter-combinations-of-a-phone-number/Cargo.lock b/0017-letter-combinations-of-a-phone-number/Cargo.lock new file mode 100644 index 0000000..8779c0d --- /dev/null +++ b/0017-letter-combinations-of-a-phone-number/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "leetcode" +version = "0.1.0" diff --git a/0017-letter-combinations-of-a-phone-number/Cargo.toml b/0017-letter-combinations-of-a-phone-number/Cargo.toml new file mode 100644 index 0000000..884c0d3 --- /dev/null +++ b/0017-letter-combinations-of-a-phone-number/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/0017-letter-combinations-of-a-phone-number/src/main.rs b/0017-letter-combinations-of-a-phone-number/src/main.rs new file mode 100644 index 0000000..df129c9 --- /dev/null +++ b/0017-letter-combinations-of-a-phone-number/src/main.rs @@ -0,0 +1,66 @@ +pub fn letter_combinations(digits: String) -> Vec { + let mut current = Vec::new(); + current.push("".to_string()); + + let mut next = Vec::new(); + + for digit in digits.chars() { + for entry in current.drain(..) { + for letter in to_letter(digit) { + let mut this_entry = entry.clone(); + this_entry.push(letter); + next.push(this_entry); + } + } + std::mem::swap(&mut current, &mut next); + next.clear(); + } + + current +} + +fn to_letter(digit: char) -> impl Iterator { + let letters: &'static [char] = match digit { + '2' => &['a', 'b', 'c'], + '3' => &['d', 'e', 'f'], + '4' => &['g', 'h', 'i'], + '5' => &['j', 'k', 'l'], + '6' => &['m', 'n', 'o'], + '7' => &['p', 'q', 'r', 's'], + '8' => &['t', 'u', 'v'], + '9' => &['w', 'x', 'y', 'z'], + _ => panic!(), + }; + letters.iter().copied() +} + +fn main() { + println!("Hello, world!"); +} + +#[cfg(test)] +mod tests { + use std::collections::HashSet; + + use crate::letter_combinations; + + #[test] + fn test_1() { + let letters = letter_combinations("23".to_string()) + .into_iter() + .collect::>(); + for example in ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"] { + assert!(letters.contains(example)); + } + } + + #[test] + fn test_2() { + let letters = letter_combinations("2".to_string()) + .into_iter() + .collect::>(); + for example in ["a", "b", "c"] { + assert!(letters.contains(example)); + } + } +} diff --git a/0019-remove-nth-node-from-end-of-list/Cargo.lock b/0019-remove-nth-node-from-end-of-list/Cargo.lock new file mode 100644 index 0000000..8779c0d --- /dev/null +++ b/0019-remove-nth-node-from-end-of-list/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "leetcode" +version = "0.1.0" diff --git a/0019-remove-nth-node-from-end-of-list/Cargo.toml b/0019-remove-nth-node-from-end-of-list/Cargo.toml new file mode 100644 index 0000000..884c0d3 --- /dev/null +++ b/0019-remove-nth-node-from-end-of-list/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/0019-remove-nth-node-from-end-of-list/src/main.rs b/0019-remove-nth-node-from-end-of-list/src/main.rs new file mode 100644 index 0000000..dfd6375 --- /dev/null +++ b/0019-remove-nth-node-from-end-of-list/src/main.rs @@ -0,0 +1,45 @@ +fn main() { + println!("Hello, world!"); +} + +// created with guidance from claude + +pub fn remove_nth_from_end(head: Option>, n: i32) -> Option> { + let mut dummy = ListNode::new(0); + dummy.next = head; + + let mut current = &dummy.next; + + let mut length = 0; + + while let Some(node) = current { + length += 1; + current = &node.next; + } + + let predecessor = length - n; + + let mut current = &mut dummy.next; + for _ in 0..predecessor { + current = &mut current.as_mut().unwrap().next; + } + + *current = current.take().unwrap().next; + + dummy.next +} + +//////////////////////////////// + +#[derive(PartialEq, Eq, Clone, Debug)] +pub struct ListNode { + pub val: i32, + pub next: Option>, +} + +impl ListNode { + #[inline] + pub fn new(val: i32) -> Self { + ListNode { next: None, val } + } +} diff --git a/0020-valid-parentheses/Cargo.lock b/0020-valid-parentheses/Cargo.lock new file mode 100644 index 0000000..8779c0d --- /dev/null +++ b/0020-valid-parentheses/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "leetcode" +version = "0.1.0" diff --git a/0020-valid-parentheses/Cargo.toml b/0020-valid-parentheses/Cargo.toml new file mode 100644 index 0000000..884c0d3 --- /dev/null +++ b/0020-valid-parentheses/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "leetcode" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/0020-valid-parentheses/src/main.rs b/0020-valid-parentheses/src/main.rs new file mode 100644 index 0000000..c88116b --- /dev/null +++ b/0020-valid-parentheses/src/main.rs @@ -0,0 +1,64 @@ +fn main() { + println!("Hello, world!"); +} + +pub fn is_valid(s: String) -> bool { + helper(s).unwrap_or(false) +} + +fn helper(s: String) -> Option { + let mut stack = vec![]; + + for c in s.chars() { + if ['(', '[', '{'].contains(&c) { + stack.push(c); + } + if [')', ']', '}'].contains(&c) { + if matches(c, *stack.last()?) { + stack.pop(); + } else { + return Some(false); + } + } + } + Some(stack.is_empty()) +} + +fn matches(current: char, previous: char) -> bool { + match current { + ')' => previous == '(', + ']' => previous == '[', + '}' => previous == '{', + _ => unreachable!(), + } +} + +#[cfg(test)] +mod tests { + use crate::is_valid; + + #[test] + fn test_1() { + assert!(is_valid("()".to_string())) + } + + #[test] + fn test_2() { + assert!(is_valid("()[]{}".to_string())) + } + + #[test] + fn test_3() { + assert!(!is_valid("(]".to_string())) + } + + #[test] + fn test_4() { + assert!(is_valid("([])".to_string())) + } + + #[test] + fn test_5() { + assert!(!is_valid("([)]".to_string())) + } +} diff --git a/add-two-numbers/Cargo.lock b/add-two-numbers/Cargo.lock new file mode 100644 index 0000000..0363b43 --- /dev/null +++ b/add-two-numbers/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "add-two-numbers" +version = "0.1.0" diff --git a/add-two-numbers/Cargo.toml b/add-two-numbers/Cargo.toml new file mode 100644 index 0000000..a23d8ae --- /dev/null +++ b/add-two-numbers/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "add-two-numbers" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/add-two-numbers/src/main.rs b/add-two-numbers/src/main.rs new file mode 100644 index 0000000..4029ba4 --- /dev/null +++ b/add-two-numbers/src/main.rs @@ -0,0 +1,77 @@ +fn main() { + let l1 = to_nodes(942); + let l2 = to_nodes(9465); + let result = *add_two_numbers(l1, l2).unwrap(); + dbg!(result); +} + +fn add_two_numbers(l1: Option>, l2: Option>) -> Option> { + let mut l1 = l1; + let mut l2 = l2; + + let mut carry = false; + let mut head = None; + let mut tail = &mut head; + + while l1.is_some() || l2.is_some() || carry { + let a = l1.as_ref().map_or(0, |n| n.val); + let b = l2.as_ref().map_or(0, |n| n.val); + + let addition = a + b + carry as i32; + + let node = Box::new(ListNode::new(addition % 10)); + carry = addition >= 10; + + *tail = Some(node); + tail = &mut tail.as_mut().unwrap().next; + + l1 = l1.and_then(|n| n.next); + l2 = l2.and_then(|n| n.next); + } + + head +} + +///////////////////////////// + +// Definition for singly-linked list. +#[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 } + } +} + +//////////////////////////////// + +fn to_nodes(number: i32) -> Option> { + let digits = number + .to_string() + .chars() + .map(|c| c.to_string().parse().unwrap()) + .rev() + .collect::>(); + + let mut node = ListNode::new(digits[0]); + + for item in digits.iter().skip(1) { + push(&mut node, *item); + } + + Some(Box::new(node)) +} + +fn push(node: &mut ListNode, digit: i32) { + if node.next.is_some() { + push(node.next.as_mut().unwrap(), digit); + } else { + let new = ListNode::new(digit); + node.next = Some(Box::new(new)); + } +} diff --git a/find-the-index-of-the-first-occurrence-in-a-string/Cargo.lock b/find-the-index-of-the-first-occurrence-in-a-string/Cargo.lock new file mode 100644 index 0000000..a1b9474 --- /dev/null +++ b/find-the-index-of-the-first-occurrence-in-a-string/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "find-the-index-of-the-first-occurrence-in-a-string" +version = "0.1.0" 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..0236b44 --- /dev/null +++ b/find-the-index-of-the-first-occurrence-in-a-string/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "find-the-index-of-the-first-occurrence-in-a-string" +version = "0.1.0" +edition = "2024" + +[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..09d3688 --- /dev/null +++ b/find-the-index-of-the-first-occurrence-in-a-string/src/main.rs @@ -0,0 +1,20 @@ +fn main() { + println!("{}", str_str("leetcode".to_string(), "leeto".to_string())); +} + +fn str_str(haystack: String, needle: String) -> i32 { + if needle.len() > haystack.len() { + return -1; + } + + let length = needle.len(); + + for i in 0..haystack.len() - length + 1 { + let substring = &haystack[i..i + length]; + if substring == needle { + return i as _; + } + } + + -1 +} diff --git a/length-of-last-word/Cargo.lock b/length-of-last-word/Cargo.lock new file mode 100644 index 0000000..460fd3c --- /dev/null +++ b/length-of-last-word/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "length-of-last-word" +version = "0.1.0" diff --git a/length-of-last-word/Cargo.toml b/length-of-last-word/Cargo.toml new file mode 100644 index 0000000..df32b4a --- /dev/null +++ b/length-of-last-word/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "length-of-last-word" +version = "0.1.0" +edition = "2024" + +[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..5fec598 --- /dev/null +++ b/length-of-last-word/src/main.rs @@ -0,0 +1,7 @@ +fn main() { + dbg!(length_of_last_word("Hello World".to_string())); +} + +fn length_of_last_word(s: String) -> i32 { + s.split_whitespace().last().unwrap().len() as _ +} diff --git a/longest-common-prefix/Cargo.lock b/longest-common-prefix/Cargo.lock new file mode 100644 index 0000000..302e793 --- /dev/null +++ b/longest-common-prefix/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "longest-common-prefix" +version = "0.1.0" diff --git a/longest-common-prefix/Cargo.toml b/longest-common-prefix/Cargo.toml new file mode 100644 index 0000000..1c5b66b --- /dev/null +++ b/longest-common-prefix/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "longest-common-prefix" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/longest-common-prefix/src/main.rs b/longest-common-prefix/src/main.rs new file mode 100644 index 0000000..e7e520e --- /dev/null +++ b/longest-common-prefix/src/main.rs @@ -0,0 +1,28 @@ +fn main() { + println!("Hello, world!"); +} + +fn longest_common_prefix(strs: Vec) -> String { + let mut strs = strs; + + strs.sort_by_key(|x| x.len()); + + let chars = strs + .into_iter() + .map(|s| s.chars().collect::>()) + .collect::>(); + + let first_word_chars = chars.first().unwrap(); + + let mut result = String::new(); + + for (i, c) in first_word_chars.iter().enumerate() { + if chars.iter().all(|vc| vc[i] == *c) { + result.push(*c); + } else { + return result; + } + } + + result +} diff --git a/longest-substring-without-repeating-characters/Cargo.lock b/longest-substring-without-repeating-characters/Cargo.lock new file mode 100644 index 0000000..6928fcb --- /dev/null +++ b/longest-substring-without-repeating-characters/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "longest-substring-without-repeating-characters" +version = "0.1.0" diff --git a/longest-substring-without-repeating-characters/Cargo.toml b/longest-substring-without-repeating-characters/Cargo.toml new file mode 100644 index 0000000..a08bc51 --- /dev/null +++ b/longest-substring-without-repeating-characters/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "longest-substring-without-repeating-characters" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/longest-substring-without-repeating-characters/src/main.rs b/longest-substring-without-repeating-characters/src/main.rs new file mode 100644 index 0000000..f2ddeec --- /dev/null +++ b/longest-substring-without-repeating-characters/src/main.rs @@ -0,0 +1,58 @@ +fn main() {} + +fn length_of_longest_substring(s: String) -> i32 { + if s.is_empty() { + return 0; + } + + let mut char_idx_map = [-1_i64; 128]; + + let mut left: usize = 0; + let mut right: usize = 1; + + let mut best = 0; + + let bytes = s.as_bytes(); + + while right <= s.len() { + let last_char = bytes[right - 1]; + + let last_seen = char_idx_map[last_char as usize]; + + if last_seen >= left as i64 { + left = (last_seen + 1) as usize; + right = right.max(left + 1); + } else { + best = best.max(right - left); + char_idx_map[last_char as usize] = right as i64 - 1; + right += 1; + } + } + best as _ +} + +#[cfg(test)] +mod tests { + use super::length_of_longest_substring; + + #[test] + fn test1() { + assert_eq!(length_of_longest_substring("abcabcbb".to_string()), 3); + } + #[test] + fn test2() { + assert_eq!(length_of_longest_substring("bbbbb".to_string()), 1); + } + #[test] + fn test3() { + assert_eq!(length_of_longest_substring("pwwkew".to_string()), 3); + } + #[test] + fn test4() { + assert_eq!(length_of_longest_substring("".to_string()), 0); + } + #[test] + fn test5() { + assert_eq!(length_of_longest_substring("S".to_string()), 1); + } +} diff --git a/palindrome-number/Cargo.lock b/palindrome-number/Cargo.lock new file mode 100644 index 0000000..14d9e9a --- /dev/null +++ b/palindrome-number/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "palindrome-number" +version = "0.1.0" diff --git a/palindrome-number/Cargo.toml b/palindrome-number/Cargo.toml new file mode 100644 index 0000000..ccb6453 --- /dev/null +++ b/palindrome-number/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "palindrome-number" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/palindrome-number/src/main.rs b/palindrome-number/src/main.rs new file mode 100644 index 0000000..6da312a --- /dev/null +++ b/palindrome-number/src/main.rs @@ -0,0 +1,20 @@ +fn main() { + println!("Hello, world!"); +} + +fn is_palindrome(x: i32) -> bool { + if x < 0 { + return false; + } + + let mut original = x; + let mut reversed = 0; + + while original > 0 { + let digit = original % 10; + reversed = reversed * 10 + digit; + original /= 10; + } + + x == reversed +} diff --git a/remove-duplicates-from-sorted-array/Cargo.lock b/remove-duplicates-from-sorted-array/Cargo.lock new file mode 100644 index 0000000..f71410a --- /dev/null +++ b/remove-duplicates-from-sorted-array/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "remove-duplicates-from-sorted-array" +version = "0.1.0" diff --git a/remove-duplicates-from-sorted-array/Cargo.toml b/remove-duplicates-from-sorted-array/Cargo.toml new file mode 100644 index 0000000..f88be88 --- /dev/null +++ b/remove-duplicates-from-sorted-array/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "remove-duplicates-from-sorted-array" +version = "0.1.0" +edition = "2024" + +[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..b3decc8 --- /dev/null +++ b/remove-duplicates-from-sorted-array/src/main.rs @@ -0,0 +1,32 @@ +fn main() { + let mut v = vec![1, 1, 2]; + dbg!(remove_duplicates(&mut v)); + dbg!(v); + + let mut v = vec![0, 0, 1, 1, 1, 2, 2, 3, 3, 4]; + dbg!(remove_duplicates(&mut v)); + dbg!(v); +} + +fn remove_duplicates(nums: &mut Vec) -> i32 { + let mut result = 1; + + let mut unique_nums = vec![nums.first().cloned().unwrap()]; + let mut previous = *unique_nums.first().unwrap(); + + for item in &mut *nums { + if *item != previous { + result += 1; + unique_nums.push(*item); + previous = *item; + } + } + + // write back + nums.clear(); + for item in unique_nums { + nums.push(item); + } + + result +} diff --git a/remove-element/Cargo.lock b/remove-element/Cargo.lock new file mode 100644 index 0000000..ded1aed --- /dev/null +++ b/remove-element/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "remove-element" +version = "0.1.0" diff --git a/remove-element/Cargo.toml b/remove-element/Cargo.toml new file mode 100644 index 0000000..ba3500e --- /dev/null +++ b/remove-element/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "remove-element" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/remove-element/src/main.rs b/remove-element/src/main.rs new file mode 100644 index 0000000..c89cb26 --- /dev/null +++ b/remove-element/src/main.rs @@ -0,0 +1,29 @@ +fn main() { + let mut v = vec![3, 2, 2, 3]; + dbg!(remove_element(&mut v, 3)); + dbg!(v); + + let mut v = vec![0, 1, 2, 2, 3, 0, 4, 2]; + dbg!(remove_element(&mut v, 2)); + dbg!(v); +} + +fn remove_element(nums: &mut Vec, val: i32) -> i32 { + let mut result = 0; + + let mut removed = vec![]; + + for item in nums.iter() { + if *item != val { + removed.push(*item); + result += 1; + } + } + + nums.clear(); + for item in removed { + nums.push(item) + } + + result +} diff --git a/search-insert-position/Cargo.lock b/search-insert-position/Cargo.lock new file mode 100644 index 0000000..5ea68cc --- /dev/null +++ b/search-insert-position/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "search-insert-position" +version = "0.1.0" diff --git a/search-insert-position/Cargo.toml b/search-insert-position/Cargo.toml new file mode 100644 index 0000000..d34d4c4 --- /dev/null +++ b/search-insert-position/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "search-insert-position" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/search-insert-position/src/main.rs b/search-insert-position/src/main.rs new file mode 100644 index 0000000..77d3c35 --- /dev/null +++ b/search-insert-position/src/main.rs @@ -0,0 +1,19 @@ +fn main() { + let vec = vec![1, 3, 5, 6]; + dbg!(search_insert(vec, 5)); + + let vec = vec![1, 3, 5, 6]; + dbg!(search_insert(vec, 2)); + + let vec = vec![1, 3, 5, 6]; + dbg!(search_insert(vec, 7)); +} + +fn search_insert(nums: Vec, target: i32) -> i32 { + for (i, item) in nums.iter().enumerate() { + if *item >= target { + return i as _; + } + } + nums.len() as _ +} diff --git a/two-sum/Cargo.lock b/two-sum/Cargo.lock new file mode 100644 index 0000000..46e62fb --- /dev/null +++ b/two-sum/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "two-sum" +version = "0.1.0" diff --git a/two-sum/Cargo.toml b/two-sum/Cargo.toml new file mode 100644 index 0000000..3bd5327 --- /dev/null +++ b/two-sum/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "two-sum" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/two-sum/src/main.rs b/two-sum/src/main.rs new file mode 100644 index 0000000..0a8e99c --- /dev/null +++ b/two-sum/src/main.rs @@ -0,0 +1,45 @@ +struct Solution; + +use std::collections::HashMap; + +impl Solution { + pub fn two_sum_o_n(nums: Vec, target: i32) -> Vec { + // value -> idx map + let mut map: HashMap = HashMap::with_capacity(nums.len()); + + for (idx, num) in nums.iter().enumerate() { + let diff = target - *num; + if let Some(idx2) = map.get(&diff) { + return vec![idx as _, *idx2 as _]; + } + map.insert(*num, idx); + } + + unreachable!("we are guaranteed an answer exists") + } + + pub fn two_sum_o_n_log_n(nums: Vec, target: i32) -> Vec { + let mut indexed_nums: Vec<_> = nums.into_iter().enumerate().collect(); + indexed_nums.sort_unstable_by_key(|(_, val)| *val); + + let mut left = 0; + let mut right = indexed_nums.len() - 1; + + while left < right { + let sum = indexed_nums[left].1 + indexed_nums[right].1; + if sum == target { + return vec![indexed_nums[left].0 as _, indexed_nums[right].0 as _]; + } else if sum > target { + right -= 1; + } else { + left += 1; + } + } + + unreachable!("we are guaranteed a solution exists") + } +} + +fn main() { + println!("Hello, world!"); +} diff --git a/valid-parentheses/Cargo.lock b/valid-parentheses/Cargo.lock new file mode 100644 index 0000000..51c4e98 --- /dev/null +++ b/valid-parentheses/Cargo.lock @@ -0,0 +1,7 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "valid-parentheses" +version = "0.1.0" diff --git a/valid-parentheses/Cargo.toml b/valid-parentheses/Cargo.toml new file mode 100644 index 0000000..35f3bdc --- /dev/null +++ b/valid-parentheses/Cargo.toml @@ -0,0 +1,6 @@ +[package] +name = "valid-parentheses" +version = "0.1.0" +edition = "2024" + +[dependencies] diff --git a/valid-parentheses/src/main.rs b/valid-parentheses/src/main.rs new file mode 100644 index 0000000..f29d0c6 --- /dev/null +++ b/valid-parentheses/src/main.rs @@ -0,0 +1,41 @@ +fn main() { + dbg!(is_valid("()".to_string())); + dbg!(is_valid("()[]{}".to_string())); + dbg!(is_valid("(]".to_string())); + dbg!(is_valid("([])".to_string())); + dbg!(is_valid("([)])".to_string())); +} + +fn is_valid(s: String) -> bool { + let mut stack = vec![]; + for c in s.chars() { + if OPEN.contains(&c) { + stack.push(c); + } else { + let last = stack.last(); + if last.is_none() { + return false; + } + if matches(*last.unwrap(), c) { + stack.pop(); + } else { + return false; + } + } + } + if !stack.is_empty() { + return false; + } + true +} + +fn matches(c1: char, c2: char) -> bool { + (c1 == '(' && c2 == ')') + || (c1 == ')' && c2 == '(') + || (c1 == '[' && c2 == ']') + || (c1 == ']' && c2 == '(') + || (c1 == '{' && c2 == '}') + || (c1 == '}' && c2 == '{') +} + +const OPEN: [char; 3] = ['(', '[', '{'];