結果
問題 | No.713 素数の和 |
ユーザー | くれちー |
提出日時 | 2018-07-13 22:25:57 |
言語 | Rust (1.77.0 + proconio) |
結果 |
AC
|
実行時間 | 1 ms / 2,000 ms |
コード長 | 6,035 bytes |
コンパイル時間 | 14,196 ms |
コンパイル使用メモリ | 400,708 KB |
実行使用メモリ | 6,820 KB |
最終ジャッジ日時 | 2024-10-09 05:15:52 |
合計ジャッジ時間 | 13,351 ms |
ジャッジサーバーID (参考情報) |
judge5 / judge1 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 1 ms
6,820 KB |
testcase_01 | AC | 1 ms
6,816 KB |
testcase_02 | AC | 1 ms
6,820 KB |
testcase_03 | AC | 1 ms
6,820 KB |
testcase_04 | AC | 1 ms
6,816 KB |
testcase_05 | AC | 1 ms
6,816 KB |
testcase_06 | AC | 1 ms
6,820 KB |
testcase_07 | AC | 1 ms
6,816 KB |
testcase_08 | AC | 1 ms
6,820 KB |
ソースコード
fn solve<R: BufRead, W: Write>(_reader: R, _writer: &mut W) { let mut _scanner = Scanner::new(_reader); #[allow(unused_macros)] macro_rules! scan { ($t:ty) => { _scanner.next::<$t>().unwrap() }; ($($t:ty),+) => { ($(scan!($t)),+) }; ($t:ty; $n:expr $(; $m:expr)*) => {{ let mut vec = Vec::with_capacity($n); for _ in 0..$n { vec.push(scan!($t $(; $m)*)); } vec }}; ($t_0:ty, $t_1:ty; $n:expr) => { scan!($t_0 = 0, $t_1 = 1; $n) }; ($t_0:ty, $t_1:ty, $t_2:ty; $n:expr) => { scan!($t_0 = 0, $t_1 = 1, $t_2 = 2; $n) }; ($($t:ty = $i:tt),+; $n:expr) => {{ let mut vecs = ($(Vec::<$t>::with_capacity($n)),+); for _ in 0..$n {$( vecs.$i.push(scan!($t)); )+} vecs }}; } #[allow(unused_macros)] macro_rules! scan_iter { ($t:ty; $n:expr) => { _scanner.take::<$t>($n).map(|x| x.unwrap()) }; } #[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 { () => { writeln!(_writer).unwrap() }; ($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 { () => { #[cfg(debug_assertions)] writeln!(::std::io::stderr()).unwrap() }; ($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! dump { ($($x:expr),+) => { eprint!("[{}:{}] ", file!(), line!()); eprintln!(concat!($(stringify!($x), " = {:?}; "),+), $($x),+); }; } fn is_prime(x: u64) -> bool { if x == 1 { return false; } let mut t = 2; while t * t <= x { if x % t == 0 { return false; } t += 1; } true } let n = scan!(u64); let ans: u64 = (1..n + 1).filter(|&i| is_prime(i)).sum(); println!("{}", ans); } const STACK_SIZE_MEBIBYTES: Option<usize> = None; fn main() { fn run_solver() { let stdin = stdin(); let stdout = stdout(); #[cfg(debug_assertions)] let mut writer = stdout.lock(); #[cfg(not(debug_assertions))] let mut writer = ::std::io::BufWriter::new(stdout.lock()); solve(stdin.lock(), &mut writer); writer.flush().unwrap(); } if let Some(size) = STACK_SIZE_MEBIBYTES { let builder = ::std::thread::Builder::new().stack_size(size * 1024 * 1024); builder.spawn(run_solver).unwrap().join().unwrap(); } else { run_solver(); } } use io::Scanner; use std::io::{stdin, stdout, BufRead, Write}; pub mod io { pub use self::scanner::*; mod scanner { use std::io::BufRead; use std::marker::PhantomData; use std::str::{from_utf8, from_utf8_unchecked, FromStr}; pub struct Scanner<R> { reader: R, buffer: Vec<u8>, position: usize, } impl<R: BufRead> Scanner<R> { pub fn new(reader: R) -> Self { Scanner { reader: reader, buffer: vec![], position: 0 } } pub fn next<T: Parse>(&mut self) -> Option<T> { Parse::parse(self.next_bytes().unwrap_or(&[])) } pub fn take<T: Parse>(&mut self, n: usize) -> Take<R, T> { Take { scanner: self, n: n, _marker: PhantomData } } pub fn next_bytes(&mut self) -> Option<&[u8]> { if self.buffer.is_empty() { self.read_line(); } loop { match self.buffer.get(self.position) { Some(&b' ') => self.position += 1, Some(&b'\n') => self.read_line(), Some(_) => break, None => return None, } } let start = self.position; loop { match self.buffer.get(self.position) { Some(&b' ') | Some(&b'\n') | None => break, Some(_) => self.position += 1, } } Some(&self.buffer[start..self.position]) } fn read_line(&mut self) { self.position = 0; self.buffer.clear(); self.reader.read_until(b'\n', &mut self.buffer).unwrap(); } } pub struct Take<'a, R: 'a, T> { scanner: &'a mut Scanner<R>, n: usize, _marker: PhantomData<fn() -> T>, } impl<'a, R: BufRead, T: Parse> Iterator for Take<'a, R, T> { type Item = Option<T>; fn next(&mut self) -> Option<Self::Item> { if self.n > 0 { self.n -= 1; Some(self.scanner.next()) } else { None } } fn size_hint(&self) -> (usize, Option<usize>) { (self.n, Some(self.n)) } } impl<'a, R: BufRead, T: Parse> ExactSizeIterator for Take<'a, R, T> {} pub trait Parse: Sized { fn parse(bytes: &[u8]) -> Option<Self>; } impl Parse for u8 { fn parse(bytes: &[u8]) -> Option<Self> { if bytes.len() == 1 { Some(*unsafe { bytes.get_unchecked(0) }) } else { None } } } macro_rules! parse_impl { ($($t:ty)+) => {$( impl Parse for $t { fn parse(bytes: &[u8]) -> Option<Self> { let s = if cfg!(debug_assertions) { from_utf8(bytes).unwrap() } else { unsafe { from_utf8_unchecked(bytes) } }; <$t>::from_str(s).ok() } } )+}; } parse_impl! { i32 i64 isize u32 u64 usize f64 String } } }