結果

問題 No.3171 Color Restoration
ユーザー sanket143
提出日時 2025-06-06 22:07:28
言語 Rust
(1.83.0 + proconio)
結果
WA  
実行時間 -
コード長 4,084 bytes
コンパイル時間 16,941 ms
コンパイル使用メモリ 398,304 KB
実行使用メモリ 7,848 KB
最終ジャッジ日時 2025-06-06 22:07:48
合計ジャッジ時間 18,731 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge4
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 23 WA * 3
権限があれば一括ダウンロードができます

ソースコード

diff # 

use std::collections::HashMap;
use std::fmt::Debug;
use std::io;
use std::str::FromStr;

struct Scanner<R, W>
where
    R: io::BufRead,
    W: io::Write,
{
    reader: R,
    writer: W,
    #[allow(dead_code)]
    buffer: Vec<String>,
}

impl<R: io::BufRead, W: io::Write> Scanner<R, W> {
    fn new(reader: R, writer: W) -> Self
    where
        R: io::BufRead,
        W: io::Write,
    {
        Self {
            reader,
            writer,
            buffer: Vec::new(),
        }
    }

    #[allow(dead_code)]
    fn next<T: std::str::FromStr>(&mut self) -> T {
        loop {
            if let Some(token) = self.buffer.pop() {
                return token.parse().ok().expect("Failed parse");
            }
            let mut input = String::new();
            self.reader.read_line(&mut input).expect("Failed read");
            self.buffer = input.split_whitespace().rev().map(String::from).collect();
        }
    }

    #[allow(dead_code)]
    fn next_vec<T: std::str::FromStr>(&mut self) -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut input = String::new();
        self.reader.read_line(&mut input).expect("Failed read");
        input
            .split_whitespace()
            .rev()
            .map(|x| x.parse::<T>().unwrap())
            .collect()
    }
}

fn solve<R: io::BufRead, W: io::Write>(scan: &mut Scanner<R, W>) {
    let mut records = HashMap::from([
        ("gray", vec![0, 1, 2]),
        ("brown", vec![0]),
        ("green", vec![0, 1, 2]),
        ("cyan", vec![0, 2]),
        ("blue", vec![0, 1, 2]),
        ("yellow", vec![0, 1]),
        ("orange", vec![0, 2]),
        ("red", vec![0, 1, 2]),
        ("violet", vec![2]),
    ]);

    let mut input = scan.next_vec::<String>();

    input.sort_by(|a, b| {
        records
            .get(a.as_str())
            .unwrap()
            .len()
            .cmp(&records.get(b.as_str()).unwrap().len())
    });

    let mut guesses = 0;

    for i in records.get(input[0].as_str()).unwrap().iter() {
        for j in records.get(input[1].as_str()).unwrap().iter() {
            for k in records.get(input[2].as_str()).unwrap().iter() {
                if i != j && j != k && i != k {
                    guesses += 1;
                }
            }
        }
    }

    input.dedup();

    if input.len() == 2 {
        let mut r = records.get_mut(input[1].as_str()).unwrap().to_owned();
        let rec = records.get_mut(input[0].as_str()).unwrap();

        rec.append(&mut r);
        rec.sort_by(|a, b| a.cmp(&b));
        rec.dedup();

        if rec.len() == 3 {
            writeln!(scan.writer, "Yes",).ok();
        } else {
            writeln!(scan.writer, "No").ok();
        }
    } else if guesses == 1 || input.len() == 1 {
        writeln!(scan.writer, "Yes",).ok();
    } else {
        writeln!(scan.writer, "No").ok();
    }
}

fn main() {
    let stdin = io::stdin();
    let stdout = &mut io::BufWriter::new(io::stdout());
    let mut scan = Scanner::new(stdin.lock(), stdout);

    solve(&mut scan);
}

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

    fn get_output(input: &[u8]) -> String {
        let stdout = Vec::new();

        let mut scan = Scanner::new(&input[..], stdout);
        solve(&mut scan);

        let output = String::from_utf8(scan.writer).expect("what?");
        let output = output.trim();

        output.to_string()
    }

    #[test]
    fn case_0() {
        let output = get_output(b"gray green blue");

        assert_eq!(output, "No".to_owned());
    }

    #[test]
    fn case_1() {
        let output = get_output(b"violet red orange");

        assert_eq!(output, "Yes".to_owned());
    }

    #[test]
    fn case_2() {
        let output = get_output(b"red red red");

        assert_eq!(output, "Yes".to_owned());
    }

    #[test]
    fn case_3() {
        let output = get_output(b"brown gray gray");

        assert_eq!(output, "Yes".to_owned());
    }

    #[test]
    fn case_4() {
        let output = get_output(b"cyan cyan brown");

        assert_eq!(output, "No".to_owned());
    }
}
0