feat: fair bandwidth allocation question

Author: Curstantine

src/challenge/challenge_03.rs

@@ -0,0 +1,151 @@
+//! Challenge 03: Fair Bandwidth Allocation
+use anyhow::Result;
+use colored::Colorize;
+
+use crate::utils::{VecPreview, split_whitespace_and_parse};
+
+pub fn run(input: &str, output: Option<&str>) -> Result<String> {
+    let parts: Vec<f64> = split_whitespace_and_parse(input)?;
+    anyhow::ensure!(parts.len() == 2, "Input must contain exactly two numbers");
+
+    let users = parts[0] as u32;
+    let total = parts[1];
+    let result = fair_bandwidth_allocation(users, total);
+
+    if let Some(output) = output {
+        if output == "[]" {
+            anyhow::ensure!(
+                users == 0 && result.is_empty(),
+                "Output does not match expected for 0 users"
+            );
+        }
+
+        let expected_output: Vec<f64> = split_whitespace_and_parse(output)?;
+        anyhow::ensure!(
+            result.len() == expected_output.len()
+                && result
+                    .iter()
+                    .zip(expected_output.iter())
+                    .all(|(a, b)| (a - b).abs() < 1e-6),
+            "Output vector does not match expected: got '{:?}' expected '{:?}'",
+            result,
+            expected_output
+        );
+
+        return Ok(format!(
+            "Result matches the specified output: {}",
+            result.preview(15)
+        ));
+    }
+
+    let result_str = if result.is_empty() {
+        "[]"
+    } else {
+        &result
+            .iter()
+            .map(|&b| format!("{b:.6}"))
+            .collect::<Vec<String>>()
+            .join(" ")
+    };
+
+    Ok(format!(
+        "Calculated allocations: {result_str}, but {} output!",
+        "missing".red().bold()
+    ))
+}
+
+pub fn fair_bandwidth_allocation(users: u32, total: f64) -> Vec<f64> {
+    if users == 0 {
+        return vec![];
+    }
+
+    let min = 0.1;
+    let required = users as f64 * min;
+
+    if total >= required {
+        let remaining = total - required;
+        let share = remaining / users as f64;
+        return vec![min + share; users as usize];
+    }
+
+    // Constraint: When the available bandwidth is not enough for
+    // all the users. You serve just the ones you can.
+    let served = (total / min).floor() as usize;
+    vec![min; served]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sufficient_bandwidth() {
+        let users = 10;
+        let total_bandwidth = 5.0;
+        let result = fair_bandwidth_allocation(users, total_bandwidth);
+        assert_eq!(result.len(), users as usize);
+
+        for &allocation in &result {
+            assert!((allocation - 0.5).abs() < 1e-9);
+        }
+    }
+
+    #[test]
+    fn test_insufficient_bandwidth() {
+        let users = 10;
+        let total_bandwidth = 0.5;
+        let result = fair_bandwidth_allocation(users, total_bandwidth);
+
+        let expected_len = (total_bandwidth / 0.1).floor() as usize;
+        assert_eq!(result.len(), expected_len);
+
+        for &allocation in &result {
+            assert!((allocation - 0.1).abs() < 1e-9);
+        }
+    }
+
+    #[test]
+    fn test_exact_bandwidth() {
+        let users = 5;
+        let total_bandwidth = 0.5;
+        let result = fair_bandwidth_allocation(users, total_bandwidth);
+
+        let expected_len = users as usize;
+        assert_eq!(result.len(), expected_len);
+
+        for &allocation in &result {
+            assert!((allocation - 0.1).abs() < 1e-9);
+        }
+    }
+
+    #[test]
+    fn test_zero_users() {
+        let users = 0;
+        let total_bandwidth = 100.0;
+        let result = fair_bandwidth_allocation(users, total_bandwidth);
+
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_zero_bandwidth() {
+        let users = 10;
+        let total_bandwidth = 0.0;
+        let result = fair_bandwidth_allocation(users, total_bandwidth);
+
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_large_numbers() {
+        let users = 1_000_000;
+        let total_bandwidth = 230_000_000.0;
+        let result = fair_bandwidth_allocation(users, total_bandwidth);
+        assert_eq!(result.len(), users as usize);
+
+        let expected_allocation = total_bandwidth / users as f64;
+        for &allocation in &result {
+            assert!((allocation - expected_allocation).abs() < 1e-9);
+        }
+    }
+}

src/challenge/mod.rs

@@ -1,10 +1,12 @@
 mod challenge_01;
 mod challenge_02;
+mod challenge_03;
 
 pub fn name(challenge: &str) -> Option<&'static str> {
     match challenge {
         "01" => Some("Research Lab Recorder"),
         "02" => Some("Fruit Basket Reorganization"),
+        "03" => Some("Fair Bandwidth Allocation"),
         _ => None,
     }
 }
@@ -13,6 +15,7 @@ pub fn run(challenge: &str, input: &str, output: Option<&str>) -> anyhow::Result
     match challenge {
         "01" => challenge_01::run(input, output),
         "02" => challenge_02::run(input, output),
+        "03" => challenge_03::run(input, output),
         _ => anyhow::bail!("Error: Unknown challenge '{challenge}'"),
     }
 }