Säähavainnot

use std::{
    io::{self, BufRead},
    iter,
};
 
const DAY_COUNT: usize = 6;
const PREDICTION_STRENGTH: f64 = 0.6;
 
fn main() {
    let reader = io::stdin().lock();
    let predictions = predict(reader);
    print_predictions(predictions);
}
 
fn predict<T>(mut reader: T) -> Vec<Vec<Option<f64>>>
where
    T: BufRead,
{
    let mut input = String::new();
    reader.read_line(&mut input).unwrap();
 
    let _n: i32 = input
        .trim()
        .parse()
        .expect("first line of input should be the number of days");
 
    let days = get_temperatures(reader);
    let diffs = calculate_average_diffs(&days);
    dbg!(&diffs);
 
    days.iter().map(|day| predict_day(day, &diffs)).collect()
}
 
fn get_temperatures<T>(reader: T) -> Vec<Vec<f64>>
where
    T: BufRead,
{
    reader
        .lines()
        .map(|line| {
            line.unwrap()
                .split_whitespace()
                .map(|x| x.parse::<f64>().unwrap())
                .collect()
        })
        .collect()
}
 
fn calculate_average_diffs(days: &Vec<Vec<f64>>) -> Vec<f64> {
    let n = days.len();
    let mut diffs = vec![0.0; 12];
    for day in days {
        diffs
            .iter_mut()
            .zip(day.iter())
            .for_each(|(diff, temp)| *diff += temp);
    }
    let avg: f64 = days
        .iter()
        .map(|day| day.iter().skip(23).next().unwrap())
        .sum();
    diffs
        .iter_mut()
        .for_each(|diff| *diff = (*diff - avg) / n as f64);
    diffs
}
 
fn predict_day(day: &Vec<f64>, diffs: &Vec<f64>) -> Vec<Option<f64>> {
    let base = day.iter().skip(23).next().unwrap();
 
    diffs
        .iter()
        .map(|diff| Some(base + PREDICTION_STRENGTH * diff))
        .take(DAY_COUNT)
        .chain(iter::repeat(None))
        .take(12)
        .collect()
}
 
fn print_predictions(predictions: Vec<Vec<Option<f64>>>) {
    for prediction in predictions {
        println!(
            "{}",
            prediction
                .iter()
                .map(|x| match x {
                    Some(t) => t.to_string(),
                    None => String::from("?"),
                })
                .collect::<Vec<String>>()
                .join(" ")
        );
    }
}
 
#[cfg(test)]
mod tests {
    use super::*;
    use std::{fs::File, io::BufReader};
 
    #[test]
    fn example_input() {
        let file =
            File::open("in.txt").expect("there should be an example input file named `in.txt`");
        let reader = BufReader::new(file);
        let predictions = predict(reader);
        print_predictions(predictions);
    }
 
    #[test]
    fn test_data_set() {
        const DATA_FILE_NAME: &str = "data.txt";
 
        let file = File::open(DATA_FILE_NAME)
            .unwrap_or_else(|_| panic!("expected to find file `{}`", DATA_FILE_NAME));
        let reader = BufReader::new(file);
        let predictions = predict(reader);
 
        let file = File::open(DATA_FILE_NAME)
            .unwrap_or_else(|_| panic!("expected to find file `{}`", DATA_FILE_NAME));
        let reader = BufReader::new(file);
        let measurements = get_measurements(reader);
 
        let score = calculate_score(predictions, measurements);
        println!("Score: {}", score);
    }
 
    fn get_measurements(reader: BufReader<File>) -> Vec<Vec<f64>> {
        reader
            .lines()
            .map(|line| {
                line.unwrap()
                    .split_whitespace()
                    .map(|x| x.parse().unwrap())
                    .skip(24)
                    .collect()
            })
            .collect()
    }
 
    fn calculate_score(predictions: Vec<Vec<Option<f64>>>, measurements: Vec<Vec<f64>>) -> f64 {
        let n = predictions.len();
        let a: f64 = predictions
            .iter()
            .flatten()
            .zip(measurements.iter().flatten())
            .map(|x| {
                f64::from(match x {
                    (Some(p), m) => (p - m).abs() < 0.75,
                    (None, _) => false,
                })
            })
            .sum();
        let b: f64 = predictions
            .iter()
            .flatten()
            .zip(measurements.iter().flatten())
            .map(|x| {
                f64::from(match x {
                    (Some(p), m) => (p - m).abs() >= 2.05,
                    (None, _) => false,
                })
            })
            .sum();
        25.0 * (a - b) / n as f64
    }
}

Test 1

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.11330000000000563,
    0.1026999999999989,
    -0.0535...

Test 2

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.3182000000000062,
    0.32030000000000564,
    0.11010...

Test 3

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.11960000000001036,
    0.10040000000000691,
    -0.056...

Test 4

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.28929999999999384,
    0.23950000000000726,
    0.0611...

Test 5

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.2491999999999889,
    0.20329999999999837,
    0.01739...

Test 6

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.07039999999999418,
    0.07540000000000237,
    -0.098...

Test 7

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.14089999999998326,
    0.04540000000000236,
    -0.082...

Test 8

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.17110000000000672,
    0.14219999999999344,
    -0.052...