20. 有效的括号
pub struct Solution {}
impl Solution {
pub fn is_valid(s: String) -> bool {
let len = s.len();
let mut stack: Vec<char> = Vec::new();
for ch in s.chars().into_iter() {
match stack.last() {
None => {}
Some(&last) => {
if Solution::pair(last, ch) {
stack.pop();
continue;
}
}
}
stack.push(ch);
}
stack.is_empty()
}
#[inline(always)]
fn pair(open: char, close: char) -> bool {
(open == '{' && close == '}')
|| (open == '(' && close == ')')
|| (open == '[' && close == ']')
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_20() {
assert_eq!(Solution::is_valid("()".to_string()), true);
assert_eq!(Solution::is_valid("()[]{}".to_string()), true);
assert_eq!(Solution::is_valid("(]".to_string()), false);
assert_eq!(Solution::is_valid("([)]".to_string()), false);
assert_eq!(Solution::is_valid("{[]}".to_string()), true);
}
}
26. 删除排序数组中的重复项
pub struct Solution {}
impl Solution {
pub fn remove_duplicates(nums: &mut Vec<i32>) -> i32 {
let len = nums.len();
if len <= 1 {
return len as i32;
}
let mut slow = 0usize;
for fast in 1..len {
if nums[slow] != nums[fast] {
slow += 1;
nums[slow] = nums[fast];
}
}
(slow + 1) as i32
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_26() {
let mut vec1 = vec![1, 1, 2];
assert_eq!(Solution::remove_duplicates(&mut vec1), 2);
vec1 = vec![0, 0, 1, 1, 1, 2, 2, 3, 3, 4];
assert_eq!(Solution::remove_duplicates(&mut vec1), 5);
}
}
27. 移除元素
pub struct Solution {}
impl Solution {
pub fn remove_element(nums: &mut Vec<i32>, val: i32) -> i32 {
if nums.len() < 1 {
return 0;
}
let (mut start, mut end) = (0_usize, nums.len());
while start < end {
if nums[start] == val {
nums[start] = nums[end - 1];
end -= 1;
} else {
start += 1;
}
}
end as i32
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_27() {
let mut vec1 = vec![3, 2, 2, 3];
assert_eq!(Solution::remove_element(&mut vec1, 3), 2);
vec1 = vec![0, 1, 2, 2, 3, 0, 4, 2];
assert_eq!(Solution::remove_element(&mut vec1, 2), 5);
}
}
28. 实现 strStr()
pub struct Solution {}
impl Solution {
pub fn str_str(haystack: String, needle: String) -> i32 {
if haystack == needle {
return 0;
}
if haystack.len() < needle.len() {
return -1;
}
for i in 0..=(haystack.len() - needle.len()) {
if haystack[i..(i + needle.len())] == needle {
return i as i32;
}
}
return -1;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_28() {
assert_eq!(Solution::str_str("hello".to_string(), "ll".to_string()), 2);
assert_eq!(
Solution::str_str("aaaaa".to_string(), "bba".to_string()),
-1
);
}
}
35. 搜索插入位置
pub struct Solution {}
impl Solution {
pub fn search_insert(nums: Vec<i32>, target: i32) -> i32 {
if nums.is_empty() {
return 0;
}
for (i, &num) in nums.iter().enumerate() {
if num >= target {
return i as i32;
}
}
return nums.len() as i32;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_35() {
assert_eq!(Solution::search_insert(vec![1, 3, 5, 6], 5), 2);
assert_eq!(Solution::search_insert(vec![1, 3, 5, 6], 2), 1);
assert_eq!(Solution::search_insert(vec![1, 3, 5, 6], 7), 4);
assert_eq!(Solution::search_insert(vec![1, 3, 5, 6], 0), 0);
}
}
53. 最大子序和
pub struct Solution {}
impl Solution {
pub fn max_sub_array(nums: Vec<i32>) -> i32 {
let mut result = i32::min_value();
let mut sum = 0;
for num in nums {
if sum > 0 {
sum += num;
} else {
sum = num;
}
result = i32::max(result, sum);
}
result
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_53() {
assert_eq!(
Solution::max_sub_array(vec![-2, 1, -3, 4, -1, 2, 1, -5, 4]),
6
);
assert_eq!(Solution::max_sub_array(vec![-8]), -8);
assert_eq!(Solution::max_sub_array(vec![-8, -2, 2, 1, -1, 2]), 4);
}
}