結果

問題 No.969 じゃんけん
ユーザー くれちーくれちー
提出日時 2020-01-17 21:21:21
言語 Rust
(1.83.0 + proconio)
結果
CE  
(最新)
AC  
(最初)
実行時間 -
コード長 12,992 bytes
コンパイル時間 11,670 ms
コンパイル使用メモリ 391,112 KB
最終ジャッジ日時 2024-11-14 22:02:57
合計ジャッジ時間 12,276 ms
ジャッジサーバーID
(参考情報)
judge5 / judge3
このコードへのチャレンジ
(要ログイン)
コンパイルエラー時のメッセージ・ソースコードは、提出者また管理者しか表示できないようにしております。(リジャッジ後のコンパイルエラーは公開されます)
ただし、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};
    |      

ソースコード

diff #
プレゼンテーションモードにする

// 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 x = scan!(u64);
let ans = if x == 0 * 2 || x == 2 * 2 || x == 5 * 2 {
"Yes"
} else {
"No"
};
println!("{}", ans);
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0