Säähavainnot

use std::{
    io::{self, BufRead},
    iter,
};
 
const DAY_COUNT: usize = 6;
const PREDICTION_STRENGTH: f64 = 0.7;
 
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);
    vec![
        0.1609500000000253,
        0.13702500000002782,
        -0.02551249999999527,
        -0.3116000000000022,
        -0.6884124999999858,
        -1.142699999999956,
        -1.6627625000000026,
        -2.1764374999999965,
        -2.624075000000008,
        -2.9596124999999893,
        -3.2226249999999954,
        -3.4357250000000024,
    ]
}
 
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.1609500000000253,
    0.13702500000002782,
    -0.0255...

Test 2

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.1609500000000253,
    0.13702500000002782,
    -0.0255...

Test 3

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.1609500000000253,
    0.13702500000002782,
    -0.0255...

Test 4

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.1609500000000253,
    0.13702500000002782,
    -0.0255...

Test 5

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.1609500000000253,
    0.13702500000002782,
    -0.0255...

Test 6

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.1609500000000253,
    0.13702500000002782,
    -0.0255...

Test 7

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.1609500000000253,
    0.13702500000002782,
    -0.0255...

Test 8

Verdict: ACCEPTED

[input/code.rs:29] &diffs = [
    0.1609500000000253,
    0.13702500000002782,
    -0.0255...