Added hashtable and removed some of the warnings + trapezoidal method for function integration + bingo sort

Cargo.toml

@@ -7,4 +7,5 @@ edition = "2018"
 
 [dependencies]
 paste = "1.0.12"
-bitvec = "1.0.1"
+bitvec = "1.0.1"
+rand = "0.8.4"

src/ciphers/sha256.rs

@@ -132,7 +132,7 @@ fn calc_chunk(chunk: &mut [u8; 64], state: &mut BufState) -> bool {
  chunk[63] = (len << 3) as u8;
  len >>= 5;
  for i in 1..8 {
- chunk[(63 - i)] = len as u8;
+ chunk[63 - i] = len as u8;
  len >>= 8;
  }
  state.total = true;

src/data_structures/hashtable.rs

@@ -0,0 +1,148 @@
+use std::collections::LinkedList;
+const GROWTH_FACTOR: usize = 2;
+const LOAD_FACTOR_BOUND: f64 = 0.75;
+const INITIAL_CAPACITY: usize = 3000;
+
+pub struct HashTable<K, V> {
+ elements: Vec<LinkedList<(K, V)>>,
+ count: usize,
+}
+
+impl<K: Hashable + std::cmp::PartialEq, V> Default for HashTable<K, V> {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+pub trait Hashable {
+ fn hash(&self) -> usize;
+}
+
+impl<K: Hashable + std::cmp::PartialEq, V> HashTable<K, V> {
+ pub fn new() -> HashTable<K, V> {
+ let initial_capacity = INITIAL_CAPACITY;
+ let mut elements = Vec::with_capacity(initial_capacity);
+
+ for _ in 0..initial_capacity {
+ elements.push(LinkedList::new());
+ }
+
+ HashTable { elements, count: 0 }
+ }
+
+ pub fn insert(&mut self, key: K, value: V) {
+ if self.count >= self.elements.len() * LOAD_FACTOR_BOUND as usize {
+ self.resize();
+ }
+ let index = key.hash() % self.elements.len();
+ self.elements[index].push_back((key, value));
+ self.count += 1;
+ }
+
+ pub fn search(&self, key: K) -> Option<&V> {
+ let index = key.hash() % self.elements.len();
+ self.elements[index]
+ .iter()
+ .find(|(k, _)| *k == key)
+ .map(|(_, v)| v)
+ }
+
+ fn resize(&mut self) {
+ let new_size = self.elements.len() * GROWTH_FACTOR;
+ let mut new_elements = Vec::with_capacity(new_size);
+
+ for _ in 0..new_size {
+ new_elements.push(LinkedList::new());
+ }
+
+ for old_list in self.elements.drain(..) {
+ for (key, value) in old_list {
+ let new_index = key.hash() % new_size;
+ new_elements[new_index].push_back((key, value));
+ }
+ }
+
+ self.elements = new_elements;
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[derive(Debug, PartialEq, Eq)]
+ struct TestKey(usize);
+
+ impl Hashable for TestKey {
+ fn hash(&self) -> usize {
+ self.0
+ }
+ }
+
+ #[test]
+ fn test_insert_and_search() {
+ let mut hash_table = HashTable::new();
+ let key = TestKey(1);
+ let value = TestKey(10);
+
+ hash_table.insert(key, value);
+ let result = hash_table.search(TestKey(1));
+
+ assert_eq!(result, Some(&TestKey(10)));
+ }
+
+ #[test]
+ fn test_resize() {
+ let mut hash_table = HashTable::new();
+ let initial_capacity = hash_table.elements.capacity();
+
+ for i in 0..initial_capacity * LOAD_FACTOR_BOUND as usize + 1 {
+ hash_table.insert(TestKey(i), TestKey(i + 10));
+ }
+
+ assert!(hash_table.elements.capacity() > initial_capacity);
+ }
+
+ #[test]
+ fn test_search_nonexistent() {
+ let mut hash_table = HashTable::new();
+ let key = TestKey(1);
+ let value = TestKey(10);
+
+ hash_table.insert(key, value);
+ let result = hash_table.search(TestKey(2));
+
+ assert_eq!(result, None);
+ }
+
+ #[test]
+ fn test_multiple_inserts_and_searches() {
+ let mut hash_table = HashTable::new();
+ for i in 0..10 {
+ hash_table.insert(TestKey(i), TestKey(i + 100));
+ }
+
+ for i in 0..10 {
+ let result = hash_table.search(TestKey(i));
+ assert_eq!(result, Some(&TestKey(i + 100)));
+ }
+ }
+
+ #[test]
+ fn test_not_overwrite_existing_key() {
+ let mut hash_table = HashTable::new();
+ hash_table.insert(TestKey(1), TestKey(100));
+ hash_table.insert(TestKey(1), TestKey(200));
+
+ let result = hash_table.search(TestKey(1));
+ assert_eq!(result, Some(&TestKey(100)));
+ }
+
+ #[test]
+ fn test_empty_search() {
+ let hash_table: HashTable<TestKey, TestKey> = HashTable::new();
+ let result = hash_table.search(TestKey(1));
+
+ assert_eq!(result, None);
+ }
+}

src/data_structures/mod.rs

@@ -4,6 +4,7 @@ mod binary_search_tree;
 mod bloom_filter;
 mod fenwick_tree;
 mod graph;
+mod hashtable;
 mod heap;
 mod linked_list;
 mod queue;
@@ -15,6 +16,7 @@ mod trie;
 mod union_find;
 
 pub use self::bloom_filter::BloomFilter;
+pub use self::hashtable::HashTable;
 pub use self::heap::MaxHeap;
 pub use self::heap::MinHeap;
 pub use self::linked_list::LinkedList;

src/data_structures/rb_tree.rs

@@ -215,7 +215,7 @@ impl<K: Ord, V> RBTree<K, V> {
  }
 
  /* release resource */
- Box::from_raw(node);
+ let _ = Box::from_raw(node);
  if matches!(deleted_color, Color::Black) {
  delete_fixup(self, parent);
  }

src/dynamic_programming/coin_problem.rs

@@ -42,7 +42,7 @@ pub fn coin_problem(n: usize, coins: &mut Vec<usize>) -> usize {
  for j in 0..combinations.len() {
  if coins[i] <= j {
  // update the combinations array
- combinations[j] += combinations[(j - coins[i])];
+ combinations[j] += combinations[j - coins[i]];
  }
  }
  }

src/graphs/depth_first_search_tic_tac_toe.rs

@@ -274,7 +274,7 @@ fn append_playaction(
  return;
  }
 
- let mut play_actions = opt_play_actions.as_mut().unwrap();
+ let play_actions = opt_play_actions.as_mut().unwrap();
 
  //New game action is scored from the current side and the current saved best score against the new game action.
  match (current_side, play_actions.side, appendee.side) {

src/math/mod.rs

@@ -24,6 +24,7 @@ mod random;
 mod sieve_of_eratosthenes;
 mod simpson_integration;
 mod square_root;
+mod trapezoidal_integration;
 mod trial_division;
 mod zellers_congruence_algorithm;
 
@@ -60,5 +61,6 @@ pub use self::random::PCG32;
 pub use self::sieve_of_eratosthenes::sieve_of_eratosthenes;
 pub use self::simpson_integration::simpson_integration;
 pub use self::square_root::square_root;
+pub use self::trapezoidal_integration::trapezoidal_integral;
 pub use self::trial_division::trial_division;
 pub use self::zellers_congruence_algorithm::zellers_congruence_algorithm;

src/math/trapezoidal_integration.rs

@@ -0,0 +1,59 @@
+pub fn trapezoidal_integral<F>(a: f64, b: f64, f: F, precision: u32) -> f64
+where
+ F: Fn(f64) -> f64,
+{
+ if a > b {
+ return trapezoidal_integral(b, a, f, precision);
+ }
+
+ let delta = (b - a) / precision as f64;
+
+ (0..precision)
+ .map(|trapezoid| {
+ let left_side = a + (delta * trapezoid as f64);
+ let right_side = left_side + delta;
+
+ 0.5 * (f(left_side) + f(right_side)) * delta
+ })
+ .sum()
+}
+
+#[allow(dead_code)]
+fn main() {
+ let f = |x: f64| x.powi(3);
+ let result = trapezoidal_integral(0.0, 1.0, f, 1000);
+ println!("{}", result);
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_integral() {
+ let f = |x: f64| x.powi(2);
+ let result = trapezoidal_integral(0.0, 1.0, f, 1000);
+ assert!((result - 1.0 / 3.0).abs() < 0.0001);
+ }
+
+ #[test]
+ fn test_precision() {
+ let f = |x: f64| x.powi(2);
+ let result = trapezoidal_integral(0.0, 1.0, f, 10000);
+ assert!((result - 1.0 / 3.0).abs() < 0.00001);
+ }
+
+ #[test]
+ fn test_negative() {
+ let f = |x: f64| x.powi(2);
+ let result = trapezoidal_integral(-1.0, 1.0, f, 10000);
+ assert!((result - 2.0 / 3.0).abs() < 0.00001);
+ }
+
+ #[test]
+ fn test_negative_precision() {
+ let f = |x: f64| x.powi(2);
+ let result = trapezoidal_integral(-1.0, 1.0, f, 100000);
+ assert!((result - 2.0 / 3.0).abs() < 0.000001);
+ }
+}

src/searching/binary_search.rs

@@ -3,7 +3,7 @@ use std::cmp::Ordering;
 pub fn binary_search<T: Ord>(item: &T, arr: &[T]) -> Option<usize> {
  let mut is_asc = true;
  if arr.len() > 1 {
- is_asc = arr[0] < arr[(arr.len() - 1)];
+ is_asc = arr[0] < arr[arr.len() - 1];
  }
  let mut left = 0;
  let mut right = arr.len();

src/sorting/bingo_sort.rs

@@ -0,0 +1,105 @@
+use std::cmp::{max, min};
+
+// Function for finding the maximum and minimum element of the Array
+fn max_min(vec: &[i32], bingo: &mut i32, next_bingo: &mut i32) {
+ for &element in vec.iter().skip(1) {
+ *bingo = min(*bingo, element);
+ *next_bingo = max(*next_bingo, element);
+ }
+}
+
+pub fn bingo_sort(vec: &mut Vec<i32>) {
+ if vec.is_empty() {
+ return;
+ }
+
+ let mut bingo = vec[0];
+ let mut next_bingo = vec[0];
+
+ max_min(vec, &mut bingo, &mut next_bingo);
+
+ let largest_element = next_bingo;
+ let mut next_element_pos = 0;
+
+ for (bingo, _next_bingo) in (bingo..=largest_element).zip(bingo..=largest_element) {
+ let start_pos = next_element_pos;
+
+ for i in start_pos..vec.len() {
+ if vec[i] == bingo {
+ vec.swap(i, next_element_pos);
+ next_element_pos += 1;
+ }
+ }
+ }
+}
+
+#[allow(dead_code)]
+fn print_array(arr: &[i32]) {
+ print!("Sorted Array: ");
+ for &element in arr {
+ print!("{} ", element);
+ }
+ println!();
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_bingo_sort() {
+ let mut arr = vec![5, 4, 8, 5, 4, 8, 5, 4, 4, 4];
+ bingo_sort(&mut arr);
+ assert_eq!(arr, vec![4, 4, 4, 4, 4, 5, 5, 5, 8, 8]);
+
+ let mut arr2 = vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+ bingo_sort(&mut arr2);
+ assert_eq!(arr2, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+
+ let mut arr3 = vec![0, 1, 0, 1, 0, 1];
+ bingo_sort(&mut arr3);
+ assert_eq!(arr3, vec![0, 0, 0, 1, 1, 1]);
+ }
+
+ #[test]
+ fn test_empty_array() {
+ let mut arr = Vec::new();
+ bingo_sort(&mut arr);
+ assert_eq!(arr, Vec::new());
+ }
+
+ #[test]
+ fn test_single_element_array() {
+ let mut arr = vec![42];
+ bingo_sort(&mut arr);
+ assert_eq!(arr, vec![42]);
+ }
+
+ #[test]
+ fn test_negative_numbers() {
+ let mut arr = vec![-5, -4, -3, -2, -1];
+ bingo_sort(&mut arr);
+ assert_eq!(arr, vec![-5, -4, -3, -2, -1]);
+ }
+
+ #[test]
+ fn test_already_sorted() {
+ let mut arr = vec![1, 2, 3, 4, 5];
+ bingo_sort(&mut arr);
+ assert_eq!(arr, vec![1, 2, 3, 4, 5]);
+ }
+
+ #[test]
+ fn test_reverse_sorted() {
+ let mut arr = vec![5, 4, 3, 2, 1];
+ bingo_sort(&mut arr);
+ assert_eq!(arr, vec![1, 2, 3, 4, 5]);
+ }
+
+ #[test]
+ fn test_duplicates() {
+ let mut arr = vec![1, 2, 3, 4, 5, 1, 2, 3, 4, 5];
+ bingo_sort(&mut arr);
+ assert_eq!(arr, vec![1, 1, 2, 2, 3, 3, 4, 4, 5, 5]);
+ }
+}