Merge branch 'master' of https://github.com/TheAlgorithms/Rust into email-address

Author: lyqio

src/dynamic_programming/maximum_subarray.rs

@@ -1,62 +1,82 @@
-/// ## maximum subarray via Dynamic Programming
+//! This module provides a function to find the the largest sum of the subarray
+//! in a given array of integers using dynamic programming. It also includes
+//! tests to verify the correctness of the implementation.
 
-/// maximum_subarray(array) find the subarray (containing at least one number) which has the largest sum
-/// and return its sum.
+/// Custom error type for maximum subarray
+#[derive(Debug, PartialEq)]
+pub enum MaximumSubarrayError {
+    EmptyArray,
+}
+
+/// Finds the subarray (containing at least one number) which has the largest sum
+/// and returns its sum.
 ///
 /// A subarray is a contiguous part of an array.
 ///
-/// Arguments:
-///     * `array` - an integer array
-/// Complexity
-///     - time complexity: O(array.length),
-///     - space complexity: O(array.length),
-pub fn maximum_subarray(array: &[i32]) -> i32 {
-    let mut dp = vec![0; array.len()];
-    dp[0] = array[0];
-    let mut result = dp[0];
-
-    for i in 1..array.len() {
-        if dp[i - 1] > 0 {
-            dp[i] = dp[i - 1] + array[i];
-        } else {
-            dp[i] = array[i];
-        }
-        result = result.max(dp[i]);
+/// # Arguments
+///
+/// * `array` - A slice of integers.
+///
+/// # Returns
+///
+/// A `Result` which is:
+/// * `Ok(isize)` representing the largest sum of a contiguous subarray.
+/// * `Err(MaximumSubarrayError)` if the array is empty.
+///
+/// # Complexity
+///
+/// * Time complexity: `O(array.len())`
+/// * Space complexity: `O(1)`
+pub fn maximum_subarray(array: &[isize]) -> Result<isize, MaximumSubarrayError> {
+    if array.is_empty() {
+        return Err(MaximumSubarrayError::EmptyArray);
     }
 
-    result
+    let mut cur_sum = array[0];
+    let mut max_sum = cur_sum;
+
+    for &x in &array[1..] {
+        cur_sum = (cur_sum + x).max(x);
+        max_sum = max_sum.max(cur_sum);
+    }
+
+    Ok(max_sum)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn non_negative() {
-        //the maximum value: 1 + 0 + 5 + 8 = 14
-        let array = vec![1, 0, 5, 8];
-        assert_eq!(maximum_subarray(&array), 14);
-    }
-
-    #[test]
-    fn negative() {
-        //the maximum value: -1
-        let array = vec![-3, -1, -8, -2];
-        assert_eq!(maximum_subarray(&array), -1);
-    }
-
-    #[test]
-    fn normal() {
-        //the maximum value: 3 + (-2) + 5 = 6
-        let array = vec![-4, 3, -2, 5, -8];
-        assert_eq!(maximum_subarray(&array), 6);
+    macro_rules! maximum_subarray_tests {
+        ($($name:ident: $tc:expr,)*) => {
+            $(
+                #[test]
+                fn $name() {
+                    let (array, expected) = $tc;
+                    assert_eq!(maximum_subarray(&array), expected);
+                }
+            )*
+        }
     }
 
-    #[test]
-    fn single_element() {
-        let array = vec![6];
-        assert_eq!(maximum_subarray(&array), 6);
-        let array = vec![-6];
-        assert_eq!(maximum_subarray(&array), -6);
+    maximum_subarray_tests! {
+        test_all_non_negative: (vec![1, 0, 5, 8], Ok(14)),
+        test_all_negative: (vec![-3, -1, -8, -2], Ok(-1)),
+        test_mixed_negative_and_positive: (vec![-4, 3, -2, 5, -8], Ok(6)),
+        test_single_element_positive: (vec![6], Ok(6)),
+        test_single_element_negative: (vec![-6], Ok(-6)),
+        test_mixed_elements: (vec![-2, 1, -3, 4, -1, 2, 1, -5, 4], Ok(6)),
+        test_empty_array: (vec![], Err(MaximumSubarrayError::EmptyArray)),
+        test_all_zeroes: (vec![0, 0, 0, 0], Ok(0)),
+        test_single_zero: (vec![0], Ok(0)),
+        test_alternating_signs: (vec![3, -2, 5, -1], Ok(6)),
+        test_all_negatives_with_one_positive: (vec![-3, -4, 1, -7, -2], Ok(1)),
+        test_all_positives_with_one_negative: (vec![3, 4, -1, 7, 2], Ok(15)),
+        test_all_positives: (vec![2, 3, 1, 5], Ok(11)),
+        test_large_values: (vec![1000, -500, 1000, -500, 1000], Ok(2000)),
+        test_large_array: ((0..1000).collect::<Vec<_>>(), Ok(499500)),
+        test_large_negative_array: ((0..1000).map(|x| -x).collect::<Vec<_>>(), Ok(0)),
+        test_single_large_positive: (vec![1000000], Ok(1000000)),
+        test_single_large_negative: (vec![-1000000], Ok(-1000000)),
     }
 }

src/string/hamming_distance.rs

@@ -1,13 +1,24 @@
-pub fn hamming_distance(string_a: &str, string_b: &str) -> usize {
+/// Error type for Hamming distance calculation.
+#[derive(Debug, PartialEq)]
+pub enum HammingDistanceError {
+    InputStringsHaveDifferentLength,
+}
+
+/// Calculates the Hamming distance between two strings.
+///
+/// The Hamming distance is defined as the number of positions at which the corresponding characters of the two strings are different.
+pub fn hamming_distance(string_a: &str, string_b: &str) -> Result<usize, HammingDistanceError> {
     if string_a.len() != string_b.len() {
-        panic!("Strings must have the same length");
+        return Err(HammingDistanceError::InputStringsHaveDifferentLength);
     }
 
-    string_a
+    let distance = string_a
         .chars()
         .zip(string_b.chars())
         .filter(|(a, b)| a != b)
-        .count()
+        .count();
+
+    Ok(distance)
 }
 
 #[cfg(test)]
@@ -16,30 +27,31 @@ mod tests {
 
     macro_rules! test_hamming_distance {
         ($($name:ident: $tc:expr,)*) => {
-        $(
-            #[test]
-            fn $name() {
-                let (str_a, str_b, expected) = $tc;
-                assert_eq!(hamming_distance(str_a, str_b), expected);
-                assert_eq!(hamming_distance(str_b, str_a), expected);
-            }
-        )*
+            $(
+                #[test]
+                fn $name() {
+                    let (str_a, str_b, expected) = $tc;
+                    assert_eq!(hamming_distance(str_a, str_b), expected);
+                    assert_eq!(hamming_distance(str_b, str_a), expected);
+                }
+            )*
         }
     }
 
     test_hamming_distance! {
-        empty_inputs: ("", "", 0),
-        length_1_inputs: ("a", "a", 0),
-        same_strings: ("rust", "rust", 0),
-        regular_input_0: ("karolin", "kathrin", 3),
-        regular_input_1: ("kathrin", "kerstin", 4),
-        regular_input_2: ("00000", "11111", 5),
-        different_case: ("x", "X", 1),
-    }
-
-    #[test]
-    #[should_panic]
-    fn panic_when_inputs_are_of_different_length() {
-        hamming_distance("0", "");
+        empty_inputs: ("", "", Ok(0)),
+        different_length: ("0", "", Err(HammingDistanceError::InputStringsHaveDifferentLength)),
+        length_1_inputs_identical: ("a", "a", Ok(0)),
+        length_1_inputs_different: ("a", "b", Ok(1)),
+        same_strings: ("rust", "rust", Ok(0)),
+        regular_input_0: ("karolin", "kathrin", Ok(3)),
+        regular_input_1: ("kathrin", "kerstin", Ok(4)),
+        regular_input_2: ("00000", "11111", Ok(5)),
+        different_case: ("x", "X", Ok(1)),
+        strings_with_no_common_chars: ("abcd", "wxyz", Ok(4)),
+        long_strings_one_diff: (&"a".repeat(1000), &("a".repeat(999) + "b"), Ok(1)),
+        long_strings_many_diffs: (&("a".repeat(500) + &"b".repeat(500)), &("b".repeat(500) + &"a".repeat(500)), Ok(1000)),
+        strings_with_special_chars_identical: ("!@#$%^", "!@#$%^", Ok(0)),
+        strings_with_special_chars_diff: ("!@#$%^", "&*()_+", Ok(6)),
     }
 }