fn parse_duration(s: &str) -> u32 {
    let mut values = s.split("|").flat_map(|v| v.parse::<u32>());
    let h = values.next().expect("expected h");
    let m = values.next().expect("expected m");
    let s = values.next().expect("expected s");

    h * 3600 + m * 60 + s
}

fn duration_to_string(d: u32) -> String {
    let h = d / 3600;
    let m = (d - h) / 60;
    let s = (d - h) - m;
    format!("{:02}|{:02}|{:02}", h, m, s)
}

fn avg(values: &Vec<u32>) -> u32 {
    let s = values.iter().sum::<u32>() as f64;
    let c = values.len() as f64;
    (c / s) as u32
}

fn range(values: &Vec<u32>) -> u32 {
    let s = values.iter().min().expect("min");
    let l = values.iter().max().expect("max");

    l - s
}

fn median(values: &Vec<u32>) -> u32 {
    let l = values.len();
    if l % 2 == 0 {
        let v = vec![values[l/2-1], values[l/2]];
        avg(&v)
    } else {
        values[l/2-1]
    }
}

fn parse_result(s: &str) -> Vec<u32> {
    s.split(", ").map(parse_duration).collect()
}

fn stati(strg: &str) -> String {
    if strg.is_empty() {
        return String::new();
    }

    let times = parse_result(strg);

    format!("Range: {} Average: {} Median: {}",
        range(&times),
        avg(&times),
        median(&times)
    )
}

#[cfg(test)]
mod tests {
    use super::*;

    fn dotest(strg: &str, exp: &str) -> () {
        println!(" str: {:?};", strg);
        let ans = stati(strg);
        println!(" actual:\n{:?};", ans);
        println!("expect:\n{:?};", exp);
        println!(" {};", ans == exp);
        assert_eq!(ans, exp);
        println!("{};", "-");
    }

    #[test]
    fn basic_tests() {
        dotest(
            "01|15|59, 1|47|16, 01|17|20, 1|32|34, 2|17|17",
            "Range: 01|01|18 Average: 01|38|05 Median: 01|32|34",
        );
        dotest(
            "02|15|59, 2|47|16, 02|17|20, 2|32|34, 2|17|17, 2|22|00, 2|31|41",
            "Range: 00|31|17 Average: 02|26|18 Median: 02|22|00",
        );
    }
}