Submission #1642510
Source Code Expand
///////////////////////////////////////////// Template /////////////////////////////////////////////
#![allow(non_snake_case, unused)]
use std::io::Write;
use std::collections::*;
macro_rules! debug {
($($v: expr),*) => {
$(let _ = write!(::std::io::stderr(), "{} = {:?} ", stringify!($v), $v);)*
let _ = writeln!(::std::io::stderr(), "@ {}:{}", file!(), line!());
}
}
macro_rules! mat {
($e:expr) => { $e };
($e:expr; $d:expr $(; $ds:expr)*) => { vec![mat![$e $(; $ds)*]; $d] };
}
macro_rules! ok {
($a:ident$([$i:expr])*.$f:ident()$(@$t:ident)*) => {
$a$([$i])*.$f($($t),*)
};
($a:ident$([$i:expr])*.$f:ident($e:expr$(,$es:expr)*)$(@$t:ident)*) => { {
let t = $e;
ok!($a$([$i])*.$f($($es),*)$(@$t)*@t)
} };
}
mod template {
type I<'a> = ::std::iter::Peekable<::std::str::SplitWhitespace<'a>>;
pub trait FromLn<'a> {
fn fromln(&mut I<'a>) -> Self;
}
pub fn readln<T: for<'a> FromLn<'a>>() -> T {
let mut buf = String::new();
let _ = ::std::io::stdin().read_line(&mut buf).unwrap_or_else(|e| panic!("{}", e));
let mut it = buf.split_whitespace().peekable();
let t = T::fromln(&mut it);
if it.peek().is_some() { panic!("input mismatch") }
t
}
pub fn readlns<T: for<'a> FromLn<'a>>(n: usize) -> Vec<T> {
(0..n).map(|_| readln()).collect()
}
macro_rules! read_primitives {
($($t:ty),*) => { $(
impl<'a> FromLn<'a> for $t {
fn fromln(it: &mut I<'a>) -> $t {
it.next().unwrap_or_else(|| panic!("input mismatch")).parse().unwrap_or_else(|e| panic!("{}", e))
}
}
)* }
}
read_primitives!(String, bool, f64, i32, i64, usize, u32, u64);
impl<'a, T> FromLn<'a> for Vec<T> where T: for<'b> FromLn<'b> {
fn fromln(it: &mut I) -> Vec<T> {
let mut vs = vec![];
while it.peek().is_some() {
vs.push(T::fromln(it));
}
vs
}
}
impl<'a> FromLn<'a> for Vec<char> {
fn fromln(it: &mut I) -> Vec<char> {
String::fromln(it).chars().collect()
}
}
impl<'a> FromLn<'a> for Vec<u8> {
fn fromln(it: &mut I) -> Vec<u8> {
String::fromln(it).into()
}
}
macro_rules! read_tuple {
($($t:ident),*) => {
impl<'a, $($t),*> FromLn<'a> for ($($t),*) where $($t: for<'b> FromLn<'b>),* {
fn fromln(it: &mut I) -> ($($t),*) {
($($t::fromln(it)),*)
}
}
}
}
read_tuple!(A, B);
read_tuple!(A, B, C);
read_tuple!(A, B, C, D);
pub trait SetMin {
fn setmin(&mut self, v: Self) -> bool;
}
impl<T> SetMin for T where T: PartialOrd {
fn setmin(&mut self, v: T) -> bool {
*self > v && { *self = v; true }
}
}
pub trait SetMax {
fn setmax(&mut self, v: Self) -> bool;
}
impl<T> SetMax for T where T: PartialOrd {
fn setmax(&mut self, v: T) -> bool {
*self < v && { *self = v; true }
}
}
}
use self::template::*;
pub fn main() {
let _ = writeln!(::std::io::stderr(), "----- {} -----", file!());
let _ = ::std::thread::Builder::new().name("run".to_string()).stack_size(32 * 1024 * 1024).spawn(run).unwrap().join();
}
////////////////////////////////////////////////////////////////////////////////////////////////////
fn run() {
let (N, A, B) = readln::<(usize, i32, i32)>();
let mut ans = 0;
for t in readlns(N) {
if t < A || B <= t {
ans += 1;
}
}
println!("{}", ans);
}
Submission Info
Submission Time |
|
Task |
A - A Barricade |
User |
wata |
Language |
Rust (1.15.1) |
Score |
66 |
Code Size |
3309 Byte |
Status |
AC |
Exec Time |
3 ms |
Memory |
8572 KB |
Judge Result
Set Name |
All |
Score / Max Score |
66 / 66 |
Status |
|
Set Name |
Test Cases |
All |
00_sample.txt, 01_sample.txt, 02_sampe.txt, 03_sample.txt, corner_case_03.txt, corner_case_04.txt, random_case_00.txt, random_case_01.txt, random_case_02.txt |
Case Name |
Status |
Exec Time |
Memory |
00_sample.txt |
AC |
3 ms |
8572 KB |
01_sample.txt |
AC |
3 ms |
8572 KB |
02_sampe.txt |
AC |
3 ms |
8572 KB |
03_sample.txt |
AC |
3 ms |
8572 KB |
corner_case_03.txt |
AC |
3 ms |
8572 KB |
corner_case_04.txt |
AC |
3 ms |
8572 KB |
random_case_00.txt |
AC |
3 ms |
8572 KB |
random_case_01.txt |
AC |
3 ms |
8572 KB |
random_case_02.txt |
AC |
3 ms |
8572 KB |