[pull] master from TheAlgorithms:master

DIRECTORY.md

@@ -1,6 +1,6 @@
 # List of all files
 
-## Src
+## src
   * Backtracking
     * [All Combinations of Size K](https://github.com/TheAlgorithms/Rust/blob/master/src/backtracking/all_combination_of_size_k.rs)
     * [Graph Coloring](https://github.com/TheAlgorithms/Rust/blob/master/src/backtracking/graph_coloring.rs)
@@ -21,13 +21,16 @@
     * [Counting Bits](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/counting_bits.rs)
     * [Highest Set Bit](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/highest_set_bit.rs)
     * [Is Power of Two](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/is_power_of_two.rs)
+    * [Missing Number](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/find_missing_number.rs)
     * [N Bits Gray Code](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/n_bits_gray_code.rs)
     * [Previous Power of Two](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/find_previous_power_of_two.rs)
     * [Reverse Bits](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/reverse_bits.rs)
+    * [Rightmost Set Bit](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/rightmost_set_bit.rs)
     * [Sum of Two Integers](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/sum_of_two_integers.rs)
     * [Swap Odd and Even Bits](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/swap_odd_even_bits.rs)
     * [Trailing Zeros](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/binary_count_trailing_zeros.rs)
     * [Two's Complement](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/twos_complement.rs)
+    * [Unique Number](https://github.com/TheAlgorithms/Rust/blob/master/src/bit_manipulation/find_unique_number.rs)
   * Ciphers
     * [AES](https://github.com/TheAlgorithms/Rust/blob/master/src/ciphers/aes.rs)
     * [Another ROT13](https://github.com/TheAlgorithms/Rust/blob/master/src/ciphers/another_rot13.rs)

src/bit_manipulation/find_missing_number.rs

@@ -0,0 +1,122 @@
+/// Finds the missing number in a slice of consecutive integers.
+///
+/// This function uses XOR bitwise operation to find the missing number.
+/// It XORs all expected numbers in the range [min, max] with the actual
+/// numbers present in the array. Since XOR has the property that `a ^ a = 0`,
+/// all present numbers cancel out, leaving only the missing number.
+///
+/// # Arguments
+///
+/// * `nums` - A slice of integers forming a sequence with one missing number
+///
+/// # Returns
+///
+/// * `Ok(i32)` - The missing number in the sequence
+/// * `Err(String)` - An error message if the input is invalid
+///
+/// # Examples
+///
+/// ```
+/// # use the_algorithms_rust::bit_manipulation::find_missing_number;
+/// assert_eq!(find_missing_number(&[0, 1, 3, 4]).unwrap(), 2);
+/// assert_eq!(find_missing_number(&[4, 3, 1, 0]).unwrap(), 2);
+/// assert_eq!(find_missing_number(&[-4, -3, -1, 0]).unwrap(), -2);
+/// assert_eq!(find_missing_number(&[-2, 2, 1, 3, 0]).unwrap(), -1);
+/// assert_eq!(find_missing_number(&[1, 3, 4, 5, 6]).unwrap(), 2);
+/// ```
+pub fn find_missing_number(nums: &[i32]) -> Result<i32, String> {
+    if nums.is_empty() {
+        return Err("input array must not be empty".to_string());
+    }
+
+    if nums.len() == 1 {
+        return Err("array must have at least 2 elements to find a missing number".to_string());
+    }
+
+    let low = *nums.iter().min().unwrap();
+    let high = *nums.iter().max().unwrap();
+
+    let mut missing_number = high;
+
+    for i in low..high {
+        let index = (i - low) as usize;
+        missing_number ^= i ^ nums[index];
+    }
+
+    Ok(missing_number)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_missing_in_middle() {
+        assert_eq!(find_missing_number(&[0, 1, 3, 4]).unwrap(), 2);
+    }
+
+    #[test]
+    fn test_unordered_array() {
+        assert_eq!(find_missing_number(&[4, 3, 1, 0]).unwrap(), 2);
+    }
+
+    #[test]
+    fn test_negative_numbers() {
+        assert_eq!(find_missing_number(&[-4, -3, -1, 0]).unwrap(), -2);
+    }
+
+    #[test]
+    fn test_negative_and_positive() {
+        assert_eq!(find_missing_number(&[-2, 2, 1, 3, 0]).unwrap(), -1);
+    }
+
+    #[test]
+    fn test_missing_at_start() {
+        assert_eq!(find_missing_number(&[1, 3, 4, 5, 6]).unwrap(), 2);
+    }
+
+    #[test]
+    fn test_unordered_missing_middle() {
+        assert_eq!(find_missing_number(&[6, 5, 4, 2, 1]).unwrap(), 3);
+    }
+
+    #[test]
+    fn test_another_unordered() {
+        assert_eq!(find_missing_number(&[6, 1, 5, 3, 4]).unwrap(), 2);
+    }
+
+    #[test]
+    fn test_empty_array() {
+        assert!(find_missing_number(&[]).is_err());
+        assert_eq!(
+            find_missing_number(&[]).unwrap_err(),
+            "input array must not be empty"
+        );
+    }
+
+    #[test]
+    fn test_single_element() {
+        assert!(find_missing_number(&[5]).is_err());
+        assert_eq!(
+            find_missing_number(&[5]).unwrap_err(),
+            "array must have at least 2 elements to find a missing number"
+        );
+    }
+
+    #[test]
+    fn test_two_elements() {
+        assert_eq!(find_missing_number(&[0, 2]).unwrap(), 1);
+        assert_eq!(find_missing_number(&[2, 0]).unwrap(), 1);
+    }
+
+    #[test]
+    fn test_large_range() {
+        assert_eq!(find_missing_number(&[100, 101, 103, 104]).unwrap(), 102);
+    }
+
+    #[test]
+    fn test_missing_at_boundaries() {
+        // Missing is the second to last element
+        assert_eq!(find_missing_number(&[1, 2, 3, 5]).unwrap(), 4);
+    }
+}

src/bit_manipulation/find_unique_number.rs

@@ -0,0 +1,85 @@
+/// Finds the unique number in a slice where every other element appears twice.
+///
+/// This function uses the XOR bitwise operation. Since XOR has the property that
+/// `a ^ a = 0` and `a ^ 0 = a`, all paired numbers cancel out, leaving only the
+/// unique number.
+///
+/// # Arguments
+///
+/// * `arr` - A slice of integers where all elements except one appear exactly twice
+///
+/// # Returns
+///
+/// * `Ok(i32)` - The unique number that appears only once
+/// * `Err(String)` - An error message if the input is empty
+///
+/// # Examples
+///
+/// ```
+/// # use the_algorithms_rust::bit_manipulation::find_unique_number;
+/// assert_eq!(find_unique_number(&[1, 1, 2, 2, 3]).unwrap(), 3);
+/// assert_eq!(find_unique_number(&[4, 5, 4, 6, 6]).unwrap(), 5);
+/// assert_eq!(find_unique_number(&[7]).unwrap(), 7);
+/// assert_eq!(find_unique_number(&[10, 20, 10]).unwrap(), 20);
+/// assert!(find_unique_number(&[]).is_err());
+/// ```
+pub fn find_unique_number(arr: &[i32]) -> Result<i32, String> {
+    if arr.is_empty() {
+        return Err("input list must not be empty".to_string());
+    }
+
+    let result = arr.iter().fold(0, |acc, &num| acc ^ num);
+    Ok(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_basic_case() {
+        assert_eq!(find_unique_number(&[1, 1, 2, 2, 3]).unwrap(), 3);
+    }
+
+    #[test]
+    fn test_different_order() {
+        assert_eq!(find_unique_number(&[4, 5, 4, 6, 6]).unwrap(), 5);
+    }
+
+    #[test]
+    fn test_single_element() {
+        assert_eq!(find_unique_number(&[7]).unwrap(), 7);
+    }
+
+    #[test]
+    fn test_three_elements() {
+        assert_eq!(find_unique_number(&[10, 20, 10]).unwrap(), 20);
+    }
+
+    #[test]
+    fn test_empty_array() {
+        assert!(find_unique_number(&[]).is_err());
+        assert_eq!(
+            find_unique_number(&[]).unwrap_err(),
+            "input list must not be empty"
+        );
+    }
+
+    #[test]
+    fn test_negative_numbers() {
+        assert_eq!(find_unique_number(&[-1, -1, -2, -2, -3]).unwrap(), -3);
+    }
+
+    #[test]
+    fn test_large_numbers() {
+        assert_eq!(
+            find_unique_number(&[1000, 2000, 1000, 3000, 3000]).unwrap(),
+            2000
+        );
+    }
+
+    #[test]
+    fn test_zero() {
+        assert_eq!(find_unique_number(&[0, 1, 1]).unwrap(), 0);
+    }
+}

src/bit_manipulation/mod.rs

@@ -1,23 +1,29 @@
 mod binary_coded_decimal;
 mod binary_count_trailing_zeros;
 mod counting_bits;
+mod find_missing_number;
 mod find_previous_power_of_two;
+mod find_unique_number;
 mod highest_set_bit;
 mod is_power_of_two;
 mod n_bits_gray_code;
 mod reverse_bits;
+mod rightmost_set_bit;
 mod sum_of_two_integers;
 mod swap_odd_even_bits;
 mod twos_complement;
 
 pub use self::binary_coded_decimal::binary_coded_decimal;
 pub use self::binary_count_trailing_zeros::binary_count_trailing_zeros;
 pub use self::counting_bits::count_set_bits;
+pub use self::find_missing_number::find_missing_number;
 pub use self::find_previous_power_of_two::find_previous_power_of_two;
+pub use self::find_unique_number::find_unique_number;
 pub use self::highest_set_bit::find_highest_set_bit;
 pub use self::is_power_of_two::is_power_of_two;
 pub use self::n_bits_gray_code::generate_gray_code;
 pub use self::reverse_bits::reverse_bits;
+pub use self::rightmost_set_bit::{index_of_rightmost_set_bit, index_of_rightmost_set_bit_log};
 pub use self::sum_of_two_integers::add_two_integers;
 pub use self::swap_odd_even_bits::swap_odd_even_bits;
 pub use self::twos_complement::twos_complement;