結果
問題 | No.3059 tan |
ユーザー | くれちー |
提出日時 | 2020-04-01 22:15:44 |
言語 | Rust (1.77.0 + proconio) |
結果 |
CE
(最新)
AC
(最初)
|
実行時間 | - |
コード長 | 12,988 bytes |
コンパイル時間 | 13,265 ms |
コンパイル使用メモリ | 381,928 KB |
最終ジャッジ日時 | 2024-11-14 22:16:27 |
合計ジャッジ時間 | 13,924 ms |
ジャッジサーバーID (参考情報) |
judge3 / judge2 |
(要ログイン)
コンパイルエラー時のメッセージ・ソースコードは、提出者また管理者しか表示できないようにしております。(リジャッジ後のコンパイルエラーは公開されます)
ただし、clay言語の場合は開発者のデバッグのため、公開されます。
ただし、clay言語の場合は開発者のデバッグのため、公開されます。
コンパイルメッセージ
error[E0433]: failed to resolve: use of undeclared crate or module `spella` --> src/main.rs:402:11 | 402 | pub use spella::byte::{ByteChar, ByteStr, ByteString}; | ^^^^^^ use of undeclared crate or module `spella` error[E0433]: failed to resolve: use of undeclared crate or module `spella` --> src/main.rs:32:11 | 32 | use spella::byte::{ByteChar, ByteString}; | ^^^^^^ use of undeclared crate or module `spella` error[E0433]: failed to resolve: use of undeclared crate or module `spella` --> src/main.rs:128:11 | 128 | use spella::byte::{ByteChar, ByteStr}; | ^^^^^^ use of undeclared crate or module `spella` error[E0433]: failed to resolve: use of undeclared crate or module `spella` --> src/main.rs:197:11 | 197 | use spella::byte::{ByteChar, ByteStr, ByteString}; | ^^^^^^ use of undeclared crate or module `spella` error[E0433]: failed to resolve: use of undeclared crate or module `spella` --> src/main.rs:336:11 | 336 | use spella::byte::{ByteStr, FromByteStr}; | ^^^^^^ use of undeclared crate or module `spella` warning: unused import: `std::collections::*` --> src/main.rs:403:11 | 403 | pub use std::collections::*; | ^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` on by default warning: unused import: `std::iter::FromIterator` --> src/main.rs:405:11 | 405 | pub use std::iter::FromIterator; | ^^^^^^^^^^^^^^^^^^^^^^^ warning: unused import: `std::marker::PhantomData` --> src/main.rs:406:11 | 406 | pub use std::marker::PhantomData; | ^^^^^^^^^^^^^^^^^^^^^^^^ warning: unused import: `std::num::Wrapping` --> src/main.rs:407:11 | 407 | pub use std::num::Wrapping; | ^^^^^^^^^^^^^^^^^^ warning: unused imports: `RangeFrom`, `RangeTo`, `Range` --> src/main.rs:408:22 | 408 | pub use std::ops::{Range, RangeFrom, RangeTo}; |
ソースコード
// The main code is at the very bottom. #[allow(unused_imports)] #[macro_use] pub mod spella { pub mod byte { pub use self::byte_char::*; pub use self::byte_str::*; pub use self::byte_string::*; pub use self::from_byte_str::*; mod byte_char { use std::fmt::{self, Debug, Display, Formatter}; #[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ByteChar(pub u8); impl Debug for ByteChar { fn fmt(&self, f: &mut Formatter) -> fmt::Result { write!(f, "b'{}'", self.0 as char) } } impl Display for ByteChar { fn fmt(&self, f: &mut Formatter) -> fmt::Result { write!(f, "{}", self.0 as char) } } } mod byte_str { use spella::byte::{ByteChar, ByteString}; use std::fmt::{self, Debug, Display, Formatter}; use std::ops::{Deref, DerefMut}; #[derive(PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ByteStr([ByteChar]); macro_rules! cast { (mut $x:expr, $($T:ty)=>*) => { unsafe { &mut *($x $(as *mut $T)*) } }; ($x:expr, $($T:ty)=>*) => { unsafe { &*($x $(as *const $T)*) } }; } impl ByteStr { pub fn from_bytes(s: &[u8]) -> &Self { cast!(s, [u8] => [ByteChar] => ByteStr) } pub fn from_bytes_mut(s: &mut [u8]) -> &mut Self { cast!(mut s, [u8] => [ByteChar] => ByteStr) } pub fn from_byte_chars(s: &[ByteChar]) -> &Self { cast!(s, [ByteChar] => ByteStr) } pub fn from_byte_chars_mut(s: &mut [ByteChar]) -> &mut Self { cast!(mut s, [ByteChar] => ByteStr) } pub fn as_byte_chars(&self) -> &[ByteChar] { &self.0 } pub fn as_byte_chars_mut(&mut self) -> &mut [ByteChar] { &mut self.0 } pub fn as_bytes(&self) -> &[u8] { cast!(self, ByteStr => [ByteChar] => [u8]) } pub fn as_bytes_mut(&mut self) -> &mut [u8] { cast!(mut self, ByteStr => [ByteChar] => [u8]) } } impl ToOwned for ByteStr { type Owned = ByteString; fn to_owned(&self) -> ByteString { ByteString::from(self.0.to_owned()) } } impl Debug for ByteStr { fn fmt(&self, f: &mut Formatter) -> fmt::Result { write!(f, "b\"")?; for &c in &self.0 { write!(f, "{}", c)?; } write!(f, "\"") } } impl Display for ByteStr { fn fmt(&self, f: &mut Formatter) -> fmt::Result { for &c in &self.0 { write!(f, "{}", c)?; } Ok(()) } } impl Deref for ByteStr { type Target = [ByteChar]; fn deref(&self) -> &[ByteChar] { self.as_byte_chars() } } impl DerefMut for ByteStr { fn deref_mut(&mut self) -> &mut [ByteChar] { self.as_byte_chars_mut() } } } mod byte_string { use spella::byte::{ByteChar, ByteStr}; use std::borrow::{Borrow, BorrowMut}; use std::fmt::{self, Debug, Display, Formatter}; use std::ops::{Deref, DerefMut}; #[derive(Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ByteString(Vec<ByteChar>); impl ByteString { pub fn into_byte_chars(self) -> Vec<ByteChar> { self.0 } pub fn as_byte_str(&self) -> &ByteStr { ByteStr::from_byte_chars(&self.0) } pub fn as_mut_byte_str(&mut self) -> &mut ByteStr { ByteStr::from_byte_chars_mut(&mut self.0) } } impl From<Vec<ByteChar>> for ByteString { fn from(s: Vec<ByteChar>) -> ByteString { ByteString(s) } } impl Borrow<ByteStr> for ByteString { fn borrow(&self) -> &ByteStr { self.as_byte_str() } } impl BorrowMut<ByteStr> for ByteString { fn borrow_mut(&mut self) -> &mut ByteStr { self.as_mut_byte_str() } } impl Debug for ByteString { fn fmt(&self, f: &mut Formatter) -> fmt::Result { Debug::fmt(self.as_byte_str(), f) } } impl Display for ByteString { fn fmt(&self, f: &mut Formatter) -> fmt::Result { Display::fmt(self.as_byte_str(), f) } } impl Deref for ByteString { type Target = ByteStr; fn deref(&self) -> &ByteStr { ByteStr::from_byte_chars(&self.0) } } impl DerefMut for ByteString { fn deref_mut(&mut self) -> &mut ByteStr { ByteStr::from_byte_chars_mut(&mut self.0) } } } mod from_byte_str { use spella::byte::{ByteChar, ByteStr, ByteString}; use std::error::Error; use std::fmt::{self, Debug, Display, Formatter}; use std::str::{self, FromStr, Utf8Error}; pub trait FromByteStr: Sized { type Err; fn from_byte_str(s: &ByteStr) -> Result<Self, Self::Err>; } macro_rules! fn_description { () => { fn description(&self) -> &str { "description() is deprecated; use Display" } }; } #[derive(Debug)] pub struct ParseByteCharError(ParseByteCharErrorKind); #[derive(Debug)] enum ParseByteCharErrorKind { EmptyByteStr, TooManyByteChars, } impl Display for ParseByteCharError { fn fmt(&self, f: &mut Formatter) -> fmt::Result { use self::ParseByteCharErrorKind::*; f.write_str(match self.0 { EmptyByteStr => "empty `ByteStr`", TooManyByteChars => "too many `ByteChar`s", }) } } impl Error for ParseByteCharError { fn_description! {} } impl FromByteStr for ByteChar { type Err = ParseByteCharError; fn from_byte_str(s: &ByteStr) -> Result<Self, Self::Err> { use self::ParseByteCharErrorKind::*; match s.len() { 1 => Ok(unsafe { *s.get_unchecked(0) }), 0 => Err(ParseByteCharError(EmptyByteStr)), _ => Err(ParseByteCharError(TooManyByteChars)), } } } #[derive(Debug)] pub enum ParseByteStringError {} impl Display for ParseByteStringError { fn fmt(&self, _: &mut Formatter) -> fmt::Result { match *self {} } } impl Error for ParseByteStringError { fn_description! {} } impl FromByteStr for ByteString { type Err = ParseByteStringError; fn from_byte_str(s: &ByteStr) -> Result<Self, Self::Err> { Ok(ByteString::from(s.to_vec())) } } pub struct ParseFromStrError<T: FromStr>(ParseFromStrErrorKind<T>); enum ParseFromStrErrorKind<T: FromStr> { Utf8Error(Utf8Error), FromStrError(T::Err), } impl<T: FromStr> Debug for ParseFromStrError<T> where T::Err: Debug, { fn fmt(&self, f: &mut Formatter) -> fmt::Result { use self::ParseFromStrErrorKind::*; match self.0 { Utf8Error(ref err) => f.debug_tuple("Utf8Error").field(err).finish(), FromStrError(ref err) => f.debug_tuple("FromStrError").field(err).finish(), } } } impl<T: FromStr> Display for ParseFromStrError<T> where T::Err: Display, { fn fmt(&self, f: &mut Formatter) -> fmt::Result { use self::ParseFromStrErrorKind::*; match self.0 { Utf8Error(ref err) => write!(f, "{}", err), FromStrError(ref err) => write!(f, "{}", err), } } } impl<T: FromStr> Error for ParseFromStrError<T> where T::Err: Debug + Display, { fn_description! {} } impl<T: FromStr> FromByteStr for T { type Err = ParseFromStrError<T>; fn from_byte_str(s: &ByteStr) -> Result<T, Self::Err> { use self::ParseFromStrErrorKind::*; str::from_utf8(s.as_bytes()) .map_err(|e| ParseFromStrError(Utf8Error(e))) .and_then(|s| s.parse().map_err(|e| ParseFromStrError(FromStrError(e)))) } } } } pub mod io { pub use self::scanner::*; mod scanner { use spella::byte::{ByteStr, FromByteStr}; use std::io::{self, BufRead}; #[derive(Debug)] pub struct Scanner<R> { reader: R, buf: Vec<u8>, pos: usize, } const INITIAL_CAPACITY: usize = 32; impl<R: BufRead> Scanner<R> { pub fn new(reader: R) -> Self { Scanner { reader: reader, buf: Vec::with_capacity(INITIAL_CAPACITY), pos: 0, } } pub fn next<T: FromByteStr>(&mut self) -> io::Result<Result<T, T::Err>> { self.next_byte_str().map(T::from_byte_str) } pub fn next_byte_str(&mut self) -> io::Result<&ByteStr> { if self.buf.is_empty() { self.read_line()?; } loop { match self.buf.get(self.pos) { Some(&b' ') => self.pos += 1, Some(&b'\n') => self.read_line()?, Some(_) => break, None => return Err(io::Error::from(io::ErrorKind::UnexpectedEof)), } } let start = self.pos; self.pos += 1; loop { match self.buf.get(self.pos) { Some(&b' ') | Some(&b'\n') | None => break, Some(_) => self.pos += 1, } } Ok(ByteStr::from_bytes(&self.buf[start..self.pos])) } fn read_line(&mut self) -> io::Result<()> { self.buf.clear(); self.pos = 0; self.reader.read_until(b'\n', &mut self.buf)?; Ok(()) } } } } } mod prelude { pub use spella::byte::{ByteChar, ByteStr, ByteString}; pub use std::collections::*; pub use std::io::prelude::*; pub use std::iter::FromIterator; pub use std::marker::PhantomData; pub use std::num::Wrapping; pub use std::ops::{Range, RangeFrom, RangeTo}; pub use std::{cell, cmp, f64, i32, i64, isize, iter, mem, rc, str, time, u32, u64, usize}; } use prelude::*; const CUSTOM_STACK_SIZE_MEBIBYTES: Option<usize> = None; fn main() { fn exec_solver() { let stdin = std::io::stdin(); let stdout = std::io::stdout(); #[cfg(not(debug_assertions))] let mut writer = std::io::BufWriter::new(stdout.lock()); #[cfg(debug_assertions)] let mut writer = stdout.lock(); solve(stdin.lock(), &mut writer); writer.flush().unwrap(); } if let Some(stack_size_mebibytes) = CUSTOM_STACK_SIZE_MEBIBYTES { std::thread::Builder::new() .name("exec_solver".to_owned()) .stack_size(stack_size_mebibytes * 1024 * 1024) .spawn(exec_solver) .unwrap() .join() .unwrap(); } else { exec_solver(); } } fn solve<R: BufRead, W: Write>(reader: R, mut writer: W) { let mut _scanner = spella::io::Scanner::new(reader); #[allow(unused_macros)] macro_rules! scan { ($T:ty) => { _scanner.next::<$T>().unwrap().unwrap() }; ($($T:ty),+) => { ($(scan!($T)),+) }; ($($T:ty),+; $n:expr $(; $m:expr)*) => {{ (0..$n).map(|_| scan!($($T),+ $(; $m)*)).collect::<Vec<_>>() }}; } #[allow(unused_macros)] macro_rules! scan_iter { ($($T:ty),+; $n:expr) => { (0..$n).map(|_| scan!($($T),+)) }; } #[allow(unused_macros)] macro_rules! print { ($fmt:expr) => { write!(writer, $fmt).unwrap() }; ($fmt:expr, $($arg:tt)*) => { write!(writer, $fmt, $($arg)*).unwrap() }; } #[allow(unused_macros)] macro_rules! println { ($fmt:expr) => { writeln!(writer, $fmt).unwrap() }; ($fmt:expr, $($arg:tt)*) => { writeln!(writer, $fmt, $($arg)*).unwrap() }; } #[allow(unused_macros)] macro_rules! eprint { ($fmt:expr) => { #[cfg(debug_assertions)] write!(std::io::stderr(), $fmt).unwrap() }; ($fmt:expr, $($arg:tt)*) => { #[cfg(debug_assertions)] write!(std::io::stderr(), $fmt, $($arg)*).unwrap() }; } #[allow(unused_macros)] macro_rules! eprintln { ($fmt:expr) => { #[cfg(debug_assertions)] writeln!(std::io::stderr(), $fmt).unwrap() }; ($fmt:expr, $($arg:tt)*) => { #[cfg(debug_assertions)] writeln!(std::io::stderr(), $fmt, $($arg)*).unwrap() }; } #[allow(unused_macros)] macro_rules! dbg { ($($x:expr),+) => {{ eprintln!(concat!("[{}:{}] ", $(stringify!($x), " = {:?}; "),+), file!(), line!(), $($x),+); }}; } let t = scan!(usize); for _ in 0..t { let x = scan!(u32); println!("{}", if x == 0 || x == 45 { "Y" } else { "N" }); } }