feat: Added Implemention of Job Sequencing Problem with Deadlines (using Greedy Approach)

DIRECTORY.md

@@ -157,6 +157,7 @@
     * [Two Satisfiability](https://github.com/TheAlgorithms/Rust/blob/master/src/graph/two_satisfiability.rs)
   * Greedy
     * [Stable Matching](https://github.com/TheAlgorithms/Rust/blob/master/src/greedy/stable_matching.rs)
+    * [Job Sequencing](https://github.com/TheAlgorithms/Rust/blob/master/src/greedy/job_sequencing.rs)
   * [Lib](https://github.com/TheAlgorithms/Rust/blob/master/src/lib.rs)
   * Machine Learning
     * [Cholesky](https://github.com/TheAlgorithms/Rust/blob/master/src/machine_learning/cholesky.rs)

src/ciphers/aes.rs

@@ -318,7 +318,7 @@ fn key_expansion(init_key: &[Byte], num_rounds: usize) -> Vec<Byte> {
 }
 
 fn add_round_key(data: &mut [Byte], round_key: &[Byte]) {
-    assert!(data.len() % AES_BLOCK_SIZE == 0 && round_key.len() == AES_BLOCK_SIZE);
+    assert!(data.len().is_multiple_of(AES_BLOCK_SIZE) && round_key.len() == AES_BLOCK_SIZE);
     let num_blocks = data.len() / AES_BLOCK_SIZE;
     data.iter_mut()
         .zip(round_key.repeat(num_blocks))
@@ -348,7 +348,7 @@ fn mix_column_blocks(data: &mut [Byte], mode: AesMode) {
 }
 
 fn padding<T: Clone + Default>(data: &[T], block_size: usize) -> Vec<T> {
-    if data.len() % block_size == 0 {
+    if data.len().is_multiple_of(block_size) {
         Vec::from(data)
     } else {
         let num_blocks = data.len() / block_size + 1;

src/ciphers/blake2b.rs

@@ -55,7 +55,7 @@ fn add(a: &mut Word, b: Word) {
 
 #[inline]
 const fn ceil(dividend: usize, divisor: usize) -> usize {
-    (dividend / divisor) + ((dividend % divisor != 0) as usize)
+    (dividend / divisor) + (!(dividend.is_multiple_of(divisor)) as usize)
 }
 
 fn g(v: &mut [Word; 16], a: usize, b: usize, c: usize, d: usize, x: Word, y: Word) {

src/ciphers/diffie_hellman.rs

@@ -228,11 +228,8 @@ impl DiffieHellman {
     // Both parties now have the same shared secret key s which can be used for encryption or authentication.
 
     pub fn new(group: Option<u8>) -> Self {
-        let mut _group: u8 = 14;
-        if let Some(x) = group {
-            _group = x;
-        }
-
+        // made this idiomatic according to clippy's suggestions
+        let _group = group.unwrap_or(14);
         if !PRIMES.contains_key(&_group) {
             panic!("group not in primes")
         }

src/ciphers/sha3.rs

@@ -271,10 +271,11 @@ fn h2b(h: &[u8], n: usize) -> Vec<bool> {
 }
 
 fn b2h(s: &[bool]) -> Vec<u8> {
-    let m = if s.len() % U8BITS != 0 {
-        (s.len() / 8) + 1
-    } else {
+    // changed this function a bit to stop the clippy warnings
+    let m = if s.len().is_multiple_of(U8BITS) {
         s.len() / 8
+    } else {
+        (s.len() / 8) + 1
     };
     let mut bytes = vec![0u8; m];
 

src/data_structures/probabilistic/bloom_filter.rs

@@ -109,7 +109,8 @@ pub struct MultiBinaryBloomFilter {
 
 impl MultiBinaryBloomFilter {
     pub fn with_dimensions(filter_size: usize, hash_count: usize) -> Self {
-        let bytes_count = filter_size / 8 + usize::from(filter_size % 8 > 0); // we need 8 times less entries in the array, since we are using bytes. Careful that we have at least one element though
+        // changed the % operation to .is_multiple_of()
+        let bytes_count = filter_size / 8 + usize::from(!(filter_size.is_multiple_of(8))); // we need 8 times less entries in the array, since we are using bytes. Careful that we have at least one element though
         Self {
             filter_size,
             bytes: vec![0; bytes_count],

src/general/permutations/heap.rs

@@ -23,7 +23,8 @@ fn heap_recurse<T: Clone + Debug>(arr: &mut [T], k: usize, collector: &mut Vec<V
     // Heap's algorithm has a more clever way of permuting the elements so that we never need to swap back!
     for i in 0..k {
         // now deal with [a, b]
-        let swap_idx = if k % 2 == 0 { i } else { 0 };
+        // changed % operator to is_multiple_of()
+        let swap_idx = if k.is_multiple_of(2) { i } else { 0 };
         arr.swap(swap_idx, k - 1);
         heap_recurse(arr, k - 1, collector);
     }

src/greedy/job_sequencing.rs

@@ -0,0 +1,86 @@
+#[derive(Debug, Clone)]
+pub struct Job {
+    pub id: String,
+    pub deadline: usize,
+    pub profit: i32,
+}
+
+pub fn job_sequencing(mut jobs: Vec<Job>) -> (Vec<Job>, i32) {
+    if jobs.is_empty() {
+        return (Vec::new(), 0);
+    }
+
+    // Sort by profit (descending)
+    jobs.sort_by(|a, b| b.profit.cmp(&a.profit));
+
+    // Find the maximum deadline
+    let max_deadline = jobs.iter().map(|j| j.deadline).max().unwrap();
+
+    // Track time slots that are filled
+    let mut slots = vec![false; max_deadline];
+    let mut scheduled = Vec::new();
+    let mut total_profit = 0;
+
+    // Schedule each job in the latest available slot before its deadline is reached
+    for job in jobs {
+        for slot in (0..job.deadline.min(max_deadline)).rev() {
+            if !slots[slot] {
+                slots[slot] = true;
+                scheduled.push(job.clone());
+                total_profit += job.profit;
+                break;
+            }
+        }
+    }
+
+    (scheduled, total_profit)
+}
+
+// test algorithm
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_basic() {
+        let jobs = vec![
+            Job {
+                id: "J1".to_string(),
+                deadline: 2,
+                profit: 100,
+            },
+            Job {
+                id: "J2".to_string(),
+                deadline: 1,
+                profit: 19,
+            },
+            Job {
+                id: "J3".to_string(),
+                deadline: 2,
+                profit: 27,
+            },
+            Job {
+                id: "J4".to_string(),
+                deadline: 1,
+                profit: 25,
+            },
+            Job {
+                id: "J5".to_string(),
+                deadline: 3,
+                profit: 15,
+            },
+        ];
+
+        let (scheduled, profit) = job_sequencing(jobs);
+
+        assert_eq!(profit, 142);
+        assert_eq!(scheduled.len(), 3);
+    }
+
+    #[test]
+    fn test_empty() {
+        let (scheduled, profit) = job_sequencing(vec![]);
+        assert_eq!(profit, 0);
+        assert!(scheduled.is_empty());
+    }
+}

src/greedy/mod.rs

@@ -1,3 +1,5 @@
+mod job_sequencing;
 mod stable_matching;
 
+pub use self::job_sequencing::job_sequencing;
 pub use self::stable_matching::stable_matching;

src/machine_learning/loss_function/kl_divergence_loss.rs

@@ -16,7 +16,7 @@ pub fn kld_loss(actual: &[f64], predicted: &[f64]) -> f64 {
     let loss: f64 = actual
         .iter()
         .zip(predicted.iter())
-        .map(|(&a, &p)| ((a + eps) * ((a + eps) / (p + eps)).ln()))
+        .map(|(&a, &p)| (a + eps) * ((a + eps) / (p + eps)).ln())
         .sum();
     loss
 }

src/math/aliquot_sum.rs

@@ -10,8 +10,8 @@ pub fn aliquot_sum(number: u64) -> u64 {
     if number == 0 {
         panic!("Input has to be positive.")
     }
-
-    (1..=number / 2).filter(|&d| number % d == 0).sum()
+    // changed % operator to .is_multiple_of()
+    (1..=number / 2).filter(|&d| number.is_multiple_of(d)).sum()
 }
 
 #[cfg(test)]

src/math/collatz_sequence.rs

@@ -6,7 +6,7 @@ pub fn sequence(mut n: usize) -> Option<Vec<usize>> {
     let mut list: Vec<usize> = vec![];
     while n != 1 {
         list.push(n);
-        if n % 2 == 0 {
+        if n.is_multiple_of(2) {
             n /= 2;
         } else {
             n = 3 * n + 1;

src/math/factors.rs

@@ -7,7 +7,8 @@ pub fn factors(number: u64) -> Vec<u64> {
     let mut factors: Vec<u64> = Vec::new();
 
     for i in 1..=((number as f64).sqrt() as u64) {
-        if number % i == 0 {
+        // changed % operation to .is_multiple_of()
+        if number.is_multiple_of(i) {
             factors.push(i);
             if i != number / i {
                 factors.push(number / i);

src/math/interquartile_range.rs

@@ -12,7 +12,8 @@ pub fn find_median(numbers: &[f64]) -> f64 {
     let length = numbers.len();
     let mid = length / 2;
 
-    if length % 2 == 0 {
+    // changed % operation to .is_multiple_of()
+    if length.is_multiple_of(2) {
         f64::midpoint(numbers[mid - 1], numbers[mid])
     } else {
         numbers[mid]
@@ -29,7 +30,8 @@ pub fn interquartile_range(numbers: &[f64]) -> f64 {
 
     let length = numbers.len();
     let mid = length / 2;
-    let (q1, q3) = if length % 2 == 0 {
+    // changed % operation to is_multiple_of()
+    let (q1, q3) = if length.is_multiple_of(2) {
         let first_half = &numbers[0..mid];
         let second_half = &numbers[mid..length];
         (find_median(first_half), find_median(second_half))

src/math/perfect_numbers.rs

@@ -2,7 +2,8 @@ pub fn is_perfect_number(num: usize) -> bool {
     let mut sum = 0;
 
     for i in 1..num - 1 {
-        if num % i == 0 {
+        // changed % operation to is_multiple_of()
+        if num.is_multiple_of(i) {
             sum += i;
         }
     }

src/math/pollard_rho.rs

@@ -137,7 +137,8 @@ pub fn pollard_rho_get_one_factor(number: u64, seed: &mut u32, check_is_prime: b
 fn get_small_factors(mut number: u64, primes: &[usize]) -> (u64, Vec<u64>) {
     let mut result: Vec<u64> = Vec::new();
     for p in primes {
-        while (number % *p as u64) == 0 {
+        // changed % operation to is_multiple_of()
+        while number.is_multiple_of(*p as u64) {
             number /= *p as u64;
             result.push(*p as u64);
         }
@@ -201,7 +202,8 @@ mod test {
     use super::*;
 
     fn check_is_proper_factor(number: u64, factor: u64) -> bool {
-        factor > 1 && factor < number && ((number % factor) == 0)
+        // changed % operation to is_multiple_of()
+        factor > 1 && factor < number && (number.is_multiple_of(factor))
     }
 
     fn check_factorization(number: u64, factors: &[u64]) -> bool {

src/math/prime_check.rs

@@ -1,13 +1,15 @@
 pub fn prime_check(num: usize) -> bool {
     if (num > 1) & (num < 4) {
         return true;
-    } else if (num < 2) || (num % 2 == 0) {
+    // changed % operation to is_multiple_of()
+    } else if (num < 2) || (num.is_multiple_of(2)) {
         return false;
     }
 
     let stop: usize = (num as f64).sqrt() as usize + 1;
     for i in (3..stop).step_by(2) {
-        if num % i == 0 {
+        // changed % operation to is_multiple_of()
+        if num.is_multiple_of(i) {
             return false;
         }
     }

src/math/prime_factors.rs

@@ -5,14 +5,16 @@ pub fn prime_factors(n: u64) -> Vec<u64> {
     let mut n = n;
     let mut factors = Vec::new();
     while i * i <= n {
-        if n % i != 0 {
+        // changed % operation to is_multiple_of()
+        // changed function a bit to remove clippy warnings
+        if n.is_multiple_of(i) {
+            n /= i;
+            factors.push(i);
+        } else {
             if i != 2 {
                 i += 1;
             }
             i += 1;
-        } else {
-            n /= i;
-            factors.push(i);
         }
     }
     if n > 1 {

src/math/quadratic_residue.rs

@@ -78,7 +78,8 @@ fn is_residue(x: u64, modulus: u64) -> bool {
 ///
 /// <https://en.wikipedia.org/wiki/Legendre_symbol>
 pub fn legendre_symbol(a: u64, odd_prime: u64) -> i64 {
-    debug_assert!(odd_prime % 2 != 0, "prime must be odd");
+    // changed % operation to is_multiple_of()
+    debug_assert!(!(odd_prime.is_multiple_of(2)), "prime must be odd");
     if a == 0 {
         0
     } else if is_residue(a, odd_prime) {

src/number_theory/euler_totient.rs

@@ -6,10 +6,12 @@ pub fn euler_totient(n: u64) -> u64 {
     // Find  all prime factors and apply formula
     while p * p <= num {
         // Check if p is a divisor of n
-        if num % p == 0 {
+        // Changed % operation to is_multiple_of()
+        if num.is_multiple_of(p) {
             // If yes, then it is a prime factor
             // Apply the formula: result = result * (1 - 1/p)
-            while num % p == 0 {
+            // Changed % operation to is_multiple_of()
+            while num.is_multiple_of(p) {
                 num /= p;
             }
             result -= result / p;