Add decimal to hexadecimal conversion (#631)

Author: alcyone33

DIRECTORY.md

@@ -43,6 +43,7 @@
     * [Binary To Decimal](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/binary_to_decimal.rs)
     * [Binary To Hexadecimal](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/binary_to_hexadecimal.rs)
     * [Decimal To Binary](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/decimal_to_binary.rs)
+    * [Decimal To Hexadecimal](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/decimal_to_hexadecimal.rs)
     * [Hexadecimal To Binary](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/hexadecimal_to_binary.rs)
     * [Octal To Binary](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/octal_to_binary.rs)
     * [Octal To Decimal](https://github.com/TheAlgorithms/Rust/blob/master/src/conversions/octal_to_decimal.rs)

src/backtracking/n_queens.rs

@@ -36,7 +36,7 @@ pub fn n_queens_solver(n: usize) -> Vec<Vec<String>> {
     solutions
 }
 
-fn is_safe(board: &Vec<Vec<char>>, row: usize, col: usize) -> bool {
+fn is_safe(board: &[Vec<char>], row: usize, col: usize) -> bool {
     // Check if there is a queen in the same column
     for (i, _) in board.iter().take(row).enumerate() {
         if board[i][col] == 'Q' {

src/ciphers/base64.rs

@@ -31,7 +31,7 @@ fn collect_six_bits(from: (u8, u8), offset: u8) -> u8 {
     ((combined & (0b1111110000000000u16 >> offset)) >> (10 - offset)) as u8
 }
 
-pub fn base64_encode(data: &Vec<u8>) -> String {
+pub fn base64_encode(data: &[u8]) -> String {
     let mut bits_encoded = 0usize;
     let mut encoded_string = String::new();
     // Using modulo twice to prevent an underflow, Wolfram|Alpha says this is optimal

src/conversions/decimal_to_hexadecimal.rs

@@ -0,0 +1,56 @@
+pub fn decimal_to_hexadecimal(base_num: u64) -> String {
+    let mut num = base_num;
+    let mut hexadecimal_num = String::new();
+
+    loop {
+        let remainder = num % 16;
+        let hex_char = if remainder < 10 {
+            (remainder as u8 + b'0') as char
+        } else {
+            (remainder as u8 - 10 + b'A') as char
+        };
+
+        hexadecimal_num.insert(0, hex_char);
+        num /= 16;
+        if num == 0 {
+            break;
+        }
+    }
+
+    hexadecimal_num
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_zero() {
+        assert_eq!(decimal_to_hexadecimal(0), "0");
+    }
+
+    #[test]
+    fn test_single_digit_decimal() {
+        assert_eq!(decimal_to_hexadecimal(9), "9");
+    }
+
+    #[test]
+    fn test_single_digit_hexadecimal() {
+        assert_eq!(decimal_to_hexadecimal(12), "C");
+    }
+
+    #[test]
+    fn test_multiple_digit_hexadecimal() {
+        assert_eq!(decimal_to_hexadecimal(255), "FF");
+    }
+
+    #[test]
+    fn test_big() {
+        assert_eq!(decimal_to_hexadecimal(u64::MAX), "FFFFFFFFFFFFFFFF");
+    }
+
+    #[test]
+    fn test_random() {
+        assert_eq!(decimal_to_hexadecimal(123456), "1E240");
+    }
+}

src/conversions/mod.rs

@@ -1,12 +1,14 @@
 mod binary_to_decimal;
 mod binary_to_hexadecimal;
 mod decimal_to_binary;
+mod decimal_to_hexadecimal;
 mod hexadecimal_to_binary;
 mod octal_to_binary;
 mod octal_to_decimal;
 pub use self::binary_to_decimal::binary_to_decimal;
 pub use self::binary_to_hexadecimal::binary_to_hexadecimal;
 pub use self::decimal_to_binary::decimal_to_binary;
+pub use self::decimal_to_hexadecimal::decimal_to_hexadecimal;
 pub use self::hexadecimal_to_binary::hexadecimal_to_binary;
 pub use self::octal_to_binary::octal_to_binary;
 pub use self::octal_to_decimal::octal_to_decimal;

src/data_structures/probabilistic/bloom_filter.rs

@@ -136,7 +136,7 @@ impl<Item: Hash> BloomFilter<Item> for MultiBinaryBloomFilter {
         for builder in &self.hash_builders {
             let mut hasher = builder.build_hasher();
             item.hash(&mut hasher);
-            let hash = hasher.finish();
+            let hash = builder.hash_one(&item);
             let index = hash % self.filter_size as u64;
             let byte_index = index as usize / 8; // this is this byte that we need to modify
             let bit_index = (index % 8) as u8; // we cannot only OR with value 1 this time, since we have 8 bits
@@ -148,7 +148,7 @@ impl<Item: Hash> BloomFilter<Item> for MultiBinaryBloomFilter {
         for builder in &self.hash_builders {
             let mut hasher = builder.build_hasher();
             item.hash(&mut hasher);
-            let hash = hasher.finish();
+            let hash = builder.hash_one(item);
             let index = hash % self.filter_size as u64;
             let byte_index = index as usize / 8; // this is this byte that we need to modify
             let bit_index = (index % 8) as u8; // we cannot only OR with value 1 this time, since we have 8 bits

src/data_structures/probabilistic/count_min_sketch.rs

@@ -1,6 +1,6 @@
 use std::collections::hash_map::RandomState;
 use std::fmt::{Debug, Formatter};
-use std::hash::{BuildHasher, Hash, Hasher};
+use std::hash::{BuildHasher, Hash};
 
 /// A probabilistic data structure holding an approximate count for diverse items efficiently (using constant space)
 ///
@@ -129,7 +129,7 @@ impl<Item: Hash, const WIDTH: usize, const DEPTH: usize> CountMinSketch
         for (row, r) in self.hashers.iter_mut().enumerate() {
             let mut h = r.build_hasher();
             item.hash(&mut h);
-            let hashed = h.finish();
+            let hashed = r.hash_one(&item);
             let col = (hashed % WIDTH as u64) as usize;
             self.counts[row][col] += count;
         }
@@ -142,7 +142,7 @@ impl<Item: Hash, const WIDTH: usize, const DEPTH: usize> CountMinSketch
             .map(|(row, r)| {
                 let mut h = r.build_hasher();
                 item.hash(&mut h);
-                let hashed = h.finish();
+                let hashed = r.hash_one(&item);
                 let col = (hashed % WIDTH as u64) as usize;
                 self.counts[row][col]
             })

src/geometry/polygon_points.rs

@@ -5,7 +5,7 @@ fn cross(x1: Ll, y1: Ll, x2: Ll, y2: Ll) -> Ll {
     x1 * y2 - x2 * y1
 }
 
-pub fn polygon_area(pts: &Vec<Pll>) -> Ll {
+pub fn polygon_area(pts: &[Pll]) -> Ll {
     let mut ats = 0;
     for i in 2..pts.len() {
         ats += cross(
@@ -27,7 +27,7 @@ fn gcd(mut a: Ll, mut b: Ll) -> Ll {
     a
 }
 
-fn boundary(pts: &Vec<Pll>) -> Ll {
+fn boundary(pts: &[Pll]) -> Ll {
     let mut ats = pts.len() as Ll;
     for i in 0..pts.len() {
         let deltax = pts[i].0 - pts[(i + 1) % pts.len()].0;
@@ -37,7 +37,7 @@ fn boundary(pts: &Vec<Pll>) -> Ll {
     ats
 }
 
-pub fn lattice_points(pts: &Vec<Pll>) -> Ll {
+pub fn lattice_points(pts: &[Pll]) -> Ll {
     let bounds = boundary(pts);
     let area = polygon_area(pts);
     area + 1 - bounds / 2

src/machine_learning/loss_function/mae_loss.rs

@@ -13,7 +13,7 @@
 //! It returns the average loss by dividing the `total_loss` by total no. of
 //! elements.
 //!
-pub fn mae_loss(predicted: &Vec<f64>, actual: &[f64]) -> f64 {
+pub fn mae_loss(predicted: &[f64], actual: &[f64]) -> f64 {
     let mut total_loss: f64 = 0.0;
     for (p, a) in predicted.iter().zip(actual.iter()) {
         let diff: f64 = p - a;

src/machine_learning/loss_function/mse_loss.rs

@@ -13,7 +13,7 @@
 //! It returns the average loss by dividing the `total_loss` by total no. of
 //! elements.
 //!
-pub fn mse_loss(predicted: &Vec<f64>, actual: &[f64]) -> f64 {
+pub fn mse_loss(predicted: &[f64], actual: &[f64]) -> f64 {
     let mut total_loss: f64 = 0.0;
     for (p, a) in predicted.iter().zip(actual.iter()) {
         let diff: f64 = p - a;

src/machine_learning/optimization/adam.rs

@@ -64,7 +64,7 @@ impl Adam {
         }
     }
 
-    pub fn step(&mut self, gradients: &Vec<f64>) -> Vec<f64> {
+    pub fn step(&mut self, gradients: &[f64]) -> Vec<f64> {
         let mut model_params = vec![0.0; gradients.len()];
         self.t += 1;
 

src/math/area_of_polygon.rs

@@ -25,7 +25,7 @@ pub struct Point {
  * @return The area of the polygon.
  */
 
-pub fn area_of_polygon(fig: &Vec<Point>) -> f64 {
+pub fn area_of_polygon(fig: &[Point]) -> f64 {
     let mut res = 0.0;
 
     for i in 0..fig.len() {

src/searching/moore_voting.rs

@@ -41,7 +41,7 @@
 
 */
 
-pub fn moore_voting(arr: &Vec<i32>) -> i32 {
+pub fn moore_voting(arr: &[i32]) -> i32 {
     let n = arr.len();
     let mut cnt = 0; // initializing cnt
     let mut ele = 0; // initializing ele

src/searching/saddleback_search.rs

@@ -4,7 +4,7 @@
 // element with the target element.
 use std::cmp::Ordering;
 
-pub fn saddleback_search(matrix: &Vec<Vec<i32>>, element: i32) -> (usize, usize) {
+pub fn saddleback_search(matrix: &[Vec<i32>], element: i32) -> (usize, usize) {
     // Initialize left and right indices
     let mut left_index = 0;
     let mut right_index = matrix[0].len() - 1;

src/string/aho_corasick.rs

@@ -65,7 +65,7 @@ impl AhoCorasick {
         let mut ans = vec![];
         let mut cur = Rc::clone(&self.root);
         let mut position: usize = 0;
-        for (_, c) in s.chars().enumerate() {
+        for c in s.chars() {
             loop {
                 if let Some(child) = Rc::clone(&cur).borrow().trans.get(&c) {
                     cur = Rc::clone(child);