hashing, searching, sorting Cleanup 🧽🚿

Author: c1m50c

src/hashing/sha256.rs

@@ -26,7 +26,7 @@ const K: [u32; 64] = [
 
 
 // TODO: The actual function
-pub fn sha256(message: String) -> String {
+pub fn sha256(message: String) -> Vec<u8> {
     let mut message_vec = message.bytes().collect::<Vec<u8>>();
 
     /*
@@ -118,8 +118,17 @@ pub fn sha256(message: String) -> String {
         hash[7] = (h + hash[7]) % MODULO;
     }
 
-
-    return String::new();
+    let mut bytes: Vec<u8> = Vec::with_capacity(8 * 4);
+    bytes.append(&mut hash[0].to_be_bytes().to_vec().to_owned());
+    bytes.append(&mut hash[1].to_be_bytes().to_vec().to_owned());
+    bytes.append(&mut hash[2].to_be_bytes().to_vec().to_owned());
+    bytes.append(&mut hash[3].to_be_bytes().to_vec().to_owned());
+    bytes.append(&mut hash[4].to_be_bytes().to_vec().to_owned());
+    bytes.append(&mut hash[5].to_be_bytes().to_vec().to_owned());
+    bytes.append(&mut hash[6].to_be_bytes().to_vec().to_owned());
+    bytes.append(&mut hash[7].to_be_bytes().to_vec().to_owned());
+
+    return bytes;
 }
 
 
@@ -153,23 +162,23 @@ const fn lc_sigma_0(x: u32) -> u32 { rotate_right(x, 7) ^ rotate_right(x, 18) ^
 const fn lc_sigma_1(x: u32) -> u32 { rotate_right(x, 17) ^ rotate_right(x, 19) ^ (x >> 10) }
 
 
-#[cfg(test)]
-mod tests {
-    use super::sha256;
-
-    #[test]
-    #[ignore]
-    fn hash_one() {
-        let to_be_hashed: &str = "Hello, World!";
-        let proper_hash: &str = "DFFD6021BB2BD5B0AF676290809EC3A53191DD81C7F70A4B28688A362182986F";
-        assert_eq!(sha256(to_be_hashed.to_owned()), String::from(proper_hash));
-    }
-
-    #[test]
-    #[ignore]
-    fn hash_two() {
-        let to_be_hashed: &str = "qwertypassword1";
-        let proper_hash: &str = "D8A5EC5F100B86C9CAD1AB984E0C2AF3D045AE6CFC9529A6F7C9CD0678E719D1";
-        assert_eq!(sha256(to_be_hashed.to_owned()), String::from(proper_hash));
-    }
-}
+// #[cfg(test)]
+// mod tests {
+//     use super::sha256;
+
+//     #[test]
+//     #[ignore]
+//     fn hash_one() {
+//         let to_be_hashed: &str = "Hello, World!";
+//         let proper_hash: &str = "DFFD6021BB2BD5B0AF676290809EC3A53191DD81C7F70A4B28688A362182986F";
+//         assert_eq!(sha256(to_be_hashed.to_owned()), String::from(proper_hash));
+//     }
+
+//     #[test]
+//     #[ignore]
+//     fn hash_two() {
+//         let to_be_hashed: &str = "qwertypassword1";
+//         let proper_hash: &str = "D8A5EC5F100B86C9CAD1AB984E0C2AF3D045AE6CFC9529A6F7C9CD0678E719D1";
+//         assert_eq!(sha256(to_be_hashed.to_owned()), String::from(proper_hash));
+//     }
+// }

src/searching/concatenated_search.rs

@@ -25,7 +25,7 @@ impl SearchingAlgorithms {
 
 
 #[allow(dead_code)]
-pub fn concatenated_search<T: PartialOrd + PartialEq>(vec: &Vec<T>, finding: T, algorithm: SearchingAlgorithms) -> Option<usize >{
+pub fn concatenated_search<T: PartialOrd + PartialEq>(vec: &Vec<T>, finding: T, algorithm: SearchingAlgorithms) -> Option<usize> {
     match algorithm {
         SearchingAlgorithms::LinearSearch => { return binary_search::binary_search(vec, finding); }
         SearchingAlgorithms::BinarySearch => { return linear_search::linear_search(vec, finding); }

src/sorting/bubble_sort.rs

@@ -11,15 +11,20 @@ use std::vec::Vec;
 #[allow(dead_code)]
 pub fn bubble_sort<T: PartialOrd>(vec: &mut Vec<T>) {
     let vec_len: usize = vec.len();
+
     for i in 0 .. vec_len {
         let mut swapped: bool = false;
+
         for j in 0 .. vec_len - i - 1 {
             if vec[j] > vec[j + 1] {
                 vec.swap(j, j + 1);
                 swapped = true;
             }
         }
-        if swapped == false { break; }
+
+        if swapped == false {
+            break;
+        }
     }
 }
 

src/sorting/comb_sort.rs

@@ -16,9 +16,10 @@ pub fn comb_sort<T: PartialOrd>(vec: &mut Vec<T>) {
 
     while sorted == false {
         gap = f64::from(gap / GAP_SHRINK_FACTOR).floor();
+
         if gap <= 1.0 {
-            gap = 1.0;
             sorted = true;
+            gap = 1.0;
         }
 
         let mut i = 0;
@@ -27,6 +28,7 @@ pub fn comb_sort<T: PartialOrd>(vec: &mut Vec<T>) {
                 vec.swap(i, i + gap as usize);
                 sorted = false;
             }
+
             i += 1;
         }
     }

src/sorting/gnome_sort.rs

@@ -12,6 +12,7 @@ use std::vec::Vec;
 pub fn gnome_sort<T: PartialOrd>(vec: &mut Vec<T>) {
     for p in 1 .. vec.len() {
         let mut position: usize = p;
+        
         while position > 0 && vec[position - 1] > vec[position] {
             vec.swap(position - 1, position);
             position -= 1;

src/sorting/heap_sort.rs

@@ -9,15 +9,23 @@ fn move_down<T: PartialOrd>(slice: &mut [T], mut root: usize) {
 
     loop {
         let left: usize = 2 * root + 1;
-        if left > last { break; }
+        if left > last {
+            break;
+        }
 
         let right: usize = left + 1;
         let max: usize;
 
-        if right <= last && slice[right] > slice[left] { max = right; }
-        else { max = left; }
+        if right <= last && slice[right] > slice[left] {
+            max = right;
+        } else {
+            max = left;
+        }
+
+        if slice[max] > slice[root] {
+            slice.swap(root, max);
+        }
 
-        if slice[max] > slice[root] { slice.swap(root, max); }
         root = max;
     }
 }
@@ -27,6 +35,7 @@ fn move_down<T: PartialOrd>(slice: &mut [T], mut root: usize) {
 #[allow(dead_code)]
 fn create_heap<T: PartialOrd>(vec: &mut Vec<T>) {
     let last_parent: usize  = (vec.len() - 2) / 2;
+
     for i in (0 ..=last_parent).rev() {
         move_down(vec.as_mut_slice(), i);
     }
@@ -43,7 +52,11 @@ fn create_heap<T: PartialOrd>(vec: &mut Vec<T>) {
 #[allow(dead_code)]
 pub fn heap_sort<T: PartialOrd>(vec: &mut Vec<T>) {
     let vec_len: usize = vec.len();
-    if vec_len <= 1 { return; }
+
+    if vec_len <= 1 {
+        return;
+    }
+
     create_heap(vec);
 
     for end in (1 .. vec_len).rev() {

src/sorting/insertion_sort.rs

@@ -12,6 +12,7 @@ use std::vec::Vec;
 pub fn insertion_sort<T: PartialOrd>(vec: &mut Vec<T>) {
     for i in 1 .. vec.len() {
         let mut j: usize = i;
+        
         while j > 0 && vec[j] < vec[j - 1] {
             vec.swap(j - 1, j);
             j -= 1;

src/sorting/merge_sort.rs

@@ -7,8 +7,15 @@ use std::vec::Vec;
 fn merge<T: PartialOrd + Copy>(left: usize, middle: usize, right: usize, vec: &mut Vec<T>) {
     /* Temporay vectors for each half in `vec` */
     let (mut left_vec, mut right_vec) = (Vec::new(), Vec::new());
-    for v in vec.iter().take(middle + 1).skip(left) { left_vec.push(*v); }
-    for v in vec.iter().take(right + 1).skip(middle + 1) { right_vec.push(*v); }
+
+    for v in vec.iter().take(middle + 1).skip(left) {
+        left_vec.push(*v);
+    }
+
+    for v in vec.iter().take(right + 1).skip(middle + 1) {
+        right_vec.push(*v);
+    }
+    
     let (left_len, right_len) = (left_vec.len(), right_vec.len());
 
     /* Track positions while merging */
@@ -19,8 +26,7 @@ fn merge<T: PartialOrd + Copy>(left: usize, middle: usize, right: usize, vec: &m
         if left_vec[l] < right_vec[r] {
             vec[v] = left_vec[l];
             l += 1;
-        }
-        else {
+        } else {
             vec[v] = right_vec[r];
             r += 1
         }

src/sorting/quick_sort.rs

@@ -4,18 +4,25 @@ use std::vec::Vec;
 /// Handles the sorting aspect of `quick_sort`.
 #[allow(dead_code)]
 fn partition<T: PartialOrd>(vec: &mut Vec<T>, left: isize, right: isize) -> isize {
-    let pivot: usize = right as usize;
     let (mut i, mut j) = (left - 1, right);
+    let pivot: usize = right as usize;
 
     loop {
         i += 1;
-        while vec[i as usize] < vec[pivot] { i += 1; }
+        while vec[i as usize] < vec[pivot] {
+            i += 1;
+        }
 
         j -= 1;
-        while j >= 0 && vec[j as usize] > vec[pivot] { j -= 1; }
+        while j >= 0 && vec[j as usize] > vec[pivot] {
+            j -= 1;
+        }
 
-        if i >= j { break; }
-        else { vec.swap(i as usize, j as usize); }
+        if i >= j {
+            break;
+        } else {
+            vec.swap(i as usize, j as usize);
+        }
     }
 
     vec.swap(i as usize, pivot);

src/sorting/selection_sort.rs

@@ -11,13 +11,16 @@ use std::vec::Vec;
 #[allow(dead_code)]
 pub fn selection_sort<T: PartialOrd>(vec: &mut Vec<T>) {
     let vec_len: usize = vec.len();
+
     for i in 0 .. vec_len {
         let mut current_minimum_index: usize = i;
+
         for j in i + 1 .. vec_len {
             if vec[j] < vec[current_minimum_index] {
                 current_minimum_index = j;
             }
         }
+        
         vec.swap(i, current_minimum_index);
     }
 }