結果

問題 No.1367 文字列門松
ユーザー StrorkisStrorkis
提出日時 2021-01-29 22:20:09
言語 Rust
(1.77.0 + proconio)
結果
CE  
(最新)
AC  
(最初)
実行時間 -
コード長 2,249 bytes
コンパイル時間 15,367 ms
コンパイル使用メモリ 393,208 KB
最終ジャッジ日時 2024-11-15 05:05:54
合計ジャッジ時間 16,205 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge2
このコードへのチャレンジ
（要ログイン）
コンパイルエラー時のメッセージ・ソースコードは、提出者また管理者しか表示できないようにしております。（リジャッジ後のコンパイルエラーは公開されます）
ただし、clay言語の場合は開発者のデバッグのため、公開されます。

コンパイルメッセージ
error: format argument must be a string literal
  --> src/main.rs:25:42
   |
25 |                         Err(e) => panic!(e), 
   |                                          ^
   |
help: you might be missing a string literal to format with
   |
25 |                         Err(e) => panic!("{}", e), 
   |                                          +++++

error: could not compile `main` (bin "main") due to 1 previous error

ソースコード

diff # 

mod my {
    #[macro_export]
    macro_rules! scan {
        ($r:expr, [$t:tt; $n:expr]) => (
            (0..$n).map(|_| scan!($r, $t)).collect::<Vec<_>>()
        );
        ($r:expr, ($($t:tt),*)) => (
            ($(scan!($r, $t)),*)
        );
        ($r:expr, $t:ty) => ({
            std::str::from_utf8(&scan($r)).unwrap().parse::<$t>().unwrap()
        });
    }

    pub mod io {
        use std::io::{BufRead, ErrorKind};

        pub fn scan<R: BufRead>(r: &mut R) -> Vec<u8> {
            let mut buf = Vec::new();
            loop {
                let (done, used) = {
                    let available = match r.fill_buf() {
                        Ok(n) => n,
                        Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
                        Err(e) => panic!(e), 
                    };
                    match available.iter().position(u8::is_ascii_whitespace) {
                        Some(i) => {
                            buf.extend_from_slice(&available[..i]);
                            (buf.len() > 0, i + 1)
                        }
                        None => {
                            buf.extend_from_slice(available);
                            (false, available.len())
                        }
                    }
                };
                r.consume(used);
                if done || used == 0 {
                    return buf;
                }
            }
        }
    }
}

use std::io::{BufRead, Write};
use my::io::scan;

fn run<R: BufRead, W: Write>(reader: &mut R, writer: &mut W) {
    const N: usize = 9;
    const KADOMATSU: [u8; N] = [b'k', b'a', b'd', b'o', b'm', b'a', b't', b's', b'u'];

    let s = scan(reader);

    for i in 1..(1 << N) {
        let mut t = Vec::new();
        for j in 0..N {
            if i >> j & 1 == 0 { continue; }
            t.push(KADOMATSU[j]);
        }
        if s == t {
            writeln!(writer, "Yes").ok();
            return;
        }
    }
    writeln!(writer, "No").ok();
}

fn main() {
    let (stdin, stdout) = (std::io::stdin(), std::io::stdout());
    let reader = &mut std::io::BufReader::new(stdin.lock());
    let writer = &mut std::io::BufWriter::new(stdout.lock());
    run(reader, writer);
}
0