diff --git a/DIRECTORY.md b/DIRECTORY.md index d8d527a02e3..af47f388d1c 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -21,6 +21,7 @@ * [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) * [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) * [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) @@ -195,7 +196,7 @@ * [Gradient Descent](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/optimization/gradient_descent.rs) * [Momentum](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/optimization/momentum.rs) * Math - * [Abs](https://github.com/TheAlgorithms/Rust/blob/master/src/math/abs.rs) + * [Absolute](https://github.com/TheAlgorithms/Rust/blob/master/src/math/abs.rs) * [Aliquot Sum](https://github.com/TheAlgorithms/Rust/blob/master/src/math/aliquot_sum.rs) * [Amicable Numbers](https://github.com/TheAlgorithms/Rust/blob/master/src/math/amicable_numbers.rs) * [Area Of Polygon](https://github.com/TheAlgorithms/Rust/blob/master/src/math/area_of_polygon.rs) @@ -259,8 +260,8 @@ * [Prime Numbers](https://github.com/TheAlgorithms/Rust/blob/master/src/math/prime_numbers.rs) * [Quadratic Residue](https://github.com/TheAlgorithms/Rust/blob/master/src/math/quadratic_residue.rs) * [Random](https://github.com/TheAlgorithms/Rust/blob/master/src/math/random.rs) - * [Relu](https://github.com/TheAlgorithms/Rust/blob/master/src/math/relu.rs) - * [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sieve_of_eratosthenes.rs) + * [ReLU](https://github.com/TheAlgorithms/Rust/blob/master/src/math/relu.rs) + * [Sieve of Eratosthenes](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sieve_of_eratosthenes.rs) * [Sigmoid](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sigmoid.rs) * [Signum](https://github.com/TheAlgorithms/Rust/blob/master/src/math/signum.rs) * [Simpsons Integration](https://github.com/TheAlgorithms/Rust/blob/master/src/math/simpsons_integration.rs) @@ -268,9 +269,9 @@ * [Sprague Grundy Theorem](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sprague_grundy_theorem.rs) * [Square Pyramidal Numbers](https://github.com/TheAlgorithms/Rust/blob/master/src/math/square_pyramidal_numbers.rs) * [Square Root](https://github.com/TheAlgorithms/Rust/blob/master/src/math/square_root.rs) - * [Sum Of Digits](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sum_of_digits.rs) - * [Sum Of Geometric Progression](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sum_of_geometric_progression.rs) - * [Sum Of Harmonic Series](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sum_of_harmonic_series.rs) + * [Sum of Digits](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sum_of_digits.rs) + * [Sum of Geometric Progression](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sum_of_geometric_progression.rs) + * [Sum of Harmonic Series](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sum_of_harmonic_series.rs) * [Sylvester Sequence](https://github.com/TheAlgorithms/Rust/blob/master/src/math/sylvester_sequence.rs) * [Tanh](https://github.com/TheAlgorithms/Rust/blob/master/src/math/tanh.rs) * [Trapezoidal Integration](https://github.com/TheAlgorithms/Rust/blob/master/src/math/trapezoidal_integration.rs) @@ -285,7 +286,7 @@ * Number Theory * [Compute Totient](https://github.com/TheAlgorithms/Rust/blob/master/src/number_theory/compute_totient.rs) * [Euler Totient](https://github.com/TheAlgorithms/Rust/blob/master/src/number_theory/euler_totient.rs) - * [Kth Factor](https://github.com/TheAlgorithms/Rust/blob/master/src/number_theory/kth_factor.rs) + * [K-th Factor](https://github.com/TheAlgorithms/Rust/blob/master/src/number_theory/kth_factor.rs) * Searching * [Binary Search](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/binary_search.rs) * [Binary Search Recursive](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/binary_search_recursive.rs) @@ -293,8 +294,8 @@ * [Fibonacci Search](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/fibonacci_search.rs) * [Interpolation Search](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/interpolation_search.rs) * [Jump Search](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/jump_search.rs) - * [Kth Smallest](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/kth_smallest.rs) - * [Kth Smallest Heap](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/kth_smallest_heap.rs) + * [K-th Smallest](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/kth_smallest.rs) + * [K-th Smallest Heap](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/kth_smallest_heap.rs) * [Linear Search](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/linear_search.rs) * [Moore Voting](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/moore_voting.rs) * [Quick Select](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/quick_select.rs) diff --git a/src/bit_manipulation/find_previous_power_of_two.rs b/src/bit_manipulation/find_previous_power_of_two.rs new file mode 100644 index 00000000000..a6d730d3fde --- /dev/null +++ b/src/bit_manipulation/find_previous_power_of_two.rs @@ -0,0 +1,172 @@ +//! Previous Power of Two +//! +//! This module provides a function to find the largest power of two that is less than +//! or equal to a given non-negative integer. +//! +//! # Algorithm +//! +//! The algorithm works by repeatedly left-shifting (doubling) a power value starting +//! from 1 until it exceeds the input number, then returning the previous power (by +//! right-shifting once). +//! +//! For more information: + +/// Finds the largest power of two that is less than or equal to a given integer. +/// +/// The function uses bit shifting to efficiently find the power of two. It starts +/// with 1 and keeps doubling (left shift) until it exceeds the input, then returns +/// the previous value (right shift). +/// +/// # Arguments +/// +/// * `number` - A non-negative integer +/// +/// # Returns +/// +/// A `Result` containing: +/// - `Ok(u32)` - The largest power of two ≤ the input number +/// - `Err(String)` - An error message if the input is negative +/// +/// # Examples +/// +/// ``` +/// use the_algorithms_rust::bit_manipulation::find_previous_power_of_two; +/// +/// assert_eq!(find_previous_power_of_two(0).unwrap(), 0); +/// assert_eq!(find_previous_power_of_two(1).unwrap(), 1); +/// assert_eq!(find_previous_power_of_two(2).unwrap(), 2); +/// assert_eq!(find_previous_power_of_two(3).unwrap(), 2); +/// assert_eq!(find_previous_power_of_two(4).unwrap(), 4); +/// assert_eq!(find_previous_power_of_two(5).unwrap(), 4); +/// assert_eq!(find_previous_power_of_two(8).unwrap(), 8); +/// assert_eq!(find_previous_power_of_two(15).unwrap(), 8); +/// assert_eq!(find_previous_power_of_two(16).unwrap(), 16); +/// assert_eq!(find_previous_power_of_two(17).unwrap(), 16); +/// +/// // Negative numbers return an error +/// assert!(find_previous_power_of_two(-5).is_err()); +/// ``` +/// +/// # Errors +/// +/// Returns an error if the input number is negative. +pub fn find_previous_power_of_two(number: i32) -> Result { + if number < 0 { + return Err("Input must be a non-negative integer".to_string()); + } + + let number = number as u32; + + if number == 0 { + return Ok(0); + } + + let mut power = 1u32; + while power <= number { + power <<= 1; // Equivalent to multiplying by 2 + } + + Ok(if number > 1 { power >> 1 } else { 1 }) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_zero() { + assert_eq!(find_previous_power_of_two(0).unwrap(), 0); + } + + #[test] + fn test_one() { + assert_eq!(find_previous_power_of_two(1).unwrap(), 1); + } + + #[test] + fn test_powers_of_two() { + assert_eq!(find_previous_power_of_two(2).unwrap(), 2); + assert_eq!(find_previous_power_of_two(4).unwrap(), 4); + assert_eq!(find_previous_power_of_two(8).unwrap(), 8); + assert_eq!(find_previous_power_of_two(16).unwrap(), 16); + assert_eq!(find_previous_power_of_two(32).unwrap(), 32); + assert_eq!(find_previous_power_of_two(64).unwrap(), 64); + assert_eq!(find_previous_power_of_two(128).unwrap(), 128); + assert_eq!(find_previous_power_of_two(256).unwrap(), 256); + assert_eq!(find_previous_power_of_two(512).unwrap(), 512); + assert_eq!(find_previous_power_of_two(1024).unwrap(), 1024); + } + + #[test] + fn test_numbers_between_powers() { + // Between 2 and 4 + assert_eq!(find_previous_power_of_two(3).unwrap(), 2); + + // Between 4 and 8 + assert_eq!(find_previous_power_of_two(5).unwrap(), 4); + assert_eq!(find_previous_power_of_two(6).unwrap(), 4); + assert_eq!(find_previous_power_of_two(7).unwrap(), 4); + + // Between 8 and 16 + assert_eq!(find_previous_power_of_two(9).unwrap(), 8); + assert_eq!(find_previous_power_of_two(10).unwrap(), 8); + assert_eq!(find_previous_power_of_two(11).unwrap(), 8); + assert_eq!(find_previous_power_of_two(12).unwrap(), 8); + assert_eq!(find_previous_power_of_two(13).unwrap(), 8); + assert_eq!(find_previous_power_of_two(14).unwrap(), 8); + assert_eq!(find_previous_power_of_two(15).unwrap(), 8); + + // Between 16 and 32 + assert_eq!(find_previous_power_of_two(17).unwrap(), 16); + assert_eq!(find_previous_power_of_two(20).unwrap(), 16); + assert_eq!(find_previous_power_of_two(31).unwrap(), 16); + } + + #[test] + fn test_range_0_to_17() { + // Test the exact output from the Python docstring + let expected = vec![0, 1, 2, 2, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 16, 16]; + let results: Vec = (0..18) + .map(|i| find_previous_power_of_two(i).unwrap()) + .collect(); + assert_eq!(results, expected); + } + + #[test] + fn test_large_numbers() { + assert_eq!(find_previous_power_of_two(100).unwrap(), 64); + assert_eq!(find_previous_power_of_two(500).unwrap(), 256); + assert_eq!(find_previous_power_of_two(1000).unwrap(), 512); + assert_eq!(find_previous_power_of_two(2000).unwrap(), 1024); + assert_eq!(find_previous_power_of_two(10000).unwrap(), 8192); + } + + #[test] + fn test_max_safe_values() { + assert_eq!(find_previous_power_of_two(1023).unwrap(), 512); + assert_eq!(find_previous_power_of_two(2047).unwrap(), 1024); + assert_eq!(find_previous_power_of_two(4095).unwrap(), 2048); + } + + #[test] + fn test_negative_number_returns_error() { + let result = find_previous_power_of_two(-1); + assert!(result.is_err()); + assert_eq!(result.unwrap_err(), "Input must be a non-negative integer"); + } + + #[test] + fn test_negative_numbers_return_errors() { + assert!(find_previous_power_of_two(-5).is_err()); + assert!(find_previous_power_of_two(-10).is_err()); + assert!(find_previous_power_of_two(-100).is_err()); + } + + #[test] + fn test_edge_cases() { + // One less than powers of two + assert_eq!(find_previous_power_of_two(127).unwrap(), 64); + assert_eq!(find_previous_power_of_two(255).unwrap(), 128); + assert_eq!(find_previous_power_of_two(511).unwrap(), 256); + } +} diff --git a/src/bit_manipulation/mod.rs b/src/bit_manipulation/mod.rs index d2405375483..13f649207c2 100644 --- a/src/bit_manipulation/mod.rs +++ b/src/bit_manipulation/mod.rs @@ -1,5 +1,6 @@ mod binary_coded_decimal; mod counting_bits; +mod find_previous_power_of_two; mod highest_set_bit; mod n_bits_gray_code; mod reverse_bits; @@ -9,6 +10,7 @@ mod twos_complement; pub use self::binary_coded_decimal::binary_coded_decimal; pub use self::counting_bits::count_set_bits; +pub use self::find_previous_power_of_two::find_previous_power_of_two; pub use self::highest_set_bit::find_highest_set_bit; pub use self::n_bits_gray_code::generate_gray_code; pub use self::reverse_bits::reverse_bits;