Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

[pull] master from TheAlgorithms:master #224

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
pull merged 3 commits into AlgorithmAndLeetCode:master from TheAlgorithms:master
Dec 18, 2025
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 4 additions & 1 deletion DIRECTORY.md
View file Open in desktop
Original file line number Diff line number Diff line change
@@ -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)
Expand All @@ -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)
Expand Down
122 changes: 122 additions & 0 deletions src/bit_manipulation/find_missing_number.rs
View file Open in desktop
Original file line number Diff line number Diff line change
@@ -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);
}
}
85 changes: 85 additions & 0 deletions src/bit_manipulation/find_unique_number.rs
View file Open in desktop
Original file line number Diff line number Diff line change
@@ -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);
}
}
6 changes: 6 additions & 0 deletions src/bit_manipulation/mod.rs
View file Open in desktop
Original file line number Diff line number Diff line change
@@ -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;
Loading

AltStyle によって変換されたページ (->オリジナル) /