{"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut w = String::new();\n io::stdin()\n .read_line(&mut w)\n .expect(\"Read error\");\n \n let w: isize = w.trim().parse().expect(\"Parse error\");\n \n let mut i = 1;\n while i < w && (i % 2 == 1 || (w - i) % 2 == 1) {\n i += 1;\n }\n\n if i < w {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}", "lang_cluster": "Rust", "tags": ["brute force", "math"], "code_uid": "6b88bc2fcb8eeace99839710612b419a", "src_uid": "230a3c4d7090401e5fa3c6b9d994cdf2", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut v = String::new();\n std::io::stdin().read_line(&mut v);\n let v = v.trim();\n let result = v.parse::();\n let num:u32;\n match result {\n Ok(v)=> num = v,\n Err(e)=> panic!(\"failed to parse {}\",e)\n }\n if num <= 3\n {\n println!(\"NO\");\n return;\n }\n if num % 2 == 0\n {\n println!(\"YES\")\n } else {\n println!(\"NO\");\n }\n\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math"], "code_uid": "c5d6c63de874b3a1e22c468505a25362", "src_uid": "230a3c4d7090401e5fa3c6b9d994cdf2", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n\n let line = buf.trim_end();\n\n if line.len() < 7 {\n println!(\"NO\");\n return;\n }\n\n for index in 0..(line.len() - 7 + 1) {\n let substr: String = line.chars().skip(index).take(7).collect();\n\n if substr == \"0000000\" || substr == \"1111111\" {\n println!(\"YES\");\n return;\n }\n }\n\n println!(\"NO\");\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "05a6ecbd28e0c96c28810433fceb30e6", "src_uid": "ed9a763362abc6ed40356731f1036b38", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{Read, Write, stdin, stdout};\n\npub struct Scanner {\n pub buffer: Vec,\n pub reader: U,\n}\nimpl Scanner {\n pub fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_to_string(&mut input).expect(\"Failed read\");\n self.buffer = input.lines().rev().map(String::from).collect();\n }\n }\n\n pub fn new(reader: U) -> Self {\n return Scanner {\n buffer: vec![],\n reader,\n };\n }\n}\npub fn solution_of_p96a(input: &mut Read, out: &mut Write) {\n let mut scanner = Scanner::new(input);\n let s = scanner.next::();\n if s.contains(\"0000000\") || s.contains(\"1111111\") {\n write!(out, \"YES\\n\").ok();\n } else {\n write!(out, \"NO\\n\").ok();\n }\n}\n\nfn main() {\n solution_of_p96a(&mut stdin(), &mut stdout());\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "86abe8f40123663ef257edf49240debd", "src_uid": "ed9a763362abc6ed40356731f1036b38", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "\n#![allow(unused_imports)]\nuse std::io;\nuse std::io::prelude::*;\nuse std::io::BufReader;\nuse std::str::FromStr;\n\nfn main() {\n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n\n let numbers = get_numbers(&input);\n let M = numbers[0];\n let N = numbers[1];\n println!(\"{}\", cover(M, N));\n}\n\nfn cover(cols: u8, rows: u8) -> u8 {\n // start with laying them flat\n let flat = ((cols - (cols % 2)) / 2) * rows;\n \n let tall = if cols % 2 == 1 {\n // there is a leftover column, place dominos tall\n rows / 2\n } else {\n 0\n };\n\n flat + tall\n}\n\n// get numbers from line seperated by spaces\nfn get_numbers(line: &str) -> Vec\n where T: FromStr,\n ::Err: std::fmt::Debug,\n{\n line.split_whitespace()\n .map(|chunk| chunk.parse::().expect(\"failed to parse\"))\n .collect()\n}\n\n", "lang_cluster": "Rust", "tags": ["math", "greedy"], "code_uid": "5a03f072204425fe734ae2e2005ab5c5", "src_uid": "e840e7bfe83764bee6186fcf92a1b5cd", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "macro_rules! input_list {\n ($var:ident, $type:ty, $ch:expr) => {\n let mut $var: Vec<$type> = Vec::new();\n let mut temp = String::new();\n std::io::stdin().read_line(&mut temp).unwrap();\n let temp_list: Vec<&str> = temp.split($ch).collect();\n for num in temp_list {\n $var.push(num.trim().parse::<$type>().unwrap());\n }\n }\n}\n\nfn main() {\n input_list!(size, i32, ' ');\n let dominoes_needed = (size[0] * size[1])/2;\n println!(\"{}\", dominoes_needed);\n}\n", "lang_cluster": "Rust", "tags": ["math", "greedy"], "code_uid": "28f47acb9bddbaf9837a11a92942de01", "src_uid": "e840e7bfe83764bee6186fcf92a1b5cd", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\n/**fn main() {\n \n let mut input = String::new();\n println!(\"Say something: \");\n \n match io::stdin().read_line(&mut input){\n Ok(_) =>{\n println!(\"You typed {}\",input);\n },\n Err(e) => println!(\"Error: {}\",e)\n }\n}*/\nfn contar(line: &str) -> (isize, isize) {\n let mut x = 0;\n let mut y = 0;\n for i in line.chars(){\n match i {\n 'Q' => x+=9,\n 'R' => x+=5,\n 'B' => x+=3,\n 'N' => x+=3,\n 'P' => x+=1,\n 'q' => y+=9,\n 'r' => y+=5,\n 'b' => y+=3,\n 'n' => y+=3,\n 'p' => y+=1,\n _ => x = x,\n }\n }\n (x,y)\n}\n\nfn main(){\n let mut pw = 0;\n let mut pb = 0;\n for _ in 0..8 {\n let mut input = String::new();\n //println!(\"Say something: \");\n \n match io::stdin().read_line(&mut input){\n Ok(_) =>{\n let (xx,yy) = contar(&input);\n pw += xx;\n pb += yy;\n //println!(\"You typed {}\",input);\n },\n Err(e) => println!(\"Error: {}\",e)\n }\n\t}\n let res = pw-pb;\n /*match res {\n Ok(value) if value<0 => println!(\"Black\"),\n Ok(value) if value>0 => println!(\"White\"),\n Ok(value) if value==0 => println!(\"Draw\"),\n Err(_) => println!(\"an error occurred\"),\n \n\t}*/\n if res<0{\n println!(\"Black\");\n\t} else if res>0{\n println!(\"White\");\n\t}else{\n println!(\"Draw\");\n\t}\n //println!(\"{} y {}\",pw,pb);\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "c1f7fb6cb044821bce544ccafad1270d", "src_uid": "44bed0ca7a8fb42fb72c1584d39a4442", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::iter::Iterator;\n\nfn conteo(input: String) -> i32 {\n let mut c :i32 = 0;\n\n for i in input.chars() {\n match i {\n 'Q' => c += 9,\n 'R' => c += 5,\n 'B' | 'N' => c += 3,\n 'P' => c += 1,\n 'q' => c -= 9,\n 'r' => c -= 5,\n 'b' | 'n' => c -= 3,\n 'p' => c -= 1,\n _ => (),\n }\n }\n\n return c;\n}\n\nfn main() {\n let mut comando = String::new();\n let mut res :i32 = 0;\n\n for _i in 0..8 {\n \n match io::stdin().read_line(&mut comando) {\n Ok(_n) => {\n let iter = comando.chars().filter(|&x| x != '.');\n res += conteo(iter.collect::());\n }\n Err(error) => println!(\"error: {}\", error),\n }\n \n comando = String::new(); \n }\n\n if res > 0 {\n println!(\"White\")\n }\n else if res < 0 {\n println!(\"Black\")\n }\n else{\n println!(\"Draw\")\n }\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "095d027e97392abd256b5f9c2eef77ed", "src_uid": "44bed0ca7a8fb42fb72c1584d39a4442", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\n#![allow(dead_code)]\n\nuse std::char::*;\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io::*;\nuse std::str::FromStr;\n\nmacro_rules! debug {($($a:expr),*) => {println!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);}}\nmacro_rules! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }\nmacro_rules! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }\nmacro_rules! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\n\n\nfn read() -> T {\n let stdin = stdin();\n let stdin = stdin.lock();\n let token: String = stdin\n .bytes()\n .map(|c| c.expect(\"failed to read char\") as char)\n .skip_while(|c| c.is_whitespace())\n .take_while(|c| !c.is_whitespace())\n .collect();\n token.parse().ok().expect(\"failed to parse token\")\n}\n\nfn read_vec() -> Vec {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).ok();\n s.trim().split_whitespace()\n .map(|e| e.parse().ok().unwrap()).collect()\n}\n\n\nuse std::f64;\n\nfn min(a:T, b:T) -> T {\n if a < b { a }\n else { b }\n}\n\nfn max(a:T, b:T) -> T {\n if a < b { b }\n else { a }\n}\n\nuse std::hash::Hash;\nfn inc(map:&mut BTreeMap, key:T) {\n let count = map.entry(key).or_insert(0);\n *count += 1;\n}\n\nfn int(ch: char) -> i64 {\n return (ch as u8 - b'0') as i64\n}\n\nconst MAX:usize = 100006;\nconst INF:i64 = std::i64::MAX;\nconst MOD:i64 = 1e9 as i64 + 7;\n\n\nfn main() {\n input!{n:usize, a:[usize;3]};\n\n let mut dp = vec![-1;n+1];\n dp[0] = 0;\n\n for i in 0..n+1 {\n for j in 0..3 {\n if i < a[j] { continue; }\n if dp[i-a[j]] == -1 { continue; }\n dp[i] = max(dp[i], dp[i-a[j]]+1);\n }\n }\n //debug!(dp);\n\n println!(\"{}\", dp[n]);\n}\n\n/*\n\n\u9577\u3055 n \u306e\u30ea\u30dc\u30f3\u3092 a,b,c \u306e\u3044\u305a\u308c\u304b\u306e\u9577\u3055\u306b\u3059\u308b\u3002\n\u3053\u306e\u3068\u304d\u3001\u6700\u5927\u306e\u30ea\u30dc\u30f3\u306e\u6570\u3092\u6c42\u3081\u308b\u3002\n\ndp[i] := \u9577\u3055 i \u306e\u30ea\u30dc\u30f3\u3092\u5207\u308c\u308b\u6700\u5927\u306e\u6570\ndp[i] = max(dp[i-a[j]]+1, j=0,1,2)\n\n\n\n*/", "lang_cluster": "Rust", "tags": ["brute force", "dp"], "code_uid": "80241c78dec82beabb5e8df94bd35bf4", "src_uid": "062a171cc3ea717ea95ede9d7a1c3a43", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\n\nfn read_line() -> String {\n let mut buf = String::new();\n stdin().read_line(&mut buf).expect(\"Failed to read a line\");\n buf\n}\n\nfn read_params() -> (usize, Vec) {\n let line = read_line();\n let mut input = line.trim().split_whitespace().map(|x| x.parse::().unwrap());\n let n = input.next().unwrap();\n let mut sizes: Vec = input.collect();\n\n sizes.sort();\n if sizes.len() == 3 {\n if sizes[2] % sizes[0] == 0 || sizes[2] % sizes[1] == 0 {\n sizes.pop();\n }\n }\n if sizes.len() > 1 {\n if sizes[1] % sizes[0] == 0 {\n sizes.remove(1);\n }\n }\n\n (n, sizes)\n}\n\nfn calculate_max_cuts(n: usize, sizes: &[usize]) -> usize {\n if n % sizes.first().unwrap() == 0 {\n return n / sizes.first().unwrap();\n }\n\n let mut counts: Vec = vec![0; n + 1];\n for i in 1..counts.len() {\n for x in sizes.iter().cloned() {\n let value = if x > i {\n 0\n } else if x == i {\n 1\n } else if counts[i - x] == 0 {\n 0\n } else {\n counts[i - x] + 1\n };\n counts[i] = std::cmp::max(value, counts[i]);\n }\n }\n\n *counts.last().unwrap()\n}\n\nfn main() {\n let (n, sizes) = read_params();\n println!(\"{}\", calculate_max_cuts(n, &sizes));\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "dp"], "code_uid": "a5029a2558d551a7c4aad4ca217b1a3c", "src_uid": "062a171cc3ea717ea95ede9d7a1c3a43", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, BufRead};\n\nconst M: u64 = 998244353;\n\nfn pow(n: u64, p: u64) -> u64 {\n let mut q = p;\n let mut r = n;\n let mut result = 1;\n while q > 0 { \n if q % 2 == 1 { \n result = result * r % M;\n } \n r = r * r % M;\n q >>= 1;\n }\n result\n}\n\nfn inv(n: u64) -> u64 {\n pow(n, M - 2)\n}\n\nfn main() {\n let stdin = io::stdin();\n let mut lines = stdin.lock().lines();\n let n: usize = lines.next().unwrap().unwrap().parse().unwrap();\n let mut cs: Vec = vec![0, 0];\n let mut x: u64 = 0;\n for i in 0..n {\n let p = i % 2;\n let q = (i + 1) % 2;\n x = (cs[q] + q as u64) % M;\n cs[p] = (cs[p] + x) % M;\n }\n let d = pow(2, n as u64);\n println!(\"{}\", x * inv(d) % M);\n}", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics"], "code_uid": "bc630931fdd1a73beb09d67e67c9bdd9", "src_uid": "cec37432956bb0a1ce62a0188fe2d805", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_parens)]\n#![allow(unused_imports)]\n#![allow(non_upper_case_globals)]\n#![allow(non_snake_case)]\n#![allow(unused_mut)]\n#![allow(unused_variables)]\n#![allow(dead_code)]\n\ntype Vec2 = Vec>;\ntype Vec3 = Vec>>;\n\n#[allow(unused_macros)]\nmacro_rules! invec {\n ( $ t : ty ) => {{\n let mut s = String::new();\n match std::io::stdin().read_line(&mut s) {\n Ok(0) => Vec::<$t>::new(),\n Ok(n) => s\n .trim()\n .split_whitespace()\n .map(|s| s.parse::<$t>().unwrap())\n .collect::>(),\n Err(_) => Vec::<$t>::new(),\n }\n }};\n}\n\n#[allow(unused_macros)]\nmacro_rules! get {\n ($t:ty) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().parse::<$t>().unwrap()\n }\n };\n ($($t:ty),*) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n $(iter.next().unwrap().parse::<$t>().unwrap(),)*\n )\n }\n };\n ($t:ty; $n:expr) => {\n (0..$n).map(|_|\n get!($t)\n ).collect::>()\n };\n ($($t:ty),*; $n:expr) => {\n (0..$n).map(|_|\n get!($($t),*)\n ).collect::>()\n };\n ($t:ty ;;) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.split_whitespace()\n .map(|t| t.parse::<$t>().unwrap())\n .collect::>()\n }\n };\n ($t:ty ;; $n:expr) => {\n (0..$n).map(|_| get!($t ;;)).collect::>()\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let mut s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n ($iter:expr, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n\n ($next:expr, [$t:tt]) => {\n {\n let len = read_value!($next, usize);\n (0..len).map(|_| read_value!($next, $t)).collect::>()\n }\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n#[allow(unused_macros)]\n#[cfg(debug_assertions)]\nmacro_rules! mydbg {\n //($arg:expr) => (dbg!($arg))\n //($arg:expr) => (println!(\"{:?}\",$arg));\n ($($a:expr),*) => {\n eprintln!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);\n }\n}\n#[cfg(not(debug_assertions))]\nmacro_rules! mydbg {\n ($($arg:expr),*) => {};\n}\n\nmacro_rules! echo {\n ($($a:expr),*) => {\n $(println!(\"{}\",$a))*\n }\n}\n\nuse std::cmp::*;\nuse std::collections::*;\nuse std::ops::{Add, Div, Mul, Sub};\n\n#[allow(dead_code)]\nstatic INF_I64: i64 = i64::max_value() / 2;\n#[allow(dead_code)]\nstatic INF_I32: i32 = i32::max_value() / 2;\n#[allow(dead_code)]\nstatic INF_USIZE: usize = usize::max_value() / 2;\n#[allow(dead_code)]\nstatic M_O_D: usize = 1000000007;\n#[allow(dead_code)]\nstatic PAI: f64 = 3.1415926535897932;\n\ntrait IteratorExt: Iterator {\n fn toVec(self) -> Vec;\n}\n\nimpl IteratorExt for T {\n fn toVec(self) -> Vec {\n self.collect()\n }\n}\n\ntrait CharExt {\n fn toNum(&self) -> usize;\n fn toAlphabetIndex(&self) -> usize;\n fn toNumIndex(&self) -> usize;\n}\nimpl CharExt for char {\n fn toNum(&self) -> usize {\n return *self as usize;\n }\n fn toAlphabetIndex(&self) -> usize {\n return self.toNum() - 'a' as usize;\n }\n fn toNumIndex(&self) -> usize {\n return self.toNum() - '0' as usize;\n }\n}\n\ntrait VectorExt {\n fn joinToString(&self, s: &str) -> String;\n}\nimpl VectorExt for Vec {\n fn joinToString(&self, s: &str) -> String {\n return self\n .iter()\n .map(|x| x.to_string())\n .collect::>()\n .join(s);\n }\n}\n\ntrait StringExt {\n fn get_reverse(&self) -> String;\n}\nimpl StringExt for String {\n fn get_reverse(&self) -> String {\n self.chars().rev().collect::()\n }\n}\n\ntrait UsizeExt {\n fn pow(&self, n: usize) -> usize;\n}\nimpl UsizeExt for usize {\n fn pow(&self, n: usize) -> usize {\n return ((*self as u64).pow(n as u32)) as usize;\n }\n}\n\n#[derive(Debug, Copy, Clone)]\npub struct ModInt {\n x: i64,\n global_mod: i64,\n}\nimpl ModInt {\n pub fn new(p: i64) -> Self {\n let gm = 998244353;\n let a = (p % gm + gm) % gm;\n return ModInt {\n x: a,\n global_mod: gm,\n };\n }\n pub fn inv(self) -> Self {\n return self.pow(self.global_mod - 2);\n }\n pub fn pow(self, t: i64) -> Self {\n if (t == 0) {\n return ModInt::new(1);\n };\n let mut a = self.pow(t >> 1);\n a = a * a;\n if (t & 1 != 0) {\n a = a * self\n };\n return a;\n }\n}\nimpl Add for ModInt {\n type Output = ModInt;\n fn add(self, other: ModInt) -> ModInt {\n let ret = self.x + other.x;\n return ModInt::new(ret);\n }\n}\nimpl Sub for ModInt {\n type Output = ModInt;\n fn sub(self, other: ModInt) -> ModInt {\n let ret = self.x - other.x;\n return ModInt::new(ret);\n }\n}\nimpl Mul for ModInt {\n type Output = ModInt;\n fn mul(self, other: ModInt) -> ModInt {\n let ret = self.x * other.x;\n return ModInt::new(ret);\n }\n}\nimpl Div for ModInt {\n type Output = ModInt;\n fn div(self, other: ModInt) -> ModInt {\n let ret = self.x * other.inv().x;\n return ModInt::new(ret);\n }\n}\nimpl std::string::ToString for ModInt {\n fn to_string(&self) -> String {\n return self.x.to_string();\n }\n}\npub struct Combination {\n fact: Vec,\n ifact: Vec,\n}\nimpl Combination {\n pub fn new(n: i32) -> Self {\n if n > 3000000 {\n panic!(\"error\");\n }\n let mut fact = vec![ModInt::new(0); (n + 1) as usize];\n let mut ifact = vec![ModInt::new(0); (n + 1) as usize];\n fact[0] = ModInt::new(1);\n for i in 1..n + 1 {\n fact[i as usize] = fact[(i - 1) as usize] * ModInt::new(i as i64)\n }\n ifact[n as usize] = fact[n as usize].inv();\n for i in (1..n + 1).rev() {\n ifact[(i - 1) as usize] = ifact[i as usize] * ModInt::new(i as i64)\n }\n let a = Combination {\n fact: fact,\n ifact: ifact,\n };\n return a;\n }\n #[macro_use]\n pub fn gen(&mut self, n: i32, k: i32) -> ModInt {\n if (k < 0 || k > n) {\n return ModInt::new(0 as i64);\n };\n return self.fact[n as usize] * self.ifact[k as usize] * self.ifact[(n - k) as usize];\n }\n pub fn P(&mut self, n: i32, k: i32) -> ModInt {\n self.fact[n as usize] * self.ifact[(n - k) as usize]\n }\n}\n\nfn main() {\n let N = get!(usize);\n\n let mut dp = vec![ModInt::new(0); N + 10];\n\n dp[0] = ModInt::new(1);\n\n let mut e = vec![ModInt::new(0); N + 2];\n let mut o = vec![ModInt::new(0); N + 2];\n\n for i in 0..N + 1 {\n if i % 2 == 0 {\n dp[i] = dp[i] + o[i];\n e[i + 1] = e[i] + dp[i];\n o[i + 1] = o[i];\n } else {\n dp[i] = dp[i] + e[i];\n o[i + 1] = o[i] + dp[i];\n e[i + 1] = e[i];\n }\n }\n\n mydbg!(dp[N]);\n let mut ans = ModInt::new(1) / ModInt::new(2).pow(N as i64);\n ans = ans * dp[N];\n echo!(ans.to_string());\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics"], "code_uid": "911a7074d7556ccf25620d8428871f74", "src_uid": "cec37432956bb0a1ce62a0188fe2d805", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\nuse std::io::{StdinLock, stdin, BufRead};\nuse std::collections::*;\nuse std::cmp::*;\n\nfn scan_helper(lock : &mut StdinLock) -> String {\n let mut buffer = String::new();\n lock.read_line(&mut buffer).ok();\n buffer\n}\n\nmacro_rules! scan {\n ($lock:ident, $t:ty) => ({\n scan_helper(&mut $lock).split_whitespace()\n .next().unwrap()\n .parse::<$t>().unwrap()\n });\n ($lock:ident, $($t:ty),+) => ({\n let buffer = scan_helper(&mut $lock);\n let mut iter = buffer.split_whitespace();\n ($(\n {\n iter.next().unwrap()\n .parse::<$t>().unwrap()\n },\n )+)\n })\n}\n\nmacro_rules! scan_iter {\n ($lock:ident, $t:ty) => ({\n scan_helper(&mut $lock).split_whitespace()\n .map(|x| x.parse::<$t>().unwrap())\n .collect()\n })\n}\n\ntrait Ext {\n fn idx(&self) -> usize;\n fn num(&self) -> i64;\n}\n\nmacro_rules! ext {\n ($t:ty) => (\n impl Ext for $t {\n #[inline]\n fn idx(&self) -> usize {\n *self as usize\n }\n\n #[inline]\n fn num(&self) -> i64 {\n *self as i64\n }\n }\n )\n}\next!(i64);\next!(usize);\n\n\n#[derive(Copy, Clone, Debug)]\nstruct Pair {\n i : usize,\n cost : i64\n}\nimpl PartialOrd for Pair {\n fn partial_cmp(&self, other : &Pair) -> Option {\n Some(self.cost.cmp(&other.cost))\n }\n}\n\nimpl Ord for Pair {\n fn cmp(&self, other : &Pair) -> Ordering {\n self.partial_cmp(other).unwrap()\n }\n}\n\nimpl PartialEq for Pair {\n fn eq(&self, other : &Pair) -> bool {\n self.cost == other.cost\n }\n}\nimpl Eq for Pair {}\n\nfn main() {\n let stdin = stdin();\n let mut s = stdin.lock();\n let (n, m) = scan!(s, i64, i64);\n let mut possible = false;\n\n let mut scale = m;\n while scale <= n {\n if 2*scale >= n {\n possible = true;\n break;\n }\n scale += m;\n }\n\n if possible {\n println!(\"{}\", scale);\n } else {\n println!(\"-1\");\n }\n}", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "a9c6f67b0f7245618f5e20ec63be0d64", "src_uid": "0fa526ebc0b4fa3a5866c7c5b3a4656f", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max,min};\n\nmacro_rules! readln {\n () => {{\n use std::io;\n \n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim().to_string()\n }};\n ( $t:ty ) => {{\n let input = readln!();\n input.parse::<$t>().unwrap()\n }};\n ( $( $t:ty ),+ ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n (\n $(\n input.next().unwrap().parse::<$t>().unwrap(),\n )+\n )\n }}\n}\n\nmacro_rules! readvec {\n ( $t:ty ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n let mut result = Vec::new();\n for elem in input {\n result.push(elem.parse::<$t>().unwrap());\n }\n result\n }}\n}\n\nfn main() {\n let (n,m) = readln!(i32,i32);\n let (mn,mx) = ((n+1)/2,n);\n let qmin = (mn+m-1)/m;\n let vmin = qmin*m;\n if vmin >= mn && vmin <= mx {\n println!(\"{}\",vmin);\n } else {\n println!(\"-1\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "23d516567f48231805b4badaa2e2f36b", "src_uid": "0fa526ebc0b4fa3a5866c7c5b3a4656f", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str;\n\npub struct Scanner {\n reader: R,\n buffer: Vec,\n}\n\nimpl Scanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buffer: vec![],\n }\n }\n\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn zeros_factorial(n: u64) -> u64 {\n let mut ans = 0;\n let mut n = n;\n while n > 0 {\n ans += n / 5;\n n /= 5;\n }\n ans\n}\n\nfn search(m: u64) -> u64 {\n let mut lo = 0;\n let mut hi = 500000; // zeros_factorial(n) >= n / 5\n while lo < hi {\n let mid = lo + (hi - lo) / 2;\n if zeros_factorial(mid) >= m {\n hi = mid;\n } else {\n lo = mid + 1;\n }\n }\n lo\n}\n\nfn solve(scan: &mut Scanner, out: &mut W) {\n let m: u64 = scan.token();\n let n = search(m);\n if zeros_factorial(n) == m {\n writeln!(out, \"5\").ok();\n for i in 0..5 {\n write!(out, \"{} \", n + i).ok();\n }\n writeln!(out).ok();\n } else {\n writeln!(out, \"0\").ok();\n }\n}\n\nfn main() {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout.lock());\n solve(&mut scan, &mut out);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "constructive algorithms", "number theory"], "code_uid": "3e6d2415a95cf12a4020e114b98c5a35", "src_uid": "c27ecc6e4755b21f95a6b1b657ef0744", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n// let mut user_count = 0;\n// let mut size = 0;\n\n let mut input_text = String::new();\n io::stdin()\n .read_line(&mut input_text)\n .expect(\"failed to read from stdin\");\n\n let mut id = 0;\n let mut array: [i32; 4] = [0; 4];\n\n for token in input_text.split_whitespace(){\n match token.parse::() {\n Ok(i) => {\n array[id] = i;\n id = id + 1;\n },\n Err(..) => {},\n };\n }\n\n array.sort();\n if (array[2] < (array[0] + array[1]) || array[3] < (array[1] + array[2])) {\n println!(\"TRIANGLE\");\n return;\n };\n\n if (array[2] == (array[0] + array[1]) || array[3] == (array[1] + array[2])) {\n println!(\"SEGMENT\");\n return;\n };\n\n println!(\"IMPOSSIBLE\");\n\n}", "lang_cluster": "Rust", "tags": ["brute force", "geometry"], "code_uid": "6139c64b3b699e6c55c1454da743fe31", "src_uid": "8f5df9a41e6e100aa65b9fc1d26e447a", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#[allow(unused_imports)]\nuse std::io::{BufWriter, stdin, stdout, Write};\n\n#[derive(Default)]\nstruct Scanner {\n buffer: Vec\n}\nimpl Scanner {\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n stdin().read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn last_odd_number_less_than_number(n: i32) -> i32 {\n let mut i = n;\n while i > 0 {\n if i % 2 == 1 {\n return i;\n }\n i -= 1;\n }\n 0\n}\n\nfn get_result(input: &u32) -> String {\n let base: i32 = 2;\n let num_of_players: i32 = base.pow(*input);\n last_odd_number_less_than_number(num_of_players)\n .to_string()\n}\n\nfn main() {\n let mut scan = Scanner::default();\n let out = &mut BufWriter::new(stdout());\n let n = scan.next::();\n let contents: Vec = (0..n).map(|_| scan.next()).collect();\n for content in contents {\n writeln!(out, \"{}\", get_result(&content)).ok();\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "e9024af3f19dc2b60a9664b7519c382a", "src_uid": "d5e66e34601cad6d78c3f02898fa09f4", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(warnings, unused)]\nuse std::cmp::Ordering;\nuse std::io::Write;\n\nuse std::cmp;\nuse std::cmp::min;\nuse std::collections::BTreeMap;\nuse std::process;\nuse std::cmp::Ord;\nuse std::collections::HashMap;\nuse std::collections::HashSet;\nuse std::collections::VecDeque;\nuse std::collections::BTreeSet;\nuse std::mem;\nuse std::collections::BinaryHeap;\nuse std::hash::{Hash, Hasher};\n\npub struct Scanner {\n stdin: R,\n}\n \nimpl Scanner {\n pub fn read(&mut self) -> T {\n use std::io::Read;\n let buf = self\n .stdin\n .by_ref()\n .bytes()\n .map(|b| b.unwrap())\n .skip_while(|&b| b == b' ' || b == b'\\n' || b == b'\\r')\n .take_while(|&b| b != b' ' && b != b'\\n' && b != b'\\r')\n .collect::>();\n std::str::from_utf8(&buf).unwrap()\n .parse()\n .ok()\n .expect(\"Parse error.\")\n }\n pub fn vec(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.read()).collect()\n }\n pub fn chars(&mut self) -> Vec {\n self.read::().chars().collect()\n }\n}\n\n\npub trait BinarySearch {\n fn lower_bound(&self, x:&T) -> usize;\n fn upper_bound(&self, x:&T) -> usize;\n}\n\nimpl BinarySearch for VecDeque{\n fn lower_bound(&self, x: &T) -> usize {\n let mut low = 0;\n let mut high = self.len();\n\n while low != high {\n let mid = (low + high) / 2;\n match self[mid].cmp(x) {\n Ordering::Less => {\n low = mid + 1;\n }\n Ordering::Equal | Ordering::Greater => {\n high = mid;\n }\n }\n }\n low\n }\n\n fn upper_bound(&self, x: &T) -> usize {\n let mut low = 0;\n let mut high = self.len();\n\n while low != high {\n let mid = (low + high) / 2;\n match self[mid].cmp(x) {\n Ordering::Less | Ordering::Equal => {\n low = mid + 1;\n }\n Ordering::Greater => {\n high = mid;\n }\n }\n }\n low\n }\n}\nimpl BinarySearch for [T]{\n fn lower_bound(&self, x: &T) -> usize {\n let mut low = 0;\n let mut high = self.len();\n\n while low != high {\n let mid = (low + high) / 2;\n match self[mid].cmp(x) {\n Ordering::Less => {\n low = mid + 1;\n }\n Ordering::Equal | Ordering::Greater => {\n high = mid;\n }\n }\n }\n low\n }\n\n fn upper_bound(&self, x: &T) -> usize {\n let mut low = 0;\n let mut high = self.len();\n\n while low != high {\n let mid = (low + high) / 2;\n match self[mid].cmp(x) {\n Ordering::Less | Ordering::Equal => {\n low = mid + 1;\n }\n Ordering::Greater => {\n high = mid;\n }\n }\n }\n low\n }\n}\n\nstruct MultiSet {\n set: BTreeSet,\n map: HashMap\n}\n\nimpl MultiSet {\n fn new() -> MultiSet {\n MultiSet{\n set: BTreeSet::new(), map: HashMap::new()\n }\n }\n fn len(& self)->usize{\n return self.set.len();\n }\n fn contains(& self, i:&T)->bool{\n if self.set.contains(i){\n return true;\n }\n else{\n return false\n }\n }\n \n\n ///\u91cd\u8907\u8a31\u53ef\u633f\u5165\n fn insert(&mut self, i:T) -> Option\n {\n if let Some(_i) = self.set.get(&i) {\n //set\u306b\u3042\u308b\n *self.map.entry(i).or_insert(0) += 1;\n }else{\n //set\u306b\u306a\u3044\n self.set.insert(i);\n *self.map.entry(i).or_insert(0) += 1;\n }\n return Some(i);\n }\n\n ///1\u3064\u524a\u9664\n fn remove(&mut self, e:&T) -> Option\n {\n if let Some(_e) = self.set.get(e) {\n //set\u306b\u3042\u308b\n *self.map.entry(*e).or_insert(0) -= 1;\n if self.map[&e]==0 {\n //\u306a\u304f\u306a\u3063\u305f\n self.set.take(e);\n }\n return Some(*e);\n }else{\n //set\u306b\u306a\u3044\n return None;\n }\n }\n\n ///\u6700\u5c0f\u5024\u306e\u53d6\u5f97\n fn get_min(&self) -> Option\n {\n if let Some(&m) = self.set.iter().nth(0) {\n return Some(m);\n }else{\n return None;\n }\n }\n\n ///\u6700\u5927\u5024\u306e\u53d6\u5f97\n fn get_max(&self) -> Option\n {\n if let Some(&m) = self.set.iter().last() {\n return Some(m);\n }else{\n return None;\n }\n }\n}\nfn invs(max:usize)->(Vec, Vec){\n let mut fac = vec![0;max+1];\n let mut ifac = vec![0;max+1];\n fac[0] = 1;\n ifac[0] = 1;\n for i in 0..max{\n\n fac[i+1] = ((fac[i] as u64 * (i+1) as u64)%MODu as u64) as usize;\n ifac[i+1] = ((ifac[i] as u64 * modpow(i+1, MODu - 2) as u64)%MODu as u64) as usize;\n }\n (fac, ifac)\n}\nfn modpow(x:usize, n:usize) -> usize{\n let mut ans = 1;\n let mut n = n as usize;\n let mut x = x;\n while(n != 0){\n if (n&1 == 1){ans = (ans as u64*x as u64%MODu as u64) as usize;}\n x = (((x%MODu) as u64*(x%MODu) as u64)%MODu as u64) as usize;\n n = n>>1;\n }\n ans\n}\nfn comb(a:usize, b:usize, fac:&Vec, ifac:&Vec)->usize{\n let mut a = a;\n let mut b = b;\n if a == 0 && b == 0{return 1;}\n if a,\n rank:Vec,\n size:Vec,\n size_edge:Vec,\n}\nimpl union_find{\n fn new(n:usize) -> union_find{\n let mut par = vec![0;n];\n for i in 0..n{\n par[i] = i;\n }\n union_find{\n par:par,\n rank:vec![0;n],\n size:vec![1;n],\n size_edge:vec![0;n],\n }\n }\n fn find(&mut self, x:usize) ->usize{\n if(self.par[x] == x){\n x\n }\n else{\n let p = self.par[x];\n let res = self.find(p);\n self.par[x] = res;\n res\n }\n }\n fn same(&mut self, a:usize, b:usize)->bool{\n self.find(a) == self.find(b)\n }\n fn unite(&mut self, a:usize, b:usize){\n let x = self.find(a);\n let y = self.find(b);\n if x != y{\n if (self.rank[x] < self.rank[y]){\n self.par[x] = y;\n self.size[y] += self.size[x];\n self.size_edge[y] += self.size_edge[x];\n self.size_edge[y] += 1;\n }\n else{\n self.par[y] = x;\n self.size[x] += self.size[y];\n self.size_edge[x] += self.size_edge[y];\n self.size_edge[x] += 1;\n if(self.rank[x] == self.rank[y]){ self.rank[x]+=1;}\n }\n\n }\n else{\n self.size_edge[x] += 1;\n }\n }\n fn check_size(&mut self, a:usize) -> usize{\n let x = self.find(a);\n let s = self.size[x];\n s\n }\n}\n\n\nstruct segment_tree{\n n: usize,\n dat: Vec,\n op:Op,\n e:I,\n}\nimpl segment_tree\n \n \n where Op: Fn(I, I) -> I, I:Copy{\n \n pub fn new(n_:usize, op: Op, e:I)->Self{\n let mut n = 1;\n while(n0){\n k = (k-1)/2;\n self.dat[k] = (self.op)(self.dat[k*2 + 1], self.dat[k*2+2]);\n }\n }\n \n pub fn query_sub(&self, a:usize, b:usize, k:usize, l:usize, r:usize) -> I{\n if r<=a || b<=l{return self.e;}\n if a<=l && r<=b{return self.dat[k];}\n else{\n let mut vl = self.query_sub(a, b, k*2+1, l, (l+r)/2);\n let mut vr = self.query_sub(a, b, k*2+2, (l+r)/2, r);\n return (self.op)(vl, vr);\n }\n }\n pub fn query(&self, a:usize, b:usize)->I{\n return self.query_sub(a, b, 0, 0, self.n);\n }\n }\n \n\n\n\nstruct rolling_hash{\n base1:u64,\n base2:u64,\n mod1:u64,\n mod2:u64,\n hash1:Vec,\n hash2:Vec,\n power1:Vec,\n power2:Vec\n}\n\nimpl rolling_hash{\n fn new(S:&Vec)->rolling_hash{\n let mut n = S.len();\n let mut base1 = 1007;\n let mut base2 = 2009;\n let mut mod1 = 1000000007;\n let mut mod2 = 1000000009;\n let mut hash1 = vec![0;n+1];\n let mut hash2 = vec![0;n+1];\n let mut power1 = vec![1;n+1];\n let mut power2 = vec![1;n+1];\n\n for i in 0..n{\n hash1[i+1] = (hash1[i] * base1 + S[i])%mod1;\n hash2[i+1] = (hash2[i] * base2 + S[i])%mod2;\n power1[i+1] = (power1[i] * base1)%mod1;\n power2[i+1] = (power2[i] * base2)%mod2;\n }\n\n return rolling_hash{\n hash1:hash1,\n hash2:hash2,\n power1:power1,\n power2:power2,\n base1:base1,\n base2:base2,\n mod1:mod1,\n mod2:mod2\n }\n }\n // [l, r) \n fn get(&self, l:usize, r:usize)->(u64, u64){\n let mut res1 = self.hash1[r] as i64 - self.hash1[l] as i64 * self.power1[r-l] as i64%self.mod1 as i64;\n if (res1<0) {res1+= self.mod1 as i64;}\n let mut res2 = self.hash2[r] as i64 - self.hash2[l] as i64 * self.power2[r-l] as i64%self.mod2 as i64;\n if (res2<0) {res2+= self.mod2 as i64;}\n return (res1 as u64, res2 as u64);\n }\n}\nfn base_number(x:u64, n:u64)->Vec{\n let mut x = x;\n let mut n = n;\n let mut r = 1;\n let mut q = x;\n let mut res = vec![];\n while(q>=n){\n r = q%n;\n res.push(r);\n q = q/n;\n }\n r = q%n;\n res.push(r);\n res.reverse();\n return res\n}\npub struct point_set_range_max {\n xss: Vec>,\n h: usize,\n w: usize,\n initial: i64,\n }\n\n impl point_set_range_max {\n pub fn new(h: usize, w: usize, initial: i64) -> Self {\n let H = w.next_power_of_two();\n let W = h.next_power_of_two();\n Self {\n xss: vec![vec![initial; 2 * W]; 2 * H],\n h:H,\n w:W,\n initial,\n }\n }\n fn update(&mut self, x: usize, y: usize) {\n if x >= self.w && y >= self.h {\n return;\n }\n let s = if x < self.w {\n std::cmp::max(self.xss[y][2 * x + 0], self.xss[y][2 * x + 1])\n } else {\n self.initial\n };\n let t = if y < self.h {\n std::cmp::max(self.xss[2 * y + 0][x], self.xss[2 * y + 1][x])\n } else {\n self.initial\n };\n let r = std::cmp::max(s, t);\n self.xss[y][x] = r;\n }\n pub fn set(&mut self, x: usize, y: usize, v: i64) {\n self.xss[y + self.h][x + self.w] = v;\n let mut x = x + self.w;\n while x > 0 {\n let mut y = y + self.h;\n while y > 0 {\n self.update(x, y);\n y >>= 1;\n }\n x >>= 1;\n }\n }\n pub fn query(&mut self, l: usize, r: usize, u: usize, d: usize) -> i64 {\n let mut l = l + self.w;\n let mut r = r + self.w;\n let mut res = self.initial;\n while l < r {\n if l & 1 != 0 {\n let mut u = u + self.h;\n let mut d = d + self.h;\n while u < d {\n if u & 1 != 0 {\n res = std::cmp::max(res, self.xss[u][l]);\n u += 1;\n }\n if d & 1 != 0 {\n d -= 1;\n res = std::cmp::max(res, self.xss[d][l]);\n }\n u >>= 1;\n d >>= 1;\n }\n l += 1;\n }\n if r & 1 != 0 {\n r -= 1;\n let mut u = u + self.h;\n let mut d = d + self.h;\n while u < d {\n if u & 1 != 0 {\n res = std::cmp::max(res, self.xss[u][r]);\n u += 1;\n }\n if d & 1 != 0 {\n d -= 1;\n res = std::cmp::max(res, self.xss[d][r]);\n }\n u >>= 1;\n d >>= 1;\n }\n }\n l >>= 1;\n r >>= 1;\n }\n res\n }\n }\n\npub struct point_set_range_sum_bool {\n xss: Vec>,\n h: usize,\n w: usize,\n initial: bool,\n }\n \n impl point_set_range_sum_bool {\n pub fn new(h: usize, w: usize, initial: bool) -> Self {\n let H = w.next_power_of_two();\n let W = h.next_power_of_two();\n Self {\n xss: vec![vec![initial; 2 * W]; 2 * H],\n h:H,\n w:W,\n initial,\n }\n }\n fn update(&mut self, x: usize, y: usize) {\n if x >= self.w && y >= self.h {\n return;\n }\n let s = if x < self.w {\n self.xss[y][2 * x + 0] | self.xss[y][2 * x + 1]\n } else {\n self.initial\n };\n let t = if y < self.h {\n self.xss[2 * y + 0][x] | self.xss[2 * y + 1][x]\n } else {\n self.initial\n };\n let r = s | t;\n self.xss[y][x] = r;\n }\n pub fn set(&mut self, x: usize, y: usize, v: bool) {\n self.xss[y + self.h][x + self.w] = v;\n let mut x = x + self.w;\n while x > 0 {\n let mut y = y + self.h;\n while y > 0 {\n self.update(x, y);\n y >>= 1;\n }\n x >>= 1;\n }\n }\n pub fn query(&mut self, l: usize, r: usize, u: usize, d: usize) -> bool {\n let mut l = l + self.w;\n let mut r = r + self.w;\n let mut res = self.initial;\n while l < r {\n if l & 1 != 0 {\n let mut u = u + self.h;\n let mut d = d + self.h;\n while u < d {\n if u & 1 != 0 {\n res = res | self.xss[u][l];\n u += 1;\n }\n if d & 1 != 0 {\n d -= 1;\n res = res | self.xss[d][l];\n }\n u >>= 1;\n d >>= 1;\n }\n l += 1;\n }\n if r & 1 != 0 {\n r -= 1;\n let mut u = u + self.h;\n let mut d = d + self.h;\n while u < d {\n if u & 1 != 0 {\n res = res | self.xss[u][r];\n u += 1;\n }\n if d & 1 != 0 {\n d -= 1;\n res = res | self.xss[d][r];\n }\n u >>= 1;\n d >>= 1;\n }\n }\n l >>= 1;\n r >>= 1;\n }\n res\n }\n }\n\n//\u6700\u5927\u516c\u7d04\u6570\nfn gcd(a:usize, b:usize)->usize{\n if b==0{return a;}\n return gcd(b, a%b);\n}\nenum Node {\n Operator {\n nxt0: Box,\n nxt1: Box,\n }, \n Number {\n lazy:i64,\n cnt:i64\n }, \n}\nfn dijkstra(s:usize, g:&Vec>)->Vec{\n let mut dist = vec![INF;g.len()];\n dist[s] = 0;\n let mut h = BinaryHeap::new();\n h.push((0, s));\n while(h.len() != 0){\n let mut t = h.pop().unwrap();\n let mut d = t.0 * -1;\n let mut v = t.1;\n if dist[v]d+dd{\n dist[n] = d+dd;\n h.push((dist[n]*-1, n));\n }\n }\n }\n return dist;\n}\nfn safe_mod(x:i64, m:i64)->i64{\n let mut x = x;\n let mut m = m;\n x%=m;\n if x<0{\n x+=m;\n }\n return x;\n}\nfn pow_mod(x: i64, mut n: i64, m: i64) -> i64 {\n if m == 1 {\n return 0;\n }\n let _m = m as u32;\n let mut r: u64 = 1;\n let mut y: u64 = safe_mod(x, m as i64) as u64;\n while n != 0 {\n if (n & 1) > 0 {\n r = (r * y) % (_m as u64);\n }\n y = (y * y) % (_m as u64);\n n >>= 1;\n }\n r as i64\n}\nfn is_prime(n: i64) -> bool {\n let n = n as i64;\n match n {\n _ if n <= 1 => return false,\n 2 | 7 | 61 => return true,\n _ if n % 2 == 0 => return false,\n _ => {}\n }\n let mut d = n - 1;\n while d % 2 == 0 {\n d /= 2;\n }\n for &a in &[2, 7, 61] {\n let mut t = d;\n let mut y = pow_mod(a, t, n as i64);\n while t != n - 1 && y != 1 && y != n - 1 {\n y = y * y % n;\n t <<= 1;\n }\n if y != n - 1 && t % 2 == 0 {\n return false;\n }\n }\n true\n}\nfn prime_factor(n:i64)->HashMap{\n let mut res = HashMap::new();\n let mut n = n;\n for i in 2..n{\n if i*i>n{break;}\n while(n%i==0){\n *res.entry(i).or_insert(0)+=1;\n n/=i;\n }\n }\n if n != 1{\n res.insert(n, 1);\n }\n res\n}\nfn solve(){\n let sssss = std::io::stdin();\n let mut sc = Scanner { stdin: sssss.lock() };\n let out = std::io::stdout();\n let mut out = std::io::BufWriter::new(out.lock());\n let mut test:usize = sc.read();\n for _ in 0..test{\n let mut i:i64 = sc.read();\n\n writeln!(out, \"{}\", (1<(for _ in 0..$c{$($s)+})}\nmacro_rules!l{\n\t($($v:ident),+:$t:ty=$e:expr)=>{$(let$v:$t=$e;)+};(mut $($v:ident),+ =$e:expr)=>{$(let mut$v=$e;)+};\n\t(mut $($v:ident),+:$t:ty=$e:expr)=>{$(let mut$v:$t=$e;)+};($($v:ident),+ =$e:expr)=>{$(let$v=$e;)+};}\nmacro_rules!v{\n\t($(:$t:ty)?=$e:expr)=>{$e$(as$t)?};([$d:expr]$(:$t:ty)?)=>{Vec::$(<$t>::)?with_capacity($d)};\n\t([]$(:$t:ty)?)=>{Vec::$(<$t>::)?new()};([$d:expr]$($s:tt)+)=>{vec![v!($($s)+);$d]};}\nfn rio()->(Reader,BufWriter){(Reader::new(),BufWriter::new(stdout()))}\nstruct Reader{buf:Vec,pos:usize,x:*mut Stdin,q:StdinLock<'static>}//'\n#[allow(dead_code)]impl Reader{\n\tfn new()->Self{let x=Box::into_raw(Box::new(stdin()));let q=unsafe{&*x}.lock();Self{x,q,buf:v!([]),pos:0}}\n\tfn next_line(&mut self)->bool{self.buf.clear();self.pos=0;self.q.read_until(b'\\n',&mut self.buf).unwrap_or(0)>0}\n\tfn byte(&mut self)->Option{\n\t\tif self.pos==self.buf.len(){if!self.next_line(){return None;}}self.pos+=1;Some(self.buf[self.pos-1])}\n\tfn vb(&mut self)->Vec{let mut s=v!([10]);let mut f=false;while let Some(c)=self.byte(){\n\t\tif!c.is_ascii_whitespace(){s.push(c);f=true;}else if f{break;}}s}\n\tfn p(&mut self)->T where T::Err:Debug{let w=self.vb();str::from_utf8(w.as_ref()).unwrap().parse::().unwrap()}\n\tfn u(&mut self) -> usize { self.p() }\n}impl Drop for Reader{fn drop(&mut self){unsafe{Box::from_raw(self.x)};}}\n//----------}}}\n\n// Field (mod prime) {{{\nmod field {\n\tuse std::ops::*;\n\t#[allow(dead_code)] pub const Z0: Field = Field(0);\n\t#[allow(dead_code)] pub const Z1: Field = Field(1);\n\tconst P5: i32 = 998_244_353;\n\tconst P6: i64 = P5 as i64;\n\t#[derive(Debug,Clone,Copy,PartialEq,Eq,PartialOrd,Ord,Default)] pub struct Field(pub i32);\n\t#[allow(dead_code)] impl Field {\n\t\tpub fn new>(a: T) -> Self { Self(Self::cv(a)) }\n\t\tpub unsafe fn new_unchecked(a: i32) -> Self { Self(a) }\n\t\tfn hi(mut a: i32) -> i32 { if a >= P5 { a -= P5; } a }\n\t\tfn lo(mut a: i32) -> i32 { if a < 0 { a += P5; } a }\n\t\tfn cv>(a: T) -> i32 { Self::lo((a.into() % P6) as i32) }\n\t\tpub fn inv(self) -> Self { self.pow(P5-2) }\n\t\tpub fn pow>(self, b: T) -> Self {\n\t\t\tlet b = b.into(); if b == 0 { Self(1) } else {\n\t\t\t\tlet mut res = self.pow(b/2); res *= res; if b % 2 == 1 {res *= self;} res\n\t\t\t}\n\t\t}\n\t}\n\timpl Add for Field { type Output = Self; fn add(self, a: Self) -> Self::Output { Self(Self::hi(self.0 + a.0)) }}\n\timpl Sub for Field { type Output = Self; fn sub(self, a: Self) -> Self::Output { Self(Self::lo(self.0 - a.0)) }}\n\timpl Mul for Field { type Output = Self; fn mul(self, a: Self) -> Self::Output { Self(Self::cv(self.0 as i64 * a.0 as i64)) }}\n\timpl Div for Field { type Output = Self; fn div(self, a: Self) -> Self::Output { self * a.inv() }}\n\timpl Neg for Field { type Output = Self; fn neg(self) -> Self::Output { Self(Self::lo(-self.0)) }}\n\timpl AddAssign for Field { fn add_assign(&mut self, a: Self) { *self = *self + a; } }\n\timpl SubAssign for Field { fn sub_assign(&mut self, a: Self) { *self = *self - a; } }\n\timpl MulAssign for Field { fn mul_assign(&mut self, a: Self) { *self = *self * a; } }\n\timpl DivAssign for Field { fn div_assign(&mut self, a: Self) { *self = *self / a; } }\n\tuse std::fmt::{Display, Formatter, Result};\n\timpl Display for Field { fn fmt(&self, f: &mut Formatter) -> Result { write!(f, \"{}\", self.0) } }\n}\n#[allow(unused_imports)] use field::{Field, Field as Z, Z0, Z1};\n//}}}\n\nfn main() {\n\tlet (mut rin,mut rout) = rio();\n\tconst N: usize = 500;\n\n\tl!(mut f,fi = v!([N+1] = Z1));\n\tfor i in 2..N {\n\t\tf[i] = f[i-1] * Z::new(i as i32);\n\t\tfi[i] = f[i].inv();\n\t}\n\tlet cnr = |n,r| -> Z {\n\t\tif r > n {\n\t\t\tZ0\n\t\t} else {\n\t\t\tf[n] * fi[n-r] * fi[r]\n\t\t}\n\t};\n\tlet mut p = v!([N+1][N+1]);\n\tfor i in 0..=N {\n\t\tlet x = Z::new(i as i32);\n\t\tlet mut y = Z1;\n\t\tlet p = &mut p[i];\n\t\trp!{[N+1]\n\t\t\tp.push(y);\n\t\t\ty *= x;\n\t\t}\n\t}\n\n\tl!(n,x = rin.u());\n\tlet mut dp = v!([x+1][n+1] = Z0);\n\tlet mut s = Z0;\n\tfor i in 1..=x {\n\t\tdp[i][1] = Z1;\n\t\tfor j in 2..=n.min(i) {\n\t\t\tlet mut res = Z0;\n\t\t\tfor k in 1..=j {\n\t\t\t\tres += dp[i-j+1][k] * p[j-1][j-k] * cnr(j-1,k-1);\n\t\t\t}\n\t\t\tdp[i][j] = res;\n\t\t}\n\t\ts += dp[i][n];\n\t}\n\ts *= Z::new(n as i32);\n\tlet ans = p[x][n] - s;\n\twriteln!(rout, \"{}\", ans).unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics"], "code_uid": "2cf94331e78dad75176683c144898017", "src_uid": "1908d1c8c6b122a4c6633a7af094f17f", "difficulty": 2100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(dead_code, unused_macros, unused_imports)]\nuse std::{cell::{Cell, RefCell, UnsafeCell}, cmp::{Ordering, Reverse, max, min}, collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque, hash_map::{DefaultHasher, RandomState}}, error::Error, fmt::{Display, Write as FmtWrite}, hash::{BuildHasher, Hash, Hasher}, io::{BufWriter, Read, Stdin, Stdout, Write}, iter::{FromIterator, Peekable}, mem::swap, ops::*, process::exit, rc::Rc, str::{FromStr, from_utf8_unchecked}, time::{Duration, Instant}};\n\nconst IO_BUF_SIZE: usize = 1 << 16;\ntype Input = Scanner;\ntype Output = BufWriter;\nfn _init_input() -> Input { Scanner::new(std::io::stdin()) }\nfn _init_output() -> Output { BufWriter::with_capacity(IO_BUF_SIZE, std::io::stdout()) }\n\n#[repr(transparent)] struct Unsync(T);\nunsafe impl Sync for Unsync {}\n \ntype BadLazy = Unsync>>;\nimpl BadLazy {\n const fn new() -> Self { Self(UnsafeCell::new(None)) }\n}\n \nstatic INPUT: BadLazy = BadLazy::new();\nstatic OUTPUT: BadLazy = BadLazy::new();\n \nfn inp R, R>(f: F) -> R {\n unsafe { f((&mut *INPUT.0.get()).get_or_insert_with(_init_input)) }\n}\nfn out R, R>(f: F) -> R {\n unsafe { f((&mut *OUTPUT.0.get()).get_or_insert_with(_init_output)) }\n}\n\nmacro_rules! read {\n () => { read() };\n ($t: ty) => { read::<$t>() };\n ($t: ty, $($tt: ty),*) => { (read::<$t>(), $(read::<$tt>(),)*) };\n [$t: ty; $n: expr] => { read_vec::<$t>($n) };\n}\nmacro_rules! println { \n () => { out(|x| { let _ = writeln!(x); }) };\n ($exp: expr) => { out(|x| { let _ = writeln!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = writeln!(x, $fmt, $($arg)*); }) }\n}\nmacro_rules! print { \n ($exp: expr) => { out(|x| { let _ = write!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = write!(x, $fmt, $($arg)*); }) }\n}\n\nfn out_flush() { out(|x| { let _ = x.flush(); }); }\n\nfn input_is_eof() -> bool { inp(|x| x.eof()) }\nfn read_byte() -> u8 { inp(|x| x.byte()) }\nfn read_bytes_no_skip(n: usize) -> Vec { inp(|x| x.bytes_no_skip(n)) }\nfn read_bytes(n: usize) -> Vec { inp(|x| x.bytes(n)) }\nfn read_bytes2(n: usize, m: usize) -> Vec> { inp(|x| x.bytes2(n, m)) }\nfn read_token() -> Vec { inp(|x| x.token_bytes()) }\nfn read_token_str() -> String { unsafe { String::from_utf8_unchecked(read_token()) } }\nfn read_line() -> Vec { inp(|x| x.line_bytes()) }\nfn read_line_str() -> String { unsafe { String::from_utf8_unchecked(read_line()) } }\nfn read() -> T { read_token_str().parse::().ok().expect(\"failed parse\") }\nfn read_vec(n: usize) -> Vec { (0..n).map(|_| read()).collect() }\nfn read_vec2(n: usize, m: usize) -> Vec> { (0..n).map(|_| read_vec(m)).collect() }\n\nstruct Scanner {\n src: R,\n _buf: Vec,\n _pt: usize, // pointer\n _rd: usize, // bytes read\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new(src: R) -> Scanner {\n Scanner { src, _buf: vec![0; IO_BUF_SIZE], _pt: 1, _rd: 1 }\n }\n \n fn _check_buf(&mut self) {\n if self._pt == self._rd {\n self._rd = self.src.read(&mut self._buf).unwrap_or(0);\n self._pt = (self._rd == 0) as usize;\n }\n }\n \n // returns true if end of file\n fn eof(&mut self) -> bool {\n self._check_buf();\n self._rd == 0\n }\n \n // filters \\r, returns \\0 if eof\n fn byte(&mut self) -> u8 {\n loop {\n self._check_buf();\n if self._rd == 0 { return 0; }\n let res = self._buf[self._pt];\n self._pt += 1;\n if res != b'\\r' { return res; }\n }\n }\n\n fn bytes_no_skip(&mut self, n: usize) -> Vec { (0..n).map(|_| self.byte()).collect() }\n fn bytes(&mut self, n: usize) -> Vec {\n let res = self.bytes_no_skip(n);\n self.byte();\n res\n }\n fn bytes2(&mut self, n: usize, m: usize) -> Vec> { (0..n).map(|_| self.bytes(m)).collect() }\n \n fn token_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c <= b' ' {\n if c == b'\\0' { return res; }\n c = self.byte();\n }\n loop {\n res.push(c);\n c = self.byte();\n if c <= b' ' { return res; }\n }\n }\n \n fn line_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c != b'\\n' && c != b'\\0' {\n res.push(c);\n c = self.byte();\n }\n res\n }\n}\n\ntrait JoinToStr { \n fn join_to_str(self, sep: &str) -> String;\n fn concat_to_str(self) -> String;\n}\nimpl> JoinToStr for I { \n fn join_to_str(mut self, sep: &str) -> String {\n match self.next() {\n Some(first) => {\n let mut res = first.to_string();\n while let Some(item) = self.next() {\n res.push_str(sep);\n res.push_str(&item.to_string());\n }\n res\n }\n None => { String::new() }\n }\n }\n \n fn concat_to_str(self) -> String {\n let mut res = String::new();\n for item in self { res.push_str(&item.to_string()); }\n res\n }\n}\ntrait AsStr { fn as_str(&self) -> &str; }\nimpl AsStr for [u8] { fn as_str(&self) -> &str {std::str::from_utf8(self).expect(\"attempt to convert non-UTF8 byte string.\")} }\n\nmacro_rules! veci {\n ($n:expr , $i:ident : $gen:expr) => {{\n let _veci_n = $n;\n let mut _veci_list = Vec::with_capacity(_veci_n);\n for $i in 0.._veci_n {\n _veci_list.push($gen);\n }\n _veci_list\n }};\n ($n:expr , $gen:expr) => { veci!($n, _veci_: $gen); }\n}\n\nfn abs_diff + PartialOrd>(x: T, y: T) -> T {\n if x < y { y - x } else { x - y }\n}\n\ntrait CommonNumExt {\n fn div_ceil(self, b: Self) -> Self;\n fn div_floor(self, b: Self) -> Self;\n fn gcd(self, b: Self) -> Self;\n fn highest_one(self) -> Self;\n fn lowest_one(self) -> Self;\n}\n\nmacro_rules! impl_common_num_ext {\n ($($ix:tt = $ux:tt),*) => {\n $(\n impl CommonNumExt for $ux {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { self / b }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self; while a != 0 { swap(&mut a, &mut b); a %= b; }\n b\n }\n #[inline] fn highest_one(self) -> Self { \n if self == 0 { 0 } else { const ONE: $ux = 1; ONE.rotate_right(1) >> self.leading_zeros() } \n }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n }\n\n impl CommonNumExt for $ix {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if self ^ b >= 0 && r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { \n let q = self / b; let r = self % b;\n if self ^ b < 0 && r != 0 { q - 1 } else { q }\n }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self; while a != 0 { swap(&mut a, &mut b); a %= b; }\n b.abs()\n }\n #[inline] fn highest_one(self) -> Self { (self as $ux).highest_one() as _ }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n }\n )*\n }\n}\nimpl_common_num_ext!(i8 = u8, i16 = u16, i32 = u32, i64 = u64, i128 = u128, isize = usize);\n\ntrait ChMaxMin {\n fn set_max(&mut self, v: T) -> bool;\n fn set_min(&mut self, v: T) -> bool;\n}\nimpl ChMaxMin for T {\n fn set_max(&mut self, v: T) -> bool { if v > *self { *self = v; true } else { false } }\n fn set_min(&mut self, v: T) -> bool { if v < *self { *self = v; true } else { false } }\n}\n\n// * end commons * //\n\n#[macro_use]\n#[allow(dead_code)]\nmod modint {\n use std::{fmt::{Display, Formatter}, marker::PhantomData, mem::swap, ops::*, str::FromStr, cell::Cell};\n use crate::ModInt;\n \n pub trait RemEuclidU32: Copy {\n /// Calculates `self` _mod_ `modulus` losslessly.\n fn rem_euclid_u32(self, modulus: u32) -> u32;\n }\n \n macro_rules! impl_rem_euclid_u32_for_small_signed {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self as i64).rem_euclid(i64::from(modulus)) as _\n }\n }\n )*\n }\n }\n \n impl_rem_euclid_u32_for_small_signed!(i8, i16, i32, i64, isize);\n \n impl RemEuclidU32 for i128 {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self.rem_euclid(i128::from(modulus)) as _\n }\n }\n \n macro_rules! impl_rem_euclid_u32_for_small_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self as u32 % modulus\n }\n }\n )*\n }\n }\n \n macro_rules! impl_rem_euclid_u32_for_large_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self % (modulus as $ty)) as _\n }\n }\n )*\n }\n }\n \n impl_rem_euclid_u32_for_small_unsigned!(u8, u16, u32);\n impl_rem_euclid_u32_for_large_unsigned!(u64, u128);\n \n #[cfg(target_pointer_width = \"32\")]\n impl_rem_euclid_u32_for_small_unsigned!(usize);\n \n #[cfg(target_pointer_width = \"64\")]\n impl_rem_euclid_u32_for_large_unsigned!(usize);\n #[inline]\n pub fn mul_mod_u32(a: u32, b: u32, m: u32) -> u32 {\n (a as u64 * b as u64 % m as u64) as u32\n }\n \n // for a, b < m, unspecified otherwise\n #[inline]\n fn add_mod_raw(a: u32, b: u32, m: u32) -> u32 {\n let (r, c) = a.wrapping_sub(m).overflowing_add(b);\n if c { r } else { r.wrapping_add(m) }\n }\n #[inline]\n fn sub_mod_raw(a: u32, b: u32, m: u32) -> u32 {\n let (r, c) = a.overflowing_sub(b);\n if c { r.wrapping_add(m) } else { r }\n }\n fn pow_mod_raw(a: u32, mut k: u64, m: u32) -> u32 {\n if m == 1 { return 0; }\n let mut a = a as u64;\n let m = m as u64;\n let mut r: u64 = 1;\n while k > 0 {\n if k & 1 == 1 {\n r = r * a % m;\n }\n k >>= 1;\n a = a * a % m;\n }\n r as u32\n }\n \n /// # Parameters\n /// * `b` `1 <= b`\n /// # Returns\n /// (x, g) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g\n fn inv_gcd(a: i64, b: i64) -> (i64, i64) {\n let a = a.rem_euclid(b);\n if a == 0 { return (0, b); }\n let mut s = b;\n let mut t = a;\n let mut m0 = 0;\n let mut m1 = 1;\n \n while t != 0 {\n let u = s / t;\n s -= t * u;\n m0 -= m1 * u;\n swap(&mut s, &mut t);\n swap(&mut m0, &mut m1);\n }\n \n if m0 < 0 { m0 += b / s; }\n (m0, s)\n }\n \n pub trait Modulus: Copy + Eq {\n fn get_modulus() -> u32;\n }\n \n #[derive(Clone, Copy, PartialEq, Eq, Hash)]\n #[repr(transparent)]\n pub struct ModIntBase { \n val: u32,\n _phantom: PhantomData\n }\n \n impl ModIntBase {\n #[inline(always)]\n pub fn modulus() -> u32 { M::get_modulus() }\n #[inline] pub fn new(val: I) -> Self { Self::raw(val.rem_euclid_u32(Self::modulus())) }\n #[inline] pub fn raw(val: u32) -> Self { Self { val, _phantom: PhantomData } }\n pub fn inv(self) -> Self { \n let (x, gcd) = inv_gcd(self.val.into(), Self::modulus().into());\n debug_assert!(gcd == 1, \"the multiplicative inverse {}^-1 mod {} does not exist\", self.val, Self::modulus());\n Self::raw(x as u32)\n }\n #[inline] pub fn val(self) -> u32 { self.val }\n #[inline] pub fn pow(self, k: u64) -> Self {\n Self::raw(pow_mod_raw(self.val, k, Self::modulus()))\n }\n pub fn powi(self, k: i64) -> Self { if k < 0 { self.inv().pow(-k as _) } else { self.pow(k as _) } }\n pub fn pow_vec(self, n: usize) -> Vec {\n let mut res = vec![Self::raw(0); n+1];\n res[0] += 1;\n for i in 1..=n {\n res[i] = res[i-1] * self;\n }\n res\n }\n }\n \n #[inline]\n pub fn mi(val: I) -> ModInt { ModIntBase::new(val) }\n #[inline] pub fn mir(v: u32) -> ModInt { ModIntBase::raw(v) }\n \n impl From for ModIntBase {\n #[inline]\n fn from(from: V) -> Self { Self::new(from) }\n }\n impl Default for ModIntBase {\n fn default() -> Self { Self::raw(0) }\n }\n impl FromStr for ModIntBase {\n type Err = std::convert::Infallible;\n #[inline]\n fn from_str(s: &str) -> Result {\n Ok(s.parse::()\n .map(Self::new)\n .unwrap_or_else(|_| todo!(\"parsing as an arbitrary precision integer?\")))\n }\n }\n impl Display for ModIntBase {\n #[inline]\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n self.val.fmt(f)\n }\n }\n impl std::fmt::Debug for ModIntBase {\n #[inline]\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n std::fmt::Debug::fmt(&self.val, f)\n }\n }\n impl Neg for ModIntBase {\n type Output = Self;\n \n #[inline]\n fn neg(self) -> Self::Output {\n Self::raw(0) - self\n }\n }\n \n impl>, M: Modulus> Add for ModIntBase {\n type Output = Self;\n #[inline]\n fn add(self, rhs: V) -> Self::Output {\n Self::raw(add_mod_raw(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Sub for ModIntBase {\n type Output = Self;\n #[inline]\n fn sub(self, rhs: V) -> Self::Output {\n Self::raw(sub_mod_raw(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Mul for ModIntBase {\n type Output = Self;\n #[inline]\n fn mul(self, rhs: V) -> Self::Output {\n Self::raw(mul_mod_u32(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Div for ModIntBase {\n type Output = Self;\n #[inline]\n fn div(self, rhs: V) -> Self::Output { self * rhs.into().inv() }\n }\n \n impl >, M: Modulus> AddAssign for ModIntBase {\n #[inline]\n fn add_assign(&mut self, rhs: V) { *self = *self + rhs; }\n }\n impl >, M: Modulus> SubAssign for ModIntBase {\n #[inline]\n fn sub_assign(&mut self, rhs: V) { *self = *self - rhs; }\n }\n impl >, M: Modulus> MulAssign for ModIntBase {\n #[inline]\n fn mul_assign(&mut self, rhs: V) { *self = *self * rhs; }\n }\n impl >, M: Modulus> DivAssign for ModIntBase {\n #[inline]\n fn div_assign(&mut self, rhs: V) { *self = *self / rhs; }\n }\n \n impl std::iter::Sum for ModIntBase {\n #[inline] fn sum>(iter: I) -> Self {\n iter.fold(Self::raw(0), Add::add)\n }\n }\n impl std::iter::Product for ModIntBase {\n #[inline] fn product>(iter: I) -> Self {\n iter.fold(1.into(), Mul::mul)\n }\n }\n impl<'a, M: Modulus> std::iter::Sum<&'a Self> for ModIntBase {\n #[inline] fn sum>(iter: I) -> ModIntBase {\n iter.fold(Self::raw(0), |a, &b| a + b)\n }\n }\n impl<'a, M: Modulus> std::iter::Product<&'a Self> for ModIntBase {\n #[inline] fn product>(iter: I) -> ModIntBase {\n iter.fold(1.into(), |a, &b| a * b)\n }\n }\n \n macro_rules! const_modulus {\n ($mint: ident, $name: ident, $modulus: expr) => {\n #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]\n pub enum $name {}\n impl Modulus for $name {\n #[inline(always)] fn get_modulus() -> u32 { $modulus }\n }\n pub type $mint = ModIntBase<$name>;\n }\n }\n \n macro_rules! dynamic_modulus {\n ($mint: ident, $name: ident, $modulus: ident) => {\n static $modulus: crate::Unsync> = crate::Unsync(Cell::new(0));\n #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]\n pub enum $name {}\n impl Modulus for $name {\n fn get_modulus() -> u32 { $modulus.0.get() }\n }\n impl $name {\n pub fn set_modulus(val: u32) { $modulus.0.set(val) }\n }\n pub type $mint = ModIntBase<$name>;\n }\n }\n \n const_modulus!(ModInt998_244_353, Mod998_244_353, 998_244_353);\n const_modulus!(ModInt1_000_000_007, Mod1_000_000_007, 1_000_000_007);\n dynamic_modulus!(DynamicModInt, DynamicModulus, DYNAMIC_MODULUS);\n}\n \nuse crate::modint::*;\ntype ModInt = ModInt998_244_353;\n// type ModInt = ModInt1_000_000_007;\n// const_modulus!(ModInt, DefaultModulus, 1_000_000_009);\n// type ModInt = DynamicModInt;\n\n\nfn mod_factorials(maxn: usize) -> Vec {\n let mut res = vec![ModInt::default(); maxn+1];\n res[0] = 1.into();\n for i in 1..=maxn {\n res[i] = res[i-1] * i\n }\n return res;\n}\n\nstruct ModCombinatorics {\n factorials: Vec,\n inv_factorials: Vec\n}\nimpl ModCombinatorics {\n fn new(maxn: usize) -> Self {\n let factorials = mod_factorials(maxn);\n let mut inv = vec![ModInt::default(); maxn+1];\n inv[maxn] = factorials[maxn].inv();\n for i in (1..=maxn).rev() {\n inv[i-1] = inv[i] * i;\n }\n Self { factorials, inv_factorials: inv }\n }\n #[inline]\n fn factorial(&self, n: usize) -> ModInt { self.factorials[n] }\n #[inline]\n fn inv_factorial(&self, n: usize) -> ModInt { self.inv_factorials[n] }\n fn P(&self, n: usize, k: usize) -> ModInt {\n if k > n { ModInt::raw(0) } else { self.factorial(n) * self.inv_factorial(n-k) }\n }\n fn C(&self, n: usize, k: usize) -> ModInt {\n if k > n { ModInt::raw(0) } else { self.factorial(n) * self.inv_factorial(k) * self.inv_factorial(n-k) }\n }\n\n // multi-choose, be sure to adjust maxn accordingly\n fn M(&self, n: usize, k: usize) -> ModInt {\n if k == 0 { 1.into() } else { self.C(n + k - 1, k) }\n }\n}\n \n#[allow(non_snake_case, non_upper_case_globals)]\nfn main() {\n let num_cases: usize = 1;//read();\n \n for _case_num in 1..=num_cases {\n let n = read!(usize);\n let x = read!(usize);\n\n let mc = ModCombinatorics::new(n);\n\n let P = veci!(x+1, i: ModInt::pow_vec(mi(i), n));\n\n struct Dp<'a> {\n D: Vec>>>,\n f: &'a dyn Fn(&Dp, usize, usize) -> ModInt\n }\n\n let dp = Dp {\n D: vec![vec![Cell::new(None); x+1]; n+1],\n f: &mut|dp, i, j| {\n match dp.D[i][j].get() {\n Some(x) => x,\n None => {\n let res = if j < i { P[j][i] - P[j-1][i] } else {\n (2..=i).map(|k| (dp.f)(dp, k, j-(i-1)) * mc.C(i, k) * P[i-1][i-k]).sum()\n };\n\n dp.D[i][j].set(Some(res));\n res\n }\n }\n }\n };\n\n\n let mut ans = mi(0);\n for i in 1..=x { ans += (dp.f)(&dp, n, i); }\n println!(ans);\n }\n \n out_flush();\n}", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics"], "code_uid": "48e21bd77c99bde74ca53dca56c7dd61", "src_uid": "1908d1c8c6b122a4c6633a7af094f17f", "difficulty": 2100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\n#[allow(unused_imports)]\nuse std::io::{self,Read};\n\nstruct WordReader {\n it : std::vec::IntoIter,\n}\n#[allow(dead_code)]\nimpl WordReader {\n fn new(mut reader : T) -> WordReader {\n let mut s = String::new();\n reader.read_to_string(&mut s).unwrap();\n WordReader { it : s\n .split_ascii_whitespace()\n .map(String::from).collect::>()\n .into_iter()\n }\n }\n fn from_stdin() -> WordReader {\n WordReader::new(std::io::stdin())\n }\n fn s(&mut self) -> String {\n self.it.next().unwrap()\n }\n fn ab(&mut self) -> Vec {\n self.it.next().unwrap().into_bytes()\n }\n fn i(&mut self) -> i32 {\n self.it.next().unwrap().parse().unwrap()\n }\n}\n\nfn main() {\n let mut input = WordReader::from_stdin();\n let n = input.i() as usize;\n let t = input.i();\n let mut a = input.ab();\n\n for _ in 0..t {\n let mut b = a.clone();\n for i in (0..n-1).rev() {\n if a[i] == b'B' && a[i + 1] == b'G' {\n b[i] = b'G';\n b[i + 1] = b'B';\n }\n }\n a = b;\n }\n println!(\"{}\", String::from_utf8(a).unwrap());\n}\n\n", "lang_cluster": "Rust", "tags": ["constructive algorithms", "implementation", "shortest paths", "graph matchings"], "code_uid": "4a38b3d23f59218bebf397a581dd0459", "src_uid": "964ed316c6e6715120039b0219cc653a", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let (num,turns,mut list)=input();\n for _ in 0..turns{\n let mut ii=1;\n while ii String{\n let mut input=String::new();\n io::stdin().read_line(&mut input).expect(\"unable to read\");\n input.trim().to_string()\n}\n\nfn input() -> (i32,i32,Vec){\n let inp=read();\n let list: Vec<_>=inp.split_whitespace().collect();\n let qu: Vec<_>=read().chars().collect();\n (list[0].parse::().expect(\"Failed to parse\"),\n list[1].parse::().expect(\"Failed to parse\"),qu)\n}", "lang_cluster": "Rust", "tags": ["constructive algorithms", "implementation", "shortest paths", "graph matchings"], "code_uid": "bdd931cf9b881218540fb12152bf07af", "src_uid": "964ed316c6e6715120039b0219cc653a", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin ModInt ----------\r\n// \u30e2\u30f3\u30b4\u30e1\u30ea\u4e57\u7b97\u3092\u7528\u3044\u308b\r\n// \u307b\u307cCodeforces\u7528\r\n// \u6ce8\u610f\r\n// new_unchecked \u306f\u5024x\u304c 0 <= x < modulo \u3067\u3042\u308b\u3053\u3068\u3092\u4eee\u5b9a\r\n// ModInt \u306e\u4e2d\u8eab\u306f\u6b63\u898f\u5316\u3055\u308c\u305f\u5024\u3067\u6301\u3063\u3066\u308b\u306e\u3067\u76f4\u63a5\u8aad\u3093\u3060\u308a\u66f8\u3044\u305f\u308a\u3059\u308b\u3068\u3076\u3063\u58ca\u308c\u308b\r\n// \u5947\u7d20\u6570\u306e\u307f\r\nmod modint {\r\n\r\n use std::marker::*;\r\n use std::ops::*;\r\n\r\n pub trait Modulo {\r\n fn modulo() -> u32;\r\n fn rem() -> u32;\r\n fn ini() -> u64;\r\n fn reduce(x: u64) -> u32 {\r\n assert!(x < (Self::modulo() as u64) << 32);\r\n let b = (x as u32 * Self::rem()) as u64;\r\n let t = x + b * Self::modulo() as u64;\r\n let mut c = (t >> 32) as u32;\r\n if c >= Self::modulo() {\r\n c -= Self::modulo();\r\n }\r\n c as u32\r\n }\r\n }\r\n\r\n #[allow(dead_code)]\r\n pub enum Mod1_000_000_007 {}\r\n\r\n impl Modulo for Mod1_000_000_007 {\r\n fn modulo() -> u32 {\r\n 1_000_000_007\r\n }\r\n fn rem() -> u32 {\r\n 2226617417\r\n }\r\n fn ini() -> u64 {\r\n 582344008\r\n }\r\n }\r\n\r\n #[allow(dead_code)]\r\n pub enum Mod998_244_353 {}\r\n\r\n impl Modulo for Mod998_244_353 {\r\n fn modulo() -> u32 {\r\n 998_244_353\r\n }\r\n fn rem() -> u32 {\r\n 998244351\r\n }\r\n fn ini() -> u64 {\r\n 932051910\r\n }\r\n }\r\n\r\n #[allow(dead_code)]\r\n pub fn generate_umekomi_modulo(p: u32) {\r\n assert!(\r\n p < (1 << 31)\r\n && p > 2\r\n && p & 1 == 1\r\n && (2u32..).take_while(|v| v * v <= p).all(|k| p % k != 0)\r\n );\r\n let mut t = 1u32;\r\n let mut s = !p + 1;\r\n let mut n = !0u32 >> 2;\r\n while n > 0 {\r\n if n & 1 == 1 {\r\n t *= s;\r\n }\r\n s *= s;\r\n n >>= 1;\r\n }\r\n let mut ini = (1u64 << 32) % p as u64;\r\n ini = (ini << 32) % p as u64;\r\n assert!(t * p == !0);\r\n println!(\"pub enum Mod{} {{}}\", p);\r\n println!(\"impl Modulo for Mod{} {{\", p);\r\n println!(\" fn modulo() -> u32 {{\");\r\n println!(\" {}\", p);\r\n println!(\" }}\");\r\n println!(\" fn rem() -> u32 {{\");\r\n println!(\" {}\", t);\r\n println!(\" }}\");\r\n println!(\" fn ini() -> u32 {{\");\r\n println!(\" {}\", ini);\r\n println!(\" }}\");\r\n println!(\"}}\");\r\n let mut f = vec![];\r\n let mut n = p - 1;\r\n for i in 2.. {\r\n if i * i > n {\r\n break;\r\n }\r\n if n % i == 0 {\r\n f.push(i);\r\n while n % i == 0 {\r\n n /= i;\r\n }\r\n }\r\n }\r\n if n > 1 {\r\n f.push(n);\r\n }\r\n let mut order = 1;\r\n let mut n = p - 1;\r\n while n % 2 == 0 {\r\n n /= 2;\r\n order <<= 1;\r\n }\r\n let z = (2u64..)\r\n .find(|z| {\r\n f.iter()\r\n .all(|f| mod_pow(*z, ((p - 1) / *f) as u64, p as u64) != 1)\r\n })\r\n .unwrap();\r\n let zeta = mod_pow(z, ((p - 1) / order) as u64, p as u64);\r\n println!(\"impl transform::NTTFriendly for Mod{} {{\", p);\r\n println!(\" fn order() -> usize {{\");\r\n println!(\" {}\", order);\r\n println!(\" }}\");\r\n println!(\" fn zeta() -> u32 {{\");\r\n println!(\" {}\", zeta);\r\n println!(\" }}\");\r\n println!(\"}}\");\r\n }\r\n\r\n pub struct ModInt(u32, PhantomData);\r\n\r\n impl Clone for ModInt {\r\n fn clone(&self) -> Self {\r\n ModInt::build(self.0)\r\n }\r\n }\r\n\r\n impl Copy for ModInt {}\r\n\r\n impl Add for ModInt {\r\n type Output = ModInt;\r\n fn add(self, rhs: Self) -> Self::Output {\r\n let mut d = self.0 + rhs.0;\r\n if d >= T::modulo() {\r\n d -= T::modulo();\r\n }\r\n Self::build(d)\r\n }\r\n }\r\n\r\n impl AddAssign for ModInt {\r\n fn add_assign(&mut self, rhs: Self) {\r\n *self = *self + rhs;\r\n }\r\n }\r\n\r\n impl Sub for ModInt {\r\n type Output = ModInt;\r\n fn sub(self, rhs: Self) -> Self::Output {\r\n let mut d = self.0 - rhs.0;\r\n if d >= T::modulo() {\r\n d += T::modulo();\r\n }\r\n Self::build(d)\r\n }\r\n }\r\n\r\n impl SubAssign for ModInt {\r\n fn sub_assign(&mut self, rhs: Self) {\r\n *self = *self - rhs;\r\n }\r\n }\r\n\r\n impl Mul for ModInt {\r\n type Output = ModInt;\r\n fn mul(self, rhs: Self) -> Self::Output {\r\n Self::build(T::reduce(self.0 as u64 * rhs.0 as u64))\r\n }\r\n }\r\n\r\n impl MulAssign for ModInt {\r\n fn mul_assign(&mut self, rhs: Self) {\r\n *self = *self * rhs;\r\n }\r\n }\r\n\r\n impl Neg for ModInt {\r\n type Output = ModInt;\r\n fn neg(self) -> Self::Output {\r\n if self.0 == 0 {\r\n Self::zero()\r\n } else {\r\n Self::build(T::modulo() - self.0)\r\n }\r\n }\r\n }\r\n\r\n impl std::fmt::Display for ModInt {\r\n fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {\r\n write!(f, \"{}\", self.get())\r\n }\r\n }\r\n\r\n impl std::fmt::Debug for ModInt {\r\n fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {\r\n write!(f, \"{}\", self.get())\r\n }\r\n }\r\n\r\n impl std::str::FromStr for ModInt {\r\n type Err = std::num::ParseIntError;\r\n fn from_str(s: &str) -> Result {\r\n let val = s.parse::()?;\r\n Ok(ModInt::new(val))\r\n }\r\n }\r\n\r\n impl From for ModInt {\r\n fn from(val: usize) -> ModInt {\r\n ModInt::new_unchecked((val % T::modulo() as usize) as u32)\r\n }\r\n }\r\n\r\n impl From for ModInt {\r\n fn from(val: u64) -> ModInt {\r\n ModInt::new_unchecked((val % T::modulo() as u64) as u32)\r\n }\r\n }\r\n\r\n impl From for ModInt {\r\n fn from(val: i64) -> ModInt {\r\n let m = T::modulo() as i64;\r\n ModInt::new((val % m + m) as u32)\r\n }\r\n }\r\n\r\n #[allow(dead_code)]\r\n impl ModInt {\r\n fn build(d: u32) -> Self {\r\n ModInt(d, PhantomData)\r\n }\r\n pub fn zero() -> Self {\r\n Self::build(0)\r\n }\r\n pub fn is_zero(&self) -> bool {\r\n self.0 == 0\r\n }\r\n }\r\n\r\n #[allow(dead_code)]\r\n impl ModInt {\r\n pub fn new_unchecked(d: u32) -> Self {\r\n Self::build(T::reduce(d as u64 * T::ini()))\r\n }\r\n pub fn new(d: u32) -> Self {\r\n Self::new_unchecked(d % T::modulo())\r\n }\r\n pub fn one() -> Self {\r\n Self::new_unchecked(1)\r\n }\r\n pub fn get(&self) -> u32 {\r\n T::reduce(self.0 as u64)\r\n }\r\n pub fn pow(&self, mut n: u64) -> Self {\r\n let mut t = Self::one();\r\n let mut s = *self;\r\n while n > 0 {\r\n if n & 1 == 1 {\r\n t *= s;\r\n }\r\n s *= s;\r\n n >>= 1;\r\n }\r\n t\r\n }\r\n pub fn inv(&self) -> Self {\r\n assert!(!self.is_zero());\r\n self.pow((T::modulo() - 2) as u64)\r\n }\r\n }\r\n\r\n pub fn mod_pow(mut r: u64, mut n: u64, m: u64) -> u64 {\r\n let mut t = 1 % m;\r\n while n > 0 {\r\n if n & 1 == 1 {\r\n t = t * r % m;\r\n }\r\n r = r * r % m;\r\n n >>= 1;\r\n }\r\n t\r\n }\r\n}\r\n// ---------- end ModInt ----------\r\n// ---------- begin Precalc ----------\r\nmod precalc {\r\n use super::modint::*;\r\n #[allow(dead_code)]\r\n pub struct Precalc {\r\n inv: Vec>,\r\n fact: Vec>,\r\n ifact: Vec>,\r\n }\r\n #[allow(dead_code)]\r\n impl Precalc {\r\n pub fn new(n: usize) -> Precalc {\r\n let mut inv = vec![ModInt::one(); n + 1];\r\n let mut fact = vec![ModInt::one(); n + 1];\r\n let mut ifact = vec![ModInt::one(); n + 1];\r\n for i in 2..(n + 1) {\r\n fact[i] = fact[i - 1] * ModInt::new_unchecked(i as u32);\r\n }\r\n ifact[n] = fact[n].inv();\r\n if n > 0 {\r\n inv[n] = ifact[n] * fact[n - 1];\r\n }\r\n for i in (1..n).rev() {\r\n ifact[i] = ifact[i + 1] * ModInt::new_unchecked((i + 1) as u32);\r\n inv[i] = ifact[i] * fact[i - 1];\r\n }\r\n Precalc {\r\n inv: inv,\r\n fact: fact,\r\n ifact: ifact,\r\n }\r\n }\r\n pub fn inv(&self, n: usize) -> ModInt {\r\n assert!(n > 0);\r\n self.inv[n]\r\n }\r\n pub fn fact(&self, n: usize) -> ModInt {\r\n self.fact[n]\r\n }\r\n pub fn ifact(&self, n: usize) -> ModInt {\r\n self.ifact[n]\r\n }\r\n pub fn perm(&self, n: usize, k: usize) -> ModInt {\r\n if k > n {\r\n return ModInt::zero();\r\n }\r\n self.fact[n] * self.ifact[n - k]\r\n }\r\n pub fn comb(&self, n: usize, k: usize) -> ModInt {\r\n if k > n {\r\n return ModInt::zero();\r\n }\r\n self.fact[n] * self.ifact[k] * self.ifact[n - k]\r\n }\r\n }\r\n}\r\n// ---------- end Precalc ----------\r\n\r\nuse modint::*;\r\n\r\ntype M = ModInt;\r\n\r\n// ---------- begin input macro ----------\r\n// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\r\nmacro_rules! input {\r\n (source = $s:expr, $($r:tt)*) => {\r\n let mut iter = $s.split_whitespace();\r\n input_inner!{iter, $($r)*}\r\n };\r\n ($($r:tt)*) => {\r\n let s = {\r\n use std::io::Read;\r\n let mut s = String::new();\r\n std::io::stdin().read_to_string(&mut s).unwrap();\r\n s\r\n };\r\n let mut iter = s.split_whitespace();\r\n input_inner!{iter, $($r)*}\r\n };\r\n}\r\n\r\nmacro_rules! input_inner {\r\n ($iter:expr) => {};\r\n ($iter:expr, ) => {};\r\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\r\n let $var = read_value!($iter, $t);\r\n input_inner!{$iter $($r)*}\r\n };\r\n}\r\n\r\nmacro_rules! read_value {\r\n ($iter:expr, ( $($t:tt),* )) => {\r\n ( $(read_value!($iter, $t)),* )\r\n };\r\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\r\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\r\n };\r\n ($iter:expr, chars) => {\r\n read_value!($iter, String).chars().collect::>()\r\n };\r\n ($iter:expr, bytes) => {\r\n read_value!($iter, String).bytes().collect::>()\r\n };\r\n ($iter:expr, usize1) => {\r\n read_value!($iter, usize) - 1\r\n };\r\n ($iter:expr, $t:ty) => {\r\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\r\n };\r\n}\r\n// ---------- end input macro ----------\r\n\r\nuse std::collections::*;\r\nuse std::io::Write;\r\n\r\ntype Map = BTreeMap;\r\ntype Set = BTreeSet;\r\ntype Deque = VecDeque;\r\n\r\nfn run() {\r\n input! {\r\n h: u64,\r\n w: u64,\r\n k: u64,\r\n r: u64,\r\n c: u64,\r\n a: (u64, u64),\r\n b: (u64, u64),\r\n }\r\n let mut a = a;\r\n let mut b = b;\r\n if a.1 > b.1 {\r\n std::mem::swap(&mut a, &mut b);\r\n }\r\n if a.0 > b.0 {\r\n a.0 = h + 1 - (a.0 + r - 1);\r\n b.0 = h + 1 - (b.0 + r - 1);\r\n }\r\n let mut cnt = h * w;\r\n if a == b {\r\n } else {\r\n cnt -= r * c;\r\n }\r\n let ans = M::from(k).pow(cnt);\r\n println!(\"{}\", ans);\r\n}\r\n\r\nfn main() {\r\n run();\r\n}\r\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "a46f58e734c13609c3d4df7358ec37bc", "src_uid": "3478e6a4ff2415508fd517413d40c13a", "difficulty": 2200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, Stdin};\nuse std::str::{self, FromStr};\nuse std::error::Error;\n\nfn exec() {\n let mut sc = Scanner::new();\n let s: Vec = sc.ne::().into_bytes();\n let k: usize = sc.ne();\n let mut div = 1i64;\n for _ in 0..k {\n div *= 10;\n }\n let n = s.len();\n let mut mi = 100;\n for i in 0..(1 << n) {\n let mut a = Vec::new();\n for j in 0..n {\n if (1 << j) & i != 0 {\n a.push(s[j] - b'0');\n }\n }\n if a.is_empty() {\n continue;\n }\n if a.len() > 1 && a[0] == 0 {\n continue;\n }\n let score = n - (i as usize).count_ones() as usize;\n let mut val = 0i64;\n for j in 0..a.len() {\n val *= 10;\n val += a[j] as i64;\n }\n if val % div == 0 {\n mi = std::cmp::min(mi, score);\n }\n }\n println!(\"{}\", mi);\n}\n\nfn main() {\n const STACK: usize = 16 * 1024 * 1024;\n let _ = std::thread::Builder::new()\n .stack_size(STACK)\n .spawn(|| { exec(); })\n .unwrap()\n .join()\n .unwrap();\n}\n\n#[allow(dead_code)]\nstruct Scanner {\n stdin: Stdin,\n id: usize,\n buf: Vec,\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new() -> Scanner {\n Scanner {\n stdin: io::stdin(),\n id: 0,\n buf: Vec::new(),\n }\n }\n fn next_line(&mut self) -> Option {\n let mut res = String::new();\n match self.stdin.read_line(&mut res) {\n Ok(0) => None,\n Ok(_) => Some(res),\n Err(why) => panic!(\"error in read_line: {}\", why.description()),\n }\n }\n fn next(&mut self) -> Option {\n while self.buf.len() == 0 {\n self.buf = match self.next_line() {\n Some(r) => {\n self.id = 0;\n r.trim().as_bytes().to_owned()\n }\n None => return None,\n };\n }\n let l = self.id;\n assert!(self.buf[l] != b' ');\n let n = self.buf.len();\n let mut r = l;\n while r < n && self.buf[r] != b' ' {\n r += 1;\n }\n let res = match str::from_utf8(&self.buf[l..r]).ok().unwrap().parse::() {\n Ok(s) => Some(s),\n Err(_) => {\n panic!(\"parse error, {:?}\",\n String::from_utf8(self.buf[l..r].to_owned()))\n }\n };\n while r < n && self.buf[r] == b' ' {\n r += 1;\n }\n if r == n {\n self.buf.clear();\n } else {\n self.id = r;\n }\n res\n }\n fn ne(&mut self) -> T {\n self.next::().unwrap()\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "greedy"], "code_uid": "6ffa827d951cb310c75f199dfe5fd46a", "src_uid": "7a8890417aa48c2b93b559ca118853f9", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let s: usize = scan.next();\n let v1: usize = scan.next();\n let v2: usize = scan.next();\n let t1: usize = scan.next();\n let t2: usize = scan.next();\n let score1 = s * v1 + 2 * t1;\n let score2 = s * v2 + 2 * t2;\n if score1 == score2 {\n println!(\"Friendship\");\n } else {\n println!(\"{}\", if score1 < score2 { \"First\" } else { \"Second\" });\n }\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "5c4c742142694218fa64e9386e855ccc", "src_uid": "10226b8efe9e3c473239d747b911a1ef", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str;\n\nfn main() {\n let mut input = String::new();\n io::stdin().read_line(&mut input)\n .expect(\"Failed to read line\");\n let input = input.trim().split(\" \").collect::>();\n\n let s = str_to_int(input[0]);\n let v1 = str_to_int(input[1]);\n let v2 = str_to_int(input[2]);\n let t1 = str_to_int(input[3]);\n let t2 = str_to_int(input[4]);\n\n let cli1 = s*v1 + 2*t1;\n let cli2 = s*v2 + 2*t2;\n\n if cli1 < cli2 {\n println!(\"First\");\n } else if cli1 > cli2 {\n println!(\"Second\");\n } else {\n println!(\"Friendship\");\n }\n}\n\nfn str_to_int(a:&str) -> i32 {\n a.parse::().unwrap()\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "541fc37c5abcf03f657ec998ec848aff", "src_uid": "10226b8efe9e3c473239d747b911a1ef", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn is_interesting(x: usize) -> bool {\n let mut aux = x;\n let mut dsum = 0usize;\n while aux > 0 {\n dsum += aux % 10;\n aux /= 10;\n }\n dsum % 4 == 0\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let mut a: usize = scan.next();\n while !is_interesting(a) {\n a += 1;\n }\n println!(\"{}\", a);\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "b648867301c7e7bce9986171b612f7c1", "src_uid": "bb6fb9516b2c55d1ee47a30d423562d7", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\n\nfn sum_dig(n: i32) -> i32 {\n let mut x = n;\n let mut s = 0;\n while x > 0 {\n s += x % 10;\n x /= 10;\n }\n s\n}\n\nfn main() {\n let mut buf = String::new();\n let _ = stdin().read_line(&mut buf).unwrap();\n let n = buf.trim().trim_end().parse::().unwrap();\n let mut i = n;\n loop {\n if sum_dig(i) % 4 == 0 {\n println!(\"{}\", i);\n break;\n }\n i += 1;\n }\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "6aef083480a7baf3cda1e94dc5a6ec56", "src_uid": "bb6fb9516b2c55d1ee47a30d423562d7", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut n = String::new();\n std::io::stdin().read_line(&mut n);\n let n: i32 = n.trim().parse().unwrap();\n // 1 2 3 4 5\n if n % 5 == 0 {\n println!(\"{:?}\", n / 5);\n } else {\n println!(\"{:?}\", n / 5 + 1);\n }\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "2fef2c61858c643b9b917ee8eb78fcd9", "src_uid": "4b3d65b1b593829e92c852be213922b6", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused)]\nuse std::io;\n\n#[macro_export]\nmacro_rules! dbg {\n ($expr:expr) => {\n match $expr {\n expr => {\n eprintln!(\"{}: {} = {:#?}\", line!(), stringify!($expr), &expr);\n expr\n }\n }\n };\n ($l:literal, $expr:expr) => {\n match $expr {\n expr => {\n eprintln!(concat!(line!(), \": \",\n stringify!($expr), \" = \", $l), &expr);\n ($l, expr)\n }\n }\n }\n}\n\n#[macro_export]\nmacro_rules! ternary { ($condition: expr, $_true: expr, $_false: expr) => { if $condition { $_true } else { $_false } };}\n\nfn main() {\n let mut input = String::new();\n io::stdin().read_line(&mut input).expect(\"\");\n let x: u32 = input.trim().parse().expect(\"\");\n println!(\"{}\", x / 5 + ternary!(x % 5 > 0, 1, 0));\n}", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "28020a99d228eade2f392b68d9a910b9", "src_uid": "4b3d65b1b593829e92c852be213922b6", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// https://codeforces.com/problemset/problem/337/A\nuse std::io;\n\nfn main() {\n let mut line = String::new();\n\n io::stdin()\n .read_line(&mut line)\n .unwrap();\n\n let words: Vec =\n line\n .split_whitespace()\n .map(|x| x.parse().unwrap())\n .collect();\n\n let n = words[0];\n\n let mut line = String::new();\n\n io::stdin()\n .read_line(&mut line)\n .unwrap();\n\n let mut f: Vec =\n line\n .split_whitespace()\n .map(|x| x.parse().unwrap())\n .collect();\n\n f.sort();\n\n let mut minima = 999;\n\n let iter = f.windows(n as usize);\n\n for x in iter {\n minima = std::cmp::min(minima, x.last().unwrap() - x[0]);\n }\n\n println!(\"{}\", minima);\n}\n", "lang_cluster": "Rust", "tags": ["greedy"], "code_uid": "92b5bb8d657891d9ef2c9fd20ef9b56a", "src_uid": "7830aabb0663e645d54004063746e47f", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line);\n let line = line.trim();\n let v: Vec = line.trim().split(\" \").map(|s| s.parse::().unwrap()).collect();\n\n let n = v[0] as usize;\n let mut line = String::new();\n std::io::stdin().read_line(&mut line);\n let line = line.trim();\n let mut v: Vec = line.trim().split(\" \").map(|s| s.parse::().unwrap()).collect();\n \n v.sort();\n let mut ret = std::i32::MAX;\n for i in 0..v.len() - n + 1 {\n let tmp = v[i + n - 1] - v[i];\n ret = std::cmp::min(tmp, ret);\n }\n println!(\"{:?}\", ret);\n\n}\n", "lang_cluster": "Rust", "tags": ["greedy"], "code_uid": "e9a037fb1cd15e377bc3c5d8bcccd28f", "src_uid": "7830aabb0663e645d54004063746e47f", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_macros)]\nmacro_rules! scan {\n () => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().to_string()\n }\n };\n (;;$n:expr) => {\n (0..$n).map(|_| scan!()).collect::>()\n };\n ($t:ty) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().parse::<$t>().unwrap()\n }\n };\n ($($t:ty),*) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n $(iter.next().unwrap().parse::<$t>().unwrap(),)*\n )\n }\n };\n ($t:ty;;) => {\n {\n let mut line: String = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.split_whitespace()\n .map(|t| t.parse::<$t>().unwrap())\n .collect::>()\n }\n };\n ($t:ty;;$n:expr) => {\n (0..$n).map(|_| scan!($t;;)).collect::>()\n };\n ($t:ty; $n:expr) => {\n (0..$n).map(|_|\n scan!($t)\n ).collect::>()\n };\n ($($t:ty),*; $n:expr) => {\n (0..$n).map(|_|\n scan!($($t),*)\n ).collect::>()\n };\n}\n\nfn main() {\n let (w1, h1, w2, h2) = scan!(i64, i64, i64, i64);\n println!(\"{}\", w1 + 2 * h1 + 4 + w2 + 2 * h2 + w1 - w2);\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "cf6e19e5e1d506283b3ce70d3bd230b2", "src_uid": "b5d44e0041053c996938aadd1b3865f6", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut sin = String::new();\n std::io::stdin().read_line(&mut sin).expect(\"read error\");\n let vi32: Vec = sin.split_whitespace().map(|c| c.parse().unwrap()).collect();\n let (w1, h1, w2, h2) = (vi32[0], vi32[1], vi32[2], vi32[3]);\n let ret = (h1 + h2) * 2 + (w1 + w2) + 4 + if w1 > w2 { w1 - w2 } else { 0 };\n println!(\"{}\", ret);\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "12070d31959892957bd0ff530cfadaff", "src_uid": "b5d44e0041053c996938aadd1b3865f6", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut text = String::new();\n std::io::stdin().read_line(&mut text).unwrap();\n let mut x = text.trim().parse::().unwrap();\n let mut xx = 0;\n while x > 0 {\n let d = x % 10;\n x = x / 10;\n if d == 7 || d == 4 {\n xx = xx + 1;\n }\n }\n if xx == 0 {\n println!(\"NO\");\n return;\n }\n while xx > 0 {\n let d = xx % 10;\n xx = xx / 10;\n if d != 4 && d != 7 {\n println!(\"NO\");\n return;\n }\n }\n println!(\"YES\");\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "45cc7854ac31400acccf2c0e5ad44162", "src_uid": "33b73fd9e7f19894ea08e98b790d07f1", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\n\nfn main() {\n let mut buf = String::new();\n let _ = stdin().read_line(&mut buf);\n let mut ans = 0;\n for i in buf.trim_end().chars() {\n if i == '4' || i == '7' {\n ans += 1;\n };\n }\n println!(\"{}\", if ans == 4 || ans == 7 { \"YES\" } else { \"NO\" });\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "6062b8185e79d0b154ebc2bd34c54af5", "src_uid": "33b73fd9e7f19894ea08e98b790d07f1", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports, unused_macros, non_snake_case)]\nuse std::cmp::{max, min, Ordering};\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\n\nfn run() {\n let stdin = std::io::stdin();\n let mut sc = Scanner::new(stdin.lock());\n let mut n: usize = sc.read();\n let k: usize = sc.read();\n for _ in 0..k {\n if n % 10 == 0 {\n n /= 10;\n } else {\n n -= 1;\n }\n }\n println!(\"{}\", n);\n}\n\nfn main() {\n std::thread::Builder::new()\n .name(\"run\".to_string())\n .stack_size(256 * 1024 * 1024)\n .spawn(run)\n .unwrap()\n .join()\n .unwrap()\n}\n\n//{{{ utils\npub struct Scanner {\n reader: R,\n}\n\nimpl Scanner {\n pub fn new(r: R) -> Scanner {\n Scanner { reader: r }\n }\n}\n\nfn is_whitespace(b: u8) -> bool {\n b == b' ' || b == b'\\n' || b == b'\\r' || b == b'\\t'\n}\n\nimpl Scanner {\n pub fn read(&mut self) -> T {\n let buf = std::io::Read::bytes(self.reader.by_ref())\n .map(|b| b.expect(\"Read failed\"))\n .skip_while(|&b| is_whitespace(b))\n .take_while(|&b| !is_whitespace(b))\n .collect::>();\n unsafe { std::str::from_utf8_unchecked(&buf) }\n .parse()\n .ok()\n .expect(\"Parse error\")\n }\n\n pub fn read_vec(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.read()).collect()\n }\n\n pub fn read_chars(&mut self) -> Vec {\n self.read::().chars().collect()\n }\n}\n\npub trait SetMinMax {\n fn set_min(&mut self, v: Self) -> bool;\n fn set_max(&mut self, v: Self) -> bool;\n}\n\nimpl SetMinMax for T\nwhere\n T: PartialOrd,\n{\n fn set_min(&mut self, v: T) -> bool {\n *self > v && {\n *self = v;\n true\n }\n }\n fn set_max(&mut self, v: T) -> bool {\n *self < v && {\n *self = v;\n true\n }\n }\n}\n\n#[derive(PartialEq, Eq, Debug, Copy, Clone, Default, Hash)]\npub struct Reverse(pub T);\n\nimpl PartialOrd for Reverse {\n #[inline]\n fn partial_cmp(&self, other: &Reverse) -> Option {\n other.0.partial_cmp(&self.0)\n }\n\n #[inline]\n fn lt(&self, other: &Self) -> bool {\n other.0 < self.0\n }\n #[inline]\n fn le(&self, other: &Self) -> bool {\n other.0 <= self.0\n }\n #[inline]\n fn ge(&self, other: &Self) -> bool {\n other.0 >= self.0\n }\n #[inline]\n fn gt(&self, other: &Self) -> bool {\n other.0 > self.0\n }\n}\n\nimpl Ord for Reverse {\n #[inline]\n fn cmp(&self, other: &Reverse) -> Ordering {\n other.0.cmp(&self.0)\n }\n}\n\n#[allow(unused)] // This is defined for read! macro\nfn readln() -> String {\n let mut line = String::new();\n ::std::io::stdin()\n .read_line(&mut line)\n .unwrap_or_else(|e| panic!(\"{}\", e));\n line\n}\n//}}}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "1a50a856df789827f4f08e90effa758e", "src_uid": "064162604284ce252b88050b4174ba55", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut s = String::new();\n io::stdin().read_line(&mut s).unwrap();\n let arr : Vec = s.split_whitespace().map(|s| s.parse().unwrap()).collect();\n let (mut n, k) = (arr[0], arr[1]);\n for _i in 0..k {\n if n % 10 == 0 {\n n /= 10;\n } else {\n n -= 1;\n }\n }\n println!(\"{}\", n);\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "7c2870e9c4c0513c423d21a699b27944", "src_uid": "064162604284ce252b88050b4174ba55", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\n\npub fn main() {\n let mut nums: Vec = {\n let mut buf = String::new();\n stdin().read_line(&mut buf).unwrap();\n buf.trim()\n .split_whitespace()\n .map(str::parse)\n .map(Result::unwrap)\n .collect()\n };\n nums.sort();\n println!(\"{}\", nums[2] - nums[1] + nums[1] - nums[0]);\n}\n", "lang_cluster": "Rust", "tags": ["math", "sortings", "implementation"], "code_uid": "8ff39742f1b282d1edcbd7aa5293f17c", "src_uid": "7bffa6e8d2d21bbb3b7f4aec109b3319", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut input = String::new();\n io::stdin().read_line(&mut input)\n .expect(\"Failed to read line\");\n\n let split_input : Vec<&str> = input.as_str().split(' ').collect();\n let a : i32 = split_input[0].trim().parse().expect(\"en\"); \n let b : i32 = split_input[1].trim().parse().expect(\"en\"); \n let c : i32 = split_input[2].trim().parse().expect(\"en\"); \n let mut minimum: i32 = 300;\n for i in 1..100 {\n if (a - i).abs() + (b - i).abs() + (c - i).abs() < minimum {\n minimum = (a - i).abs() + (b - i).abs() + (c - i).abs();\n }\n }\n println!(\"{}\", minimum);\n}\n", "lang_cluster": "Rust", "tags": ["math", "sortings", "implementation"], "code_uid": "654baaa0525aea68a941ac4f8594d868", "src_uid": "7bffa6e8d2d21bbb3b7f4aec109b3319", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn input_split() -> Vec {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n buf.trim()\n .split_whitespace()\n .map(|elem| elem.parse().unwrap())\n .collect()\n}\n\nfn determine_b(v: &[u16]) -> Option {\n let sum: u16 = v.iter().sum();\n if sum % 5 == 0 && sum != 0 {\n Some(sum / 5)\n } else {\n None\n }\n}\n\nfn print(res: Option) {\n match res {\n Some(val) => print!(\"{}\", val),\n None => print!(\"-1\"),\n }\n}\n\nfn main() {\n print(determine_b(&input_split()))\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "f40855336a71fb583430558a0b16ecb5", "src_uid": "af1ec6a6fc1f2360506fc8a34e3dcd20", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spna-rust\n#[allow(unused_imports)]\nuse std::io::{self,Read};\n\n#[derive(Debug)]\nstruct WordReader {\n it : std::vec::IntoIter,\n}\n#[allow(dead_code)]\nimpl WordReader {\n fn new(mut reader : T) -> WordReader {\n let mut s = String::new();\n reader.read_to_string(&mut s).unwrap();\n WordReader { it : s\n .split_ascii_whitespace()\n .map(String::from).collect::>()\n .into_iter()\n }\n }\n fn from_stdin() -> WordReader {\n WordReader::new(std::io::stdin())\n }\n fn s(&mut self) -> String {\n self.it.next().unwrap()\n }\n fn ab(&mut self) -> Vec {\n self.it.next().unwrap().into_bytes()\n }\n fn i(&mut self) -> i32 {\n self.it.next().unwrap().parse().unwrap()\n }\n}\n\nfn main() {\n let mut input = WordReader::from_stdin();\n let mut a = input.ab();\n a.sort();\n a.dedup();\n if a.len() % 2 == 0 {\n println!(\"CHAT WITH HER!\");\n } else {\n println!(\"IGNORE HIM!\");\n }\n}\n\n", "lang_cluster": "Rust", "tags": ["brute force", "strings", "implementation"], "code_uid": "86d1fea0cc3ba052ee39e8f1ef32f4bd", "src_uid": "a8c14667b94b40da087501fd4bdd7818", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// author: zkmrgirish\n// date: 10 Apr, Friday\n\n#[allow(unused_imports)]\nuse std::cmp::{max, min};\nuse std::collections::HashSet;\nuse std::io::{stdin, stdout, BufWriter, Write};\n\n#[derive(Default)]\nstruct Scanner {\n buffer: Vec,\n}\nimpl Scanner {\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n stdin().read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn main() {\n let mut scan = Scanner::default();\n let out = &mut BufWriter::new(stdout());\n\n let username: String = scan.next();\n let mut set = HashSet::new();\n\n for x in username.chars() {\n set.insert(x);\n }\n\n writeln!(\n out,\n \"{}\",\n if set.len() % 2 == 0 {\n \"CHAT WITH HER!\"\n } else {\n \"IGNORE HIM!\"\n }\n )\n .ok();\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "strings", "implementation"], "code_uid": "d6d9dfca0567dfe2bf90ad02d126039c", "src_uid": "a8c14667b94b40da087501fd4bdd7818", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, prelude::*, Write};\nuse std::str;\nuse std::string::String;\nuse std::vec::Vec;\n\nuse std::cmp;\n\n#[allow(unused_must_use)]\nfn run(mut reader: Scanner, mut writer: W) {\n let total_number_of_trips: i32 = reader.next();\n let number_of_trips_with_special_ticket: i32 = reader.next();\n let one_trip_price: i32 = reader.next();\n let special_ticket_price: i32 = reader.next();\n\n let number_of_special_tickets_bought: i32 = total_number_of_trips / number_of_trips_with_special_ticket;\n let mut total_cost: i32 = number_of_special_tickets_bought * special_ticket_price;\n let remaining_trips_needed: i32 = total_number_of_trips % number_of_trips_with_special_ticket;\n if remaining_trips_needed > 0 {\n total_cost += cmp::min(remaining_trips_needed * one_trip_price, special_ticket_price);\n }\n\n total_cost = cmp::min(total_cost, total_number_of_trips * one_trip_price);\n\n writeln!(writer, \"{}\", total_cost);\n}\n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n\n let reader = Scanner::new(stdin.lock());\n let writer = io::BufWriter::new(stdout.lock());\n run(reader, writer);\n io::stdout().flush().unwrap();\n}\n\npub struct Scanner {\n reader: B,\n buffer_string: Vec,\n buffer_iterator: str::SplitWhitespace<'static>,\n}\n\nimpl Scanner {\n pub fn new(reader: B) -> Self {\n return Self {\n reader,\n buffer_string: Vec::new(),\n buffer_iterator: \"\".split_whitespace()\n };\n }\n\n pub fn next(&mut self) -> T {\n loop {\n //if buffer already exists, just use existing buffer\n if let Some(token) = self.buffer_iterator.next() {\n return token.parse().ok().expect(\"Fail to parse token\");\n }\n\n //get new line\n self.buffer_string.clear();\n self.reader.read_until(b'\\n', &mut self.buffer_string).expect(\"Failed to read\");\n\n //split by white space\n self.buffer_iterator = unsafe {\n let slice = str::from_utf8_unchecked(&self.buffer_string);\n std::mem::transmute(slice.split_whitespace())\n };\n }\n }\n\n pub fn next_line(&mut self) -> String {\n //reset buffer\n self.buffer_iterator = \"\".split_whitespace();\n self.buffer_string.clear();\n\n let mut input: String = String::new();\n self.reader.read_line(&mut input).expect(\"Failed to read line\");\n return input.trim().to_string();\n }\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "7510f4a83a732df90b1abe9b7728b3ad", "src_uid": "faa343ad6028c5a069857a38fa19bb24", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::*;\n\nfn reads(i: &mut StdinLock) -> Vec {\n let mut s = String::new();\n i.by_ref().read_line(&mut s).ok();\n s.trim()\n .split_whitespace()\n .map(|e| e.parse().ok().unwrap())\n .collect()\n}\n\nfn main() {\n // initialize stdin\n let sin = std::io::stdin();\n let mut sin = sin.lock();\n let sin = &mut sin;\n\n let params: Vec = reads(sin);\n\n let n = params[0];\n let m = params[1];\n let a = params[2];\n let b = params[3];\n\n let ans = if a * m < b {\n n * a\n } else {\n let base = n / m;\n let remain = n % m;\n (base * b) + std::cmp::min(remain * a, b)\n };\n\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "f528e626936ce20d05a61284cf2501a5", "src_uid": "faa343ad6028c5a069857a38fa19bb24", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let (n, m, z) = {\n let r = getvec::();\n (r[0], r[1], r[2])\n };\n let gc = gcd(n, m);\n let lca = n * m / gc;\n println!(\"{}\", z / lca);\n}\nfn gcd(a: i64, b: i64) -> i64 {\n match b {\n 0i64 => a,\n _ => gcd(b, a % b),\n }\n}\n\n\n#[allow(dead_code)]\nfn next_line() -> String {\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).ok().unwrap();\n input\n}\n\n#[allow(dead_code)]\nfn getnum() -> T {\n let res = next_line();\n res.trim().parse::().ok().unwrap()\n}\n\n#[allow(dead_code)]\nfn getvec() -> Vec {\n let res = next_line();\n res.split_whitespace().map(|x| x.parse::().ok().unwrap()).collect()\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "implementation"], "code_uid": "7569e6b4de46d075997395fdbdb4d886", "src_uid": "e7ad55ce26fc8610639323af1de36c2d", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\nuse std::io::{ self, Write };\nuse std::str::FromStr;\nuse std::cmp::{ min, max };\nuse std::collections::{ BinaryHeap, VecDeque };\n\nmacro_rules! trace {\n ($var:expr) => ({\n let _ = writeln!(&mut std::io::stderr(), \">>> {} = {:?}\", stringify!($var), $var);\n })\n}\nmacro_rules! swap { ($a:expr, $b:expr) => ({ let t = $b; $b = $a; $a = t; }) }\n\nfn gcd(a: i64, b: i64) -> i64 { if b == 0 { a } else { gcd(b, a % b) } }\n\nfn main() {\n let mut sc = Scanner::new();\n let m: i64 = sc.cin();\n let n: i64 = sc.cin();\n let z: i64 = sc.cin();\n\n let a = z / (m * n / gcd(m, n));\n println!(\"{}\", a);\n}\n\n#[allow(dead_code)]\nstruct Scanner { stdin: io::Stdin, buffer: VecDeque, }\n#[allow(dead_code)]\nimpl Scanner {\n fn new() -> Scanner { Scanner { stdin: io::stdin(), buffer: VecDeque::new() } }\n fn reserve(&mut self) {\n while self.buffer.len() == 0 {\n let mut line = String::new();\n let _ = self.stdin.read_line(&mut line);\n for w in line.split_whitespace() {\n self.buffer.push_back(String::from(w));\n }\n }\n }\n fn cin(&mut self) -> T {\n self.reserve();\n match self.buffer.pop_front().unwrap().parse::() {\n Ok(a) => a,\n Err(_) => panic!(\"parse err\")\n }\n }\n fn get_char(&mut self) -> char {\n self.reserve();\n let head = self.buffer[0].chars().nth(0).unwrap();\n let tail = String::from( &self.buffer[0][1..] );\n if tail.len()>0 { self.buffer[0]=tail } else { self.buffer.pop_front(); }\n head\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "implementation"], "code_uid": "fd4335b11de2226aeafc6ca45353ce27", "src_uid": "e7ad55ce26fc8610639323af1de36c2d", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\npub fn get_years(weights: Vec) -> u32 {\n let mut years = 0;\n let mut limak = weights[0];\n let mut bob = weights[1];\n\n while limak <= bob {\n years += 1;\n limak *= 3;\n bob *= 2;\n }\n\n years\n}\n\npub fn solution() -> io::Result<()> {\n let mut weights = String::new();\n\n io::stdin().read_line(&mut weights)?;\n let numbers: Vec = weights\n .trim()\n .split(\" \")\n .map(|num| num.parse::().expect(\"Couldn't parse number\"))\n .collect();\n\n println!(\"{}\", get_years(numbers));\n Ok(())\n}\n\nfn main() {\n solution();\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "2b141934a19aaf3b4dc164f62ea6184f", "src_uid": "a1583b07a9d093e887f73cc5c29e444a", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn read() -> String{\n let mut input=String::new();\n io::stdin().read_line(&mut input).expect(\"unable to read\");\n input.trim().to_string()\n}\nfn main() {\n let inp=read();\n let list: Vec<_>=inp.split_whitespace().collect();\n let mut b1=list[0].parse::().expect(\"Failed to parse\");\n let mut b2=list[1].parse::().expect(\"Failed to parse\");\n let mut years=0;\n while b2>=b1{\n b1*=3;\n b2*=2;\n years+=1\n }println!(\"{}\",years);\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "6ccf078f92247d4836a44d89a008cfb9", "src_uid": "a1583b07a9d093e887f73cc5c29e444a", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// http://codeforces.com/problemset/problem/1/A\n\nuse std::io::{self, Read};\n\nfn main() {\n let mut buffer = String::new();\n io::stdin().read_to_string(&mut buffer).unwrap();\n\n let input: Vec<_> = buffer.split_whitespace().collect();\n let n = input[0].parse().unwrap();\n let m = input[1].parse().unwrap();\n let a = input[2].parse().unwrap();\n\n println!(\"{}\", pave(n, m, a));\n}\n\nfn pave(n: u64, m: u64, a: u64) -> u64 {\n //cover n\n let cover_n = if n % a == 0 { n / a } else { (n / a) + 1 };\n let cover_m = if m % a == 0 { m / a } else { (m / a) + 1 };\n\n cover_m * cover_n\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "ffc1fce8e494edc4f8735215bc2a0d0b", "src_uid": "ef971874d8c4da37581336284b688517", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nfn main(){\n let mut s:String=String::new();\n io::stdin().read_line(&mut s).unwrap();\n let mut a:Vec=Vec::new();\n let mut c:usize=0;\n let mut n:usize=0;\n while c<=s.len()-1{\n n=c;\n if s.chars().nth(c).unwrap()!=' '{\n while s.chars().nth(n).unwrap()!=' ' && n0{a[0]/a[2]+1}else{a[0]/a[2]};\n let n:i64=if a[1]%a[2]>0{a[1]/a[2]+1}else{a[1]/a[2]};\n println!(\"{}\",c*n);\n}", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "59509bc0734c8a0220cf033488bab11f", "src_uid": "ef971874d8c4da37581336284b688517", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// https://codeforces.com/problemset/problem/520/A\nuse std::io;\nuse std::collections::HashSet;\n\nfn main() {\n io::stdin()\n .read_line(&mut String::new())\n .unwrap();\n\n let mut line = String::new();\n\n io::stdin()\n .read_line(&mut line)\n .unwrap();\n\n let mut line: String = line\n .trim()\n .to_string();\n\n line.make_ascii_lowercase();\n\n let mut letters = HashSet::new();\n\n for ch in line.chars() {\n letters.insert(ch);\n }\n\n let alphabet = \"abcdefghijklmnopqrstuvwxyz\";\n\n let mut flag = true;\n\n for ch in alphabet.chars() {\n match letters.get(&ch) {\n Some(_) => continue,\n None => {\n flag = false;\n break;\n },\n }\n }\n\n if flag {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "d02958c5eb9d6a0ab3fd663518901caa", "src_uid": "f13eba0a0fb86e20495d218fc4ad532d", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::collections::HashSet;\nuse std::io::*;\n\nfn read(i: &mut StdinLock) -> T {\n let mut s = String::new();\n i.by_ref().read_line(&mut s).ok();\n s.trim().parse().ok().unwrap()\n}\n\nfn main() {\n // initialize stdin\n let sin = std::io::stdin();\n let mut sin = sin.lock();\n let sin = &mut sin;\n\n let _n: u32 = read(sin);\n let input: String = read(sin);\n\n let mut set = HashSet::new();\n\n for c in input.to_lowercase().as_str().chars() {\n set.insert(c);\n }\n\n let ans = if set.len() == 26 { \"YES\" } else { \"NO\" };\n\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "da991b794893390ae3a73c6d4b80fe7c", "src_uid": "f13eba0a0fb86e20495d218fc4ad532d", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "use std::collections::BTreeMap;\r\n\r\nfn main() {\r\n let (n,x) : (usize, u128) = input_t();\r\n\r\n if n == x.to_string().len() { println!(\"0\"); return; }\r\n if x.to_string().chars().all(|c| c=='1' || c=='0') { println!(\"-1\"); return; }\r\n let mut memo = BTreeMap::new();\r\n println!(\"{}\", f(0,x,n,&mut memo));\r\n // eprintln!(\"{:?}\", memo);\r\n}\r\n\r\nfn f(c:usize, x:u128,n:usize,memo:&mut BTreeMap) -> usize {\r\n if let Some(&res) = memo.get(&x) { return res; }\r\n let mut t = x;\r\n let mut cnt = 0;\r\n while t!=0 { t/=10;cnt+=1;}\r\n if cnt >= n { return c; }\r\n\r\n // eprintln!(\"{}\", x);\r\n\r\n let mut res = std::usize::MAX >> 4;\r\n for i in 2..10 {\r\n if !x.to_string().chars().collect::>().contains(&((i+b'0') as char)) { continue }\r\n res = res.min(f(c, x*i as u128, n,memo) + 1);\r\n }\r\n\r\n memo.insert(x,res);\r\n res\r\n}\r\n\r\n\r\n#[allow(dead_code)] fn input() -> T { let mut s = String::new(); std::io::stdin().read_line(&mut s).ok(); s.trim().parse().ok().unwrap() } #[allow(dead_code)] fn input_t() -> (T, U) { let mut s = String::new(); std::io::stdin().read_line(&mut s).ok(); let s = s.trim().split_whitespace().collect::>(); (s[0].parse().ok().unwrap(), s[1].parse().ok().unwrap()) } #[allow(dead_code)] fn input_t3() -> (T1, T2, T3) { let mut s = String::new(); std::io::stdin().read_line(&mut s).ok(); let s = s.trim().split_whitespace().collect::>(); (s[0].parse().ok().unwrap(), s[1].parse().ok().unwrap(), s[2].parse().ok().unwrap()) } #[allow(dead_code)] fn input_t4() -> (T1, T2, T3, T4) { let mut s = String::new(); std::io::stdin().read_line(&mut s).ok(); let s = s.trim().split_whitespace().collect::>(); (s[0].parse().ok().unwrap(), s[1].parse().ok().unwrap(), s[2].parse().ok().unwrap(), s[3].parse().ok().unwrap()) } #[allow(dead_code)] fn input_t5() -> (T1, T2, T3, T4, T5) { let mut s = String::new(); std::io::stdin().read_line(&mut s).ok(); let s = s.trim().split_whitespace().collect::>(); (s[0].parse().ok().unwrap(), s[1].parse().ok().unwrap(), s[2].parse().ok().unwrap(), s[3].parse().ok().unwrap(), s[4].parse().ok().unwrap()) } #[allow(dead_code)] fn input_vec() -> Vec { let mut s = String::new(); std::io::stdin().read_line(&mut s).ok(); s.trim().split_whitespace().map(|s| s.parse().ok().unwrap()).collect() }", "lang_cluster": "Rust", "tags": ["brute force", "dfs and similar", "shortest paths", "dp", "data structures"], "code_uid": "cdef21ef43bfd5329a5e25c7e221a459", "src_uid": "cedcc3cee864bf8684148df93804d029", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(unused_imports)]\r\n\r\nuse std::cmp::*;\r\nuse std::collections::*;\r\nuse std::io::*;\r\nuse std::mem::*;\r\nuse std::str;\r\n\r\nfn main() {\r\n let n: usize = read();\r\n let x: u64 = read();\r\n let target = 10_u64.pow(n as u32 - 1);\r\n let mut seen = HashSet::new();\r\n let mut heap = BinaryHeap::new();\r\n heap.push((len(x), x));\r\n while let Some((score, x)) = heap.pop() {\r\n if !seen.insert(x) {\r\n continue;\r\n }\r\n if x >= target {\r\n println!(\"{}\", n as i32 - score);\r\n return;\r\n }\r\n let has = {\r\n let mut arr = [false; 10];\r\n let mut x = x;\r\n while x > 0 {\r\n arr[(x % 10) as usize] = true;\r\n x /= 10;\r\n }\r\n arr\r\n };\r\n for d in 2..=9 {\r\n if has[d] {\r\n let next = x * d as u64;\r\n heap.push((score - 1 + len(next) - len(x), next));\r\n }\r\n }\r\n }\r\n println!(\"-1\");\r\n}\r\n\r\nfn len(mut x: u64) -> i32 {\r\n let mut ans = 0;\r\n while x > 0 {\r\n x /= 10;\r\n ans += 1;\r\n }\r\n ans\r\n}\r\n\r\npub fn read() -> T {\r\n struct Tokens {\r\n buf: Vec,\r\n iter: str::SplitWhitespace<'static>,\r\n }\r\n static mut TOKENS: Option = None;\r\n\r\n let tokens = unsafe {\r\n TOKENS.get_or_insert_with(|| Tokens {\r\n buf: Vec::new(),\r\n iter: \"\".split_whitespace(),\r\n })\r\n };\r\n loop {\r\n if let Some(token) = tokens.iter.next() {\r\n return token.parse().ok().unwrap();\r\n }\r\n tokens.buf.clear();\r\n stdin().lock().read_until(b'\\n', &mut tokens.buf).unwrap();\r\n tokens.iter = unsafe {\r\n let s = str::from_utf8_unchecked(&tokens.buf);\r\n transmute(s.split_whitespace())\r\n };\r\n }\r\n}\r\n", "lang_cluster": "Rust", "tags": ["brute force", "dfs and similar", "shortest paths", "dp", "data structures"], "code_uid": "9fa82bb24214fb115b3a3a97051c7c98", "src_uid": "cedcc3cee864bf8684148df93804d029", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "pub mod solution {\n\nuse crate::io::input::Input;\nuse crate::io::output::output;\nuse crate::{out, out_line};\nuse std::cmp::min;\nuse crate::math::modular::factorial::Factorial;\nuse crate::math::modular::primitive::ModularType;\n\ntype Mod = ModularType<1000000007>;\n\nfn solve(input: &mut Input, _test_case: usize) {\n let (n, k) = input.read();\n let mut ans = Mod::from(0);\n let factorials = Factorial::new(n);\n for i in 0..=min(k, n) {\n ans += factorials.combinations(n, i);\n }\n out_line!(ans);\n}\n\npub(crate) fn run(mut input: Input) -> bool {\n solve(&mut input, 1);\n output().flush();\n input.skip_whitespace();\n !input.peek().is_some()\n}\n\n}\npub mod io {\npub mod input {\nuse std::fmt::Debug;\nuse std::io::Read;\nuse std::marker::PhantomData;\nuse std::str::FromStr;\n\npub struct Input<'s> {\n input: &'s mut dyn Read,\n buf: Vec,\n at: usize,\n buf_read: usize,\n}\n\nimpl<'s> Input<'s> {\n const DEFAULT_BUF_SIZE: usize = 4096;\n\n pub fn new(input: &'s mut dyn Read) -> Self {\n Self {\n input,\n buf: vec![0; Self::DEFAULT_BUF_SIZE],\n at: 0,\n buf_read: 0,\n }\n }\n\n pub fn new_with_size(input: &'s mut dyn Read, buf_size: usize) -> Self {\n Self {\n input,\n buf: vec![0; buf_size],\n at: 0,\n buf_read: 0,\n }\n }\n\n pub fn get(&mut self) -> Option {\n if self.refill_buffer() {\n let res = self.buf[self.at];\n self.at += 1;\n Some(res)\n } else {\n None\n }\n }\n\n pub fn peek(&mut self) -> Option {\n if self.refill_buffer() {\n Some(self.buf[self.at])\n } else {\n None\n }\n }\n\n pub fn skip_whitespace(&mut self) {\n while let Some(b) = self.peek() {\n if !char::from(b).is_whitespace() {\n return;\n }\n self.get();\n }\n }\n\n pub fn next_token(&mut self) -> Option> {\n self.skip_whitespace();\n let mut res = Vec::new();\n while let Some(c) = self.get() {\n if char::from(c).is_whitespace() {\n break;\n }\n res.push(c);\n }\n if res.is_empty() {\n None\n } else {\n Some(res)\n }\n }\n\n //noinspection RsSelfConvention\n pub fn is_exhausted(&mut self) -> bool {\n self.peek().is_none()\n }\n\n pub fn read(&mut self) -> T {\n T::read(self)\n }\n\n pub fn read_vec(&mut self, size: usize) -> Vec {\n let mut res = Vec::with_capacity(size);\n for _ in 0usize..size {\n res.push(self.read());\n }\n res\n }\n\n pub fn read_line(&mut self) -> String {\n let mut res = String::new();\n while let Some(c) = self.get() {\n if c == b'\\n' {\n break;\n }\n if c == b'\\r' {\n if self.peek() == Some(b'\\n') {\n self.get();\n }\n break;\n }\n res.push(c.into());\n }\n res\n }\n\n #[allow(clippy::should_implement_trait)]\n pub fn into_iter(self) -> InputIterator<'s, T> {\n InputIterator {\n input: self,\n phantom: Default::default(),\n }\n }\n\n fn read_integer(&mut self) -> T\n where\n ::Err: Debug,\n {\n let res = self.read_string();\n res.parse::().unwrap()\n }\n\n fn read_string(&mut self) -> String {\n match self.next_token() {\n None => {\n panic!(\"Input exhausted\");\n }\n Some(res) => unsafe { String::from_utf8_unchecked(res) },\n }\n }\n\n fn read_char(&mut self) -> char {\n self.skip_whitespace();\n self.get().unwrap().into()\n }\n\n fn read_float(&mut self) -> f64 {\n self.read_string().parse().unwrap()\n }\n\n fn refill_buffer(&mut self) -> bool {\n if self.at == self.buf_read {\n self.at = 0;\n self.buf_read = self.input.read(&mut self.buf).unwrap();\n self.buf_read != 0\n } else {\n true\n }\n }\n}\n\npub trait Readable {\n fn read(input: &mut Input) -> Self;\n}\n\nimpl Readable for String {\n fn read(input: &mut Input) -> Self {\n input.read_string()\n }\n}\n\nimpl Readable for char {\n fn read(input: &mut Input) -> Self {\n input.read_char()\n }\n}\n\nimpl Readable for f64 {\n fn read(input: &mut Input) -> Self {\n input.read_float()\n }\n}\n\nimpl Readable for Vec {\n fn read(input: &mut Input) -> Self {\n let size = input.read();\n input.read_vec(size)\n }\n}\n\npub struct InputIterator<'s, T: Readable> {\n input: Input<'s>,\n phantom: PhantomData,\n}\n\nimpl<'s, T: Readable> Iterator for InputIterator<'s, T> {\n type Item = T;\n\n fn next(&mut self) -> Option {\n self.input.skip_whitespace();\n self.input.peek().map(|_| self.input.read())\n }\n}\n\nmacro_rules! read_integer {\n ($t:ident) => {\n impl Readable for $t {\n fn read(input: &mut Input) -> Self {\n input.read_integer()\n }\n }\n };\n}\n\nread_integer!(i8);\nread_integer!(i16);\nread_integer!(i32);\nread_integer!(i64);\nread_integer!(i128);\nread_integer!(isize);\nread_integer!(u8);\nread_integer!(u16);\nread_integer!(u32);\nread_integer!(u64);\nread_integer!(u128);\nread_integer!(usize);\n\nmacro_rules! tuple_readable {\n ( $( $name:ident )+ ) => {\n impl<$($name: Readable), +> Readable for ($($name,)+) {\n fn read(input: &mut Input) -> Self {\n ($($name::read(input),)+)\n }\n }\n }\n}\n\ntuple_readable! {T}\ntuple_readable! {T U}\ntuple_readable! {T U V}\ntuple_readable! {T U V X}\ntuple_readable! {T U V X Y}\ntuple_readable! {T U V X Y Z}\ntuple_readable! {T U V X Y Z A}\ntuple_readable! {T U V X Y Z A B}\ntuple_readable! {T U V X Y Z A B C}\ntuple_readable! {T U V X Y Z A B C D}\ntuple_readable! {T U V X Y Z A B C D E}\ntuple_readable! {T U V X Y Z A B C D E F}\n}\npub mod output {\nuse std::io::Write;\n\npub struct Output {\n output: Box,\n buf: Vec,\n at: usize,\n auto_flush: bool,\n}\n\nimpl Output {\n const DEFAULT_BUF_SIZE: usize = 4096;\n\n pub fn new(output: Box) -> Self {\n Self {\n output,\n buf: vec![0; Self::DEFAULT_BUF_SIZE],\n at: 0,\n auto_flush: false,\n }\n }\n\n pub fn new_with_auto_flush(output: Box) -> Self {\n Self {\n output,\n buf: vec![0; Self::DEFAULT_BUF_SIZE],\n at: 0,\n auto_flush: true,\n }\n }\n\n pub fn flush(&mut self) {\n if self.at != 0 {\n self.output.write_all(&self.buf[..self.at]).unwrap();\n self.at = 0;\n self.output.flush().expect(\"Couldn't flush output\");\n }\n }\n\n pub fn print(&mut self, s: &T) {\n s.write(self);\n }\n\n pub fn put(&mut self, b: u8) {\n self.buf[self.at] = b;\n self.at += 1;\n if self.at == self.buf.len() {\n self.flush();\n }\n }\n\n pub fn maybe_flush(&mut self) {\n if self.auto_flush {\n self.flush();\n }\n }\n\n pub fn print_per_line(&mut self, arg: &[T]) {\n for i in arg {\n i.write(self);\n self.put(b'\\n');\n }\n }\n\n pub fn print_iter>(&mut self, iter: I) {\n let mut first = true;\n for e in iter {\n if first {\n first = false;\n } else {\n self.put(b' ');\n }\n e.write(self);\n }\n }\n\n pub fn print_iter_ref<'a, T: 'a + Writable, I: Iterator>(&mut self, iter: I) {\n let mut first = true;\n for e in iter {\n if first {\n first = false;\n } else {\n self.put(b' ');\n }\n e.write(self);\n }\n }\n}\n\nimpl Write for Output {\n fn write(&mut self, buf: &[u8]) -> std::io::Result {\n let mut start = 0usize;\n let mut rem = buf.len();\n while rem > 0 {\n let len = (self.buf.len() - self.at).min(rem);\n self.buf[self.at..self.at + len].copy_from_slice(&buf[start..start + len]);\n self.at += len;\n if self.at == self.buf.len() {\n self.flush();\n }\n start += len;\n rem -= len;\n }\n if self.auto_flush {\n self.flush();\n }\n Ok(buf.len())\n }\n\n fn flush(&mut self) -> std::io::Result<()> {\n self.flush();\n Ok(())\n }\n}\n\npub trait Writable {\n fn write(&self, output: &mut Output);\n}\n\nimpl Writable for &str {\n fn write(&self, output: &mut Output) {\n output.write_all(self.as_bytes()).unwrap();\n }\n}\n\nimpl Writable for String {\n fn write(&self, output: &mut Output) {\n output.write_all(self.as_bytes()).unwrap();\n }\n}\n\nimpl Writable for char {\n fn write(&self, output: &mut Output) {\n output.put(*self as u8);\n }\n}\n\nimpl Writable for [T] {\n fn write(&self, output: &mut Output) {\n output.print_iter_ref(self.iter());\n }\n}\n\nimpl Writable for Vec {\n fn write(&self, output: &mut Output) {\n self[..].write(output);\n }\n}\n\nmacro_rules! write_to_string {\n ($t:ident) => {\n impl Writable for $t {\n fn write(&self, output: &mut Output) {\n self.to_string().write(output);\n }\n }\n };\n}\n\nwrite_to_string!(u8);\nwrite_to_string!(u16);\nwrite_to_string!(u32);\nwrite_to_string!(u64);\nwrite_to_string!(u128);\nwrite_to_string!(usize);\nwrite_to_string!(i8);\nwrite_to_string!(i16);\nwrite_to_string!(i32);\nwrite_to_string!(i64);\nwrite_to_string!(i128);\nwrite_to_string!(isize);\nwrite_to_string!(f32);\nwrite_to_string!(f64);\n\nimpl Writable for (T, U) {\n fn write(&self, output: &mut Output) {\n self.0.write(output);\n output.put(b' ');\n self.1.write(output);\n }\n}\n\nimpl Writable for (T, U, V) {\n fn write(&self, output: &mut Output) {\n self.0.write(output);\n output.put(b' ');\n self.1.write(output);\n output.put(b' ');\n self.2.write(output);\n }\n}\n\npub static mut OUTPUT: Option = None;\n\npub fn output() -> &'static mut Output {\n unsafe {\n match &mut OUTPUT {\n None => {\n panic!(\"Panic\");\n }\n Some(output) => output,\n }\n }\n}\n\n#[macro_export]\nmacro_rules! out {\n ($first: expr $(,$args:expr )*) => {\n output().print(&$first);\n $(output().put(b' ');\n output().print(&$args);\n )*\n }\n}\n\n#[macro_export]\nmacro_rules! out_line {\n ($first: expr $(, $args:expr )* ) => {\n out!($first $(,$args)*);\n output().put(b'\\n');\n };\n () => {\n output().put(b'\\n');\n };\n}\n}\n}\npub mod math {\npub mod modular {\npub mod factorial {\nuse crate::math::modular::inverse::compute_inverse_up_to;\nuse crate::math::modular::primitive::Modular;\n\npub struct Factorial {\n fact: Vec,\n inverse_fact: Vec,\n}\n\nimpl Factorial\nwhere\n Mod: Modular,\n{\n pub fn new(n: usize) -> Self {\n let mut fact = vec![0.into(); n + 1];\n let mut inverse_fact = vec![0.into(); n + 1];\n let inv = compute_inverse_up_to(n);\n fact[0] = 1.into();\n inverse_fact[0] = 1.into();\n for i in 1..=n {\n fact[i] = fact[i - 1] * i.into();\n inverse_fact[i] = inverse_fact[i - 1] * inv[i];\n }\n Self { fact, inverse_fact }\n }\n\n pub fn combinations(&self, n: usize, k: usize) -> Mod {\n if k > n {\n 0.into()\n } else {\n self.fact[n] * self.inverse_fact[n - k] * self.inverse_fact[k]\n }\n }\n}\n}\npub mod inverse {\nuse crate::math::modular::primitive::Modular;\n\npub fn compute_inverse_up_to(n: usize) -> Vec\nwhere\n Mod: Modular,\n{\n let mut inv: Vec = vec![0.into(); n + 1];\n inv[1] = 1.into();\n for i in 2..=n {\n inv[i] = inv[Mod::MODULO as usize % i] * (Mod::MODULO as usize / i).into();\n inv[i] = -inv[i];\n }\n inv\n}\n}\npub mod primitive {\nuse crate::io::output::{Output, Writable};\nuse std::ops::{Add, AddAssign, Mul, Neg};\n\n#[derive(Copy, Clone)]\npub struct ModularType(u32);\n\npub trait Modular:\n Add\n + AddAssign\n + Mul\n + Neg\n + From\n + From\n + From\n + Writable\n + Copy\n{\n const MODULO: u32;\n fn value(&self) -> u32;\n fn usize(&self) -> usize {\n self.value() as usize\n }\n}\n\nimpl Modular for ModularType {\n const MODULO: u32 = M;\n\n fn value(&self) -> u32 {\n self.0\n }\n}\n\nimpl Add for ModularType {\n type Output = ModularType;\n\n fn add(self, rhs: Self) -> Self::Output {\n let result = self.0 + rhs.0;\n ModularType(if result >= M { result - M } else { result })\n }\n}\n\nimpl AddAssign for ModularType {\n fn add_assign(&mut self, rhs: Self) {\n self.0 += rhs.0;\n if self.0 >= M {\n self.0 -= M;\n }\n }\n}\n\nimpl Mul for ModularType {\n type Output = ModularType;\n\n fn mul(self, rhs: Self) -> Self::Output {\n Self((self.0 as u64 * rhs.0 as u64 % M as u64) as u32)\n }\n}\n\nimpl Neg for ModularType {\n type Output = ModularType;\n\n fn neg(self) -> Self::Output {\n Self(if self.0 == 0 { 0 } else { M - self.0 })\n }\n}\n\nimpl From for ModularType {\n fn from(x: u32) -> Self {\n Self(x % M)\n }\n}\n\nimpl From for ModularType {\n fn from(x: i32) -> Self {\n Self(x.rem_euclid(M as i32) as u32)\n }\n}\n\nimpl From for ModularType {\n fn from(x: usize) -> Self {\n Self((x % M as usize) as u32)\n }\n}\n\nimpl Into for ModularType {\n fn into(self) -> usize {\n self.0 as usize\n }\n}\n\nimpl Writable for ModularType {\n fn write(&self, output: &mut Output) {\n self.0.write(output);\n }\n}\n}\n}\n}\nfn main() {\n let mut sin = std::io::stdin();\n let input = crate::io::input::Input::new(&mut sin);\n unsafe {\n crate::io::output::OUTPUT = Some(crate::io::output::Output::new(Box::new(std::io::stdout())));\n }\n crate::solution::run(input);\n}\n", "lang_cluster": "Rust", "tags": ["math", "greedy", "constructive algorithms", "combinatorics"], "code_uid": "4982fe3b92da019947aca6ec1f76a7aa", "src_uid": "dc7b887afcc2e95c4e90619ceda63071", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "type Mod = ModInt1000000007;\nfn main() {\n let stdout = std::io::stdout();\n let mut writer = std::io::BufWriter::new(stdout.lock());\n #[allow(unused_macros)] macro_rules! print { ($($tt:tt)*) => {{ use std::io::Write; std::write!(writer, $($tt)*).unwrap(); }}; }\n #[allow(unused_macros)] macro_rules! println { ($($tt:tt)*) => {{ use std::io::Write; std::writeln!(writer, $($tt)*).unwrap(); }}; }\n\n let mut precalc = Binom::::new();\n input! {\n n: usize,\n k: usize\n }\n let k = k.min(n);\n let mut ans = Mod::raw(0);\n for i in 0..=k {\n ans += precalc.binom(n, i);\n }\n println!(\"{}\", ans);\n}\n\nstruct Binom {\n len: usize,\n inv: Vec,\n fact: Vec,\n ifact: Vec,\n n: Option,\n nprod: Vec,\n m: Option,\n mprod_n: usize,\n mprod: T\n}\n\n#[allow(dead_code)]\nimpl Binom {\n pub fn new() -> Self {\n assert_eq!(std::mem::size_of::(), 8);\n\n Self {\n len: 1,\n inv: vec![0, 1],\n fact: vec![T::raw(1), T::raw(1)],\n ifact: vec![T::raw(1), T::raw(1)],\n n: None,\n nprod: vec![],\n m: None,\n mprod_n: 0,\n mprod: T::raw(0)\n }\n }\n\n fn ensure(&mut self, idx: usize) {\n if idx > self.len {\n self.inv.reserve(idx - self.len);\n self.fact.reserve(idx - self.len);\n self.ifact.reserve(idx - self.len);\n let m = T::modulus() as usize;\n for i in self.len+1..=idx {\n let inv_i = self.inv[m % i] * (m - m / i) % m;\n self.inv.push(inv_i);\n self.fact.push(self.fact[i - 1] * T::from(i));\n self.ifact.push(self.ifact[i - 1] * T::raw(inv_i as u32));\n }\n self.len = idx;\n }\n }\n\n pub fn binom(&mut self, n: usize, m: usize) -> T {\n if m > n {\n return T::raw(0)\n }\n if m == 0 || m == n {\n return T::raw(1)\n }\n self.ensure(n);\n self.fact[n] * self.ifact[m] * self.ifact[n - m]\n }\n\n pub fn binom_n(&mut self, n: usize, m: usize) -> T {\n if m > n {\n return T::raw(0)\n }\n if m == 0 || m == n {\n return T::raw(1)\n }\n if n >= T::modulus() as usize {\n return self.binom_n(n % T::modulus() as usize, m);\n }\n if self.n != Some(n) {\n self.n = Some(n);\n self.nprod = vec![T::from(n)];\n }\n for i in self.nprod.len()..m {\n self.nprod.push(self.nprod[i - 1] * T::from(n - i));\n }\n self.ensure(m);\n self.nprod[m - 1] * self.ifact[m]\n }\n\n pub fn binom_m(&mut self, n: usize, m: usize) -> T {\n if m > n {\n return T::raw(0)\n }\n if m == 0 || m == n {\n return T::raw(1)\n }\n if n >= T::modulus() as usize {\n return self.binom_m(n % T::modulus() as usize, m);\n }\n if self.m != Some(m) || self.mprod_n > n + m || self.mprod_n + m < n {\n self.m = Some(m);\n self.mprod_n = n;\n self.mprod = ((n-m+1)..=n).map(T::from).product::();\n } else {\n while self.mprod_n < n {\n self.mprod_n += 1;\n self.mprod *= T::from(self.mprod_n);\n self.mprod /= T::from(self.mprod_n - m);\n }\n while self.mprod_n > n {\n self.mprod /= T::from(self.mprod_n);\n self.mprod *= T::from(self.mprod_n - m);\n self.mprod_n -= 1;\n }\n }\n self.ensure(m);\n self.mprod * self.ifact[m]\n }\n\n}\n\n// input macro with modifications (to better align with proconio)\n// based on https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\n\n#[macro_export]\nmacro_rules! input {\n (@lock_stdin $reader:ident) => {\n let stdin = std::io::stdin();\n let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));\n let mut $reader = move || -> String {\n unsafe {\n String::from_utf8_unchecked(\n bytes\n .by_ref()\n .map_while(Result::ok)\n .skip_while(|c| c.is_ascii_whitespace())\n .take_while(|c| !c.is_ascii_whitespace())\n .collect()\n )\n }\n };\n };\n\n (@inner $reader:ident) => {};\n (@inner $reader:ident, ) => {};\n\n (@inner $reader:ident, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($reader, $t);\n input!{@inner $reader $($r)*}\n };\n\n (@inner $reader:ident, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($reader, $t);\n input!{@inner $reader $($r)*}\n };\n\n (@inner $reader:ident $($r:tt)*) => {\n compile_error!(stringify!(unable to read $($r)*))\n };\n\n (line = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_ascii_whitespace();\n let mut next = || { iter.next().unwrap_or_default() };\n input!{@inner next, $($r)*}\n };\n (name = $reader:ident, $($r:tt)*) => {\n input!{@lock_stdin $reader};\n input!{@inner $reader, $($r)*}\n };\n (use $reader:ident, $($r:tt)*) => {\n input!{@inner $reader, $($r)*}\n };\n ($($r:tt)*) => {\n input!{@lock_stdin reader};\n input!{@inner reader, $($r)*};\n };\n}\n\n#[macro_export]\nmacro_rules! read_value {\n ($reader:ident, ( $($t:tt),* )) => {\n ( $(read_value!($reader, $t)),* )\n };\n\n ($reader:ident, [ $t:tt ]) => {{\n let len = read_value!($reader, usize);\n read_value!($reader, [ $t ; len])\n }};\n\n ($reader:ident, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($reader, $t)).collect::>()\n };\n\n ($reader:ident, chars) => {\n read_value!($reader, String).chars().collect::>()\n };\n\n ($reader:ident, bytes) => {\n read_value!($reader, String).into_bytes()\n };\n\n ($reader:ident, usize1) => {\n read_value!($reader, usize) - 1\n };\n\n ($reader:ident, $t:tt) => {\n $reader().parse::<$t>().expect(stringify!(parse error($t)))\n };\n}\n\n//https://github.com/rust-lang-ja/ac-library-rs\n\npub mod internal_math {\n #![allow(dead_code)]\n use std::mem::swap;\n\n pub(crate) fn safe_mod(mut x: i64, m: i64) -> i64 {\n x %= m;\n if x < 0 {\n x += m;\n }\n x\n }\n\n pub(crate) struct Barrett {\n pub(crate) _m: u32,\n pub(crate) im: u64,\n }\n\n impl Barrett {\n pub(crate) fn new(m: u32) -> Barrett {\n Barrett {\n _m: m,\n im: (-1i64 as u64 / m as u64).wrapping_add(1),\n }\n }\n\n pub(crate) fn umod(&self) -> u32 {\n self._m\n }\n\n #[allow(clippy::many_single_char_names)]\n pub(crate) fn mul(&self, a: u32, b: u32) -> u32 {\n mul_mod(a, b, self._m, self.im)\n }\n }\n\n #[allow(clippy::many_single_char_names)]\n pub(crate) fn mul_mod(a: u32, b: u32, m: u32, im: u64) -> u32 {\n let mut z = a as u64;\n z *= b as u64;\n let x = (((z as u128) * (im as u128)) >> 64) as u64;\n let mut v = z.wrapping_sub(x.wrapping_mul(m as u64)) as u32;\n if m <= v {\n v = v.wrapping_add(m);\n }\n v\n }\n\n #[allow(clippy::many_single_char_names)]\n pub(crate) fn pow_mod(x: i64, mut n: i64, m: i32) -> i64 {\n if m == 1 {\n return 0;\n }\n let _m = m as u32;\n let mut r: u64 = 1;\n let mut y: u64 = safe_mod(x, m as i64) as u64;\n while n != 0 {\n if (n & 1) > 0 {\n r = (r * y) % (_m as u64);\n }\n y = (y * y) % (_m as u64);\n n >>= 1;\n }\n r as i64\n }\n\n pub(crate) fn is_prime(n: i32) -> bool {\n let n = n as i64;\n match n {\n _ if n <= 1 => return false,\n 2 | 7 | 61 => return true,\n _ if n % 2 == 0 => return false,\n _ => {}\n }\n let mut d = n - 1;\n while d % 2 == 0 {\n d /= 2;\n }\n for &a in &[2, 7, 61] {\n let mut t = d;\n let mut y = pow_mod(a, t, n as i32);\n while t != n - 1 && y != 1 && y != n - 1 {\n y = y * y % n;\n t <<= 1;\n }\n if y != n - 1 && t % 2 == 0 {\n return false;\n }\n }\n true\n }\n\n #[allow(clippy::many_single_char_names)]\n pub(crate) fn inv_gcd(a: i64, b: i64) -> (i64, i64) {\n let a = safe_mod(a, b);\n if a == 0 {\n return (b, 0);\n }\n\n let mut s = b;\n let mut t = a;\n let mut m0 = 0;\n let mut m1 = 1;\n\n while t != 0 {\n let u = s / t;\n s -= t * u;\n m0 -= m1 * u; // |m1 * u| <= |m1| * s <= b\n\n swap(&mut s, &mut t);\n swap(&mut m0, &mut m1);\n }\n if m0 < 0 {\n m0 += b / s;\n }\n (s, m0)\n }\n\n pub(crate) fn primitive_root(m: i32) -> i32 {\n match m {\n 2 => return 1,\n 167_772_161 => return 3,\n 469_762_049 => return 3,\n 754_974_721 => return 11,\n 998_244_353 => return 3,\n _ => {}\n }\n\n let mut divs = [0; 20];\n divs[0] = 2;\n let mut cnt = 1;\n let mut x = (m - 1) / 2;\n while x % 2 == 0 {\n x /= 2;\n }\n for i in (3..std::i32::MAX).step_by(2) {\n if i as i64 * i as i64 > x as i64 {\n break;\n }\n if x % i == 0 {\n divs[cnt] = i;\n cnt += 1;\n while x % i == 0 {\n x /= i;\n }\n }\n }\n if x > 1 {\n divs[cnt] = x;\n cnt += 1;\n }\n let mut g = 2;\n loop {\n if (0..cnt).all(|i| pow_mod(g, ((m - 1) / divs[i]) as i64, m) != 1) {\n break g as i32;\n }\n g += 1;\n }\n }\n}\npub mod modint {\n\n use crate::internal_math;\n use std::{\n cell::RefCell,\n convert::{Infallible, TryInto as _},\n fmt,\n hash::{Hash, Hasher},\n iter::{Product, Sum},\n marker::PhantomData,\n ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign},\n str::FromStr,\n sync::atomic::{self, AtomicU32, AtomicU64},\n thread::LocalKey,\n };\n\n pub type ModInt1000000007 = StaticModInt;\n pub type ModInt998244353 = StaticModInt;\n pub type ModInt = DynamicModInt;\n\n #[derive(Copy, Clone, Eq, PartialEq)]\n #[repr(transparent)]\n pub struct StaticModInt {\n val: u32,\n phantom: PhantomData M>,\n }\n\n impl StaticModInt {\n #[inline(always)]\n pub fn modulus() -> u32 {\n M::VALUE\n }\n\n #[inline]\n pub fn new(val: T) -> Self {\n Self::raw(val.rem_euclid_u32(M::VALUE))\n }\n\n #[inline]\n pub fn raw(val: u32) -> Self {\n Self {\n val,\n phantom: PhantomData,\n }\n }\n\n #[inline]\n pub fn val(self) -> u32 {\n self.val\n }\n\n #[inline]\n pub fn pow(self, n: u64) -> Self {\n ::pow(self, n)\n }\n\n #[inline]\n pub fn inv(self) -> Self {\n if M::HINT_VALUE_IS_PRIME {\n if self.val() == 0 {\n panic!(\"attempt to divide by zero\");\n }\n debug_assert!(\n internal_math::is_prime(M::VALUE.try_into().unwrap()),\n \"{} is not a prime number\",\n M::VALUE,\n );\n self.pow((M::VALUE - 2).into())\n } else {\n Self::inv_for_non_prime_modulus(self)\n }\n }\n }\n\n impl ModIntBase for StaticModInt {\n #[inline(always)]\n fn modulus() -> u32 {\n Self::modulus()\n }\n\n #[inline]\n fn raw(val: u32) -> Self {\n Self::raw(val)\n }\n\n #[inline]\n fn val(self) -> u32 {\n self.val()\n }\n\n #[inline]\n fn inv(self) -> Self {\n self.inv()\n }\n }\n\n pub trait Modulus: 'static + Copy + Eq {\n const VALUE: u32;\n const HINT_VALUE_IS_PRIME: bool;\n\n fn butterfly_cache() -> &'static LocalKey>>>;\n }\n\n #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)]\n pub enum Mod1000000007 {}\n\n impl Modulus for Mod1000000007 {\n const VALUE: u32 = 1_000_000_007;\n const HINT_VALUE_IS_PRIME: bool = true;\n\n fn butterfly_cache() -> &'static LocalKey>>> {\n thread_local! {\n static BUTTERFLY_CACHE: RefCell>> = RefCell::default();\n }\n &BUTTERFLY_CACHE\n }\n }\n\n #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)]\n pub enum Mod998244353 {}\n\n impl Modulus for Mod998244353 {\n const VALUE: u32 = 998_244_353;\n const HINT_VALUE_IS_PRIME: bool = true;\n\n fn butterfly_cache() -> &'static LocalKey>>> {\n thread_local! {\n static BUTTERFLY_CACHE: RefCell>> = RefCell::default();\n }\n &BUTTERFLY_CACHE\n }\n }\n\n #[allow(dead_code)]\n pub struct ButterflyCache {\n pub(crate) sum_e: Vec>,\n pub(crate) sum_ie: Vec>,\n }\n\n #[derive(Copy, Clone, Eq, PartialEq)]\n #[repr(transparent)]\n pub struct DynamicModInt {\n val: u32,\n phantom: PhantomData I>,\n }\n\n impl DynamicModInt {\n #[inline]\n pub fn modulus() -> u32 {\n I::companion_barrett().umod()\n }\n\n #[inline]\n pub fn set_modulus(modulus: u32) {\n if modulus == 0 {\n panic!(\"the modulus must not be 0\");\n }\n I::companion_barrett().update(modulus);\n }\n\n #[inline]\n pub fn new(val: T) -> Self {\n ::new(val)\n }\n\n #[inline]\n pub fn raw(val: u32) -> Self {\n Self {\n val,\n phantom: PhantomData,\n }\n }\n\n #[inline]\n pub fn val(self) -> u32 {\n self.val\n }\n\n #[inline]\n pub fn pow(self, n: u64) -> Self {\n ::pow(self, n)\n }\n\n #[inline]\n pub fn inv(self) -> Self {\n Self::inv_for_non_prime_modulus(self)\n }\n }\n\n impl ModIntBase for DynamicModInt {\n #[inline]\n fn modulus() -> u32 {\n Self::modulus()\n }\n\n #[inline]\n fn raw(val: u32) -> Self {\n Self::raw(val)\n }\n\n #[inline]\n fn val(self) -> u32 {\n self.val()\n }\n\n #[inline]\n fn inv(self) -> Self {\n self.inv()\n }\n }\n\n pub trait Id: 'static + Copy + Eq {\n fn companion_barrett() -> &'static Barrett;\n }\n\n #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)]\n pub enum DefaultId {}\n\n impl Id for DefaultId {\n fn companion_barrett() -> &'static Barrett {\n static BARRETT: Barrett = Barrett::default();\n &BARRETT\n }\n }\n\n pub struct Barrett {\n m: AtomicU32,\n im: AtomicU64,\n }\n\n impl Barrett {\n #[inline]\n pub const fn new(m: u32) -> Self {\n Self {\n m: AtomicU32::new(m),\n im: AtomicU64::new((-1i64 as u64 / m as u64).wrapping_add(1)),\n }\n }\n\n #[inline]\n const fn default() -> Self {\n Self::new(998_244_353)\n }\n\n #[inline]\n fn update(&self, m: u32) {\n let im = (-1i64 as u64 / m as u64).wrapping_add(1);\n self.m.store(m, atomic::Ordering::SeqCst);\n self.im.store(im, atomic::Ordering::SeqCst);\n }\n\n #[inline]\n fn umod(&self) -> u32 {\n self.m.load(atomic::Ordering::SeqCst)\n }\n\n #[inline]\n fn mul(&self, a: u32, b: u32) -> u32 {\n let m = self.m.load(atomic::Ordering::SeqCst);\n let im = self.im.load(atomic::Ordering::SeqCst);\n internal_math::mul_mod(a, b, m, im)\n }\n }\n\n impl Default for Barrett {\n #[inline]\n fn default() -> Self {\n Self::default()\n }\n }\n\n pub trait ModIntBase:\n Default\n + FromStr\n + From\n + From\n + From\n + From\n + From\n + From\n + From\n + From\n + From\n + From\n + From\n + From\n + Copy\n + Eq\n + Hash\n + fmt::Display\n + fmt::Debug\n + Neg\n + Add\n + Sub\n + Mul\n + Div\n + AddAssign\n + SubAssign\n + MulAssign\n + DivAssign\n {\n fn modulus() -> u32;\n\n fn raw(val: u32) -> Self;\n\n fn val(self) -> u32;\n\n fn inv(self) -> Self;\n\n #[inline]\n fn new(val: T) -> Self {\n Self::raw(val.rem_euclid_u32(Self::modulus()))\n }\n\n #[inline]\n fn pow(self, mut n: u64) -> Self {\n let mut x = self;\n let mut r = Self::raw(1);\n while n > 0 {\n if n & 1 == 1 {\n r *= x;\n }\n x *= x;\n n >>= 1;\n }\n r\n }\n }\n\n pub trait RemEuclidU32 {\n fn rem_euclid_u32(self, modulus: u32) -> u32;\n }\n\n macro_rules! impl_rem_euclid_u32_for_small_signed {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self as i64).rem_euclid(i64::from(modulus)) as _\n }\n }\n )*\n }\n}\n\n impl_rem_euclid_u32_for_small_signed!(i8, i16, i32, i64, isize);\n\n impl RemEuclidU32 for i128 {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self.rem_euclid(i128::from(modulus)) as _\n }\n }\n\n macro_rules! impl_rem_euclid_u32_for_small_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self as u32 % modulus\n }\n }\n )*\n }\n}\n\n macro_rules! impl_rem_euclid_u32_for_large_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self % (modulus as $ty)) as _\n }\n }\n )*\n }\n}\n\n impl_rem_euclid_u32_for_small_unsigned!(u8, u16, u32);\n impl_rem_euclid_u32_for_large_unsigned!(u64, u128);\n\n #[cfg(target_pointer_width = \"32\")]\n impl_rem_euclid_u32_for_small_unsigned!(usize);\n\n #[cfg(target_pointer_width = \"64\")]\n impl_rem_euclid_u32_for_large_unsigned!(usize);\n\n trait InternalImplementations: ModIntBase {\n #[inline]\n fn inv_for_non_prime_modulus(this: Self) -> Self {\n let (gcd, x) = internal_math::inv_gcd(this.val().into(), Self::modulus().into());\n if gcd != 1 {\n panic!(\"the multiplicative inverse does not exist\");\n }\n Self::new(x)\n }\n\n #[inline]\n fn default_impl() -> Self {\n Self::raw(0)\n }\n\n #[inline]\n fn from_str_impl(s: &str) -> Result {\n Ok(s.parse::()\n .map(Self::new)\n .unwrap_or_else(|_| todo!(\"parsing as an arbitrary precision integer?\")))\n }\n\n #[inline]\n fn hash_impl(this: &Self, state: &mut impl Hasher) {\n this.val().hash(state)\n }\n\n #[inline]\n fn display_impl(this: &Self, f: &mut fmt::Formatter) -> fmt::Result {\n fmt::Display::fmt(&this.val(), f)\n }\n\n #[inline]\n fn debug_impl(this: &Self, f: &mut fmt::Formatter) -> fmt::Result {\n fmt::Debug::fmt(&this.val(), f)\n }\n\n #[inline]\n fn neg_impl(this: Self) -> Self {\n Self::sub_impl(Self::raw(0), this)\n }\n\n #[inline]\n fn add_impl(lhs: Self, rhs: Self) -> Self {\n let modulus = Self::modulus();\n let mut val = lhs.val() + rhs.val();\n if val >= modulus {\n val -= modulus;\n }\n Self::raw(val)\n }\n\n #[inline]\n fn sub_impl(lhs: Self, rhs: Self) -> Self {\n let modulus = Self::modulus();\n let mut val = lhs.val().wrapping_sub(rhs.val());\n if val >= modulus {\n val = val.wrapping_add(modulus)\n }\n Self::raw(val)\n }\n\n fn mul_impl(lhs: Self, rhs: Self) -> Self;\n\n #[inline]\n fn div_impl(lhs: Self, rhs: Self) -> Self {\n Self::mul_impl(lhs, rhs.inv())\n }\n }\n\n impl InternalImplementations for StaticModInt {\n #[inline]\n fn mul_impl(lhs: Self, rhs: Self) -> Self {\n Self::raw((u64::from(lhs.val()) * u64::from(rhs.val()) % u64::from(M::VALUE)) as u32)\n }\n }\n\n impl InternalImplementations for DynamicModInt {\n #[inline]\n fn mul_impl(lhs: Self, rhs: Self) -> Self {\n Self::raw(I::companion_barrett().mul(lhs.val, rhs.val))\n }\n }\n\n macro_rules! impl_basic_traits {\n () => {};\n (impl <$generic_param:ident : $generic_param_bound:tt> _ for $self:ty; $($rest:tt)*) => {\n impl <$generic_param: $generic_param_bound> Default for $self {\n #[inline]\n fn default() -> Self {\n Self::default_impl()\n }\n }\n\n impl <$generic_param: $generic_param_bound> FromStr for $self {\n type Err = Infallible;\n\n #[inline]\n fn from_str(s: &str) -> Result {\n Self::from_str_impl(s)\n }\n }\n\n impl<$generic_param: $generic_param_bound, V: RemEuclidU32> From for $self {\n #[inline]\n fn from(from: V) -> Self {\n Self::new(from)\n }\n }\n\n #[allow(clippy::derive_hash_xor_eq)]\n impl<$generic_param: $generic_param_bound> Hash for $self {\n #[inline]\n fn hash(&self, state: &mut H) {\n Self::hash_impl(self, state)\n }\n }\n\n impl<$generic_param: $generic_param_bound> fmt::Display for $self {\n #[inline]\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n Self::display_impl(self, f)\n }\n }\n\n impl<$generic_param: $generic_param_bound> fmt::Debug for $self {\n #[inline]\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\n Self::debug_impl(self, f)\n }\n }\n\n impl<$generic_param: $generic_param_bound> Neg for $self {\n type Output = $self;\n\n #[inline]\n fn neg(self) -> $self {\n Self::neg_impl(self)\n }\n }\n\n impl<$generic_param: $generic_param_bound> Neg for &'_ $self {\n type Output = $self;\n\n #[inline]\n fn neg(self) -> $self {\n <$self>::neg_impl(*self)\n }\n }\n\n impl_basic_traits!($($rest)*);\n };\n}\n\n impl_basic_traits! {\n impl _ for StaticModInt ;\n impl _ for DynamicModInt;\n }\n\n macro_rules! impl_bin_ops {\n () => {};\n (for<$($generic_param:ident : $generic_param_bound:tt),*> <$lhs_ty:ty> ~ <$rhs_ty:ty> -> $output:ty { { $lhs_body:expr } ~ { $rhs_body:expr } } $($rest:tt)*) => {\n impl <$($generic_param: $generic_param_bound),*> Add<$rhs_ty> for $lhs_ty {\n type Output = $output;\n\n #[inline]\n fn add(self, rhs: $rhs_ty) -> $output {\n <$output>::add_impl(apply($lhs_body, self), apply($rhs_body, rhs))\n }\n }\n\n impl <$($generic_param: $generic_param_bound),*> Sub<$rhs_ty> for $lhs_ty {\n type Output = $output;\n\n #[inline]\n fn sub(self, rhs: $rhs_ty) -> $output {\n <$output>::sub_impl(apply($lhs_body, self), apply($rhs_body, rhs))\n }\n }\n\n impl <$($generic_param: $generic_param_bound),*> Mul<$rhs_ty> for $lhs_ty {\n type Output = $output;\n\n #[inline]\n fn mul(self, rhs: $rhs_ty) -> $output {\n <$output>::mul_impl(apply($lhs_body, self), apply($rhs_body, rhs))\n }\n }\n\n impl <$($generic_param: $generic_param_bound),*> Div<$rhs_ty> for $lhs_ty {\n type Output = $output;\n\n #[inline]\n fn div(self, rhs: $rhs_ty) -> $output {\n <$output>::div_impl(apply($lhs_body, self), apply($rhs_body, rhs))\n }\n }\n\n impl_bin_ops!($($rest)*);\n };\n}\n\n macro_rules! impl_assign_ops {\n () => {};\n (for<$($generic_param:ident : $generic_param_bound:tt),*> <$lhs_ty:ty> ~= <$rhs_ty:ty> { _ ~= { $rhs_body:expr } } $($rest:tt)*) => {\n impl <$($generic_param: $generic_param_bound),*> AddAssign<$rhs_ty> for $lhs_ty {\n #[inline]\n fn add_assign(&mut self, rhs: $rhs_ty) {\n *self = *self + apply($rhs_body, rhs);\n }\n }\n\n impl <$($generic_param: $generic_param_bound),*> SubAssign<$rhs_ty> for $lhs_ty {\n #[inline]\n fn sub_assign(&mut self, rhs: $rhs_ty) {\n *self = *self - apply($rhs_body, rhs);\n }\n }\n\n impl <$($generic_param: $generic_param_bound),*> MulAssign<$rhs_ty> for $lhs_ty {\n #[inline]\n fn mul_assign(&mut self, rhs: $rhs_ty) {\n *self = *self * apply($rhs_body, rhs);\n }\n }\n\n impl <$($generic_param: $generic_param_bound),*> DivAssign<$rhs_ty> for $lhs_ty {\n #[inline]\n fn div_assign(&mut self, rhs: $rhs_ty) {\n *self = *self / apply($rhs_body, rhs);\n }\n }\n\n impl_assign_ops!($($rest)*);\n };\n}\n\n #[inline]\n fn apply O, X, O>(f: F, x: X) -> O {\n f(x)\n }\n\n impl_bin_ops! {\n for > ~ > -> StaticModInt { { |x| x } ~ { |x| x } }\n for > ~ <&'_ StaticModInt > -> StaticModInt { { |x| x } ~ { |&x| x } }\n for <&'_ StaticModInt > ~ > -> StaticModInt { { |&x| x } ~ { |x| x } }\n for <&'_ StaticModInt > ~ <&'_ StaticModInt > -> StaticModInt { { |&x| x } ~ { |&x| x } }\n for > ~ > -> DynamicModInt { { |x| x } ~ { |x| x } }\n for > ~ <&'_ DynamicModInt> -> DynamicModInt { { |x| x } ~ { |&x| x } }\n for <&'_ DynamicModInt> ~ > -> DynamicModInt { { |&x| x } ~ { |x| x } }\n for <&'_ DynamicModInt> ~ <&'_ DynamicModInt> -> DynamicModInt { { |&x| x } ~ { |&x| x } }\n\n for > ~ -> StaticModInt { { |x| x } ~ { StaticModInt::::new } }\n for > ~ -> DynamicModInt { { |x| x } ~ { DynamicModInt::::new } }\n }\n\n impl_assign_ops! {\n for > ~= > { _ ~= { |x| x } }\n for > ~= <&'_ StaticModInt > { _ ~= { |&x| x } }\n for > ~= > { _ ~= { |x| x } }\n for > ~= <&'_ DynamicModInt> { _ ~= { |&x| x } }\n\n for > ~= { _ ~= { StaticModInt::::new } }\n for > ~= { _ ~= { DynamicModInt::::new } }\n }\n\n macro_rules! impl_folding {\n () => {};\n (impl<$generic_param:ident : $generic_param_bound:tt> $trait:ident<_> for $self:ty { fn $method:ident(_) -> _ { _($unit:expr, $op:expr) } } $($rest:tt)*) => {\n impl<$generic_param: $generic_param_bound> $trait for $self {\n #[inline]\n fn $method(iter: S) -> Self\n where\n S: Iterator,\n {\n iter.fold($unit, $op)\n }\n }\n\n impl<'a, $generic_param: $generic_param_bound> $trait<&'a Self> for $self {\n #[inline]\n fn $method(iter: S) -> Self\n where\n S: Iterator,\n {\n iter.fold($unit, $op)\n }\n }\n\n impl_folding!($($rest)*);\n };\n}\n\n impl_folding! {\n impl Sum<_> for StaticModInt { fn sum(_) -> _ { _(Self::raw(0), Add::add) } }\n impl Product<_> for StaticModInt { fn product(_) -> _ { _(Self::raw(1), Mul::mul) } }\n impl Sum<_> for DynamicModInt { fn sum(_) -> _ { _(Self::raw(0), Add::add) } }\n impl Product<_> for DynamicModInt { fn product(_) -> _ { _(Self::raw(1), Mul::mul) } }\n }\n}\nuse modint::*;\n\n", "lang_cluster": "Rust", "tags": ["math", "greedy", "constructive algorithms", "combinatorics"], "code_uid": "e4e2b1c34e33529a1aa52fead60e2441", "src_uid": "dc7b887afcc2e95c4e90619ceda63071", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let v: Vec = {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line);\n line.trim().split(\" \").map(|s| s.parse::().unwrap()).collect()\n };\n\n let min_num = v.iter().min().unwrap();\n if min_num % 2 == 0 {\n println!(\"Malvika\");\n } else {\n println!(\"Akshat\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "e4be5d4b59f78fe3b03b30d0195b65cb", "src_uid": "a4b9ce9c9f170a729a97af13e81b5fe4", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "\nstruct Scan {\n buffer: std::collections::VecDeque\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan { buffer: std::collections::VecDeque::new() }\n }\n\n fn next(&mut self)-> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn main() {\n let mut scan = Scan::new();\n let a: usize = scan.next();\n let b: usize = scan.next();\n let c = a.min(b);\n println!(\"{}\", if c % 2 == 0 { \"Malvika\" } else { \"Akshat\"});\n}\n\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "b9fd1a30298ad3cfb67ec1bd0a7a5289", "src_uid": "a4b9ce9c9f170a729a97af13e81b5fe4", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::*;\n\n\n\nfn main () {\n let mut input = String::new();\n stdin().read_line(&mut input).unwrap();\n let mut it = input.split_whitespace();\n let n: i32= it.next().unwrap().parse().unwrap();\n let pos: i32 = it.next().unwrap().parse().unwrap();\n let l: i32 = it.next().unwrap().parse().unwrap();\n let r: i32 = it.next().unwrap().parse().unwrap();\n\n let rl = l != 1;\n let rr = r != n;\n let mut steps = 0;\n\n if rl && rr {\n steps = 2 + (pos - l).abs().min((pos - r).abs()) + (r - l);\n } else if !rl && rr {\n steps = 1 + (pos - r).abs();\n } else if !rr && rl{\n steps = 1 +(pos - l).abs();\n }\n\n println!(\"{}\", steps);\n\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "a66de138b70bb6882266596d2d6c9ca4", "src_uid": "5deaac7bd3afedee9b10e61997940f78", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, prelude::*, BufWriter};\r\nuse std::str::FromStr;\r\n\r\ntype M = DynamicModInt;\r\n\r\n#[allow(unused)]\r\nfn solve2(scan: &mut Scanner, out: &mut W) {\r\n let n: usize = scan.next();\r\n M::set_modulus(scan.next());\r\n\r\n let mut dp = vec![M::zero(); n + 1];\r\n dp[1] = M::one();\r\n let mut sum = M::one();\r\n for i in 2..=n {\r\n let root = (i as f64).sqrt() as usize;\r\n for j in 2..=root {\r\n let delta = dp[i / j];\r\n dp[i] += delta;\r\n }\r\n for k in 1..i / root {\r\n let high = i / k;\r\n let low = i / (k + 1) + 1;\r\n if low <= high {\r\n let delta = dp[k] * M::from(high - low + 1);\r\n dp[i] += delta;\r\n }\r\n }\r\n\r\n dp[i] += sum;\r\n sum += dp[i];\r\n }\r\n writeln!(out, \"{}\", dp[n]).ok();\r\n}\r\n\r\nfn solve(scan: &mut Scanner, out: &mut W) {\r\n let n: usize = scan.next();\r\n DynamicModInt::set_modulus(scan.next());\r\n\r\n let mut dp = vec![M::zero(); n + 1];\r\n dp[1] = M::one();\r\n for i in 2..=n {\r\n if i == 2 {\r\n dp[2] = M::two();\r\n } else {\r\n let delta = M::two() * dp[i - 1];\r\n dp[i] += delta;\r\n let delta = dp[1];\r\n dp[i] += delta;\r\n }\r\n for j in (i + i..=n).step_by(i) {\r\n let delta = dp[i] - dp[i - 1];\r\n dp[j] += delta;\r\n }\r\n }\r\n writeln!(out, \"{}\", dp[n]).ok();\r\n}\r\n\r\nfn main() {\r\n let (stdin, stdout) = (io::stdin(), io::stdout());\r\n let mut scan = Scanner::new(stdin.lock());\r\n let mut out = BufWriter::new(stdout.lock());\r\n\r\n let tests = 1; // scan.next::();\r\n for _ in 0..tests {\r\n solve(&mut scan, &mut out);\r\n }\r\n}\r\n\r\n// {{{ Scanner\r\npub struct Scanner {\r\n reader: R,\r\n buffer: Vec,\r\n}\r\n\r\nimpl Scanner {\r\n pub fn new(reader: R) -> Self {\r\n Self {\r\n reader,\r\n buffer: vec![],\r\n }\r\n }\r\n\r\n pub fn next(&mut self) -> T {\r\n loop {\r\n if let Some(token) = self.buffer.pop() {\r\n return token.parse().ok().unwrap();\r\n }\r\n let mut line = String::new();\r\n self.reader.read_line(&mut line).unwrap();\r\n self.buffer = line\r\n .split_ascii_whitespace()\r\n .rev()\r\n .map(String::from)\r\n .collect();\r\n }\r\n }\r\n\r\n pub fn next_vec(&mut self, n: usize) -> Vec {\r\n (0..n).map(|_| self.next()).collect()\r\n }\r\n}\r\n// }}}\r\n// {{{ DynamicModInt\r\nuse std::fmt;\r\nuse std::iter::{Product, Sum};\r\nuse std::ops::*;\r\n\r\n#[derive(Clone, Copy, Eq, PartialEq, Debug, Hash)]\r\npub struct DynamicModInt(pub i32);\r\n\r\nimpl Default for DynamicModInt {\r\n fn default() -> Self {\r\n DynamicModInt(0)\r\n }\r\n}\r\n\r\nimpl fmt::Display for DynamicModInt {\r\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\r\n write!(f, \"{}\", self.0)\r\n }\r\n}\r\n\r\nimpl DynamicModInt {\r\n pub fn set_modulus(modulus: i32) {\r\n *Self::modulus_ref() = modulus;\r\n }\r\n\r\n pub fn modulus() -> i32 {\r\n *Self::modulus_ref()\r\n }\r\n\r\n fn modulus_ref() -> &'static mut i32 {\r\n static mut MODULES: i32 = 0;\r\n return unsafe { &mut MODULES };\r\n }\r\n\r\n pub fn raw(val: i32) -> Self {\r\n DynamicModInt(val)\r\n }\r\n\r\n #[inline]\r\n fn canon(val: i32) -> Self {\r\n DynamicModInt(if val < 0 { val + Self::modulus() } else { val })\r\n }\r\n\r\n #[inline]\r\n pub fn zero() -> Self {\r\n DynamicModInt(0)\r\n }\r\n\r\n #[inline]\r\n pub fn one() -> Self {\r\n DynamicModInt(1)\r\n }\r\n\r\n #[inline]\r\n pub fn two() -> Self {\r\n DynamicModInt(2)\r\n }\r\n\r\n pub fn pow(self, n: u64) -> Self {\r\n let mut n = n;\r\n let mut res = Self::one();\r\n let mut a = self;\r\n while n > 0 {\r\n if n & 1 == 1 {\r\n res = res * a;\r\n }\r\n a = a * a;\r\n n >>= 1;\r\n }\r\n\r\n res\r\n }\r\n\r\n pub fn inv(self) -> Self {\r\n self.pow(Self::modulus() as u64 - 2)\r\n }\r\n}\r\n\r\nmacro_rules! from_bigger_int {\r\n ($($int:ident)*) => {$(\r\n impl From<$int> for DynamicModInt {\r\n fn from(val: $int) -> Self {\r\n Self::canon((val % Self::modulus() as $int) as i32)\r\n }\r\n }\r\n )*};\r\n}\r\nfrom_bigger_int!(u32 usize i64 u64 i128 u128);\r\n\r\nmacro_rules! from_smaller_int {\r\n ($($int: ident)*) => {$(\r\n impl From<$int> for DynamicModInt {\r\n fn from(val: $int) -> Self {\r\n Self::canon(val as i32 % Self::modulus())\r\n }\r\n }\r\n )*}\r\n}\r\nfrom_smaller_int!(i32 i16 u16 i8 u8);\r\n\r\nimpl Neg for DynamicModInt {\r\n type Output = Self;\r\n fn neg(self) -> Self {\r\n DynamicModInt(if self.0 == 0 {\r\n 0\r\n } else {\r\n Self::modulus() - self.0\r\n })\r\n }\r\n}\r\n\r\nimpl Add for DynamicModInt {\r\n type Output = Self;\r\n fn add(self, other: Self) -> Self {\r\n let s = self.0 + other.0;\r\n let m = Self::modulus();\r\n DynamicModInt(if s >= m { s - m } else { s })\r\n }\r\n}\r\n\r\nimpl Sub for DynamicModInt {\r\n type Output = Self;\r\n fn sub(self, other: Self) -> Self {\r\n Self::canon(self.0 - other.0)\r\n }\r\n}\r\n\r\nimpl Mul for DynamicModInt {\r\n type Output = Self;\r\n fn mul(self, other: Self) -> Self {\r\n let mul: u64 = (self.0 as u64 * other.0 as u64) % Self::modulus() as u64;\r\n DynamicModInt(mul as i32)\r\n }\r\n}\r\n\r\nimpl Div for DynamicModInt {\r\n type Output = Self;\r\n fn div(self, other: Self) -> Self {\r\n self * other.inv()\r\n }\r\n}\r\n\r\nimpl AddAssign for DynamicModInt {\r\n fn add_assign(&mut self, other: Self) {\r\n *self = *self + other;\r\n }\r\n}\r\n\r\nimpl SubAssign for DynamicModInt {\r\n fn sub_assign(&mut self, other: Self) {\r\n *self = *self - other;\r\n }\r\n}\r\n\r\nimpl MulAssign for DynamicModInt {\r\n fn mul_assign(&mut self, other: Self) {\r\n *self = *self * other;\r\n }\r\n}\r\n\r\nimpl DivAssign for DynamicModInt {\r\n fn div_assign(&mut self, other: Self) {\r\n *self = *self / other;\r\n }\r\n}\r\n\r\nimpl Sum for DynamicModInt {\r\n fn sum>(iter: I) -> Self {\r\n iter.fold(Self::zero(), Add::add)\r\n }\r\n}\r\n\r\nimpl Product for DynamicModInt {\r\n fn product>(iter: I) -> Self {\r\n iter.fold(Self::one(), Mul::mul)\r\n }\r\n}\r\n// }}}\r\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "dp", "two pointers", "number theory"], "code_uid": "1e773fcb66f7bbd17da3eef615c76f37", "src_uid": "77443424be253352aaf2b6c89bdd4671", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::{cell::Cell, cmp::{Reverse, max, min}, collections::{BTreeMap, HashMap, HashSet}, error::Error, fmt::Display, io::{BufWriter, Read, Write}, iter::Peekable, mem::swap, ops::{Not, Range, RangeInclusive, Sub}, process::exit, rc::Rc, str::{FromStr, from_utf8, from_utf8_unchecked}};\n\nconst IO_BUF_SIZE: usize = 1 << 16;\nstruct Scanner<'a, R: Read> {\n src: &'a mut R,\n _buf: Vec,\n _pt: usize, // pointer\n _rd: usize, // bytes read\n}\n\n#[allow(dead_code)]\nimpl<'a, R: Read> Scanner<'a, R> {\n fn new(src: &'a mut R) -> Scanner<'a, R> {\n Scanner { src, _buf: vec![0; IO_BUF_SIZE], _pt: 1, _rd: 1 }\n }\n \n fn _check_buf(&mut self) {\n if self._pt == self._rd {\n self._rd = self.src.read(&mut self._buf).unwrap_or(0);\n self._pt = (self._rd == 0) as usize;\n }\n }\n \n // returns true if end of file\n fn eof(&mut self) -> bool {\n self._check_buf();\n self._rd == 0\n }\n \n // filters \\r, returns \\0 if eof\n fn byte(&mut self) -> u8 {\n loop {\n self._check_buf();\n if self._rd == 0 { return 0; }\n let res = self._buf[self._pt];\n self._pt += 1;\n if res != b'\\r' { return res; }\n }\n }\n \n fn char(&mut self) -> char { self.byte() as char }\n fn bytes_no_skip(&mut self, n: usize) -> Vec { (0..n).map(|_| self.byte()).collect() }\n fn bytes(&mut self, n: usize) -> Vec {\n let res = self.bytes_no_skip(n);\n self.byte();\n res\n }\n fn bytes2(&mut self, n: usize, m: usize) -> Vec> { (0..n).map(|_| self.bytes(m)).collect() }\n \n fn token_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c <= b' ' {\n if c == b'\\0' { return res; }\n c = self.byte();\n }\n loop {\n res.push(c);\n c = self.byte();\n if c <= b' ' { return res; }\n }\n }\n fn token(&mut self) -> String { unsafe { String::from_utf8_unchecked(self.token_bytes()) } }\n \n fn line_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c != b'\\n' && c != b'\\0' {\n res.push(c);\n c = self.byte();\n }\n res\n }\n fn line(&mut self) -> String { unsafe { String::from_utf8_unchecked(self.line_bytes()) } }\n \n fn read(&mut self) -> T { \n let token = self.token_bytes();\n unsafe { from_utf8_unchecked(&token).parse::().ok().unwrap() }\n }\n fn vec(&mut self, n: usize) -> Vec { (0..n).map(|_| self.read()).collect() }\n fn vec2(&mut self, n: usize, m: usize) -> Vec> { (0..n).map(|_| self.vec(m)).collect() }\n}\n\ntrait ToCharVec { fn to_char_vec(&self) -> Vec; }\nimpl ToCharVec for &str { fn to_char_vec(&self) -> Vec { self.chars().collect() } }\nimpl ToCharVec for String { fn to_char_vec(&self) -> Vec { self.chars().collect() } }\ntrait JoinToStr { \n fn join_to_str(&mut self, sep: &str) -> String;\n fn concat_to_str(&mut self) -> String;\n}\nimpl> JoinToStr for I { \n fn join_to_str(&mut self, sep: &str) -> String {\n let mut res = String::new();\n match self.next() {\n None => res,\n Some(first) => {\n res.push_str(&first.to_string());\n loop {\n match self.next() {\n None => break,\n Some(item) => {\n res.push_str(sep);\n res.push_str(&item.to_string())\n }\n }\n }\n res\n }\n }\n }\n \n fn concat_to_str(&mut self) -> String {\n let mut res = String::new();\n for item in self { res.push_str(&item.to_string()); }\n res\n }\n}\n\nmacro_rules! veci {\n ($n:expr , $i:ident : $gen:expr) => {{\n let n = $n;\n let mut list = Vec::with_capacity(n);\n for $i in 0..n {\n list.push($gen);\n }\n list\n }};\n ($n:expr , $gen:expr) => { veci!($n, __: $gen); }\n}\n\nfn abs_diff + PartialOrd>(x: T, y: T) -> T {\n if x < y { y - x } else { x - y }\n}\n\n// * end commons * //\n\nmod modint {\n\n use std::{convert::Infallible, iter::Sum, mem::swap, ops::AddAssign};\n\n pub trait RemEuclidU32: Copy {\n /// Calculates `self` _mod_ `modulus` losslessly.\n fn rem_euclid_u32(self, modulus: u32) -> u32;\n\n fn pow_mod(self, exponent: u64, modulus: u32) -> u32 {\n pow_mod_raw(self.rem_euclid_u32(modulus), exponent, modulus)\n }\n fn mul_mod(self, rhs: Rhs, modulus: u32) -> u32 {\n mul_mod_u32(self.rem_euclid_u32(modulus), rhs.rem_euclid_u32(modulus), modulus)\n }\n\n fn mod_pow_vec(self, n: usize, modulus: u32) -> Vec {\n let a = self.rem_euclid_u32(modulus);\n let mut res = vec![0u32; n+1];\n if modulus == 1 { return res; }\n res[0] = 1;\n for i in 1..=n {\n res[i] = mul_mod_u32(a, res[i-1], modulus);\n }\n res\n }\n }\n \n macro_rules! impl_rem_euclid_u32_for_small_signed {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self as i64).rem_euclid(i64::from(modulus)) as _\n }\n }\n )*\n }\n }\n \n impl_rem_euclid_u32_for_small_signed!(i8, i16, i32, i64, isize);\n \n impl RemEuclidU32 for i128 {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self.rem_euclid(i128::from(modulus)) as _\n }\n }\n \n macro_rules! impl_rem_euclid_u32_for_small_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self as u32 % modulus\n }\n }\n )*\n }\n }\n \n macro_rules! impl_rem_euclid_u32_for_large_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self % (modulus as $ty)) as _\n }\n }\n )*\n }\n }\n \n impl_rem_euclid_u32_for_small_unsigned!(u8, u16, u32);\n impl_rem_euclid_u32_for_large_unsigned!(u64, u128);\n \n #[cfg(target_pointer_width = \"32\")]\n impl_rem_euclid_u32_for_small_unsigned!(usize);\n \n #[cfg(target_pointer_width = \"64\")]\n impl_rem_euclid_u32_for_large_unsigned!(usize);\n #[inline]\n pub fn mul_mod_u32(a: u32, b: u32, m: u32) -> u32 {\n ((a as u64) * (b as u64) % (m as u64)) as u32\n }\n\n #[inline]\n fn norm(a: u32, m: u32) -> u32 {\n (((a as i32) >> 31) as u32 & m) + a\n }\n // for a, b < m < 2^31, undefined otherwise\n #[inline]\n pub fn add_mod_raw(a: u32, b: u32, m: u32) -> u32 {\n sub_mod_raw(a, m-b, m)\n //norm(a.wrapping_add(b).wrapping_sub(m), m)\n }\n #[inline]\n pub fn sub_mod_raw(a: u32, b: u32, m: u32) -> u32 {\n let (r, c) = a.overflowing_sub(b);\n if c { r + m } else { r }\n //norm(a.wrapping_sub(b), m)\n }\n pub fn pow_mod_raw(a: u32, mut k: u64, m: u32) -> u32 {\n if m == 1 { return 0; }\n let mut a= a as u64;\n let m = m as u64;\n let mut r: u64 = 1;\n while k > 0 {\n if k & 1 == 1 {\n r = r * a % m;\n }\n k >>= 1;\n a = a * a % m;\n }\n return r as u32;\n }\n\n /// # Parameters\n /// * `b` `1 <= b`\n /// # Returns\n /// (x, g) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g\n pub fn inv_gcd(a: i64, b: i64) -> (i64, i64) {\n let a = a.rem_euclid(b);\n if a == 0 { return (0, b); }\n let mut s = b;\n let mut t = a;\n let mut m0 = 0;\n let mut m1 = 1;\n\n while t != 0 {\n let u = s / t;\n s -= t * u;\n m0 -= m1 * u;\n std::mem::swap(&mut s, &mut t);\n std::mem::swap(&mut m0, &mut m1);\n }\n\n if m0 < 0 { m0 += b / s; }\n (m0, s)\n }\n\n #[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]\n #[repr(transparent)]\n pub struct ModInt { pub val: u32 }\n\n impl ModInt {\n #[inline(always)]\n pub fn modulus() -> u32 { crate::get_modulus() }\n pub fn new(val: I) -> Self { Self::raw(val.rem_euclid_u32(Self::modulus())) }\n #[inline]\n pub fn raw(val: u32) -> Self { Self { val } }\n pub fn inv(self) -> Self { \n let (x, gcd) = inv_gcd(self.val.into(), Self::modulus().into());\n if gcd != 1 { panic!(\"the multiplicative inverse {}^-1 mod {} does not exist\", self.val, Self::modulus()) }\n Self::raw(x as u32)\n }\n pub fn pow(self, k: u64) -> Self {\n Self::raw(pow_mod_raw(self.val, k, Self::modulus()))\n }\n pub fn pow_vec(self, n: usize) -> Vec {\n let mut res = vec![Self::raw(0); n+1];\n res[0] += 1;\n for i in 1..=n {\n res[i] = res[i-1] * self;\n }\n res\n }\n }\n\n #[inline]\n pub fn mi(val: I) -> ModInt { ModInt::new(val) }\n\n impl From for ModInt {\n #[inline]\n fn from(from: V) -> Self { Self::new(from) }\n }\n impl std::str::FromStr for ModInt {\n type Err = std::convert::Infallible;\n #[inline]\n fn from_str(s: &str) -> Result {\n Ok(s.parse::()\n .map(Self::new)\n .unwrap_or_else(|_| todo!(\"parsing as an arbitrary precision integer?\")))\n }\n }\n impl std::fmt::Display for ModInt {\n #[inline]\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n std::fmt::Display::fmt(&self.val, f)\n }\n }\n impl std::fmt::Debug for ModInt {\n #[inline]\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n std::fmt::Debug::fmt(&self.val, f)\n }\n }\n impl std::ops::Neg for ModInt {\n type Output = ModInt;\n\n #[inline]\n fn neg(self) -> Self::Output {\n Self::raw(0) - self\n //Self::raw(norm(self.val.wrapping_neg(), Self::modulus()))\n }\n }\n\n impl std::ops::Add for ModInt {\n type Output = ModInt;\n #[inline]\n fn add(self, rhs: Self) -> Self::Output {\n Self::raw(add_mod_raw(self.val, rhs.val, Self::modulus()))\n }\n }\n impl std::ops::Sub for ModInt {\n type Output = ModInt;\n #[inline]\n fn sub(self, rhs: Self) -> Self::Output {\n Self::raw(sub_mod_raw(self.val, rhs.val, Self::modulus()))\n }\n }\n impl std::ops::Mul for ModInt {\n type Output = ModInt;\n #[inline]\n fn mul(self, rhs: Self) -> Self::Output {\n Self::raw(mul_mod_u32(self.val, rhs.val, Self::modulus()))\n }\n }\n impl std::ops::Div for ModInt {\n type Output = ModInt;\n #[inline]\n fn div(self, rhs: Self) -> Self::Output { self * rhs.inv() }\n }\n\n impl std::ops::Add for ModInt {\n type Output = ModInt;\n #[inline]\n fn add(self, rhs: I) -> Self::Output { self + Self::new(rhs) }\n }\n impl std::ops::Sub for ModInt {\n type Output = ModInt;\n #[inline]\n fn sub(self, rhs: I) -> Self::Output { self - Self::new(rhs) }\n }\n impl std::ops::Mul for ModInt {\n type Output = ModInt;\n #[inline]\n fn mul(self, rhs: I) -> Self::Output { self * Self::new(rhs) }\n }\n impl std::ops::Div for ModInt {\n type Output = ModInt;\n #[inline]\n fn div(self, rhs: I) -> Self::Output { self / Self::new(rhs) }\n }\n\n impl std::ops::AddAssign for ModInt {\n #[inline]\n fn add_assign(&mut self, rhs: Self) { *self = *self + rhs; }\n }\n impl std::ops::SubAssign for ModInt {\n #[inline]\n fn sub_assign(&mut self, rhs: Self) { *self = *self - rhs; }\n }\n impl std::ops::MulAssign for ModInt {\n #[inline]\n fn mul_assign(&mut self, rhs: Self) { *self = *self * rhs; }\n }\n impl std::ops::DivAssign for ModInt {\n #[inline]\n fn div_assign(&mut self, rhs: Self) { *self = *self / rhs; }\n }\n impl std::ops::AddAssign for ModInt {\n #[inline]\n fn add_assign(&mut self, rhs: I) { *self = *self + rhs; }\n }\n impl std::ops::SubAssign for ModInt {\n #[inline]\n fn sub_assign(&mut self, rhs: I) { *self = *self - rhs; }\n }\n impl std::ops::MulAssign for ModInt {\n #[inline]\n fn mul_assign(&mut self, rhs: I) { *self = *self * rhs; }\n }\n impl std::ops::DivAssign for ModInt {\n #[inline]\n fn div_assign(&mut self, rhs: I) { *self = *self / rhs; }\n }\n\n impl std::iter::Sum for ModInt {\n #[inline]\n fn sum>(iter: I) -> Self {\n iter.fold(Self::raw(0), std::ops::Add::add)\n }\n }\n impl std::iter::Product for ModInt {\n #[inline]\n fn product>(iter: I) -> Self {\n iter.fold(1.into(), std::ops::Mul::mul)\n }\n }\n}\n\n// const MODULUS: u32 = 998_244_353;\n// //const MODULUS: u32 = 1_000_000_007;\n// #[inline(always)]\n// fn get_modulus() -> u32 { MODULUS }\n\nstatic mut MODULUS: u32 = 998244353;\n#[inline] fn get_modulus() -> u32 { unsafe { MODULUS } }\n#[inline] fn set_modulus(value: u32) { unsafe { MODULUS = value; } }\n\nuse crate::modint::*;\n\n#[allow(non_snake_case, unused_macros)]\nfn main() -> Result<(), Box> {\n let mut INPUT = std::io::stdin();\n let OUTPUT = std::io::stdout();\n\n let mut inp = Scanner::new(&mut INPUT);\n let mut out = BufWriter::with_capacity(IO_BUF_SIZE, OUTPUT);\n\n macro_rules! inp {\n () => { inp.read(); };\n ($t: ty) => { inp.read::<$t>(); };\n ($t: ty, $($tt: ty),*) => { (inp.read::<$t>(), $(inp.read::<$tt>(),)*); };\n [$t: ty; $n: expr] => { inp.vec::<$t>($n); };\n }\n macro_rules! println { \n () => { writeln!(out).unwrap(); };\n ($exp: expr) => { writeln!(out, \"{}\", $exp).unwrap(); }; \n ($fmt: expr, $($arg : tt )*) => { writeln!(out, $fmt, $($arg)*).unwrap(); }\n }\n macro_rules! print { \n ($exp: expr) => { write!(out, \"{}\", $exp).unwrap(); }; \n ($fmt: expr, $($arg : tt )*) => { write!(out, $fmt, $($arg)*).unwrap(); }\n }\n\n { // solution start\n let num_cases = 1;//inp!(usize);\n\n for _case_num in 1..=num_cases {\n let n = inp!(usize);\n set_modulus(inp!());\n\n let mut dp = vec![mi(0); n+1];\n dp[1] = mi(1);\n dp[2] = mi(2);\n for i in 2..n {\n let d = dp[i];\n dp[i+1] += d + d + 1;\n let d = d - dp[i-1];\n for j in (i*2..=n).step_by(i) {\n dp[j] += d;\n }\n }\n\n let ans = dp[n];\n println!(ans);\n }\n } // solution end\n\n out.flush()?;\n Ok(())\n}\n\n\n\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "dp", "two pointers", "number theory"], "code_uid": "91e6f353360dcb1f17274728dd67840f", "src_uid": "77443424be253352aaf2b6c89bdd4671", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "\n#![allow(unused_imports)]\nuse std::io;\nuse std::io::prelude::*;\nuse std::io::BufReader;\nuse std::str::FromStr;\n\nfn main() {\n let mut first = String::new();\n let mut second = String::new();\n io::stdin().read_line(&mut first).unwrap();\n io::stdin().read_line(&mut second).unwrap();\n let fir: Vec = first.chars().filter(|c| c.is_digit(2)).collect();\n let sec: Vec = second.chars().filter(|c| c.is_digit(2)).collect();\n let mut out = vec!['_'; fir.len()];\n\n for i in 0..fir.len() {\n if fir[i] == sec[i] {\n out[i] = '0';\n } else {\n out[i] = '1';\n }\n }\n\n println!(\"{}\", out.iter().collect::());\n}\n\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "056d1e2f5449df2de7e62d444e304176", "src_uid": "3714b7596a6b48ca5b7a346f60d90549", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, BufRead};\n\nfn main() {\n let stdin = io::stdin();\n let mut iterator = stdin.lock().lines();\n let first = iterator.next().unwrap().unwrap();\n let second = iterator.next().unwrap().unwrap();\n\n let first_vec: Vec = first.chars().collect();\n let second_vec: Vec = second.chars().collect();\n\n let mut result = Vec::new();\n\n for i in 0..first_vec.len() {\n if first_vec[i] != second_vec[i] {\n result.push(\"1\");\n } else {\n result.push(\"0\");\n }\n }\n\n println!(\"{}\", result.join(\"\"));\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "6c999049fd1e0a7846042ea34aae56be", "src_uid": "3714b7596a6b48ca5b7a346f60d90549", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str::SplitWhitespace;\n\nfn main() {\n let mut input: String = String::new();\n io::stdin().read_line(&mut input).unwrap();\n let mut it_input: SplitWhitespace = input.split_whitespace();\n let n: i32 = it_input.next().unwrap().parse().unwrap();\n let m: i32 = it_input.next().unwrap().parse().unwrap();\n let r: i32 = it_input.next().unwrap().parse().unwrap();\n let mut n_input: String = String::new();\n let mut m_input: String = String::new();\n io::stdin().read_line(&mut n_input).unwrap();\n io::stdin().read_line(&mut m_input).unwrap();\n let mut it_n: SplitWhitespace = n_input.split_whitespace();\n let mut it_m: SplitWhitespace = m_input.split_whitespace();\n let mut n_min: i32 = 1001;\n let mut m_max: i32 = 0;\n for _i in 0..n {\n let a: i32 = it_n.next().unwrap().parse().unwrap();\n if a < n_min {\n n_min = a;\n }\n }\n for _i in 0..m {\n let a: i32 = it_m.next().unwrap().parse().unwrap();\n if a > m_max {\n m_max = a;\n }\n }\n if r / n_min * m_max + r % n_min > r {\n print!(\"{}\", r / n_min * m_max + r % n_min);\n } else {\n print!(\"{}\", r);\n }\n}\n", "lang_cluster": "Rust", "tags": ["greedy", "implementation"], "code_uid": "b89a723fc61831e0732617e6044d380c", "src_uid": "42f25d492bddc12d3d89d39315d63cb9", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next_line(&self) -> String {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n line\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let line = self.next_line();\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n\n fn next_n(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.next::()).collect()\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let n: usize = scan.next();\n let m: usize = scan.next();\n let r: usize = scan.next();\n let buy: usize = scan.next_n::(n).into_iter().min().unwrap();\n let sell: usize = scan.next_n::(m).into_iter().max().unwrap();\n println!(\n \"{}\",\n if buy >= sell {\n r\n } else {\n r % buy + r / buy * sell\n }\n );\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["greedy", "implementation"], "code_uid": "2c0e2cb630084cbe9c045f82bf11be5f", "src_uid": "42f25d492bddc12d3d89d39315d63cb9", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin ModInt ----------\nmod modint {\n\n #[allow(dead_code)]\n pub struct Mod;\n impl ConstantModulo for Mod {\n const MOD: u32 = 1_000_000_007;\n }\n\n #[allow(dead_code)]\n pub struct StaticMod;\n static mut STATIC_MOD: u32 = 0;\n impl Modulo for StaticMod {\n fn modulo() -> u32 {\n unsafe { STATIC_MOD }\n }\n }\n\n #[allow(dead_code)]\n impl StaticMod {\n pub fn set_modulo(p: u32) {\n unsafe {\n STATIC_MOD = p;\n }\n }\n }\n\n use std::marker::*;\n use std::ops::*;\n\n pub trait Modulo {\n fn modulo() -> u32;\n }\n\n pub trait ConstantModulo {\n const MOD: u32;\n }\n\n impl Modulo for T\n where\n T: ConstantModulo,\n {\n fn modulo() -> u32 {\n T::MOD\n }\n }\n\n pub struct ModInt(pub u32, PhantomData);\n\n impl Clone for ModInt {\n fn clone(&self) -> Self {\n ModInt::new_unchecked(self.0)\n }\n }\n\n impl Copy for ModInt {}\n\n impl Add for ModInt {\n type Output = ModInt;\n fn add(self, rhs: Self) -> Self::Output {\n let mut d = self.0 + rhs.0;\n if d >= T::modulo() {\n d -= T::modulo();\n }\n ModInt::new_unchecked(d)\n }\n }\n\n impl AddAssign for ModInt {\n fn add_assign(&mut self, rhs: Self) {\n *self = *self + rhs;\n }\n }\n\n impl Sub for ModInt {\n type Output = ModInt;\n fn sub(self, rhs: Self) -> Self::Output {\n let mut d = T::modulo() + self.0 - rhs.0;\n if d >= T::modulo() {\n d -= T::modulo();\n }\n ModInt::new_unchecked(d)\n }\n }\n\n impl SubAssign for ModInt {\n fn sub_assign(&mut self, rhs: Self) {\n *self = *self - rhs;\n }\n }\n\n impl Mul for ModInt {\n type Output = ModInt;\n fn mul(self, rhs: Self) -> Self::Output {\n let v = self.0 as u64 * rhs.0 as u64 % T::modulo() as u64;\n ModInt::new_unchecked(v as u32)\n }\n }\n\n impl MulAssign for ModInt {\n fn mul_assign(&mut self, rhs: Self) {\n *self = *self * rhs;\n }\n }\n\n impl Neg for ModInt {\n type Output = ModInt;\n fn neg(self) -> Self::Output {\n if self.0 == 0 {\n Self::zero()\n } else {\n Self::new_unchecked(T::modulo() - self.0)\n }\n }\n }\n\n impl std::fmt::Display for ModInt {\n fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n }\n\n impl std::str::FromStr for ModInt {\n type Err = std::num::ParseIntError;\n fn from_str(s: &str) -> Result {\n let val = s.parse::()?;\n Ok(ModInt::new(val))\n }\n }\n\n impl From for ModInt {\n fn from(val: usize) -> ModInt {\n ModInt::new_unchecked((val % T::modulo() as usize) as u32)\n }\n }\n\n impl From for ModInt {\n fn from(val: u64) -> ModInt {\n ModInt::new_unchecked((val % T::modulo() as u64) as u32)\n }\n }\n\n impl From for ModInt {\n fn from(val: i64) -> ModInt {\n let m = T::modulo() as i64;\n ModInt::new((val % m + m) as u32)\n }\n }\n\n #[allow(dead_code)]\n impl ModInt {\n pub fn new_unchecked(d: u32) -> Self {\n ModInt(d, PhantomData)\n }\n pub fn zero() -> Self {\n ModInt::new_unchecked(0)\n }\n pub fn one() -> Self {\n ModInt::new_unchecked(1)\n }\n pub fn is_zero(&self) -> bool {\n self.0 == 0\n }\n }\n\n #[allow(dead_code)]\n impl ModInt {\n pub fn new(d: u32) -> Self {\n ModInt::new_unchecked(d % T::modulo())\n }\n pub fn pow(&self, mut n: u64) -> Self {\n let mut t = Self::one();\n let mut s = *self;\n while n > 0 {\n if n & 1 == 1 {\n t *= s;\n }\n s *= s;\n n >>= 1;\n }\n t\n }\n pub fn inv(&self) -> Self {\n assert!(self.0 != 0);\n self.pow(T::modulo() as u64 - 2)\n }\n }\n\n #[allow(dead_code)]\n pub fn mod_pow(r: u64, mut n: u64, m: u64) -> u64 {\n let mut t = 1 % m;\n let mut s = r % m;\n while n > 0 {\n if n & 1 == 1 {\n t = t * s % m;\n }\n s = s * s % m;\n n >>= 1;\n }\n t\n }\n}\n// ---------- end ModInt ----------\n// ---------- begin Precalc ----------\nmod precalc {\n use super::modint::*;\n #[allow(dead_code)]\n pub struct Precalc {\n inv: Vec>,\n fact: Vec>,\n ifact: Vec>,\n }\n #[allow(dead_code)]\n impl Precalc {\n pub fn new(n: usize) -> Precalc {\n let mut inv = vec![ModInt::one(); n + 1];\n let mut fact = vec![ModInt::one(); n + 1];\n let mut ifact = vec![ModInt::one(); n + 1];\n for i in 2..(n + 1) {\n fact[i] = fact[i - 1] * ModInt::new_unchecked(i as u32);\n }\n ifact[n] = fact[n].inv();\n if n > 0 {\n inv[n] = ifact[n] * fact[n - 1];\n }\n for i in (1..n).rev() {\n ifact[i] = ifact[i + 1] * ModInt::new_unchecked((i + 1) as u32);\n inv[i] = ifact[i] * fact[i - 1];\n }\n Precalc {\n inv: inv,\n fact: fact,\n ifact: ifact,\n }\n }\n pub fn inv(&self, n: usize) -> ModInt {\n assert!(n > 0);\n self.inv[n]\n }\n pub fn fact(&self, n: usize) -> ModInt {\n self.fact[n]\n }\n pub fn ifact(&self, n: usize) -> ModInt {\n self.ifact[n]\n }\n pub fn perm(&self, n: usize, k: usize) -> ModInt {\n if k > n {\n return ModInt::zero();\n }\n self.fact[n] * self.ifact[n - k]\n }\n pub fn comb(&self, n: usize, k: usize) -> ModInt {\n if k > n {\n return ModInt::zero();\n }\n self.fact[n] * self.ifact[k] * self.ifact[n - k]\n }\n }\n}\n// ---------- end Precalc ----------\n//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, bytes) => {\n read_value!($iter, String).bytes().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n//\n\nuse modint::*;\nuse precalc::*;\n\ntype M = ModInt;\n\nfn run() {\n input! {\n p: u64,\n k: u64,\n }\n let ans = if k == 0 {\n M::from(p).pow(p - 1)\n } else if k == 1 {\n M::from(p).pow(p)\n } else {\n let mut phi = p - 1;\n let mut m = phi;\n for d in 2.. {\n if d * d > m {\n break;\n }\n if m % d == 0 {\n while m % d == 0 {\n m /= d;\n }\n while phi % d == 0 && mod_pow(k, phi / d, p) == 1 {\n phi /= d;\n }\n }\n }\n if m > 1 && mod_pow(k, phi / m, p) == 1 {\n phi /= m;\n }\n M::from(p).pow((p - 1) / phi)\n };\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["dfs and similar", "math", "combinatorics", "dsu", "number theory"], "code_uid": "587d59b41ddde8bd916b54e01203166b", "src_uid": "580bf65af24fb7f08250ddbc4ca67e0e", "difficulty": 1800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(non_snake_case)]\n\nuse std::cmp::{max, min, Ordering};\nuse std::collections::*;\nuse std::fmt::{Debug, Formatter};\nuse std::io::*;\nuse std::ops::*;\nuse std::*;\n\n// -----------------------------------------------\n// Framework\n// -----------------------------------------------\n\n#[allow(unused_macros)]\nmacro_rules! read {\n ([$t:ty] ; $n:expr) =>\n ((0..$n).map(|_| read!([$t])).collect::>());\n ($($t:ty),+ ; $n:expr) =>\n ((0..$n).map(|_| read!($($t),+)).collect::>());\n ([$t:ty]) =>\n (rl().split_whitespace().map(|w| w.parse().unwrap()).collect::>());\n ($t:ty) =>\n (rl().parse::<$t>().unwrap());\n ($($t:ty),*) => {{\n let buf = rl();\n let mut w = buf.split_whitespace();\n ($(w.next().unwrap().parse::<$t>().unwrap()),*)\n }};\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($arg:expr),*) => {\n #[cfg(debug_assertions)]\n {\n let entries = [$(&stringify!([$arg]:), &$arg as &Debug),*];\n stderr().write_fmt(format_args!(\"{:#?}\\n\", entries)).unwrap();\n }\n };\n}\n\n#[allow(dead_code)]\nfn rl() -> String {\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim_right().to_owned()\n}\n\ntrait IteratorExt: Iterator + Sized {\n fn vec(self) -> Vec {\n self.collect()\n }\n}\n\nimpl IteratorExt for T {}\n\n// -----------------------------------------------\n// Solution\n// -----------------------------------------------\n\npub fn main() {\n let (_, d) = read!(usize, i64);\n let mut A = read![[i64]];\n A.sort();\n\n let mut l = 0;\n let mut r = 0;\n let mut ma = 0;\n while l < A.len() {\n while r < A.len() && A[r] - A[l] <= d {\n r += 1;\n }\n\n ma = max(ma, r - l);\n l += 1;\n }\n\n println!(\"{}\", A.len() - ma);\n return;\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "sortings", "greedy"], "code_uid": "4f028d46857b255dc3486dab4ca880e6", "src_uid": "6bcb324c072f796f4d50bafea5f624b2", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "macro_rules! parse_line {\n ($t: ty) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let a_str = a_str.trim();\n a_str.parse::<$t>().expect(\"parse error\")\n });\n ($($t: ty),+) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let mut a_iter = a_str.split_whitespace();\n (\n $(\n a_iter.next().unwrap().parse::<$t>().expect(\"parse error\"),\n )+\n )\n })\n}\n\n#[allow(unused_macros)]\nmacro_rules! parse_line_to_vec {\n ($t: ty) => {{\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n (a_str\n .split_whitespace()\n .map(|x| x.parse::<$t>().unwrap())\n .collect::>())\n }};\n}\n\nuse std::io::Write;\n\nfn solve(writer: &mut std::io::BufWriter) {\n let n = parse_line!(u32);\n let m = parse_line!(u32);\n if n > 30 {\n writeln!(writer, \"{}\", m).unwrap();\n }else{\n writeln!(writer, \"{}\", m % (1 << n)).unwrap();\n }\n}\n\nfn main() {\n let mut writer = std::io::BufWriter::new(std::io::stdout());\n let tests = 1; // parse_line!(usize);\n for _ in 0..tests {\n solve(&mut writer);\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "3415023ce4744e679b4f71864564fb33", "src_uid": "c649052b549126e600691931b512022f", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::io::Read;\n\nfn main() {\n let mut stdin = String::new();\n io::stdin().read_to_string(&mut stdin).unwrap();\n let mut stdin = stdin.split_whitespace();\n let mut get = || stdin.next().unwrap();\n macro_rules! get {\n ($t:ty) => (get().parse::<$t>().unwrap());\n }\n \n let n = get!(u64);\n let m = get!(u64);\n \n if n > 63 {\n println!(\"{}\", m);\n } else {\n let x = (1 << n) - 1;\n println!(\"{}\", m & x);\n }\n \n}", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "b38ebf1fb921e794314fe9ecef5e115e", "src_uid": "c649052b549126e600691931b512022f", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, Write};\nuse std::vec::Vec;\nuse std::string::String;\n\nstruct Point {\n x: i8,\n y: i8,\n}\n\nfn get_line() -> String {\n let mut line: String = String::new();\n io::stdin().read_line(&mut line).expect(\"Failed to get input line\");\n return line.trim().to_string();\n}\n\nfn main() {\n let target: Point = Point{\n x: 2,\n y: 2\n };\n let mut number_one: Point = Point{\n x: 2,\n y: 2,\n };\n for i in 0..5 {\n let line: String = get_line();\n let numbers: Vec = line.split_whitespace().map(\n |n| n.parse().unwrap()\n ).collect();\n for j in 0..5 {\n if numbers[j] == 1 {\n number_one = Point{\n x: (i as i8),\n y: (j as i8),\n };\n }\n }\n }\n let mut result: i8 = 0;\n result += (number_one.x - target.x).abs();\n result += (number_one.y - target.y).abs();\n println!(\"{}\", result);\n\n io::stdout().flush().unwrap();\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "ba20a246ee42c089dabab7ef979254a2", "src_uid": "8ba7cedc3f6ae478a0bb3f902440c8e9", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::Read;\n\nfn main() {\n let inp = read_input();\n\n let index = inp.iter().position(|&i| i == 1).unwrap() as i32;\n let ans = (2 - ((index as f64 / 5 as f64).floor()) as i32).abs() + (2 - (index % 5)).abs();\n\n println!(\"{}\", ans);\n}\n\nfn read_input() -> Vec {\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s.split_whitespace().map(|i| i.parse().unwrap()).collect()\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "396b2050d7974f7cc1eaa2502470b61e", "src_uid": "8ba7cedc3f6ae478a0bb3f902440c8e9", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{BufReader, BufRead};\n\nfn main() -> Result<(), Box> {\n let line = BufReader::new(std::io::stdin())\n .lines()\n .map(Result::unwrap)\n .skip(1)\n .next()\n .unwrap();\n\n let mut days = line.chars();\n let mut location = days.next().unwrap();\n let mut seattle_to_sf = 0;\n let mut sf_to_seattle = 0;\n for day in days {\n match (location, day) {\n | ('S', 'F') => seattle_to_sf += 1,\n | ('F', 'S') => sf_to_seattle += 1,\n | _ => (),\n }\n location = day;\n }\n\n println!(\"{}\", if seattle_to_sf > sf_to_seattle { \"YES\" } else { \"NO\" });\n Ok(())\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "f9b3ede5730fba2b36132c6f5efe4f9d", "src_uid": "ab8a2070ea758d118b3c09ee165d9517", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() -> io::Result<()> {\n let mut input = String::new();\n\n io::stdin().read_line(&mut input)?;\n\n let n = input.trim().parse::().unwrap();\n input.clear();\n\n io::stdin().read_line(&mut input)?;\n\n let s = input.trim();\n\n let mut diff = 0;\n\n for i in 0..n - 1 {\n let t = &s[i..i + 2];\n if t == \"SF\" {\n diff += 1;\n } else if t == \"FS\" {\n diff -= 1;\n }\n }\n\n if diff > 0 {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n\n Ok(())\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "093e2580c6c90067d7ab194d5da55b77", "src_uid": "ab8a2070ea758d118b3c09ee165d9517", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(dead_code, unused_macros, unused_imports)]\nuse std::{cell::{Cell, RefCell, UnsafeCell}, cmp::{Ordering, Reverse, max, min}, collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque, hash_map::{DefaultHasher, RandomState}}, error::Error, fmt::{Display, Write as FmtWrite}, hash::{BuildHasher, Hash, Hasher}, io::{BufWriter, Read, Stdin, Stdout, Write}, iter::{FromIterator, Peekable}, mem::swap, ops::*, process::exit, rc::Rc, str::{FromStr, from_utf8_unchecked}, time::{Duration, Instant}, convert::{TryInto, TryFrom}, marker::PhantomData};\n\nconst IO_BUF_SIZE: usize = 1 << 16;\ntype Input = Scanner;\ntype Output = BufWriter;\nfn _init_input() -> Input { Scanner::new(std::io::stdin()) }\nfn _init_output() -> Output { BufWriter::with_capacity(IO_BUF_SIZE, std::io::stdout()) }\n\n#[repr(transparent)] struct Unsync(T);\nunsafe impl Sync for Unsync {}\n \ntype BadLazy = Unsync>>;\nimpl BadLazy {\n const fn new() -> Self { Self(UnsafeCell::new(None)) }\n}\n \nstatic INPUT: BadLazy = BadLazy::new();\nstatic OUTPUT: BadLazy = BadLazy::new();\n \nfn inp R, R>(f: F) -> R {\n unsafe { f((&mut *INPUT.0.get()).get_or_insert_with(_init_input)) }\n}\nfn out R, R>(f: F) -> R {\n unsafe { f((&mut *OUTPUT.0.get()).get_or_insert_with(_init_output)) }\n}\n\nmacro_rules! read {\n () => { read() };\n ($t: ty) => { read::<$t>() };\n ($t: ty, $($tt: ty),*) => { (read::<$t>(), $(read::<$tt>(),)*) };\n [$t: ty; $n: expr] => { read_vec::<$t>($n) };\n}\nmacro_rules! println { \n () => { out(|x| { let _ = writeln!(x); }) };\n ($exp: expr) => { out(|x| { let _ = writeln!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = writeln!(x, $fmt, $($arg)*); }) }\n}\nmacro_rules! print { \n ($exp: expr) => { out(|x| { let _ = write!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = write!(x, $fmt, $($arg)*); }) }\n}\n\nfn out_flush() { out(|x| { let _ = x.flush(); }); }\n\nfn input_is_eof() -> bool { inp(|x| x.eof()) }\nfn read_byte() -> u8 { inp(|x| x.byte()) }\nfn read_bytes_no_skip(n: usize) -> Vec { inp(|x| x.bytes_no_skip(n)) }\nfn read_bytes(n: usize) -> Vec { inp(|x| x.bytes(n)) }\nfn read_bytes2(n: usize, m: usize) -> Vec> { inp(|x| x.bytes2(n, m)) }\nfn read_token() -> Vec { inp(|x| x.token_bytes()) }\nfn read_token_str() -> String { unsafe { String::from_utf8_unchecked(read_token()) } }\nfn read_line() -> Vec { inp(|x| x.line_bytes()) }\nfn read_line_str() -> String { unsafe { String::from_utf8_unchecked(read_line()) } }\nfn read() -> T { read_token_str().parse::().ok().expect(\"failed parse\") }\nfn read_vec(n: usize) -> Vec { (0..n).map(|_| read()).collect() }\nfn read_vec2(n: usize, m: usize) -> Vec> { (0..n).map(|_| read_vec(m)).collect() }\n\nstruct Scanner {\n src: R,\n _buf: Vec,\n _pt: usize, // pointer\n _rd: usize, // bytes read\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new(src: R) -> Scanner {\n Scanner { src, _buf: vec![0; IO_BUF_SIZE], _pt: 1, _rd: 1 }\n }\n \n fn _check_buf(&mut self) {\n if self._pt == self._rd {\n self._rd = self.src.read(&mut self._buf).unwrap_or(0);\n self._pt = (self._rd == 0) as usize;\n }\n }\n \n // returns true if end of file\n fn eof(&mut self) -> bool {\n self._check_buf();\n self._rd == 0\n }\n \n // filters \\r, returns \\0 if eof\n fn byte(&mut self) -> u8 {\n loop {\n self._check_buf();\n if self._rd == 0 { return 0; }\n let res = self._buf[self._pt];\n self._pt += 1;\n if res != b'\\r' { return res; }\n }\n }\n\n fn bytes_no_skip(&mut self, n: usize) -> Vec { (0..n).map(|_| self.byte()).collect() }\n fn bytes(&mut self, n: usize) -> Vec {\n let res = self.bytes_no_skip(n);\n self.byte();\n res\n }\n fn bytes2(&mut self, n: usize, m: usize) -> Vec> { (0..n).map(|_| self.bytes(m)).collect() }\n \n fn token_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c <= b' ' {\n if c == b'\\0' { return res; }\n c = self.byte();\n }\n loop {\n res.push(c);\n c = self.byte();\n if c <= b' ' { return res; }\n }\n }\n \n fn line_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c != b'\\n' && c != b'\\0' {\n res.push(c);\n c = self.byte();\n }\n res\n }\n}\n\ntrait JoinToStr { \n fn join_to_str(self, sep: &str) -> String;\n fn concat_to_str(self) -> String;\n}\nimpl> JoinToStr for I { \n fn join_to_str(mut self, sep: &str) -> String {\n match self.next() {\n Some(first) => {\n let mut res = first.to_string();\n while let Some(item) = self.next() {\n res.push_str(sep);\n res.push_str(&item.to_string());\n }\n res\n }\n None => { String::new() }\n }\n }\n \n fn concat_to_str(self) -> String {\n let mut res = String::new();\n for item in self { res.push_str(&item.to_string()); }\n res\n }\n}\ntrait AsStr { fn as_str(&self) -> &str; }\nimpl AsStr for [u8] { fn as_str(&self) -> &str {std::str::from_utf8(self).expect(\"attempt to convert non-UTF8 byte string.\")} }\n\nmacro_rules! veci {\n ($n:expr , $i:ident : $gen:expr) => {{\n let _veci_n = $n;\n let mut _veci_list = Vec::with_capacity(_veci_n);\n for $i in 0.._veci_n {\n _veci_list.push($gen);\n }\n _veci_list\n }};\n ($n:expr , $gen:expr) => { veci!($n, _veci_: $gen) }\n}\n\nfn abs_diff + PartialOrd>(x: T, y: T) -> T {\n if x < y { y - x } else { x - y }\n}\n\ntrait CommonNumExt {\n fn div_ceil(self, b: Self) -> Self;\n fn div_floor(self, b: Self) -> Self;\n fn gcd(self, b: Self) -> Self;\n fn highest_one(self) -> Self;\n fn lowest_one(self) -> Self;\n fn sig_bits(self) -> u32;\n}\n\nmacro_rules! impl_common_num_ext {\n ($($ix:tt = $ux:tt),*) => {\n $(\n impl CommonNumExt for $ux {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { self / b }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self;\n if a == 0 || b == 0 { return a | b; }\n let shift = (a | b).trailing_zeros();\n a >>= a.trailing_zeros();\n b >>= b.trailing_zeros();\n while a != b {\n if a > b { a -= b; a >>= a.trailing_zeros(); }\n else { b -= a; b >>= b.trailing_zeros(); }\n }\n a << shift\n }\n #[inline] fn highest_one(self) -> Self { \n if self == 0 { 0 } else { const ONE: $ux = 1; ONE << self.sig_bits() - 1 } \n }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ux>() as u32 * 8 - self.leading_zeros() }\n }\n\n impl CommonNumExt for $ix {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if self ^ b >= 0 && r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { \n let q = self / b; let r = self % b;\n if self ^ b < 0 && r != 0 { q - 1 } else { q }\n }\n fn gcd(self, b: Self) -> Self {\n fn w_abs(x: $ix) -> $ux { (if x.is_negative() { x.wrapping_neg() } else { x }) as _ }\n w_abs(self).gcd(w_abs(b)) as _\n }\n #[inline] fn highest_one(self) -> Self { (self as $ux).highest_one() as _ }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ix>() as u32 * 8 - self.leading_zeros() }\n }\n )*\n }\n}\nimpl_common_num_ext!(i8 = u8, i16 = u16, i32 = u32, i64 = u64, i128 = u128, isize = usize);\n\ntrait ChMaxMin {\n fn chmax(&mut self, v: T) -> bool;\n fn chmin(&mut self, v: T) -> bool;\n}\nimpl ChMaxMin for Option {\n fn chmax(&mut self, v: T) -> bool { if self.is_none() || v > *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if self.is_none() || v < *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n}\nimpl ChMaxMin for T {\n fn chmax(&mut self, v: T) -> bool { if v > *self { *self = v; true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if v < *self { *self = v; true } else { false } }\n}\n\n// * end commons * //\n \n#[allow(non_snake_case, non_upper_case_globals)]\nfn main() {\n let num_cases: usize = 1;//read();\n\n for _case_num in 1..=num_cases {\n let n = read!(i64);\n let m = read!(i64);\n \n let ans = if m == 1 {n-1} else {n * (m-1)};\n println!(ans);\n }\n \n out_flush();\n}", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "1bfa96042ea012dc60fe92eb9701e6b3", "src_uid": "a91aab4c0618d036c81022232814ef44", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut s = String::new();\n io::stdin().read_line(&mut s).unwrap();\n s = s.trim().to_string();\n let n = s.len();\n let mut flag = 1; // 0,\u4e00\u822c\uff0c1,\u5f00\u5934, 2,\u4e2d\u95f4\n let mut i = 0;\n while i < n {\n if i+2 < n && s[i..i+3] == String::from(\"WUB\") {\n i += 3;\n if flag == 1 {\n \n } else if flag == 2 {\n \n } else { // flag == 0\n flag = 2;\n print!(\" \");\n }\n }\n else {\n flag = 0;\n print!(\"{}\", s.as_bytes()[i] as char);\n i += 1;\n }\n }\n}", "lang_cluster": "Rust", "tags": ["strings"], "code_uid": "ba2841b824839ac3a0d22ffaa3b3c386", "src_uid": "edede580da1395fe459a480f6a0a548d", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::*;\n\nfn read(i: &mut StdinLock) -> T {\n let mut s = String::new();\n i.by_ref().read_line(&mut s).ok();\n s.trim().parse().ok().unwrap()\n}\n\nfn main() {\n // initialize stdin\n let sin = std::io::stdin();\n let mut sin = sin.lock();\n let sin = &mut sin;\n\n let x: String = read(sin);\n\n let ans: Vec<&str> = x.split(\"WUB\").filter(|x| *x != \"\").collect();\n\n println!(\"{}\", ans.join(\" \"));\n}\n", "lang_cluster": "Rust", "tags": ["strings"], "code_uid": "0e09b22e5320d778e1c9a6d748365ef4", "src_uid": "edede580da1395fe459a480f6a0a548d", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rusT\nuse std::io::*;\nuse std::str::{self,*};\nuse std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::{self,*};\n#[allow(unused_imports)] use std::ops::{self,*};\n#[allow(unused_imports)] use std::iter::{self,*};\n#[allow(unused_imports)] use std::collections::*;\n#[allow(unused_imports)] use std::cell::*;\n#[allow(unused_macros)]\nmacro_rules! m {\n ($c:tt, $x:expr, $y:expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\n#[allow(unused_macros)]\nmacro_rules! l {\n ($($v:ident),* = $i:ident.$f:ident $a:tt) => {\n $( let $v = $i.$f$a; )*\n };\n ($($v:ident),*:$t:ty = $i:ident.$f:ident $a:tt) => {\n $( let $v:$t = $i.$f$a; )*\n };\n}\nstruct WordReaderB {\n bin: Box<[u8]>,\n it: Cell>>\n}\n#[allow(dead_code)]\nimpl WordReaderB {\n fn from(mut r: T) -> Self {\n let mut bin = Vec::new();\n r.read_to_end(&mut bin).ok();\n let bin = bin.into_boxed_slice();\n let it = Cell::new(Self::split(&bin).into_iter());\n Self { bin, it }\n }\n fn from_stdin() -> Self {\n Self::from(stdin())\n }\n fn split(a: &[u8]) -> Vec> {\n let mut res = Vec::new();\n let mut last = None;\n let mut space = vec![false; 256];\n for &c in b\" \\t\\n\\r\" {\n space[c as usize] = true;\n }\n for (i,&c) in a.iter().enumerate() {\n if space[c as usize] {\n if let Some(j) = last.take() {\n res.push(j..i);\n }\n } else {\n last.get_or_insert(i);\n }\n }\n if let Some(j) = last {\n res.push(j..a.len());\n }\n res\n }\n fn no_it() -> std::vec::IntoIter { \n Vec::new().into_iter()\n }\n fn bs(&self) -> &[u8] {\n let mut it = self.it.replace(Self::no_it());\n let r = it.next().expect(\"EOF\");\n self.it.set(it);\n &self.bin[r]\n }\n fn sl(&self) -> std::borrow::Cow {\n String::from_utf8_lossy(self.bs())\n }\n fn s(&self) -> String { self.sl().into_owned() }\n fn sk(&self, n: usize) {\n let mut it = self.it.replace(Self::no_it());\n it.nth(n - 1);\n self.it.set(it);\n }\n fn i(&self) -> i32 { self.p() }\n fn u(&self) -> usize { self.p() }\n fn f(&self) -> f64 { self.p() }\n fn vi(&self, n: usize) -> Vec {\n self.vp::(n)\n }\n fn vu(&self, n: usize) -> Vec {\n self.vp::(n)\n }\n fn ii(&self, n: usize) -> impl Iterator {\n self.ip(n).into_iter()\n }\n fn iu(&self, n: usize) -> impl Iterator {\n self.ip(n).into_iter()\n }\n fn p(&self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn vp(&self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n fn ip(&self, n: usize) -> impl Iterator where T::Err: Debug {\n self.vp(n).into_iter()\n }\n}\n//------------------- End rusT\n\nfn main() {\n let rin = WordReaderB::from_stdin();\n l!(a,b = rin.i());\n println!(\"{}\", a + b);\n}\n\n", "lang_cluster": "Rust", "tags": ["dsu", "constructive algorithms", "implementation", "brute force"], "code_uid": "a0df0342688220c01e7c3748c6fe2a3f", "src_uid": "b6e3f9c9b124ec3ec20eb8fcea075add", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_macros)]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n let mut next = || { iter.next().unwrap() };\n input_inner!{next, $($r)*}\n };\n ($($r:tt)*) => {\n let stdin = std::io::stdin();\n let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));\n let mut next = move || -> String{\n bytes\n .by_ref()\n .map(|r|r.unwrap() as char)\n .skip_while(|c|c.is_whitespace())\n .take_while(|c|!c.is_whitespace())\n .collect()\n };\n input_inner!{next, $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! input_inner {\n ($next:expr) => {};\n ($next:expr, ) => {};\n\n ($next:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n\n ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! read_value {\n ($next:expr, ( $($t:tt),* )) => {\n ( $(read_value!($next, $t)),* )\n };\n\n ($next:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($next, $t)).collect::>()\n };\n\n ($next:expr, chars) => {\n read_value!($next, String).chars().collect::>()\n };\n\n ($next:expr, usize1) => {\n read_value!($next, usize) - 1\n };\n\n ($next:expr, $t:ty) => {\n $next().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($a:expr),*) => {\n #[cfg(debug_assertions)]\n writeln!(&mut std::io::stderr(), concat!(\"[DEBUG] \", $(stringify!($a), \"={:?} \"),*), $($a),*);\n }\n}\n\n#[allow(unused_imports)]\nuse std::cmp::{min, max};\n#[allow(unused_imports)]\nuse std::io::{stdout, stdin, BufWriter, Write};\n\nfn main() {\n let out = std::io::stdout();\n let mut out = BufWriter::new(out.lock());\n macro_rules! puts {\n ($($format:tt)*) => (writeln!(out,$($format)*).unwrap());\n }\n\n input!{\n n: usize,\n m: usize,\n a: usize,\n b: usize,\n g0: u64,\n x: u64,\n y: u64,\n z: u64,\n }\n\n let mut hs = vec![vec![0; m]; n];\n let mut g = g0;\n for i in 0..n*m {\n let a = i/m;\n let b = i%m;\n hs[a][b] = g;\n g = (g * x + y) % z;\n }\n\n // debug!(n, m, a, b, hs);\n\n let mut min_table = vec![];\n\n // \u30b9\u30e9\u30a4\u30c9\u6700\u5c0f\u5024\n use std::collections::VecDeque;\n for i in 0..n {\n let mut q: VecDeque<(usize,usize)> = VecDeque::new();\n let mut row_mins = vec![];\n for j in 0..m {\n let h = hs[i][j];\n\n while q.len() > 0 {\n let (x, y) = *q.back().unwrap();\n if h <= hs[x][y] {\n q.pop_back();\n } else {\n break;\n }\n }\n q.push_back((i, j));\n\n if j < b-1 {\n continue;\n }\n if j >= b {\n let (_,y) = *q.front().unwrap();\n if y == j-b {\n q.pop_front();\n }\n }\n\n // debug!(i, j, q);\n let (x,y) = *q.front().unwrap();\n row_mins.push(hs[x][y]);\n }\n min_table.push(row_mins);\n }\n\n let mut ans = 0;\n for j in 0..m-b+1 {\n let mut q: VecDeque<(usize,usize)> = VecDeque::new();\n for i in 0..n {\n let h = min_table[i][j];\n\n while q.len() > 0 {\n let (x, y) = *q.back().unwrap();\n if h <= min_table[x][y] {\n q.pop_back();\n } else {\n break;\n }\n }\n q.push_back((i, j));\n\n if i < a-1 {\n continue;\n }\n if i >= a {\n let (x,_) = *q.front().unwrap();\n if x == i-a {\n q.pop_front();\n }\n }\n\n let (x,y) = *q.front().unwrap();\n ans += min_table[x][y];\n\n }\n }\n puts!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["two pointers", "data structures"], "code_uid": "ffbebbed2954a71b1d9b844d907b8852", "src_uid": "4618fbffb2b9d321a6d22c11590a4773", "difficulty": 2100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::Read;\n\nfn sliding_minimum_elements(a: &[u64], l: usize) -> Vec {\n assert!(a.len() >= l && l > 0);\n let mut d = std::collections::VecDeque::<(u64, usize)>::new();\n for (i, &a) in a[..(l - 1)].iter().enumerate() {\n while let Some(p) = d.back() {\n if p.0 >= a {\n d.pop_back();\n } else {\n break;\n }\n }\n d.push_back((a, i));\n }\n let mut b = Vec::with_capacity(a.len() - l + 1);\n for (i, &a) in a[(l - 1)..].iter().enumerate() {\n while let Some(p) = d.back() {\n if p.0 >= a {\n d.pop_back();\n } else {\n break;\n }\n }\n d.push_back((a, i + l - 1));\n if d.front().unwrap().1 < i {\n d.pop_front();\n }\n b.push(d.front().unwrap().0);\n }\n b\n}\n\nfn run() {\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n let mut it = s.trim().split_whitespace();\n let n: usize = it.next().unwrap().parse().unwrap();\n let m: usize = it.next().unwrap().parse().unwrap();\n let a: usize = it.next().unwrap().parse().unwrap();\n let b: usize = it.next().unwrap().parse().unwrap();\n let mut g: u64 = it.next().unwrap().parse().unwrap();\n let x: u64 = it.next().unwrap().parse().unwrap();\n let y: u64 = it.next().unwrap().parse().unwrap();\n let z: u64 = it.next().unwrap().parse().unwrap();\n let mut h = vec![vec![0; m]; n];\n for i in 0..n {\n for j in 0..m {\n h[i][j] = g;\n g = (g * x + y) % z;\n }\n }\n for h in &mut h {\n *h = sliding_minimum_elements(h, b);\n }\n let mut ans = 0u64;\n for j in 0..(m + 1 - b) {\n let mut c = vec![0; n];\n for i in 0..n {\n c[i] = h[i][j];\n }\n ans += sliding_minimum_elements(&c, a).into_iter().fold(0, |s, a| s + a);\n }\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["two pointers", "data structures"], "code_uid": "a3fa6c6f348e02ddced1ecb68125779f", "src_uid": "4618fbffb2b9d321a6d22c11590a4773", "difficulty": 2100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin Matrix ----------\n\n#[allow(dead_code)]\nmod matrix {\n use std::ops::Add;\n use std::ops::Mul;\n pub trait SemiRing: Add + Mul + Copy {\n fn zero() -> Self;\n fn one() -> Self;\n }\n #[derive(Clone)]\n pub struct SquareMatrix {\n n: usize,\n a: Vec,\n }\n impl SquareMatrix {\n pub fn zero(n: usize) -> Self {\n let z = T::zero();\n SquareMatrix {\n n: n,\n a: vec![z; n * n],\n }\n }\n pub fn identity(n: usize) -> Self {\n let mut m = Self::zero(n);\n for i in 0..n {\n m.a[i * n + i] = T::one();\n }\n m\n }\n pub fn set_at(&mut self, i: usize, j: usize, v: T) {\n debug_assert!(i < self.n && j < self.n);\n self.a[i * self.n + j] = v;\n }\n pub fn get_at(&self, i: usize, j: usize) -> T {\n debug_assert!(i < self.n && j < self.n);\n self.a[i * self.n + j]\n }\n pub fn matmul(l: Self, r: Self) -> Self {\n l * r\n }\n }\n impl Add for SquareMatrix {\n type Output = Self;\n fn add(self, rhs: Self) -> Self {\n debug_assert!(self.n == rhs.n);\n let n = self.n;\n let mut c = Self::zero(n);\n for i in 0..(n * n) {\n c.a[i] = self.a[i] + rhs.a[i];\n }\n c\n }\n }\n impl Mul for SquareMatrix {\n type Output = Self;\n fn mul(self, rhs: Self) -> Self {\n debug_assert!(self.n == rhs.n);\n let n = self.n;\n let mut c = Self::zero(n);\n for i in 0..n {\n for k in 0..n {\n let a = self.a[i * n + k];\n for (x, y) in c.a[(i * n)..((i + 1) * n)].iter_mut().zip(rhs.a[(k * n)..((k + 1) * n)].iter()) {\n *x = *x + a * *y;\n }\n }\n }\n c\n }\n }\n}\n\n// ---------- end Matrix ----------\n// ---------- begin ModInt ----------\n\n//https://github.com/kenkoooo/competitive-programming-rs/blob/master/src/math/mod_int.rs\n//\u3092\u53c2\u8003\u306b\u3057\u3066\u3044\u307e\u3059\n#[allow(dead_code)]\nmod modint {\n pub const MOD: u32 = 1000000000 + 7;\n use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};\n #[derive(Clone, Copy)]\n pub struct ModInt(pub T);\n pub type Num = u32;\n impl Add> for ModInt {\n type Output = ModInt;\n fn add(self, other: ModInt) -> ModInt {\n let mut d = self.0 + other.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n }\n impl AddAssign> for ModInt {\n fn add_assign(&mut self, other: ModInt) {\n *self = *self + other;\n }\n }\n impl Sub> for ModInt {\n type Output = ModInt;\n fn sub(self, other: ModInt) -> ModInt {\n let mut d = self.0 + MOD - other.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n }\n impl SubAssign> for ModInt {\n fn sub_assign(&mut self, other: ModInt) {\n *self = *self - other;\n }\n }\n impl Mul> for ModInt {\n type Output = ModInt;\n fn mul(self, other: ModInt) -> ModInt {\n ModInt(((self.0 as u64) * (other.0 as u64) % (MOD as u64)) as u32)\n }\n }\n impl MulAssign> for ModInt {\n fn mul_assign(&mut self, other: ModInt) {\n *self = *self * other;\n }\n }\n impl Div for ModInt {\n type Output = ModInt;\n fn div(self, other: Num) -> ModInt {\n self * ModInt(other).pow(MOD - 2)\n }\n }\n impl Div> for ModInt {\n type Output = ModInt;\n fn div(self, other: ModInt) -> ModInt {\n self * other.pow(MOD - 2)\n }\n }\n impl DivAssign> for ModInt {\n fn div_assign(&mut self, other: ModInt) {\n *self = *self / other;\n }\n }\n impl Neg for ModInt {\n type Output = ModInt;\n fn neg(self) -> ModInt {\n ModInt(if self.0 == 0 { 0 } else { MOD - self.0 })\n }\n }\n impl ModInt {\n pub fn new(v: u32) -> ModInt {\n ModInt(v % MOD)\n }\n pub fn pow(self, mut n: u32) -> ModInt {\n let mut t = ModInt::new(1);\n let mut s = self;\n while n > 0 {\n if (n & 1) == 1 {\n t *= s;\n }\n s *= s;\n n >>= 1;\n }\n t\n }\n }\n pub struct Precalc {\n n: usize,\n inv: Vec>,\n fact: Vec>,\n ifact: Vec>,\n }\n impl Precalc {\n pub fn new(n: usize) -> Precalc {\n let mut inv = vec![ModInt(1); n + 1];\n let mut fact = vec![ModInt(1); n + 1];\n let mut ifact = vec![ModInt(1); n + 1];\n for i in 1..(n + 1) {\n if i > 2 {\n inv[i] = -inv[(MOD as usize) % i] * ModInt(MOD / (i as u32));\n }\n fact[i] = ModInt(i as u32) * fact[i - 1];\n ifact[i] = inv[i] * ifact[i - 1];\n }\n Precalc {\n n: n,\n inv: inv,\n fact: fact,\n ifact: ifact,\n }\n }\n pub fn fact(self, n: usize) -> ModInt {\n self.fact[n]\n }\n pub fn inv(self, x: usize) -> ModInt {\n self.inv[x]\n }\n pub fn ifact(self, x: usize) -> ModInt {\n self.ifact[x]\n }\n pub fn comb(self, n: usize, k: usize) -> ModInt {\n if !(k <= n) {\n return ModInt(0);\n }\n self.fact[n] * self.ifact[k] * self.ifact[n - k]\n }\n }\n use std;\n impl std::fmt::Display for ModInt {\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n }\n}\n\n// ---------- end ModInt ----------\n\n//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n// \u3053\u3053\u307e\u3067\n\nuse matrix::SquareMatrix;\nuse modint::ModInt;\n\nimpl matrix::SemiRing for ModInt {\n fn one() -> Self {ModInt(1)}\n fn zero() -> Self {ModInt(0)}\n}\n\nfn run() {\n input! {\n n: u64,\n m: usize,\n }\n type M = SquareMatrix>;\n let mut t = M::identity(m);\n let mut s = M::zero(m);\n for i in 1..m {\n s.set_at(i - 1, i , ModInt(1));\n }\n s.set_at(m - 1, 0, ModInt(1));\n s.set_at(m - 1, m - 1, ModInt(1));\n let mut n = n;\n while n > 0 {\n if (n & 1) == 1 {\n t = t * s.clone();\n }\n s = s.clone() * s;\n n >>= 1;\n }\n let ans = t.get_at(m - 1, m - 1);\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["math", "matrices", "dp"], "code_uid": "271738982d53e269a1ffd762e27227bf", "src_uid": "e7b9eec21d950f5d963ff50619c6f119", "difficulty": 2100.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "use std::str::FromStr;\nfn read_int() -> usize {\n let stdin = std::io::stdin();\n let mut line = String::new();\n stdin.read_line(&mut line).unwrap();\n usize::from_str(&line.trim_end()).unwrap()\n}\n\nfn good_numbers(n: usize) -> usize {\n let mut set = std::collections::HashSet::new();\n for i in 1..=n {\n if i * i > n {\n break;\n }\n set.insert(i * i);\n if i * i * i > n {\n continue;\n }\n set.insert(i * i * i);\n }\n return set.len()\n}\nfn main() {\n let test_cases = read_int();\n\n for _ in 0..test_cases {\n let n = read_int();\n println!(\"{}\", good_numbers(n));\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "9e17f20414a431300c2307cd65a086a4", "src_uid": "015afbefe1514a0e18fcb9286c7b6624", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#[rustfmt::skip]\n#[allow(unused_imports)]\nuse std::{cmp::*, collections::*, fmt::Debug, io::*, iter::{self, *}, ops::{self, *}, str::{self, *}};\nmacro_rules!v{($(:$t:ty)?=$e:expr)=>{$e$(as$t)?};([$d:expr]$(:$t:ty)?)=>{Vec::$(<$t>::)?with_capacity($d)};([]$(:$t:ty)?)=>{Vec::$(<$t>::)?new()};([$d:expr]$($s:tt)+)=>{vec![v!($($s)+);$d]};}\n#[rustfmt::skip]\nstruct StdinReader { buf: Vec, pos: usize, x: *mut Stdin, q: StdinLock<'static>, }\n#[rustfmt::skip]\n#[allow(dead_code)]\nimpl StdinReader {\n fn new() -> Self { let x = Box::into_raw(Box::new(stdin()));let q = unsafe { &*x }.lock();Self { x, q, buf: v!([]), pos: 0, } }\n fn cache_line(&mut self) -> bool { self.buf.clear();self.pos = 0;self.q.read_until(b'\\n', &mut self.buf).unwrap_or(0) > 0 }\n fn b(&mut self) -> Option { if self.pos == self.buf.len() && !self.cache_line() { return None; }self.pos += 1;Some(self.buf[self.pos - 1]) }\n fn bs(&mut self) -> Vec { let mut s = v!([10]);let mut f = false;while let Some(c) = self.b() { if !c.is_ascii_whitespace() { s.push(c);f = true; } else if f { break; } }s }\n fn p(&mut self) -> T where T::Err: Debug, { let w = self.bs();str::from_utf8(w.as_ref()).unwrap().parse::().unwrap() }\n fn u(&mut self) -> usize { self.p() }\n fn i(&mut self) -> i32 { self.p() }\n}\n#[rustfmt::skip]\nimpl Drop for StdinReader { fn drop(&mut self) { unsafe { Box::from_raw(self.x) }; } }\n#[rustfmt::skip]\nfn stdio() -> (StdinReader, BufWriter) { (StdinReader::new(), BufWriter::new(stdout())) }\n\nfn main() {\n let (mut rin, mut rout) = stdio();\n let n = rin.u();\n let mut t = Vec::with_capacity(n);\n let mut z = vec![0; n];\n (0..n).for_each(|_| t.push(rin.u()));\n let m = *t.iter().max().unwrap();\n let mut h = HashSet::with_capacity(n);\n let (mut f2, mut f3) = (true, true);\n for i in 1..=31622usize {\n let e2 = i.pow(2);\n if e2 > m {\n f2 = false;\n }\n if f2 {\n h.insert(e2);\n }\n\n let e3 = i.pow(3);\n if e3 > m {\n f3 = false;\n }\n if f3 {\n h.insert(i.pow(3));\n }\n\n if !f2 && !f3 {\n break;\n };\n }\n\n for &v in h.iter() {\n for (i, &tt) in t.iter().enumerate() {\n if v <= tt {\n z[i] += 1;\n }\n }\n }\n (0..n).for_each(|i| writeln!(rout, \"{}\", z[i]).unwrap());\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "a2ce614917f6272d30c030d7f072e3ba", "src_uid": "015afbefe1514a0e18fcb9286c7b6624", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() -> io::Result<()> {\n \n let mut input = String::new();\n\n io::stdin().read_line(&mut input)?;\n let k: usize = input.trim().split(\" \").last().unwrap().parse().unwrap();\n\n input.clear();\n io::stdin().read_line(&mut input)?;\n let scores: Vec = input.trim().split(\" \").map(|s| s.parse().unwrap()).collect();\n let threshold = scores[k - 1];\n\n let mut count = 0;\n for score in scores {\n if (score == 0) || (score < threshold) {\n break;\n }\n count += 1;\n }\n\n println!(\"{}\", count);\n \n return Ok(());\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "82a071f66567385533b16b72391b53fd", "src_uid": "193ec1226ffe07522caf63e84a7d007f", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line);\n let line = line.trim();\n let v: Vec = line.trim().split(\" \").map(|s| s.parse::().unwrap()).collect();\n let n = v[1] as usize;\n\n let mut line = String::new();\n std::io::stdin().read_line(&mut line);\n let line = line.trim();\n let v: Vec = line.trim().split(\" \").map(|s| s.parse::().unwrap()).collect();\n\n let mut ret = 0;\n for i in 0..v.len() {\n if v[i] == 0 {\n break;\n }\n if i >= n && v[i] != v[n - 1] {\n break;\n }\n ret += 1;\n }\n println!(\"{}\", ret);\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "12893c9b9df77e4fe8fd2c6824106146", "src_uid": "193ec1226ffe07522caf63e84a7d007f", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rusT {{{\nuse std::io::*; use std::str::{self,*}; use std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::{self,*};\n#[allow(unused_imports)] use std::ops::{self,*};\n#[allow(unused_imports)] use std::iter::{self,*};\n#[allow(unused_imports)] use std::collections::*;\n#[allow(unused_imports)] use std::cell::*;\n#[allow(unused_macros)] macro_rules! min {\n\t($x:expr,$y:expr) => {{ let b=$y; let a=&mut$x; if b < *a {*a=b; true} else {false} }};\n}\n#[allow(unused_macros)] macro_rules! max {\n\t($x:expr,$y:expr) => {{ let b=$y; let a=&mut$x; if b > *a {*a=b; true} else {false} }};\n}\n#[allow(unused_macros)] macro_rules! l {\n\t($($v:ident),+ =$e:expr) => {$(let$v=$e;)+};\n\t($($v:ident),+:$t:ty=$e:expr) => {$(let$v:$t=$e;)+};\n\t(mut $($v:ident),+ =$e:expr) => {$(let mut$v=$e;)+};\n\t(mut $($v:ident),+:$t:ty=$e:expr) => {$(let mut$v:$t=$e;)+};\n}\n#[allow(unused_macros)] macro_rules! v {\n\t([$d:expr]$($s:tt)+) => {vec![v!($($s)+);$d]};\n\t([]) => {Vec::new()}; ([$e:expr]) => {Vec::with_capacity($e)}; (=$e:expr) => {$e};\n}\n#[allow(unused_macros)] macro_rules! rep { {[$c:expr]$($s:tt)+} => {for _ in 0..$c {$($s)+}} }\n#[allow(dead_code)] fn reader() -> WordReaderC { WordReaderC::new() }\n#[allow(dead_code)] fn writer() -> BufWriter { BufWriter::new(stdout()) }\nstruct WordReaderC {buf: Vec, pos: usize, q: std::io::StdinLock<'static>}//'\n#[allow(dead_code)] impl WordReaderC {\n\tfn new() -> Self {\n\t\tlet r = unsafe {&*Box::into_raw(Box::new(stdin()))};\n\t\tSelf { q: r.lock(), buf: v!([]), pos: 0 }\n\t}\n\tfn next_line(&mut self) -> bool {\n\t\tself.buf.clear(); self.pos = 0;\n\t\tself.q.read_until(b'\\n', &mut self.buf).unwrap_or(0) > 0\n\t}\n\tfn is_ws(c: u8) -> bool {\n\t\tc == b' ' || c == b'\\r' || c == b'\\n' || c == b'\\t'\n\t}\n\tfn byte(&mut self) -> Option {\n\t\tif self.pos == self.buf.len() { if !self.next_line() { return None; } }\n\t\tself.pos += 1; Some(self.buf[self.pos - 1])\n\t}\n\tfn vb(&mut self) -> Vec {\n\t\tlet mut s = v!([8]);\n\t\tlet mut f = false;\n\t\tloop {\n\t\t\tif let Some(c) = self.byte() {\n\t\t\t\tif !Self::is_ws(c) {\n\t\t\t\t\ts.push(c);\n\t\t\t\t\tf = true;\n\t\t\t\t} else if f { break; }\n\t\t\t} else { break; }\n\t\t}\n\t\ts\n\t}\n\tfn vvb(&mut self, r: usize, c: Option) -> Vec> {\n\t\tlet mut res = v!([r]);\n\t\tlet c = c.unwrap_or(0);\n\t\trep!{[r]\n\t\t\tlet t = self.vb();\n\t\t\tassert!(c == 0 || t.len() == c);\n\t\t\tres.push(t);\n\t\t}\n\t\tres\n\t}\n\tfn s(&mut self) -> String { String::from_utf8(self.vb()).expect(\"invalid utf8\") }\n\tfn i(&mut self) -> i32 { self.p() }\n\tfn l(&mut self) -> i64 { self.p() }\n\tfn u(&mut self) -> usize { self.p() }\n\tfn f(&mut self) -> f64 { self.p() }\n\tfn vi(&mut self, n: usize) -> Vec { self.vp(n) }\n\tfn vl(&mut self, n: usize) -> Vec { self.vp(n) }\n\tfn vu(&mut self, n: usize) -> Vec { self.vp(n) }\n\tfn ii(&mut self, n: usize) -> impl Iterator { self.ip(n).into_iter() }\n\tfn iu(&mut self, n: usize) -> impl Iterator { self.ip(n).into_iter() }\n\tfn p(&mut self) -> T where T::Err: Debug {\n\t\tlet w = self.vb(); str::from_utf8(w.as_ref()).unwrap().parse::().unwrap()\n\t}\n\tfn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n\t\t(0..n).map(|_|self.p()).collect()\n\t}\n\tfn ip(&mut self, n: usize) -> impl Iterator where T::Err: Debug {\n\t\tself.vp(n).into_iter()\n\t}\n}\n//------------------- End rusT }}}\n\nfn main() {\n\tlet mut rin = reader();\n\tlet mut rout = writer();\n\n\tlet n = rin.u();\n\tlet k = rin.l();\n\tlet s = rin.vb();\n\tlet add = |a: i64, b: i64| k.min(a+b);\n\tlet mut dp = v!([n+1][n+1] = 0);\n\tdp[0][0] = 1;\n\tfor i in 1..=n {\n\t\tfor l in 1..=i {\n\t\t\tfor j in 1..=i {\n\t\t\t\tdp[i][j] = add(dp[i][j], dp[i-l][j-1]);\n\t\t\t}\n\t\t\tif l < i && s[i-1] == s[i-1-l] {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\tlet mut sum = v!([n+1] = 0);\n\tlet mut sum0 = 0;\n\tfor i in 0..=n {\n\t\tfor j in 0..=n {\n\t\t\tlet x = dp[i][j];\n\t\t\tsum[j] = add(sum[j], x);\n\t\t\tsum0 = add(sum0, x);\n\t\t}\n\t}\n\tif sum0 < k {\n\t\twriteln!(rout, \"-1\").ok();\n\t\treturn;\n\t}\n\tlet mut sol = 0;\n\tlet mut rem = k;\n\tfor i in (0..=n).rev() {\n\t\tlet m = sum[i].min(rem);\n\t\tsol += (n-i) as i64 * m;\n\t\trem -= m;\n\t}\n\twriteln!(rout, \"{}\", sol).ok();\n}\n", "lang_cluster": "Rust", "tags": ["strings", "dp"], "code_uid": "faa077e2e1827c60ee6f79475debe4f4", "src_uid": "ae5d21919ecac431ea7507cb1b6dc72b", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n let a1: i128 = input.trim().parse().unwrap();\n\n input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n let a2: i128 = input.trim().parse().unwrap();\n\n input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n let k1: i128 = input.trim().parse().unwrap();\n\n input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n let k2: i128 = input.trim().parse().unwrap();\n\n input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n let n: i128 = input.trim().parse().unwrap();\n\n if n >= ((a1 * k1) + (a2 * k2)) {\n println!(\"{} {}\", a1 + a2, a1 + a2);\n return;\n }\n\n // Find minimum\n let minimum = if n - (a1 * (k1 - 1)) - (a2 * (k2 - 1)) > 0 {\n n - (a1 * (k1 - 1)) - (a2 * (k2 - 1))\n } else {\n 0\n };\n\n // Find maximum\n let mut maximum: i128 = 0;\n let mut cards_left = n;\n if k1 < k2 {\n cards_left -= a1 * k1;\n maximum += if cards_left >= 0 { a1 + (cards_left / k2) } else { n / k1 };\n } else {\n cards_left -= a2 * k2;\n maximum += if cards_left >= 0 { a2 + (cards_left / k1) } else { n / k2 };\n }\n\n println!(\"{} {}\", minimum, maximum);\n}\n", "lang_cluster": "Rust", "tags": ["math", "greedy", "implementation"], "code_uid": "1c412aa5a768f665f5d9ab8310e9c202", "src_uid": "2be8e0b8ad4d3de2930576c0209e8b91", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n// \u3053\u3053\u307e\u3067\n\nuse std::cmp::{max, min};\n\nfn run() {\n input! {\n a: i32,\n b: i32,\n x: i32,\n y: i32,\n n: i32,\n }\n let mut f = n;\n let mut g = 0;\n for i in 0..=n {\n if x * a < i || y * b < n - i{\n continue;\n }\n let mut p = 0;\n let mut q = 0;\n if (x - 1) * a < i {\n p += i - (x - 1) * a;\n }\n q += i / x;\n if (y - 1) * b < n - i {\n p += n - i - (y - 1) * b;\n }\n q += (n - i) / y;\n f = min(f, p);\n g = max(g, q);\n }\n println!(\"{} {}\", f, g);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["math", "greedy", "implementation"], "code_uid": "628632355947997b935e2f0b5febbcff", "src_uid": "2be8e0b8ad4d3de2930576c0209e8b91", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::error::Error;\nuse std::io::{self, Read};\n\nfn main() -> Result<(), Box> {\n let mut stdin = io::stdin();\n let mut line = String::new();\n stdin.read_line(&mut line)?;\n let num_str = line.trim();\n let num: u64 = num_str.parse()?;\n let num_nines = num_str.len() - 1;\n let remaining_num = num - (10_u64.pow(num_nines as u32) - 1);\n let rem_digit_sum: u32 = remaining_num.to_string().into_bytes().into_iter().map(|c| (c - b'0') as u32).sum();\n println!(\"{}\", num_nines as u32 * 9 + rem_digit_sum);\n\n Ok(())\n}\n", "lang_cluster": "Rust", "tags": ["greedy"], "code_uid": "9a636fdc66acfd25d2a26f572ad1a10a", "src_uid": "5c61b4a4728070b9de49d72831cd2329", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, Read};\nuse std::cmp;\n \nfn main() {\n let mut buffer = String::new();\n let stdin = io::stdin();\n let mut handle = stdin.lock();\n handle.read_to_string(&mut buffer).unwrap();\n\n let arr : Vec<_> = buffer.split_whitespace().map(|x| x.parse::().unwrap() ).collect();\n let n = arr[0];\n let mut d = 0;\n let mut h = n;\n while h > 0 {\n d += 1;\n h = h / 10;\n }\n use std::cmp;\n let mut a = 0;\n 'outer: for i in 0..d {\n // println!(\"{}\",a);\n let mut r = 0;\n for j in 0..10 {\n let y = j * 10u64.pow(i);\n if a + y <= n {\n r = cmp::max(a + y, r);\n // println!(\"{}\",r);\n }\n }\n a = r;\n }\n let mut b = n - a;\n // println!(\"{} {}\", a, b);\n let mut ans = 0;\n while a > 0 {\n ans += a % 10;\n a = a / 10;\n }\n while b > 0 {\n ans += b % 10;\n b = b / 10;\n }\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["greedy"], "code_uid": "2c5069741b0ce3f690abe026d562e150", "src_uid": "5c61b4a4728070b9de49d72831cd2329", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nstruct Reader(Vec, usize);\n\nimpl Reader {\n fn new(r: &mut io::Read) -> Reader {\n let mut b = Vec::new();\n r.read_to_end(&mut b);\n \n Reader(b, 0)\n }\n\n fn read_byte(&mut self) -> u8 {\n self.1 += 1;\n self.0[self.1 - 1]\n }\n\n fn read_string(&mut self) -> String {\n for i in self.1..self.0.len() {\n match self.0[i] {\n b' ' | b'\\t' | b'\\n' | b'\\r' => {}\n _ => { \n self.1 = i;\n break; \n }\n }\n }\n \n let old_pos = self.1;\n for i in self.1..self.0.len() {\n match self.0[i] {\n b' ' | b'\\t' | b'\\n' | b'\\r' => {\n self.1 = i;\n break;\n }\n _ => {}\n } \n }\n String::from_utf8(self.0[old_pos..self.1].to_vec()).unwrap()\n }\n \n fn read_int(&mut self) -> i32 {\n self.read_string().parse().unwrap()\n }\n}\n\npub fn main() {\n let mut r = Reader::new(&mut io::stdin());\n let n = r.read_int();\n let k = r.read_int();\n println!(\"{}\", (2 * n + k - 1) / k + (5 * n + k - 1) / k + (8 * n + k - 1) / k);\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "07518716e6a4e85588b2376375586e58", "src_uid": "d259a3a5c38af34b2a15d61157cc0a39", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "macro_rules! parse_line {\n ($t: ty) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let a_str = a_str.trim();\n a_str.parse::<$t>().expect(\"parse error\")\n });\n ($($t: ty),+) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let mut a_iter = a_str.split_whitespace();\n (\n $(\n a_iter.next().unwrap().parse::<$t>().expect(\"parse error\"),\n )+\n )\n })\n}\n\nmacro_rules! parse_line_to_vec {\n ($t: ty) => {{\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n (a_str\n .split_whitespace()\n .map(|x| x.parse::<$t>().unwrap())\n .collect::>())\n }};\n}\n\nfn solve() {\n let (n, m, min, max) = parse_line!(usize, usize, i64, i64);\n let t = parse_line_to_vec!(i64);\n let low = t.iter().fold(std::i64::MAX, |x, &y| std::cmp::min(x, y));\n let high = t.iter().fold(std::i64::MIN, |x, &y| std::cmp::max(x, y));\n let mut fail = low < min || high > max;\n fail |= (low != min && high != max && n - m < 2) ||\n ((low != min || high != max) && n - m < 1);\n if fail {\n println!(\"Incorrect\")\n }else{\n println!(\"Correct\")\n }\n}\n\nfn main() {\n let tests = 1; // parse_line!(usize);\n for _ in 0..tests {\n solve();\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "caa8f1d3d1217e995f402fef699fb338", "src_uid": "99f9cdc85010bd89434f39b78f15b65e", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max, min};\nuse std::{io, io::prelude::*, str};\n\nstruct Scanner {\n reader: R,\n buffer: Vec,\n}\nimpl Scanner {\n fn new(reader: R) -> Self {\n Self {\n reader,\n buffer: vec![],\n }\n }\n\n fn t(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n\n #[allow(dead_code)]\n fn read_vec(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.t()).collect()\n }\n\n #[allow(dead_code)]\n fn read_str(&mut self) -> Vec {\n self.t::().into_bytes()\n }\n}\n\nuse std::ops;\n\n#[derive(Copy, Clone)]\nstruct ModGroup {\n val: usize,\n}\nimpl ModGroup {\n const MOD: usize = 1000000007;\n const MOD64: i64 = Self::MOD as i64;\n\n fn new(v: usize) -> Self {\n Self { val: v }\n }\n\n fn from_usize(v: usize) -> Self {\n Self { val: v % Self::MOD }\n }\n\n fn from_i64(v: i64) -> Self {\n Self {\n val: (v % Self::MOD64) as usize,\n }\n }\n\n fn pow(self, mut p: usize) -> Self {\n let mut base = self;\n let mut res = Self::new(1);\n while p > 0 {\n if p % 2 > 0 {\n res = res * base;\n }\n base = base * base;\n p /= 2;\n }\n\n res\n }\n\n fn inv(self) -> Self {\n self.pow(Self::MOD - 2)\n }\n}\n\nimpl ops::Add for ModGroup {\n type Output = Self;\n\n fn add(self, other: usize) -> Self {\n Self::from_usize(self.val + other)\n }\n}\nimpl ops::Add for ModGroup {\n type Output = Self;\n\n fn add(self, other: Self) -> Self {\n self + other.val\n }\n}\nimpl ops::Sub for ModGroup {\n type Output = Self;\n\n fn sub(self, other: usize) -> Self {\n Self::new(if self.val > other {\n self.val - other\n } else {\n self.val + Self::MOD - other\n })\n }\n}\nimpl ops::Sub for ModGroup {\n type Output = Self;\n\n fn sub(self, other: Self) -> Self {\n self - other.val\n }\n}\nimpl ops::Mul for ModGroup {\n type Output = Self;\n\n fn mul(self, other: usize) -> Self {\n Self::from_i64(self.val as i64 * other as i64)\n }\n}\nimpl ops::Mul for ModGroup {\n type Output = Self;\n\n fn mul(self, other: Self) -> Self {\n self * other.val\n }\n}\nimpl ops::Div for ModGroup {\n type Output = Self;\n\n fn div(self, other: usize) -> Self {\n self * Self::new(other).inv()\n }\n}\nimpl ops::Div for ModGroup {\n type Output = Self;\n\n fn div(self, other: Self) -> Self {\n self * other.inv()\n }\n}\n\nfn main() -> io::Result<()> {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout);\n\n let n: usize = scan.t();\n\n let mut res = ModGroup::from_usize(1);\n for _ in 1..n {\n res = res * res * 16;\n }\n res = res * 6;\n\n writeln!(out, \"{}\", res.val)?;\n\n io::Result::Ok(())\n}\n", "lang_cluster": "Rust", "tags": ["math", "combinatorics"], "code_uid": "868018fee53a5b7206c22c59520c9844", "src_uid": "5144b9b281ea4087d8334d91c3c8bda4", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports, dead_code)]\n\nuse std::io;\nuse std::{io::*, io::prelude::*, str};\n \n#[derive(Default)]\nstruct Scanner {\n buffer: Vec\n}\nimpl Scanner {\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n stdin().read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nconst MOD: u64 = 1000_000_007;\n\nfn solve(scan: &mut Scanner, out: &mut BufWriter) -> io::Result<()> {\n let n = scan.next::();\n let mut p = 1;\n for _ in 0..n-1 {\n p = (p * p * 4) % MOD\n }\n p = (p * p * 6) % MOD;\n writeln!(out, \"{}\", p)\n}\n \nfn main() -> io::Result<()> {\n let mut scan = Scanner::default();\n let mut out = &mut BufWriter::new(stdout());\n\n solve(&mut scan, &mut out)?;\n Ok(())\n}\n", "lang_cluster": "Rust", "tags": ["math", "combinatorics"], "code_uid": "ed3b7ef4abd1860a0b7203980b164787", "src_uid": "5144b9b281ea4087d8334d91c3c8bda4", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::io::Stdin;\nuse std::str::FromStr;\n\nfn read_line(stdin : &Stdin, line : &mut String) {\n match stdin.read_line(line) {\n Ok(_) => return,\n Err(msg) => panic!(\"Could not read line! Message: {}.\", msg),\n }\n}\n\nfn parse_t(s : &str) -> T {\n match s.trim().parse() {\n Ok(y) => y,\n Err(_) => panic!(\"Could not read from string!\"),\n }\n}\n\nfn read_ts(stdin : &Stdin, ts : &mut Vec) {\n let mut line = String::new();\n read_line(stdin, &mut line);\n let word_iter = line.split_whitespace();\n for word in word_iter {\n let x = parse_t(word);\n ts.push(x);\n }\n}\n\nfn sum_1_through_n(n : u64) -> u64 {\n // Do the division before the multiplication\n // so that the result does not overflow sooner.\n if (n % 2) == 0 {\n (n / 2) * (n + 1)\n } else {\n n * ((n + 1) / 2)\n }\n}\n\nfn main() {\n let stdin = io::stdin();\n let mut knw = vec![];\n read_ts(&stdin, &mut knw);\n let k = knw[0];\n let n = knw[1];\n let w = knw[2];\n let needed_amount = k * sum_1_through_n(w);\n if needed_amount > n {\n let x = needed_amount - n;\n println!(\"{}\", x);\n } else {\n println!(\"{}\", 0);\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "implementation"], "code_uid": "667fab44e08c438cc5b590a68602b466", "src_uid": "e87d9798107734a885fd8263e1431347", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let v: Vec = {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line);\n line.trim().split(\" \").map(|s| s.parse::().unwrap()).collect()\n };\n\n let (first, total, n) = (v[0], v[1], v[2]);\n println!(\"{:?}\",\n std::cmp::max((0..n).fold(0, |total, i| total + first * (i + 1)) - total,\n 0));\n\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "implementation"], "code_uid": "a180b17e774b133fbbab78696d610c25", "src_uid": "e87d9798107734a885fd8263e1431347", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, BufRead};\n\nconst M: u64 = 998244353;\n\nfn pow(n: u64, p: u64) -> u64 {\n let mut q = p;\n let mut r = n;\n let mut result = 1;\n while q > 0 { \n if q % 2 == 1 { \n result = result * r % M;\n } \n r = r * r % M;\n q >>= 1;\n }\n result\n}\n\nfn main() {\n let stdin = io::stdin();\n let mut lines = stdin.lock().lines();\n let xs: Vec = lines.next().unwrap().unwrap().split(' ').map(|x| x.parse().unwrap()).collect();\n let (n, m) = (xs[0], xs[1]);\n if n == 2 || m == 2 {\n println!(\"0\");\n return;\n }\n let mut prods: Vec = vec![0; (m + 1) as usize];\n prods[0] = 1;\n for i in 1..=m {\n prods[i as usize] = i * prods[(i-1) as usize] % M;\n }\n let mut ans: u64 = 0;\n for pivot in (n-1)..=m {\n let n_pairs = pivot - 1;\n let n_cands = (pivot - 2) as usize;\n let choose = (n - 3) as usize;\n let comb = (prods[n_cands] * pow(prods[n_cands - choose], M - 2) % M) * pow(prods[choose], M - 2) % M;\n ans = (ans + (n_pairs * comb % M) * pow(2, choose as u64) % M) % M;\n }\n println!(\"{}\", ans);\n}", "lang_cluster": "Rust", "tags": ["math", "combinatorics"], "code_uid": "5a26fc53e1e8f531391583047b8ed0e2", "src_uid": "28d6fc8973a3e0076a21c2ea490dfdba", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max,min};\n\ntype GenError = Box;\ntype GenResult = Result;\n\nstruct Reader {\n\n}\n\nimpl Reader{\n #[allow(unused)]\n fn read_string() -> GenResult {\n let mut string: String = String::new();\n std::io::stdin().read_line(&mut string)?;\n Ok(string.trim().to_string())\n }\n\n #[allow(unused)]\n fn read_tokens() -> GenResult> {\n let mut string: String = String::new();\n std::io::stdin().read_line(&mut string)?;\n let mut v = Vec::new();\n for value in string.split_whitespace() {\n v.push(value.to_string());\n }\n Ok(v)\n }\n}\n\nfn main() {\n\n let tokens = Reader::read_tokens().unwrap();\n let n: i32 = tokens[0].parse().unwrap();\n let k: i32 = tokens[1].parse().unwrap();\n\n let mut v = Vec::new();\n for value in Reader::read_tokens().unwrap(){\n v.push(value.parse::().unwrap());\n }\n let mut ans = 0;\n let mut l = 0;\n let mut r = v.len() - 1;\n while l <= r {\n let mut L = l;\n let mut R = r;\n if v[L] <= k {\n L += 1;\n ans += 1;\n }\n if v[R] <= k && R > L {\n R -= 1;\n ans += 1;\n }\n if L == l && R == r{\n break;\n }\n l = L;\n r = R;\n }\n println!(\"{}\", ans);\n}", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "008cbb893913250be3b9fd9789d151e1", "src_uid": "ecf0ead308d8a581dd233160a7e38173", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, BufRead};\n// use std::collections::*; // HashSet, HashMap, BTreeSet, BTreeMap, ...\n\nfn main() {\n let stdin: io::Stdin = io::stdin();\n let mut lines: io::Lines = stdin.lock().lines();\n\n let next_line = lines.next()\n .unwrap() // Option { Some(Result), None }\n .unwrap(); // Result { Ok(String), Err(io::Error) }\n\n let flv: Vec<_> = next_line\n .trim()\n .split(' ')\n .map(|n| {\n n.parse::().unwrap()\n })\n .collect();\n \n let n = flv[0];\n let k = flv[1];\n\n let next_line = lines.next()\n .unwrap() // Option { Some(Result), None }\n .unwrap(); // Result { Ok(String), Err(io::Error) }\n\n let slv: Vec<_> = next_line\n .trim()\n .split(' ')\n .map(|n| {\n n.parse::().unwrap()\n })\n .collect();\n\n let mut cs = 0;\n\n for num in slv.iter() {\n if *num <= k {\n cs += 1;\n } else {\n break;\n }\n }\n\n if cs == n {\n println!(\"{}\", n);\n return;\n }\n\n\n for num in slv.iter().rev() {\n if *num <= k {\n cs += 1;\n } else {\n break;\n }\n }\n\n println!(\"{}\", cs);\n\n // let mut reach: Vec> = vec![];\n // // reach.reserve(n as usize);\n\n // let mut pairs: Vec> = vec![];\n // for l in lines {\n // let lv: Vec = l.unwrap()\n // .trim()\n // .split(' ')\n // .map(|n| n.parse::().unwrap() - 1)\n // .collect();\n // // println!(\"line values: ({}, {})\", lv[0], lv[1]);\n // reach[lv[0] as usize].insert(lv[1]);\n // reach[lv[1] as usize].insert(lv[0]);\n // pairs.push(lv);\n // }\n}", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "285884ef3c1b895f5e3dba78762b5688", "src_uid": "ecf0ead308d8a581dd233160a7e38173", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin ModInt ----------\nconst MOD: u32 = 998_244_353;\n#[derive(Clone, Copy)]\nstruct ModInt(u32);\n\nimpl std::ops::Add for ModInt {\n type Output = ModInt;\n fn add(self, rhs: ModInt) -> ModInt {\n let mut d = self.0 + rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n\nimpl std::ops::Mul for ModInt {\n type Output = ModInt;\n fn mul(self, rhs: ModInt) -> ModInt {\n ModInt((self.0 as u64 * rhs.0 as u64 % MOD as u64) as u32)\n }\n}\n\nimpl std::ops::Sub for ModInt {\n type Output = ModInt;\n fn sub(self, rhs: ModInt) -> ModInt {\n let mut d = self.0 + MOD - rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n\nimpl std::ops::Neg for ModInt {\n type Output = ModInt;\n fn neg(self) -> ModInt {\n if self.0 == 0 {self} else {ModInt(MOD - self.0)}\n }\n}\n\nimpl std::ops::AddAssign for ModInt {\n fn add_assign(&mut self, rhs: ModInt) {\n *self = *self + rhs;\n }\n}\n\nimpl std::ops::MulAssign for ModInt {\n fn mul_assign(&mut self, rhs: ModInt) {\n *self = *self * rhs;\n }\n}\n\nimpl std::ops::SubAssign for ModInt {\n fn sub_assign(&mut self, rhs: ModInt) {\n *self = *self - rhs;\n }\n}\n\n#[allow(dead_code)]\nimpl ModInt {\n pub fn new(v: u32) -> ModInt {\n ModInt(v % MOD)\n }\n pub fn zero() -> ModInt {\n ModInt(0)\n }\n pub fn one() -> ModInt {\n ModInt(1)\n }\n pub fn pow(self, mut n: u32) -> ModInt {\n let mut t = ModInt::one();\n let mut s = self;\n while n > 0 {\n if n & 1 == 1 {\n t = t * s;\n }\n s = s * s;\n n >>= 1;\n }\n t\n }\n pub fn inv(self) -> ModInt {\n self.pow(MOD - 2)\n }\n}\n// ---------- end ModInt ----------\n// ---------- begin NTT ----------\nfn ntt(f: &mut [ModInt]) {\n let n = f.len();\n assert!(n.count_ones() == 1);\n let len = n.trailing_zeros() as usize;\n for i in 1..(n - 1){\n let mut x = i;\n let mut j = 0;\n for _ in 0..len {\n j = (j << 1) | (x & 1);\n x >>= 1;\n }\n if i < j {\n f.swap(i, j);\n }\n }\n for k in 0..(n.trailing_zeros() as usize) {\n let m = 1 << k;\n let z = ModInt(3).pow((MOD - 1) >> (k + 1) as u32);\n for j in 0..(n / (2 * m)) {\n let mut q = ModInt::one();\n for i in (2 * m * j)..(2 * m * j + m) {\n let a = f[i];\n let b = q * f[i + m];\n f[i] = a + b;\n f[i + m] = a - b;\n q *= z;\n }\n }\n }\n}\n\nfn intt(f: &mut [ModInt]) {\n ntt(f);\n f[1..].reverse();\n let ik = ModInt(f.len() as u32).inv();\n for f in f.iter_mut() {\n *f *= ik;\n }\n}\n// ---------- end NTT ----------\n\nuse std::io::Read;\n\nfn run() {\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n let mut it = s.trim().split_whitespace();\n let n: usize = it.next().unwrap().parse().unwrap();\n let k = (n / 2 * 9 + 1).next_power_of_two();\n let mut f = vec![ModInt::zero(); k];\n it.next();\n for s in it {\n let a: usize = s.parse().unwrap();\n f[a] = ModInt::one();\n }\n ntt(&mut f);\n for f in &mut f {\n *f = f.pow((n / 2) as u32);\n }\n intt(&mut f);\n let ans = f.iter().fold(ModInt::zero(), |s, f| s + *f * *f);\n println!(\"{}\", ans.0);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["divide and conquer", "dp", "fft"], "code_uid": "587cb044b05c03f44d51c58e08b412d1", "src_uid": "279f1f7d250a4be6406c6c7bfc818bbf", "difficulty": 2400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::*;\n#[allow(unused_imports)]\nuse std::collections::*;\nuse std::io::{Write, BufWriter};\n// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n let mut next = || { iter.next().unwrap() };\n input_inner!{next, $($r)*}\n };\n ($($r:tt)*) => {\n let stdin = std::io::stdin();\n let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));\n let mut next = move || -> String{\n bytes\n .by_ref()\n .map(|r|r.unwrap() as char)\n .skip_while(|c|c.is_whitespace())\n .take_while(|c|!c.is_whitespace())\n .collect()\n };\n input_inner!{next, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($next:expr) => {};\n ($next:expr, ) => {};\n\n ($next:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($next:expr, ( $($t:tt),* )) => {\n ( $(read_value!($next, $t)),* )\n };\n\n ($next:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($next, $t)).collect::>()\n };\n\n ($next:expr, chars) => {\n read_value!($next, String).chars().collect::>()\n };\n\n ($next:expr, usize1) => {\n read_value!($next, usize) - 1\n };\n\n ($next:expr, [ $t:tt ]) => {{\n let len = read_value!($next, usize);\n (0..len).map(|_| read_value!($next, $t)).collect::>()\n }};\n\n ($next:expr, $t:ty) => {\n $next().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n/// Verified by: https://atcoder.jp/contests/pakencamp-2018-day3/submissions/3878249\nmod mod_int {\n use std::ops::*;\n pub trait Mod: Copy + Clone { fn m() -> i64; }\n #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]\n pub struct ModInt { pub x: i64, phantom: ::std::marker::PhantomData<*const M> }\n impl ModInt {\n fn check_integrity(self) {\n debug_assert!(self.x >= 0);\n debug_assert!(self.x < M::m());\n }\n // x >= 0\n pub fn new(x: i64) -> Self { ModInt::new_internal(x % M::m()) }\n fn new_internal(x: i64) -> Self {\n ModInt { x: x, phantom: ::std::marker::PhantomData }\n }\n #[allow(dead_code)]\n pub fn mul_fast(self, other: Self) -> Self {\n self.check_integrity();\n other.check_integrity();\n ModInt::new_internal(self.x * other.x % M::m())\n }\n #[allow(dead_code)]\n pub fn mul_slow(self, other: Self) -> Self {\n // Naive multiplication in order to avoid overflow\n self.check_integrity();\n other.check_integrity();\n let mut sum = ModInt::new_internal(0);\n let mut cur = self;\n let mut e = other.x;\n if self.x < other.x {\n cur = other;\n e = self.x;\n }\n while e > 0 {\n if e % 2 == 1 { sum += cur; }\n cur += cur;\n e /= 2;\n }\n sum\n }\n pub fn pow(self, mut e: i64) -> Self {\n self.check_integrity();\n debug_assert!(e >= 0);\n let mut sum = ModInt::new_internal(1);\n let mut cur = self;\n while e > 0 {\n if e % 2 != 0 { sum *= cur; }\n cur *= cur;\n e /= 2;\n }\n sum\n }\n #[allow(dead_code)]\n pub fn inv(self) -> Self { self.pow(M::m() - 2) }\n }\n impl Add for ModInt {\n type Output = Self;\n fn add(self, other: Self) -> Self {\n self.check_integrity();\n other.check_integrity();\n let mut sum = self.x + other.x;\n if sum >= M::m() { sum -= M::m(); }\n ModInt::new_internal(sum)\n }\n }\n impl Sub for ModInt {\n type Output = Self;\n fn sub(self, other: Self) -> Self {\n self.check_integrity();\n other.check_integrity();\n let mut sum = self.x - other.x;\n if sum < 0 { sum += M::m(); }\n ModInt::new_internal(sum)\n }\n }\n impl Mul for ModInt {\n type Output = Self;\n fn mul(self, other: Self) -> Self { self.mul_fast(other) }\n }\n impl AddAssign for ModInt {\n fn add_assign(&mut self, other: Self) { *self = *self + other; }\n }\n impl SubAssign for ModInt {\n fn sub_assign(&mut self, other: Self) { *self = *self - other; }\n }\n impl MulAssign for ModInt {\n fn mul_assign(&mut self, other: Self) { *self = *self * other; }\n }\n impl ::std::fmt::Display for ModInt {\n fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {\n self.x.fmt(f)\n }\n }\n impl ::std::fmt::Debug for ModInt {\n fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {\n self.x.fmt(f)\n }\n }\n} // mod mod_int\n\nmacro_rules! define_mod {\n ($struct_name: ident, $modulo: expr) => {\n #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]\n struct $struct_name {}\n impl mod_int::Mod for $struct_name { fn m() -> i64 { $modulo } }\n }\n}\nconst MOD: i64 = 998244353;\ndefine_mod!(P, MOD);\ntype ModInt = mod_int::ModInt

;\n\n/// FFT (in-place)\n/// R: Ring + Copy\n/// Verified by: ATC001-C (http://atc001.contest.atcoder.jp/submissions/1175827)\nmod fft {\n use std::ops::*;\n /// n should be a power of 2. zeta is a primitive n-th root of unity.\n /// one is unity\n /// Note that the result should be multiplied by 1/sqrt(n).\n pub fn transform(f: &[R], zeta: R, one: R) -> Vec\n where R: Copy +\n Add +\n Sub +\n Mul {\n let n = f.len();\n let mut output = f.to_vec();\n assert!(n.is_power_of_two());\n {\n let mut i = 0;\n for j in 1 .. n - 1 {\n let mut k = n >> 1;\n loop {\n i ^= k;\n if k <= i { break; }\n k >>= 1;\n }\n if j < i {\n output.swap(i, j);\n }\n }\n }\n let mut zetapow = Vec::new();\n {\n let mut m = 1;\n let mut cur = zeta;\n while m < n {\n zetapow.push(cur);\n cur = cur * cur;\n m *= 2;\n }\n }\n let mut m = 1;\n while m < n {\n let m2 = 2 * m;\n let base = zetapow.pop().unwrap();\n let mut r = 0;\n while r < n {\n let mut w = one;\n for x in 0 .. m {\n let s = x + r;\n let u = output[s];\n let d = output[s + m] * w;\n output[s] = u + d;\n output[s + m] = u - d;\n w = w * base;\n }\n r += m2;\n }\n m *= 2;\n }\n output\n }\n}\n\nfn solve() {\n let out = std::io::stdout();\n let mut out = BufWriter::new(out.lock());\n macro_rules! puts {\n ($($format:tt)*) => (write!(out,$($format)*).unwrap());\n }\n input! {\n n: usize,\n k: usize,\n d: [usize; k],\n }\n const N: usize = 1 << 20;\n let one = ModInt::new(1);\n let mut f = vec![ModInt::new(0); N];\n let zeta = ModInt::new(3).pow((MOD - 1) / N as i64);\n for i in 0 .. k {\n f[d[i]] += one;\n }\n let mut f = fft::transform(&f, zeta, one);\n for i in 0 .. N {\n f[i] = f[i].pow(n as i64 / 2);\n }\n let mut f = fft::transform(&f, zeta.inv(), one);\n let factor = ModInt::new(N as i64).inv();\n for i in 0 .. N {\n f[i] *= factor;\n }\n let mut tot = ModInt::new(0);\n for i in 0 .. N {\n tot += f[i].pow(2);\n }\n puts!(\"{}\\n\", tot);\n}\n\nfn main() {\n // In order to avoid potential stack overflow, spawn a new thread.\n let stack_size = 104_857_600; // 100 MB\n let thd = std::thread::Builder::new().stack_size(stack_size);\n thd.spawn(|| solve()).unwrap().join().unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["divide and conquer", "dp", "fft"], "code_uid": "f5e2a319f03cd0fe722c27e14cd62952", "src_uid": "279f1f7d250a4be6406c6c7bfc818bbf", "difficulty": 2400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": " #[allow(unused_imports)]\nuse std::cmp::{min,max};\n//const INF: i32 = 0x3f3f3f3f;\n\nstruct Scanner {\n buffer: std::collections::VecDeque\n}\n\nimpl Scanner {\n fn new() -> Scanner {\n Scanner {\n buffer: std::collections::VecDeque::new()\n }\n }\n\n fn next(&mut self) -> T {\n while self.buffer.is_empty() {\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).ok();\n self.buffer = input.split_whitespace()\n .map(ToString::to_string).collect();\n }\n let front = self.buffer.pop_front().unwrap();\n front.parse::().ok().unwrap()\n }\n}\n\nfn solution() {\n let mut scanner = Scanner::new();\n let mut s: String = scanner.next();\n let n = s.len();\n let mut ans = 0;\n let mut current = 1;\n for i in 0..n {\n let d = s.chars().next().unwrap().to_digit(10).unwrap() as usize;\n let x = std::cmp::max(d as i32 - 1, 1) as usize;\n ans = std::cmp::max(ans, current * x * 9_usize.pow((n - i - 1) as u32));\n current *= d;\n s = s[1..].to_string();\n }\n ans = std::cmp::max(ans, current);\n println!(\"{}\", ans);\n}\n\nfn main() {\n std::thread::Builder::new().stack_size(50 << 20)\n .spawn(solution).unwrap().join().unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "number theory"], "code_uid": "93371b823edb8d89c9eadfed80d536c0", "src_uid": "38690bd32e7d0b314f701f138ce19dfb", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut input = String::new();\n\n std::io::stdin().read_line(&mut input);\n\n for ch in input.to_lowercase().chars() {\n match ch {\n 'a' | 'o' | 'y' | 'e' | 'u' | 'i' | '\\n' | '\\r' => {\n continue;\n },\n _ => {\n print!(\".{}\", ch);\n }\n }\n }\n}", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "ef6810efe0d3ef80610449045f61ed7e", "src_uid": "db9520e85b3e9186dd3a09ff8d1e8c1b", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).unwrap();\n\n for c in s.trim().chars() {\n match c {\n 'A' | 'O' | 'Y' | 'E' | 'U' | 'I' |\n 'a' | 'o' | 'y' | 'e' | 'u' | 'i' => {\n continue;\n }, _ => {\n print!(\".\");\n if c.is_lowercase() {\n print!(\"{}\", c);\n } else {\n print!(\"{}\", (('a' as u8) + (c as u8) - ('A' as u8)) as char);\n }\n }\n }\n }\n\n println!(\"\");\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "32d1644bd3fca4afa53a03724bb765b8", "src_uid": "db9520e85b3e9186dd3a09ff8d1e8c1b", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "/// square root of an int\nfn sqrti(b: u64) -> u64 {\n let n = 2;\n if b < 2 {\n return b\n };\n let n1 = n - 1;\n let n2 = n;\n let n3 = n1;\n let mut c = 1;\n let mut d = (n3 + b) / n2;\n let mut e = (n3 * d + b / d.pow(n1 as u32)) / n2;\n while c != d && c != e {\n c = d;\n d = e;\n e = (n3 * e + b / e.pow(n1 as u32)) / n2;\n }\n if d < e { d }\n else { e }\n}\n\nuse std::ops::Range;\n\n/// iterator that returns `(w, h)` for rectangles of provided area\nstruct Rects {\n area: u64,\n w: u64,\n rw: Range,\n rh: Range,\n}\n\nimpl Rects {\n pub fn new(area: u64) -> Rects {\n let q = sqrti(area);\n Rects { area, rw: 1..q, rh: 1..area, w: q }\n }\n pub fn with_limits(area: u64, rw: Range, rh: Range) -> Rects {\n let q = sqrti(area);\n let maxw = q.min(area / rh.start).min(rw.end);\n let minw = (area / rh.end).max(rw.start);\n Rects { area, rw: minw..maxw, rh, w: maxw }\n }\n}\n\nimpl Iterator for Rects {\n type Item = (u64, u64);\n fn next(&mut self) -> Option<(u64, u64)> {\n while self.w >= self.rw.start {\n let w = self.w;\n self.w -= 1;\n let h = self.area / w;\n if h < self.rh.start || h > self.rh.end || h * w != self.area {\n continue;\n }\n return Some((w, h));\n }\n None\n }\n}\n\nfn solve(a: u64, b: u64) -> Option {\n if a < 1 || b < 1 {\n return None;\n }\n let area = a + b;\n Rects::new(area).flat_map(|(ow, oh)| {\n let perimeter = (ow + oh) * 2;\n Rects::with_limits(a, 1..ow, 1..oh)\n .chain(Rects::with_limits(b, 1..ow, 1..oh))\n .find(|&(iw, ih)| iw <= ow && ih <= oh)\n .and(Some(perimeter))\n }).next()\n}\n\nuse std::io::{stdin, BufRead};\nuse std::process::{exit};\nfn input() -> Result<(u64, u64), String> {\n let std = stdin();\n let mut row = String::new();\n std.lock().read_line(&mut row).map_err(|_|\"Cannot read stdin\")?;\n let words: Vec<&str> = row.trim().split(' ').collect();\n let a: u64 = words[0].parse().map_err(|_|\"Cannot parse input\")?;\n let b: u64 = words[1].parse().map_err(|_|\"Cannot parse input\")?;\n Ok((a, b))\n}\n\nfn main() {\n let rv = input().map(|(a,b)| solve(a, b));\n match rv {\n Ok(Some(perimeter)) => {\n println!(\"{}\", perimeter);\n }\n Ok(None) => {\n eprintln!(\"Error: solution not found\");\n exit(1);\n }\n Err(e) => {\n eprintln!(\"Error: {}\", e);\n exit(1);\n }\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "binary search", "number theory"], "code_uid": "6ca0289b797f9585ad59d9a005ac41c3", "src_uid": "7d0c5f77bca792b6ab4fd4088fe18ff1", "difficulty": 2000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::*;\n\nfn read(i: &mut StdinLock) -> T {\n let mut s = String::new();\n i.by_ref().read_line(&mut s).ok();\n s.trim().parse().ok().unwrap()\n}\n\nfn main() {\n // initialize stdin\n let sin = std::io::stdin();\n let mut sin = sin.lock();\n let sin = &mut sin;\n\n let input1: String = read(sin);\n let input2: String = read(sin);\n\n let input1 = input1.to_lowercase();\n let input2 = input2.to_lowercase();\n\n if input1 == input2 {\n println!(\"0\");\n } else if input1 < input2 {\n println!(\"-1\");\n } else if input2 < input1 {\n println!(\"1\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "8d08f9ff11d3d49185675f80689fc624", "src_uid": "ffeae332696a901813677bd1033cf01e", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::cmp::Ordering;\nfn main() {\n let data1 = read().to_lowercase();\n let data2 = read().to_lowercase();\n let c = data1.cmp(&data2);\n match c{\n Ordering::Greater => println!(\"1\"),\n Ordering::Less => println!(\"-1\"),\n _ => println!(\"0\"),\n };\n}\nfn read() -> String{\n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n input.trim().parse::().unwrap()\n}", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "d61a8300843759149d207069682a9362", "src_uid": "ffeae332696a901813677bd1033cf01e", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::io::Read;\n// use std::collections::VecDeque;\n\n\nfn main() {\n let mut input_text = String::new();\n io::stdin().read_to_string(&mut input_text).unwrap();\n let mut iter = input_text.split_whitespace().map(|x| x.parse::().unwrap());\n let n = iter.next().unwrap();\n let k = iter.next().unwrap();\n let mut ans = n / k * k;\n while ans <= n {\n ans += k\n }\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "456e085716db97fbda5639fd77b4b566", "src_uid": "75f3835c969c871a609b978e04476542", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//! http://codeforces.com/contest/742/problem/A\n\n#[macro_export]\nmacro_rules! scanln {\n ($($var:ident : $ty:path),+) => {\n $(let $var: $ty;)+\n {\n use std::io;\n let mut __buf = String::new();\n io::stdin().read_line(&mut __buf).unwrap();\n let mut eles = __buf.split_whitespace();\n $($var = Scan::scan(&mut eles);)+\n }\n }\n}\n\npub trait Scan {\n fn scan<'a, I>(eles: &mut I) -> Self where I: Iterator;\n}\n\nmacro_rules! impl_scan_single {\n ($ty:ty) => {\n impl Scan for $ty {\n fn scan<'a, I>(eles: &mut I) -> Self where I: Iterator {\n let next = eles.next().unwrap();\n match next.parse() {\n Ok(res) => res,\n Err(_) => panic!()\n }\n }\n }\n }\n}\n\nimpl_scan_single!(u8);\nimpl_scan_single!(u16);\nimpl_scan_single!(u32);\nimpl_scan_single!(u64);\nimpl_scan_single!(usize);\nimpl_scan_single!(i8);\nimpl_scan_single!(i16);\nimpl_scan_single!(i32);\nimpl_scan_single!(i64);\nimpl_scan_single!(f32);\nimpl_scan_single!(f64);\nimpl_scan_single!(isize);\nimpl_scan_single!(String);\n\nconst __IMPL_SCAN_FOR_VEC: () = {\n use std::str::FromStr;\n impl Scan for Vec where T: FromStr {\n fn scan<'a, I>(eles: &mut I) -> Self where I: Iterator {\n eles.map(|str| match str.parse() {\n Ok(res) => res,\n Err(_) => panic!()\n }).collect()\n }\n }\n};\n\n// -----------------------------------------------------------------------------\n\nfn main() {\n scanln!(n: u32);\n if n == 0 { println!(\"1\"); }\n else {\n println!(\"{}\",\n match n % 4 {\n 1 => 8,\n 2 => 4,\n 3 => 2,\n 0 => 6,\n _ => unreachable!()\n }\n );\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation", "number theory"], "code_uid": "2453a21e1ccd633f48be4155ed7960ca", "src_uid": "4b51b99d1dea367bf37dc5ead08ca48f", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\nuse std::io::{ self, Write };\nuse std::str::FromStr;\nuse std::cmp::{ min, max };\nuse std::collections::{ BinaryHeap, VecDeque };\n\nmacro_rules! trace {\n ($var:expr) => ({\n let _ = writeln!(&mut std::io::stderr(), \">>> {} = {:?}\", stringify!($var), $var);\n })\n}\nmacro_rules! swap { ($a:expr, $b:expr) => ({ let t = $b; $b = $a; $a = t; }) }\n\nfn bi(x: i64, n: i64, l0: i64, r0: i64) -> i64 {\n let mut left = l0;\n let mut right = r0;\n\n while right - left > 1 {\n let y = (left + right) / 2;\n if x * x + y * y <= n * n {\n left = y;\n } else {\n right = y;\n }\n }\n return left;\n}\n\nfn main() {\n let mut sc = Scanner::new();\n\n let n: i64 = sc.cin();\n\n if n == 0 {\n println!(\"1\");\n return;\n }\n\n let mut a = 0;\n let mut b = 0;\n\n let mut l0 = 0;\n let mut r0 = n + 1;\n for x in 0..n {\n let y = bi(x, n, l0, r0);\n l0 = max(0, y - 10);\n r0 = min(y + 10, n + 1);\n // trace!((x, y));\n if x < y {\n a += 1;\n } else if x == y {\n b += 1;\n break;\n } else {\n break;\n }\n }\n let ans = 4 * (a * 2 - 1 + b);\n println!(\"{}\", ans);\n}\n\n#[allow(dead_code)]\nstruct Scanner { stdin: io::Stdin, buffer: VecDeque, }\n#[allow(dead_code)]\nimpl Scanner {\n fn new() -> Scanner { Scanner { stdin: io::stdin(), buffer: VecDeque::new() } }\n fn reserve(&mut self) {\n while self.buffer.len() == 0 {\n let mut line = String::new();\n let _ = self.stdin.read_line(&mut line);\n for w in line.split_whitespace() {\n self.buffer.push_back(String::from(w));\n }\n }\n }\n fn cin(&mut self) -> T {\n self.reserve();\n match self.buffer.pop_front().unwrap().parse::() {\n Ok(a) => a,\n Err(_) => panic!(\"parse err\")\n }\n }\n fn get_char(&mut self) -> char {\n self.reserve();\n let head = self.buffer[0].chars().nth(0).unwrap();\n let tail = String::from( &self.buffer[0][1..] );\n if tail.len()>0 { self.buffer[0]=tail } else { self.buffer.pop_front(); }\n head\n }\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "750e7cbf1ddc8b8ebb8a9fc2cd138e7a", "src_uid": "d87ce09acb8401e910ca6ef3529566f4", "difficulty": null, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\n\nfn main() {\n let mut input = String::new();\n stdin().read_line(&mut input).unwrap();\n let mut input = input.split_whitespace().map(|k| k.parse::().unwrap());\n let m = input.next().unwrap();\n let b = input.next().unwrap();\n\n let ans = (0..(m * b + 1)).map(|x| {\n let y = b - (x + m - 1) / m;\n let tmp = (x + 1) * (y + 1) * (x + y) / 2 ;\n tmp\n }).max().unwrap();\n\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math"], "code_uid": "2f1ae30cab7f823730179069106c197b", "src_uid": "9300f1c07dd36e0cf7e6cb7911df4cf2", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut l = String::new();\n std::io::stdin().read_line(&mut l).unwrap();\n let mut mb = l.split_whitespace().map(|s| s.parse::().unwrap());\n let m = mb.next().unwrap();\n let b = mb.next().unwrap();\n\n let answer: u64 = (0..(b+1)).into_iter().map(|height| {\n let width = m * (b - height);\n\n let height_sum = height * (height+1) / 2;\n let width_sum = width * (width+1) / 2;\n\n height_sum * (width+1) + width_sum * (height+1)\n }).max().unwrap();\n println!(\"{}\", answer);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math"], "code_uid": "20aedeebd4f847c4e5225c800641bcef", "src_uid": "9300f1c07dd36e0cf7e6cb7911df4cf2", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max, min, Ordering};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\n#[allow(unused_imports)]\nuse std::io::prelude::BufRead;\n#[allow(unused_imports)]\nuse std::io::{stdin, stdout, BufReader, BufWriter, Write};\n#[allow(unused_imports)]\nuse std::mem::swap;\n#[allow(unused_imports)]\nuse std::str::FromStr;\n\nfn main() {\n let line = read_vector::();\n let (n, m) = (line[0], line[1]);\n if m % n != 0 {\n println!(\"-1\");\n return;\n }\n let mut quotient = m / n;\n let mut ans = 0;\n while quotient % 2 == 0 && quotient > 1 {\n quotient /= 2;\n ans += 1;\n }\n while quotient % 3 == 0 && quotient > 1 {\n quotient /= 3;\n ans += 1;\n }\n if quotient > 1 {\n println!(\"-1\");\n return;\n }\n println!(\"{}\", ans);\n}\n\n#[allow(dead_code)]\nfn read() -> T\nwhere\n T: std::str::FromStr,\n T::Err: std::fmt::Debug,\n{\n let mut buf = String::new();\n stdin().read_line(&mut buf).unwrap();\n return buf.trim().parse().unwrap();\n}\n\n#[allow(dead_code)]\nfn read_vector() -> Vec\nwhere\n T: std::str::FromStr,\n T::Err: std::fmt::Debug,\n{\n let mut buf = String::with_capacity(100);\n stdin().read_line(&mut buf).unwrap();\n return buf.split_whitespace().map(|s| s.parse().unwrap()).collect();\n}\n\n#[allow(dead_code)]\nfn read_matrix() -> Vec>\nwhere\n T: std::str::FromStr,\n T::Err: std::fmt::Debug,\n{\n use std::io::prelude::*;\n let stdin = stdin();\n let mut reader = BufReader::with_capacity(100 * 1024, stdin);\n let mut line = String::with_capacity(100);\n let mut matrix: Vec> = Vec::new();\n\n while reader.read_line(&mut line).unwrap() > 0 {\n matrix.push(\n line.trim()\n .split_whitespace()\n .map(|s| s.parse().unwrap())\n .collect(),\n );\n line.clear();\n }\n\n return matrix;\n}\n\n#[allow(dead_code)]\nfn read_chars() -> Vec {\n let stdin = stdin();\n let mut buf = String::new();\n let _bytes = stdin.read_line(&mut buf).unwrap();\n return buf.trim().chars().collect();\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "2ebd06cc3f0c0ab8d6a416780a18e5c6", "src_uid": "3f9980ad292185f63a80bce10705e806", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "pub mod solution {\n\nuse crate::io::input::Input;\nuse crate::io::output::output;\nuse crate::math::euclid::{gcd, lcm};\nuse crate::math::sieve::{euler_function_up_to, get_all_divisors_for_all_up_to};\nuse crate::{out, out_line};\n\nfn solve(input: &mut Input, _test_case: usize) {\n let n = input.read();\n let phi = euler_function_up_to(n);\n let divisors = get_all_divisors_for_all_up_to(n);\n let mut ans = 0;\n for c in 1..n - 1 {\n for &g in &divisors[n - c] {\n if g == n - c {\n continue;\n }\n let x = gcd(g as u64, c as u64);\n let z = mul((c as u64 / x) as i32, g as i32);\n add(&mut ans, mul(phi[(n - c) / g] as i32, z as i32));\n }\n }\n out_line!(ans);\n}\n\nfn add(a: &mut i32, b: i32) {\n *a += b;\n if *a >= MOD {\n *a -= MOD;\n }\n}\n\nconst MOD: i32 = 1000000007;\n\nfn mul(a: i32, b: i32) -> i32 {\n (a as i64 * b as i64 % MOD as i64) as i32\n}\n\npub(crate) fn run(mut input: Input) -> bool {\n solve(&mut input, 1);\n output().flush();\n input.skip_whitespace();\n !input.peek().is_some()\n}\n\n}\npub mod io {\npub mod input {\nuse std::fmt::Debug;\nuse std::io::Read;\nuse std::marker::PhantomData;\nuse std::str::FromStr;\n\npub struct Input<'s> {\n input: &'s mut dyn Read,\n buf: Vec,\n at: usize,\n buf_read: usize,\n}\n\nimpl<'s> Input<'s> {\n const DEFAULT_BUF_SIZE: usize = 4096;\n\n pub fn new(input: &'s mut dyn Read) -> Self {\n Self {\n input,\n buf: vec![0; Self::DEFAULT_BUF_SIZE],\n at: 0,\n buf_read: 0,\n }\n }\n\n pub fn new_with_size(input: &'s mut dyn Read, buf_size: usize) -> Self {\n Self {\n input,\n buf: vec![0; buf_size],\n at: 0,\n buf_read: 0,\n }\n }\n\n pub fn get(&mut self) -> Option {\n if self.refill_buffer() {\n let res = self.buf[self.at];\n self.at += 1;\n Some(res)\n } else {\n None\n }\n }\n\n pub fn peek(&mut self) -> Option {\n if self.refill_buffer() {\n Some(self.buf[self.at])\n } else {\n None\n }\n }\n\n pub fn skip_whitespace(&mut self) {\n while let Some(b) = self.peek() {\n if !char::from(b).is_whitespace() {\n return;\n }\n self.get();\n }\n }\n\n pub fn next_token(&mut self) -> Option> {\n self.skip_whitespace();\n let mut res = Vec::new();\n while let Some(c) = self.get() {\n if char::from(c).is_whitespace() {\n break;\n }\n res.push(c);\n }\n if res.is_empty() {\n None\n } else {\n Some(res)\n }\n }\n\n //noinspection RsSelfConvention\n pub fn is_exhausted(&mut self) -> bool {\n self.peek().is_none()\n }\n\n pub fn read(&mut self) -> T {\n T::read(self)\n }\n\n pub fn read_vec(&mut self, size: usize) -> Vec {\n let mut res = Vec::with_capacity(size);\n for _ in 0usize..size {\n res.push(self.read());\n }\n res\n }\n\n pub fn read_line(&mut self) -> String {\n let mut res = String::new();\n while let Some(c) = self.get() {\n if c == b'\\n' {\n break;\n }\n if c == b'\\r' {\n if self.peek() == Some(b'\\n') {\n self.get();\n }\n break;\n }\n res.push(c.into());\n }\n res\n }\n\n #[allow(clippy::should_implement_trait)]\n pub fn into_iter(self) -> InputIterator<'s, T> {\n InputIterator {\n input: self,\n phantom: Default::default(),\n }\n }\n\n fn read_integer(&mut self) -> T\n where\n ::Err: Debug,\n {\n let res = self.read_string();\n res.parse::().unwrap()\n }\n\n fn read_string(&mut self) -> String {\n match self.next_token() {\n None => {\n panic!(\"Input exhausted\");\n }\n Some(res) => unsafe { String::from_utf8_unchecked(res) },\n }\n }\n\n fn read_char(&mut self) -> char {\n self.skip_whitespace();\n self.get().unwrap().into()\n }\n\n fn read_float(&mut self) -> f64 {\n self.read_string().parse().unwrap()\n }\n\n fn refill_buffer(&mut self) -> bool {\n if self.at == self.buf_read {\n self.at = 0;\n self.buf_read = self.input.read(&mut self.buf).unwrap();\n self.buf_read != 0\n } else {\n true\n }\n }\n}\n\npub trait Readable {\n fn read(input: &mut Input) -> Self;\n}\n\nimpl Readable for String {\n fn read(input: &mut Input) -> Self {\n input.read_string()\n }\n}\n\nimpl Readable for char {\n fn read(input: &mut Input) -> Self {\n input.read_char()\n }\n}\n\nimpl Readable for f64 {\n fn read(input: &mut Input) -> Self {\n input.read_float()\n }\n}\n\nimpl Readable for Vec {\n fn read(input: &mut Input) -> Self {\n let size = input.read();\n input.read_vec(size)\n }\n}\n\npub struct InputIterator<'s, T: Readable> {\n input: Input<'s>,\n phantom: PhantomData,\n}\n\nimpl<'s, T: Readable> Iterator for InputIterator<'s, T> {\n type Item = T;\n\n fn next(&mut self) -> Option {\n self.input.skip_whitespace();\n self.input.peek().map(|_| self.input.read())\n }\n}\n\nmacro_rules! read_integer {\n ($t:ident) => {\n impl Readable for $t {\n fn read(input: &mut Input) -> Self {\n input.read_integer()\n }\n }\n };\n}\n\nread_integer!(i8);\nread_integer!(i16);\nread_integer!(i32);\nread_integer!(i64);\nread_integer!(i128);\nread_integer!(isize);\nread_integer!(u8);\nread_integer!(u16);\nread_integer!(u32);\nread_integer!(u64);\nread_integer!(u128);\nread_integer!(usize);\n\nmacro_rules! tuple_readable {\n ( $( $name:ident )+ ) => {\n impl<$($name: Readable), +> Readable for ($($name,)+) {\n fn read(input: &mut Input) -> Self {\n ($($name::read(input),)+)\n }\n }\n }\n}\n\ntuple_readable! {T}\ntuple_readable! {T U}\ntuple_readable! {T U V}\ntuple_readable! {T U V X}\ntuple_readable! {T U V X Y}\ntuple_readable! {T U V X Y Z}\ntuple_readable! {T U V X Y Z A}\ntuple_readable! {T U V X Y Z A B}\ntuple_readable! {T U V X Y Z A B C}\ntuple_readable! {T U V X Y Z A B C D}\ntuple_readable! {T U V X Y Z A B C D E}\ntuple_readable! {T U V X Y Z A B C D E F}\n}\npub mod output {\nuse std::io::Write;\n\npub struct Output {\n output: Box,\n buf: Vec,\n at: usize,\n auto_flush: bool,\n}\n\nimpl Output {\n const DEFAULT_BUF_SIZE: usize = 4096;\n\n pub fn new(output: Box) -> Self {\n Self {\n output,\n buf: vec![0; Self::DEFAULT_BUF_SIZE],\n at: 0,\n auto_flush: false,\n }\n }\n\n pub fn new_with_auto_flush(output: Box) -> Self {\n Self {\n output,\n buf: vec![0; Self::DEFAULT_BUF_SIZE],\n at: 0,\n auto_flush: true,\n }\n }\n\n pub fn flush(&mut self) {\n if self.at != 0 {\n self.output.write_all(&self.buf[..self.at]).unwrap();\n self.at = 0;\n self.output.flush().expect(\"Couldn't flush output\");\n }\n }\n\n pub fn print(&mut self, s: &T) {\n s.write(self);\n }\n\n pub fn put(&mut self, b: u8) {\n self.buf[self.at] = b;\n self.at += 1;\n if self.at == self.buf.len() {\n self.flush();\n }\n }\n\n pub fn maybe_flush(&mut self) {\n if self.auto_flush {\n self.flush();\n }\n }\n\n pub fn print_per_line(&mut self, arg: &[T]) {\n for i in arg {\n i.write(self);\n self.put(b'\\n');\n }\n }\n\n pub fn print_iter>(&mut self, iter: I) {\n let mut first = true;\n for e in iter {\n if first {\n first = false;\n } else {\n self.put(b' ');\n }\n e.write(self);\n }\n }\n\n pub fn print_iter_ref<'a, T: 'a + Writable, I: Iterator>(&mut self, iter: I) {\n let mut first = true;\n for e in iter {\n if first {\n first = false;\n } else {\n self.put(b' ');\n }\n e.write(self);\n }\n }\n}\n\nimpl Write for Output {\n fn write(&mut self, buf: &[u8]) -> std::io::Result {\n let mut start = 0usize;\n let mut rem = buf.len();\n while rem > 0 {\n let len = (self.buf.len() - self.at).min(rem);\n self.buf[self.at..self.at + len].copy_from_slice(&buf[start..start + len]);\n self.at += len;\n if self.at == self.buf.len() {\n self.flush();\n }\n start += len;\n rem -= len;\n }\n if self.auto_flush {\n self.flush();\n }\n Ok(buf.len())\n }\n\n fn flush(&mut self) -> std::io::Result<()> {\n self.flush();\n Ok(())\n }\n}\n\npub trait Writable {\n fn write(&self, output: &mut Output);\n}\n\nimpl Writable for &str {\n fn write(&self, output: &mut Output) {\n output.write_all(self.as_bytes()).unwrap();\n }\n}\n\nimpl Writable for String {\n fn write(&self, output: &mut Output) {\n output.write_all(self.as_bytes()).unwrap();\n }\n}\n\nimpl Writable for char {\n fn write(&self, output: &mut Output) {\n output.put(*self as u8);\n }\n}\n\nimpl Writable for [T] {\n fn write(&self, output: &mut Output) {\n output.print_iter_ref(self.iter());\n }\n}\n\nimpl Writable for Vec {\n fn write(&self, output: &mut Output) {\n self[..].write(output);\n }\n}\n\nmacro_rules! write_to_string {\n ($t:ident) => {\n impl Writable for $t {\n fn write(&self, output: &mut Output) {\n self.to_string().write(output);\n }\n }\n };\n}\n\nwrite_to_string!(u8);\nwrite_to_string!(u16);\nwrite_to_string!(u32);\nwrite_to_string!(u64);\nwrite_to_string!(u128);\nwrite_to_string!(usize);\nwrite_to_string!(i8);\nwrite_to_string!(i16);\nwrite_to_string!(i32);\nwrite_to_string!(i64);\nwrite_to_string!(i128);\nwrite_to_string!(isize);\nwrite_to_string!(f32);\nwrite_to_string!(f64);\n\nimpl Writable for (T, U) {\n fn write(&self, output: &mut Output) {\n self.0.write(output);\n output.put(b' ');\n self.1.write(output);\n }\n}\n\nimpl Writable for (T, U, V) {\n fn write(&self, output: &mut Output) {\n self.0.write(output);\n output.put(b' ');\n self.1.write(output);\n output.put(b' ');\n self.2.write(output);\n }\n}\n\npub static mut OUTPUT: Option = None;\n\npub fn output() -> &'static mut Output {\n unsafe {\n match &mut OUTPUT {\n None => {\n panic!(\"Panic\");\n }\n Some(output) => output,\n }\n }\n}\n\n#[macro_export]\nmacro_rules! out {\n ($first: expr $(,$args:expr )*) => {\n output().print(&$first);\n $(output().put(b' ');\n output().print(&$args);\n )*\n }\n}\n\n#[macro_export]\nmacro_rules! out_line {\n ($first: expr $(, $args:expr )* ) => {\n out!($first $(,$args)*);\n output().put(b'\\n');\n };\n () => {\n output().put(b'\\n');\n };\n}\n}\n}\npub mod math {\npub mod euclid {\n\n\npub fn gcd(mut a: u64, mut b: u64) -> u64 {\n while b != 0 {\n let t = a % b;\n a = b;\n b = t;\n }\n a\n}\n\npub fn lcm(a: u64, b: u64) -> u64 {\n a / gcd(a, b) * b\n}\n}\npub mod sieve {\n\n\npub fn get_all_divisors_for_all_up_to(n: usize) -> Vec> {\n let mut d = vec![Vec::new(); n + 1];\n for i in 1..=n {\n for j in (i..=n).step_by(i) {\n d[j].push(i);\n }\n }\n d\n}\n\npub fn euler_function_up_to(n: usize) -> Vec {\n let mut phi = vec![0; n + 1];\n for i in 1..=n {\n phi[i] = i;\n }\n for i in 2..=n {\n if phi[i] == i {\n for j in (i..=n).step_by(i) {\n phi[j] -= phi[j] / i;\n }\n }\n }\n phi\n}\n}\n}\nfn main() {\n let mut sin = std::io::stdin();\n let input = crate::io::input::Input::new(&mut sin);\n unsafe {\n crate::io::output::OUTPUT = Some(crate::io::output::Output::new(Box::new(std::io::stdout())));\n }\n crate::solution::run(input);\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "f2bf246aa2a426bd682aaaf2a338ab74", "src_uid": "c3694a6ff95c64bef8cbe8834c3fd6cb", "difficulty": 2200.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "const MODULUS: usize = 1_000_000_007;\n\nfn main() {\n let stdout = std::io::stdout();\n let mut writer = std::io::BufWriter::new(stdout.lock());\n #[allow(unused_macros)] macro_rules! print { ($($tt:tt)*) => {{ use std::io::Write; std::write!(writer, $($tt)*).unwrap(); }}; }\n #[allow(unused_macros)] macro_rules! println { ($($tt:tt)*) => {{ use std::io::Write; std::writeln!(writer, $($tt)*).unwrap(); }}; }\n\n input! {\n n: usize\n }\n let (_, _, phi) = prime_sieve(n);\n let mut divisors = vec![];\n let mut ans = 0;\n for c in 1..=n-2 {\n let sum_ab = n - c;\n divisors.clear();\n for i in 1.. {\n if i * i > sum_ab {\n break;\n }\n if sum_ab % i == 0 {\n divisors.push(i);\n if i * i < sum_ab {\n divisors.push(sum_ab / i);\n }\n }\n }\n for &divisor in divisors.iter() {\n if divisor == sum_ab {\n continue\n }\n let cnt = phi[sum_ab / divisor];\n let lcm = c / c.gcd(divisor) * divisor;\n ans += lcm % MODULUS * cnt % MODULUS;\n ans %= MODULUS;\n }\n }\n println!(\"{}\", ans);\n}\n\ntrait BinaryGCD {\n fn gcd(self, b: Self) -> Self;\n}\n\nmacro_rules! impl_binary_gcd_uint {\n ($($t:ty),*) => {\n $(\n impl BinaryGCD for $t {\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self;\n\n if b == 0 {\n return a\n }\n if a == 0 {\n return b\n }\n let shifts = (a|b).trailing_zeros();\n a >>= a.trailing_zeros();\n b >>= b.trailing_zeros();\n\n loop {\n if a < b {\n std::mem::swap(&mut a, &mut b);\n }\n a -= b;\n if a == 0 {\n return b << shifts\n }\n a >>= a.trailing_zeros();\n }\n }\n }\n )*\n };\n}\n\nimpl_binary_gcd_uint!(u8, u16, u32, u64, usize, u128);\n\nfn prime_sieve(n: usize) -> (Vec, Vec, Vec) {\n let mut primes = vec![];\n let mut min_div = vec![0; n + 1];\n let mut phi = vec![0; n + 1];\n phi[1] = 1;\n for i in 2..=n {\n if min_div[i] == 0 {\n min_div[i] = i;\n phi[i] = i - 1;\n primes.push(i)\n }\n for &p in primes.iter() {\n if i * p > n {\n break\n }\n min_div[i * p] = p;\n if i % p == 0 {\n phi[i * p] = phi[i] * p;\n break\n }\n phi[i * p] = phi[i] * (p - 1);\n }\n }\n (primes, min_div, phi)\n}\n\n\n// input macro with modifications (to better align with proconio)\n// based on https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\n\n#[macro_export]\nmacro_rules! input {\n (@lock_stdin $reader:ident) => {\n let stdin = std::io::stdin();\n let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));\n let mut $reader = move || -> String {\n unsafe {\n String::from_utf8_unchecked(\n bytes\n .by_ref()\n .map_while(Result::ok)\n .skip_while(|c| c.is_ascii_whitespace())\n .take_while(|c| !c.is_ascii_whitespace())\n .collect()\n )\n }\n };\n };\n\n (@inner $reader:ident) => {};\n (@inner $reader:ident, ) => {};\n\n (@inner $reader:ident, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($reader, $t);\n input!{@inner $reader $($r)*}\n };\n\n (@inner $reader:ident, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($reader, $t);\n input!{@inner $reader $($r)*}\n };\n\n (@inner $reader:ident $($r:tt)*) => {\n compile_error!(stringify!(unable to read $($r)*))\n };\n\n (line = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_ascii_whitespace();\n let mut next = || { iter.next().unwrap_or_default() };\n input!{@inner next, $($r)*}\n };\n (name = $reader:ident, $($r:tt)*) => {\n input!{@lock_stdin $reader};\n input!{@inner $reader, $($r)*}\n };\n (use $reader:ident, $($r:tt)*) => {\n input!{@inner $reader, $($r)*}\n };\n ($($r:tt)*) => {\n input!{@lock_stdin reader};\n input!{@inner reader, $($r)*};\n };\n}\n\n#[macro_export]\nmacro_rules! read_value {\n ($reader:ident, ( $($t:tt),* )) => {\n ( $(read_value!($reader, $t)),* )\n };\n\n ($reader:ident, [ $t:tt ]) => {{\n let len = read_value!($reader, usize);\n read_value!($reader, [ $t ; len])\n }};\n\n ($reader:ident, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($reader, $t)).collect::>()\n };\n\n ($reader:ident, chars) => {\n read_value!($reader, String).chars().collect::>()\n };\n\n ($reader:ident, bytes) => {\n read_value!($reader, String).into_bytes()\n };\n\n ($reader:ident, usize1) => {\n read_value!($reader, usize) - 1\n };\n\n ($reader:ident, $t:tt) => {\n $reader().parse::<$t>().expect(stringify!(parse error($t)))\n };\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "fad35a6d8b701c3afbb703410851f774", "src_uid": "c3694a6ff95c64bef8cbe8834c3fd6cb", "difficulty": 2200.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(unused_imports)]\n#![allow(dead_code)]\n#![allow(unused_variables)]\nuse std::cmp::*;\nuse std::collections::BTreeSet;\nuse std::io;\nuse std::{io::prelude::*, io::*, str};\n\nstruct IO {\n buffer: Vec,\n out: BufWriter,\n}\nimpl IO {\n fn new() -> Self {\n Self {\n buffer: vec![],\n out: BufWriter::new(stdout()),\n }\n }\n fn read(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n stdin().read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n fn read_vec(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.read::()).collect()\n }\n}\n\nfn transform(x: u64, d: u64) -> u64 {\n if x & (1u64 << 63) != 0 {\n return 0;\n }\n let mut x = (x << 1) | d;\n while x & 1 == 0 {\n x >>= 1;\n }\n let mut y = 0;\n while x != 0 {\n y = (y << 1) | (x & 1);\n x >>= 1;\n }\n\n y\n}\n\nfn solve(io: &mut IO) -> Result<()> {\n let (a, b): (u64, u64) = (io.read(), io.read());\n let mut mp = BTreeSet::::new();\n let mut vis = BTreeSet::::new();\n mp.insert(a);\n\n while let Some(&x) = mp.iter().next() {\n if x == b {\n return writeln!(io.out, \"YES\");\n }\n\n vis.insert(x);\n mp.remove(&x);\n\n for d in 0..=1 {\n let y = transform(x, d);\n if y != 0 && !vis.contains(&y) {\n mp.insert(y);\n }\n }\n }\n return writeln!(io.out, \"NO\");\n}\n\nfn main() -> io::Result<()> {\n let mut io = IO::new();\n\n solve(&mut io)\n}\n", "lang_cluster": "Rust", "tags": ["dfs and similar", "constructive algorithms", "math", "bitmasks", "strings", "implementation"], "code_uid": "3091eaa7f03e1d18eaeb8f741c4badb3", "src_uid": "9f39a3c160087beb0efab2e3cb510e89", "difficulty": 2000.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "struct Scanner {\n reader: R,\n line: Vec,\n ptr: usize\n\n}\n\nimpl Scanner {\n fn new(reader: R) -> Self {\n Self{reader, line: vec![], ptr: 0}\n }\n\n fn scan(&mut self) -> T {\n loop {\n while self.ptr < self.line.len() && self.line[self.ptr].is_ascii_whitespace() {\n self.ptr += 1;\n }\n if self.ptr != self.line.len() {\n let start = self.ptr;\n while self.ptr < self.line.len() && !self.line[self.ptr].is_ascii_whitespace() {\n self.ptr += 1;\n }\n return std::str::from_utf8(&self.line[start..self.ptr]).unwrap().parse().ok().\n expect(\"parse error\");\n }\n self.line.clear();\n self.reader.read_until(b'\\n', &mut self.line).expect(\"read error\");\n self.ptr = 0;\n }\n }\n\n fn line(&mut self) -> Vec {\n if self.ptr == self.line.len() {\n self.line.clear();\n self.reader.read_until(b'\\n', &mut self.line).expect(\"read error\");\n self.ptr = 0;\n }\n let result = self.line[self.ptr..].to_vec();\n self.ptr = self.line.len();\n return result;\n }\n\n fn eof(&mut self) -> bool {\n loop {\n while self.ptr < self.line.len() && self.line[self.ptr].is_ascii_whitespace() {\n self.ptr += 1;\n }\n if self.ptr != self.line.len() {\n return false;\n }\n self.line.clear();\n self.ptr = 0;\n if let Ok(0) = self.reader.read_until(b'\\n', &mut self.line) {\n return true;\n }\n }\n }\n\n}\n\nfn solve(scanner: &mut Scanner, writer: &mut W) {\n let mut x: i64 = scanner.scan();\n let mut y: i64 = scanner.scan();\n if y % 2 == 0 {\n writeln!(writer, \"{}\", if x == y {\"YES\"} else {\"NO\"}).unwrap();\n return;\n }\n let mut a = Vec::new();\n while x != 0 {\n a.push(x % 2);\n x /= 2;\n }\n let mut b = Vec::new();\n while y != 0 {\n b.push(y % 2);\n y /= 2;\n }\n a.reverse();\n b.reverse();\n let mut result = false;\n let mut aa = vec![a; 3];\n aa[1].push(1);\n aa[1].reverse();\n while let Some(&0) = aa[2].last() {\n aa[2].pop();\n }\n aa[2].reverse();\n for mut a in aa {\n loop {\n for i in 0..b.len() {\n if i + a.len() > b.len() {\n break;\n }\n let mut ok = true;\n for j in 0..a.len() {\n ok &= a[j] == b[i + j];\n }\n for j in 0..i {\n ok &= b[j] == 1;\n }\n for j in i + a.len()..b.len() {\n ok &= b[j] == 1;\n }\n if ok {\n result = true;\n }\n }\n if let Some(1) = a.pop() {\n break;\n }\n while let Some(&0) = a.last() {\n a.pop();\n }\n }\n }\n writeln!(writer, \"{}\", if result {\"YES\"} else {\"NO\"}).unwrap();\n}\n\nfn main() {\n let (stdin, stdout) = (std::io::stdin(), std::io::stdout());\n let mut writer = std::io::BufWriter::new(stdout.lock());\n let mut scanner = Scanner::new(stdin.lock());\n let tests: usize = 1;\n for _ in 0..tests {\n solve(&mut scanner, &mut writer);\n }\n}\n", "lang_cluster": "Rust", "tags": ["dfs and similar", "constructive algorithms", "math", "bitmasks", "strings", "implementation"], "code_uid": "3f487c785bfce27c50dba61cb47a28c5", "src_uid": "9f39a3c160087beb0efab2e3cb510e89", "difficulty": 2000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_macros)]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n let mut next = || { iter.next().unwrap() };\n input_inner!{next, $($r)*}\n };\n ($($r:tt)*) => {\n let stdin = std::io::stdin();\n let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));\n let mut next = move || -> String{\n bytes\n .by_ref()\n .map(|r|r.unwrap() as char)\n .skip_while(|c|c.is_whitespace())\n .take_while(|c|!c.is_whitespace())\n .collect()\n };\n input_inner!{next, $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! input_inner {\n ($next:expr) => {};\n ($next:expr, ) => {};\n\n ($next:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n\n ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! read_value {\n ($next:expr, ( $($t:tt),* )) => {\n ( $(read_value!($next, $t)),* )\n };\n\n ($next:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($next, $t)).collect::>()\n };\n\n ($next:expr, chars) => {\n read_value!($next, String).chars().collect::>()\n };\n\n ($next:expr, usize1) => {\n read_value!($next, usize) - 1\n };\n\n ($next:expr, $t:ty) => {\n $next().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($a:expr),*) => {\n #[cfg(debug_assertions)]\n writeln!(&mut std::io::stderr(), concat!(\"[DEBUG] \", $(stringify!($a), \"={:?} \"),*), $($a),*);\n }\n}\n\n#[allow(unused_imports)]\nuse std::cmp::{min, max};\n\n#[allow(unused_imports)]\nuse std::io::Write;\n\nfn main() {\n input!{\n n: u64,\n }\n if n%2 == 1 {\n println!(\"{}\", 0);\n } else {\n let ans = 1 << (n/2);\n println!(\"{}\", ans);\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp"], "code_uid": "a332afb32554d65ba8a9e54ce8fd1cf3", "src_uid": "4b7ff467ed5907e32fd529fb39b708db", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "macro_rules! readln {\n () => {{\n use std::io;\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim().to_string()\n }};\n ( $t:ty ) => {{\n let input = readln!();\n input.parse::<$t>().unwrap()\n }};\n ( $( $t:ty ),+ ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n (\n $(\n input.next().unwrap().parse::<$t>().unwrap(),\n )+\n )\n }}\n}\n\nfn main() {\n let length = readln!(usize);\n\n if length % 2 == 0 {\n println!(\"{}\", 1 << (length / 2));\n } else {\n println!(\"0\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp"], "code_uid": "6c79ce2d2c4412e78cff7465085895e7", "src_uid": "4b7ff467ed5907e32fd529fb39b708db", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max,min};\n#[allow(unused_imports)]\nuse std::collections::{HashMap,HashSet,VecDeque};\n\n#[allow(unused_macros)]\nmacro_rules! readln {\n () => {{\n use std::io;\n \n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim().to_string()\n }};\n ( $t:ty ) => {{\n let input = readln!();\n input.parse::<$t>().unwrap()\n }};\n ( $( $t:ty ),+ ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n (\n $(\n input.next().unwrap().parse::<$t>().unwrap(),\n )+\n )\n }}\n}\n\n#[allow(unused_macros)]\nmacro_rules! readvec {\n ( $t:ty ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n let mut result = Vec::new();\n for elem in input {\n result.push(elem.parse::<$t>().unwrap());\n }\n result\n }}\n}\n\nfn main() {\n readln!();\n let a = readvec!(i32);\n let last = a[a.len()-1];\n if last == 0 {\n println!(\"UP\");\n } else if last == 15 {\n println!(\"DOWN\");\n } else if a.len() == 1 {\n println!(\"-1\");\n } else if a[a.len()-2] < a[a.len()-1] {\n println!(\"UP\");\n } else if a[a.len()-2] > a[a.len()-1] {\n println!(\"DOWN\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "6daddcc98f9f1fb9cb68f26bca19f5b8", "src_uid": "8330d9fea8d50a79741507b878da0a75", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main()\n{\n\tlet mut s = String::new();\n\tlet mut n = String::new();\n\tio::stdin().read_line(&mut n).unwrap();\n\tlet n = n.trim().parse::().unwrap();\n\tio::stdin().read_line(&mut s).unwrap();\n\ts = s.trim().to_string();\n\tlet val: Vec = s.split(\" \").map(|x: &str| x.parse::().unwrap()).collect();\n\n\tif let Ok(res) = match val[val.len()-1] {\n\t\t0 => Ok(\"UP\"),\n\t\t15 => Ok(\"DOWN\"),\n\t\t_ => if val.len() > 1 {\n\t\t\tmatch val[val.len()-1] - val[val.len()-2] {\n\t\t\t\t1 => Ok(\"UP\"),\n\t\t\t\t-1 => Ok(\"DOWN\"),\n\t\t\t\t_ => Err(\"invalid input\"),\n\t\t\t}\n\t\t} else {\n\t\t\tprint!(\"{}\", -1);\n\t\t\treturn;\n\t\t}\n\t} {\n\t\tprint!(\"{}\", res);\n\t}\n\telse {\n\t\tprint!(\"{}\", \"invalid input\");\n\t}\n\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "b575260e19c2730536685afdc54b682e", "src_uid": "8330d9fea8d50a79741507b878da0a75", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct FenwickTree {\n val: Vec,\n}\n\nimpl FenwickTree {\n fn new(n: usize) -> Self {\n FenwickTree {\n val: vec![0; n + 1],\n }\n }\n fn add(&mut self, mut x: usize, v: i64) {\n while let Some(p) = self.val.get_mut(x) {\n *p += v;\n x += x & (!x + 1);\n }\n }\n fn sum(&mut self, mut x: usize) -> i64 {\n assert!(x < self.val.len());\n let mut ans = 0;\n while x > 0 {\n ans += self.val[x];\n x -= x & (!x + 1);\n }\n ans\n }\n}\n\nfn sieve(n: usize) -> Vec {\n let mut is_prime = vec![true; n + 1];\n for i in 2.. {\n if i * i > n {\n break;\n }\n if is_prime[i] {\n let mut j = i * i;\n while j <= n {\n is_prime[j] = false;\n j += i;\n }\n }\n }\n let len = is_prime.iter().skip(2).filter(|p| **p).count();\n let mut prime = Vec::with_capacity(len);\n for (i, is_prime) in is_prime.into_iter().enumerate().skip(2) {\n if is_prime {\n prime.push(i as i64);\n }\n }\n prime\n}\n\nstruct PrimeCountSolver {\n query: Vec,\n memo: Vec,\n}\n\nimpl PrimeCountSolver {\n fn new() -> Self {\n PrimeCountSolver {\n query: vec![],\n memo: vec![],\n }\n }\n fn add(&mut self, n: i64) {\n self.query.push(n);\n }\n fn build(&mut self) {\n self.query.sort();\n self.query.dedup();\n let n = self.query.last().map_or(1, |n| *n);\n let mut m = 1;\n while (m + 1) * (m + 1) <= n {\n m += 1;\n }\n let p = sieve(m as usize);\n let bound = (n as f64).cbrt().powi(2) as i64 + 2;\n let mut stack = vec![];\n for &v in self.query.iter() {\n let k = match p.binary_search_by(|&p| (p * p).cmp(&v)) {\n Ok(k) => k + 1,\n Err(k) => k,\n };\n stack.push((v, k));\n }\n let mut query = vec![];\n while let Some((n, k)) = stack.pop() {\n if k == 0 {\n continue;\n }\n let q = p[k - 1];\n if q * q > n {\n let x = match p[..k].binary_search_by(|&p| (p * p).cmp(&n)) {\n Ok(k) => k + 1,\n Err(k) => k,\n };\n stack.push((n, x));\n } else if n <= bound {\n query.push((k, n));\n } else {\n stack.push((n, k - 1));\n stack.push((n / q, k - 1));\n }\n }\n query.sort();\n query.dedup();\n let m = bound as usize;\n let mut bit = FenwickTree::new(m);\n for i in 1..=m {\n bit.add(i, 1);\n }\n let mut is_prime = vec![true; m + 1];\n let mut memo = vec![0; query.len()];\n let mut pos = 0;\n for (i, p) in p.iter().enumerate() {\n let p = *p as usize;\n let mut j = p;\n while j <= m {\n if is_prime[j] {\n bit.add(j, -1);\n }\n is_prime[j] = false;\n j += p;\n }\n while let Some(&(k, n)) = query.get(pos) {\n if k > i + 1 {\n break;\n } else {\n memo[pos] = bit.sum(n as usize);\n pos += 1;\n }\n }\n if pos >= query.len() {\n break;\n }\n }\n self.memo.clear();\n self.memo.resize(self.query.len(), 0);\n let mut stack = vec![];\n for (i, &n) in self.query.iter().enumerate() {\n let k = match p.binary_search_by(|&p| (p * p).cmp(&n)) {\n Ok(k) => k + 1,\n Err(k) => k,\n };\n self.memo[i] += k as i64 - 1;\n stack.push((n, k, 1, i));\n }\n while let Some((n, k, sign, i)) = stack.pop() {\n if k == 0 {\n self.memo[i] += sign * n;\n continue;\n }\n let q = p[k - 1];\n if q * q > n {\n let x = match p[..k].binary_search_by(|p| (p * p).cmp(&n)) {\n Ok(k) => k + 1,\n Err(k) => k,\n };\n self.memo[i] += -sign * (k - x) as i64;\n stack.push((n, x, sign, i));\n } else if n <= bound {\n self.memo[i] += sign * memo[query.binary_search(&(k, n)).unwrap()];\n } else {\n stack.push((n, k - 1, sign, i));\n stack.push((n / q, k - 1, -sign, i));\n }\n }\n }\n fn get(&self, n: i64) -> i64 {\n self.memo[self.query.binary_search(&n).unwrap()]\n }\n}\n\nfn run() {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).unwrap();\n let n: i64 = s.trim().parse().unwrap();\n let p = sieve((n as f64).sqrt() as usize + 2);\n let mut ans = 0i64;\n for p in p.iter() {\n if p.pow(3) <= n {\n ans += 1;\n } else {\n break;\n }\n }\n let mut solver = PrimeCountSolver::new();\n for (i, p) in p.iter().enumerate() {\n if p.pow(2) <= n {\n ans -= i as i64 + 1;\n solver.add(n / *p);\n }\n }\n solver.build();\n for p in p.iter() {\n if p.pow(2) <= n {\n ans += solver.get(n / *p);\n }\n }\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp", "sortings", "data structures", "two pointers", "number theory"], "code_uid": "a937961db8db3b21eba06aae97af50e3", "src_uid": "ffb7762f1d60dc3f16e9b27ea0ecdd7d", "difficulty": 2400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, prelude::*};\n\n\n#[allow(unused_must_use)]\n#[allow(unused_assignments)]\n#[allow(unused_variables)]\nfn solve(mut scan: Scanner, mut w: W) {\n let sum = scan.token::();\n let mut s: Vec = Vec::new();\n for n in sum.split('+') {\n s.push(n.parse().unwrap());\n }\n s.sort();\n let mut ans = vector_to_str(&s, \"+\");\n ans.pop();\n writeln!(w, \"{}\", ans);\n}\n \nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let reader = Scanner::new(stdin.lock());\n let writer = io::BufWriter::new(stdout.lock());\n solve(reader, writer);\n}\n#[allow(dead_code)]\nfn vector_to_str(vector: &Vec, separator: &str) -> String { \n use std::fmt::Write;\n let mut ans = String::new();\n for line in vector.iter() {\n write!(&mut ans, \"{}{}\", line.to_string(), separator).unwrap();\n }\n ans\n}\n#[allow(dead_code)]\nfn matrix_to_str(matrix: &Vec>, separator: &str) -> String { \n use std::fmt::Write;\n let mut ans = String::new();\n for line in matrix.iter() {\n for elem in line.iter() {\n write!(&mut ans, \"{}{}\", elem.to_string(), separator).unwrap();\n }\n write!(&mut ans, \"\\n\").unwrap();\n }\n ans\n}\npub struct Scanner {\n reader: B,\n buf_str: Vec,\n buf_iter: std::str::SplitWhitespace<'static>,\n}\nimpl Scanner {\n pub fn new(reader: B) -> Self {\n Self {\n reader,\n buf_str: Vec::new(),\n buf_iter: \"\".split_whitespace()\n }\n }\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buf_iter.next() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n self.buf_str.clear();\n self.reader.read_until(b'\\n', &mut self.buf_str).expect(\"Failed read\");\n self.buf_iter = unsafe {\n let slice = std::str::from_utf8_unchecked(&self.buf_str);\n std::mem::transmute(slice.split_whitespace()) }\n }\n }\n pub fn get_matrix(&mut self, m: usize, n: usize) -> Vec> {\n // m rows and n columns\n let mut ans: Vec> = Vec::with_capacity(m);\n for i in 0..m {\n ans.push(Vec::with_capacity(n));\n for _ in 0..n {\n ans[i].push(self.token::());\n }\n }\n ans\n }\n pub fn get_vector(&mut self, n: usize) -> Vec {\n let mut ans: Vec = Vec::with_capacity(n);\n for _ in 0..n {\n ans.push(self.token::());\n }\n ans\n }\n}\n", "lang_cluster": "Rust", "tags": ["sortings", "strings", "implementation", "greedy"], "code_uid": "f410275f2059f3901a5104dbb7bfb2e4", "src_uid": "76c7312733ef9d8278521cf09d3ccbc8", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\nfn main() {\n let mut inp = String::new();\n stdin().read_line(&mut inp).expect(\"msg: &str\");\n let mut inp = inp.trim();\n let mut a: Vec = inp\n .split(\"+\")\n .collect::>()\n .iter()\n .map(|e| e.parse::().unwrap())\n .collect();\n a.sort();\n let a: Vec = a.iter().map(|e| format!(\"{}\", e)).collect();\n println!(\"{}\", a.join(\"+\"));\n}\n", "lang_cluster": "Rust", "tags": ["sortings", "strings", "implementation", "greedy"], "code_uid": "35bd59bac143f6a127e9c7e511d65825", "src_uid": "76c7312733ef9d8278521cf09d3ccbc8", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\n#[allow(unused_imports)]\nuse std::io::{self,Read};\n\nstruct WordReader {\n it : std::vec::IntoIter,\n}\n#[allow(dead_code)]\nimpl WordReader {\n fn new(mut reader : T) -> WordReader {\n let mut s = String::new();\n reader.read_to_string(&mut s).unwrap();\n WordReader { it : s\n .split_ascii_whitespace()\n .map(String::from).collect::>()\n .into_iter()\n }\n }\n fn from_stdin() -> WordReader {\n WordReader::new(std::io::stdin())\n }\n fn s(&mut self) -> String {\n self.it.next().unwrap()\n }\n fn ab(&mut self) -> Vec {\n self.it.next().unwrap().into_bytes()\n }\n fn i(&mut self) -> i32 {\n self.it.next().unwrap().parse().unwrap()\n }\n}\n\nfn main() {\n let mut input = WordReader::from_stdin();\n if input.s() == input.s().chars().rev().collect::() {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "1d6c17dabb3495df23387dbb43b6ff9c", "src_uid": "35a4be326690b58bf9add547fb63a5a5", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused)] use std::io::*;\n#[allow(unused)] use std::collections::*;\n#[allow(unused)] use std::mem::*;\n#[allow(unused)] use std::num::*;\n#[allow(unused)] use std::cmp::*;\n#[allow(unused)] fn strarr() -> Vec {\n let mut inp = String::new();\n stdin().read_line(&mut inp).ok();\n inp.split(' ').map(|x| x.trim()).filter(|x| x.len() != 0).map(|x| x.to_string()).collect() }\n#[allow(unused)] macro_rules! scan { ($($x:ty), +) => {{\n let s = strarr(); let mut cnt : usize = 0;\n fn next(cnt: &mut usize, p: &Vec) -> T\n where T:std::str::FromStr\n { *cnt += 1; p[*cnt-1].parse().ok().unwrap() }\n ($(next::<$x>(&mut cnt, &s)), +)\n }}; }\n#[allow(unused)] macro_rules! arr { ($n:expr, $T:ty) => {{\n let mut s = strarr(); let mut v = Vec::new();\n for i in 0..$n { v.push(s[i as usize].parse::<$T>().unwrap()); } v\n }}; }\n\n///////////////////////////////////////////////////////////////////////////////\n\nfn main()\n{\n let s = scan!(String);\n let t = scan!(String);\n println!(\"{}\", if s.chars().rev().collect::>() == t.chars().collect::>() { \"YES\" } else { \"NO\" });\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "33fed4a06f7a14e95dbbe1be79dfb0d7", "src_uid": "35a4be326690b58bf9add547fb63a5a5", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut input = String::new();\n\n std::io::stdin().read_line(&mut input).expect(\"INPUT::Read line failed!\");\n\n let number = input.trim().parse::().expect(\"NUMBER::Parse to i32 failed!\");\n\n if number % 2 == 0 {\n println!(\"Mahmoud\");\n }else {\n println!(\"Ehab\");\n }\n}", "lang_cluster": "Rust", "tags": ["math", "games"], "code_uid": "f64ad38c9042529ca00b01352465ce50", "src_uid": "5e74750f44142624e6da41d4b35beb9a", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\n#[allow(unused_macros)]\nmacro_rules! a {\n ($c: tt, $x: expr, $y: expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\nuse std::io::*;\nuse std::str::*;\nuse std::fmt::Debug;\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a>, }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).unwrap();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn u(&mut self) -> usize { self.p() }\n fn vi(&mut self, n: usize) -> Vec {\n self.vp::(n)\n }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n println!(\"{}\", [\"Mahmoud\",\"Ehab\"][input.u() % 2]);\n}\n\n", "lang_cluster": "Rust", "tags": ["math", "games"], "code_uid": "7b27e305f50de547f116d7ab89e633aa", "src_uid": "5e74750f44142624e6da41d4b35beb9a", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut input = String::new();\n use std::io;\n use std::io::prelude::*;\n io::stdin().read_to_string(&mut input).unwrap();\n\n let mut it = input.split_whitespace();\n\n it.next().unwrap();\n\n let a: Vec = it.map(|x| x.parse().unwrap()).collect();\n\n let ans: i32 = a.into_iter().map(|x| x.abs()).sum();\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["greedy"], "code_uid": "edb6fe9a1f60f18474bcfc423c6a67d4", "src_uid": "4b5d14833f9b51bfd336cc0e661243a5", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n// \u3053\u3053\u307e\u3067\n\nfn run() {\n input! {\n n: usize,\n a: [i32; n],\n }\n let mut ans = 0;\n for a in a {\n ans += a.abs();\n }\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["greedy"], "code_uid": "3ae291c3488f55a34c72ccf2cb615b57", "src_uid": "4b5d14833f9b51bfd336cc0e661243a5", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn read_int_line () -> i32 {\n let mut num = String::new();\n io::stdin().read_line(&mut num)\n .expect(\"Failed to read line\");\n \n num.trim().parse()\n .expect(\"Not an integer\")\n}\n\nfn main() {\n\n\tread_int_line();\n\n\tlet mut string = String::new();\n\tio::stdin().read_line(&mut string)\n\t\t.expect(\"Failed to read line\");\n\n\n\tlet v: Vec<&str> = string.split(char::is_uppercase).collect();\n\tlet mut maximum: i32 = 0;\n\n\tfor s in v {\n\t\tlet mut vi: Vec = s.trim().chars().collect();\n\t\tvi.sort();\n\t\tvi.dedup();\n\t\tlet temp: i32 = vi.len() as i32;\n\t\tif maximum < temp {\n\t\t\t// println!(\"{:?}, {:?}\", s.trim(), temp);\n\t\t\tmaximum = temp;\n\t\t}\n\t}\n\tprintln!(\"{}\", maximum);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "strings", "implementation"], "code_uid": "72b760a3b1f822a32a2c627434674480", "src_uid": "567ce65f87d2fb922b0f7e0957fbada3", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused)] use std::io::*;\n#[allow(unused)] use std::collections::*;\n#[allow(unused)] use std::mem::*;\n#[allow(unused)] use std::num::*;\n#[allow(unused)] use std::cmp::*;\n#[allow(unused)] fn strarr() -> Vec {\n let mut inp = String::new();\n stdin().read_line(&mut inp).ok();\n inp.split(' ').map(|x| x.trim()).filter(|x| x.len() != 0).map(|x| x.to_string()).collect() }\n#[allow(unused)] macro_rules! scan { ($($x:ty), +) => {{\n let s = strarr(); let mut cnt : usize = 0;\n fn next(cnt: &mut usize, p: &Vec) -> T\n where T:std::str::FromStr\n { *cnt += 1; p[*cnt-1].parse().ok().unwrap() }\n ($(next::<$x>(&mut cnt, &s)), +)\n }}; }\n#[allow(unused)] macro_rules! arr { ($n:expr, $T:ty) => {{\n let mut s = strarr(); let mut v = Vec::new();\n for i in 0..$n { v.push(s[i as usize].parse::<$T>().unwrap()); } v\n }}; }\n\n///////////////////////////////////////////////////////////////////////////////\n\nfn main()\n{\n let s = scan!(String);\n let c1 = s.chars().filter(|x| x.is_lowercase()).count();\n let c2 = s.chars().nth(0).unwrap().is_lowercase();\n if c1 == 0 || (c1 == 1 && c2 == true) {\n for i in s.chars() {\n print!(\"{}\", if i.is_lowercase() { i.to_uppercase().nth(0).unwrap() } else { i.to_lowercase().nth(0).unwrap() });\n }\n } else {\n print!(\"{}\", s);\n }\n \n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "a041c481e8a4521cba7442101e9f3f21", "src_uid": "db0eb44d8cd8f293da407ba3adee10cf", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line);\n let line = line.trim();\n let s0 = line.to_string().to_uppercase();\n let ss = s0.as_str();\n let s1 = (&ss[0..1]).to_string().to_lowercase() + &s0[1..];\n \n let s2 = line.to_string().to_lowercase();\n let s3 = (&ss[0..1]).to_string().to_uppercase() + &s2[1..];\n\n if s0.eq(line) {\n println!(\"{}\", s2);\n } else if s1.eq(line) {\n println!(\"{}\", s3);\n } else {\n println!(\"{}\", line);\n }\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "45ce1612d740ae06047d2a4840f478c9", "src_uid": "db0eb44d8cd8f293da407ba3adee10cf", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rusT {{{\nuse std::io::*; use std::str::{self,*}; use std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::{self,*};\n#[allow(unused_imports)] use std::ops::{self,*};\n#[allow(unused_imports)] use std::iter::{self,*};\n#[allow(unused_imports)] use std::collections::*;\n#[allow(unused_imports)] use std::cell::*;\n#[allow(unused_macros)] macro_rules! min {\n\t($x:expr,$y:expr) => {{ let b=$y; let a=&mut$x; if b < *a {*a=b; true} else {false} }};\n}\n#[allow(unused_macros)] macro_rules! max {\n\t($x:expr,$y:expr) => {{ let b=$y; let a=&mut$x; if b > *a {*a=b; true} else {false} }};\n}\n#[allow(unused_macros)] macro_rules! l {\n\t($($v:ident),+ =$e:expr) => {$(let$v=$e;)+};\n\t($($v:ident),+:$t:ty=$e:expr) => {$(let$v:$t=$e;)+};\n\t(mut $($v:ident),+ =$e:expr) => {$(let mut$v=$e;)+};\n\t(mut $($v:ident),+:$t:ty=$e:expr) => {$(let mut$v:$t=$e;)+};\n}\n#[allow(unused_macros)] macro_rules! v {\n\t([$d:expr]$($s:tt)+) => {vec![v!($($s)+);$d]};\n\t([]) => {Vec::new()}; ([$e:expr]) => {Vec::with_capacity($e)}; (=$e:expr) => {$e};\n}\n#[allow(unused_macros)] macro_rules! rep { {[$c:expr]$($s:tt)+} => {for _ in 0..$c {$($s)+}} }\n#[allow(dead_code)] fn reader() -> WordReaderC { WordReaderC::new() }\n#[allow(dead_code)] fn writer() -> BufWriter { BufWriter::new(stdout()) }\nstruct WordReaderC {buf: Vec, pos: usize, q: std::io::StdinLock<'static>}//'\n#[allow(dead_code)] impl WordReaderC {\n\tfn new() -> Self {\n\t\tlet r = unsafe {&*Box::into_raw(Box::new(stdin()))};\n\t\tSelf { q: r.lock(), buf: v!([]), pos: 0 }\n\t}\n\tfn next_line(&mut self) -> bool {\n\t\tself.buf.clear(); self.pos = 0;\n\t\tself.q.read_until(b'\\n', &mut self.buf).unwrap_or(0) > 0\n\t}\n\tfn is_ws(c: u8) -> bool {\n\t\tc == b' ' || c == b'\\r' || c == b'\\n' || c == b'\\t'\n\t}\n\tfn byte(&mut self) -> Option {\n\t\tif self.pos == self.buf.len() { if !self.next_line() { return None; } }\n\t\tself.pos += 1; Some(self.buf[self.pos - 1])\n\t}\n\tfn vb(&mut self) -> Vec {\n\t\tlet mut s = v!([8]);\n\t\tlet mut f = false;\n\t\tloop {\n\t\t\tif let Some(c) = self.byte() {\n\t\t\t\tif !Self::is_ws(c) {\n\t\t\t\t\ts.push(c);\n\t\t\t\t\tf = true;\n\t\t\t\t} else if f { break; }\n\t\t\t} else { break; }\n\t\t}\n\t\ts\n\t}\n\tfn vvb(&mut self, r: usize, c: Option) -> Vec> {\n\t\tlet mut res = v!([r]);\n\t\tlet c = c.unwrap_or(0);\n\t\trep!{[r]\n\t\t\tlet t = self.vb();\n\t\t\tassert!(c == 0 || t.len() == c);\n\t\t\tres.push(t);\n\t\t}\n\t\tres\n\t}\n\tfn s(&mut self) -> String { String::from_utf8(self.vb()).expect(\"invalid utf8\") }\n\tfn i(&mut self) -> i32 { self.p() }\n\tfn l(&mut self) -> i64 { self.p() }\n\tfn u(&mut self) -> usize { self.p() }\n\tfn f(&mut self) -> f64 { self.p() }\n\tfn vi(&mut self, n: usize) -> Vec { self.vp(n) }\n\tfn vl(&mut self, n: usize) -> Vec { self.vp(n) }\n\tfn vu(&mut self, n: usize) -> Vec { self.vp(n) }\n\tfn ii(&mut self, n: usize) -> impl Iterator { self.ip(n).into_iter() }\n\tfn iu(&mut self, n: usize) -> impl Iterator { self.ip(n).into_iter() }\n\tfn p(&mut self) -> T where T::Err: Debug {\n\t\tlet w = self.vb(); str::from_utf8(w.as_ref()).unwrap().parse::().unwrap()\n\t}\n\tfn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n\t\t(0..n).map(|_|self.p()).collect()\n\t}\n\tfn ip(&mut self, n: usize) -> impl Iterator where T::Err: Debug {\n\t\tself.vp(n).into_iter()\n\t}\n\tfn graph(&mut self, n: usize, m: usize) -> Vec> {\n\t\tlet mut e = v!([n][]); rep!{[m] l!(a,b = self.u()-1); e[a].push(b); e[b].push(a); } e\n\t}\n\tfn graph_w(&mut self, n: usize, m: usize) -> Vec> where T::Err: Debug {\n\t\tlet mut e = v!([n][]); rep!{[m] l!(a,b = self.u()-1); let c: T = self.p(); e[a].push((b,c)); e[b].push((a,c)); } e\n\t}\n}\n//------------------- End rusT }}}\n\n// Field (mod prime) {{{\nmod field {\n\tuse std::ops::*;\n\t#[allow(dead_code)] pub const Z0: Field = Field(0);\n\t#[allow(dead_code)] pub const Z1: Field = Field(1);\n\tconst P5: i32 = 1_000_000_007;\n\tconst P6: i64 = P5 as i64;\n\t#[derive(Debug,Clone,Copy,PartialEq,Eq,PartialOrd,Ord,Default)] pub struct Field(i32);\n\t#[allow(dead_code)] impl Field {\n\t\tpub fn new>(a: T) -> Self { Self(Self::cv(a)) }\n\t\tpub fn new_unchecked(a: i32) -> Self { Self(a) }\n\t\tfn hi(mut a: i32) -> i32 { if a >= P5 { a -= P5; } a }\n\t\tfn lo(mut a: i32) -> i32 { if a < 0 { a += P5; } a }\n\t\tfn cv>(a: T) -> i32 { Self::lo((a.into() % P6) as i32) }\n\t\tpub fn inv(self) -> Self { self.pow(P5-2) }\n\t\tpub fn pow>(self, b: T) -> Self {\n\t\t\tlet b = b.into(); if b == 0 { Self(1) } else {\n\t\t\t\tlet mut res = self.pow(b/2); res *= res; if b % 2 == 1 {res *= self;} res\n\t\t\t}\n\t\t}\n\t}\n\timpl Add for Field { type Output = Self; fn add(self, a: Self) -> Self::Output { Self(Self::hi(self.0 + a.0)) }}\n\timpl Sub for Field { type Output = Self; fn sub(self, a: Self) -> Self::Output { Self(Self::lo(self.0 - a.0)) }}\n\timpl Mul for Field { type Output = Self; fn mul(self, a: Self) -> Self::Output { Self(Self::cv(self.0 as i64 * a.0 as i64)) }}\n\timpl Div for Field { type Output = Self; fn div(self, a: Self) -> Self::Output { self * a.inv() }}\n\timpl Neg for Field { type Output = Self; fn neg(self) -> Self::Output { Self(Self::lo(-self.0)) }}\n\timpl AddAssign for Field { fn add_assign(&mut self, a: Self) { *self = *self + a; } }\n\timpl SubAssign for Field { fn sub_assign(&mut self, a: Self) { *self = *self - a; } }\n\timpl MulAssign for Field { fn mul_assign(&mut self, a: Self) { *self = *self * a; } }\n\timpl DivAssign for Field { fn div_assign(&mut self, a: Self) { *self = *self / a; } }\n\tuse std::fmt::{Display, Formatter, Result};\n\timpl Display for Field { fn fmt(&self, f: &mut Formatter) -> Result { write!(f, \"{}\", self.0) } }\n}\n#[allow(unused_imports)] use field::{Field, Field as Z, Z0, Z1};\n//}}}\n// Binomial Coefficient (C(n,r)) {{{\n#[derive(Debug,Clone)]\nstruct Cnr {\n\tn: usize,\n\tpub f: Box<[Field]>,\n\tfi: Box<[Field]>\n}\n#[allow(dead_code)]\nimpl Cnr {\n\tfn new(n: usize) -> Self {\n\t\tlet mut f = Vec::with_capacity(n+1);\n\t\tf.push(Z1);\n\t\tfor i in 1..=n {\n\t\t\tf.push(f[i-1] * Field::new(i as i32));\n\t\t}\n\t\tlet mut fi = vec![Z1; n+1];\n\t\tfi[n] = f[n].inv();\n\t\tfor i in (0..n).rev() {\n\t\t\tfi[i] = fi[i+1] * Field::new(i as i32 + 1);\n\t\t}\n\t\tlet f = f.into_boxed_slice();\n\t\tlet fi = fi.into_boxed_slice();\n\t\tSelf {n, f, fi}\n\t}\n\tfn cnr(&self, n: usize, r: usize) -> Field {\n\t\tif r > n {\n\t\t\tZ0\n\t\t} else {\n\t\t\tself.f[n] * self.fi[r] * self.fi[n-r]\n\t\t}\n\t}\n}//}}}\n\nfn main() {\n\tlet mut rin = reader();\n\tlet mut rout = writer();\n\n\tl!(n,x,p = rin.u());\n\tlet x = x-1;\n\tlet mut lo = 0;\n\tlet mut hi = n;\n\tl!(mut lo_fix,hi_fix = 0);\n\twhile lo < hi {\n\t\tlet mid = (lo + hi) / 2;\n\t\tif mid == p {\n\t\t\tlo = mid + 1;\n\t\t} else if mid < p {\n\t\t\tlo_fix += 1;\n\t\t\tlo = mid + 1;\n\t\t} else {\n\t\t\thi_fix += 1;\n\t\t\thi = mid;\n\t\t}\n\t}\n\n\tlet f = Cnr::new(n);\n\tlet sol = f.cnr(x, lo_fix) * f.f[lo_fix] * f.cnr(n-1-x, hi_fix) * f.f[hi_fix] * f.f[n - hi_fix - lo_fix - 1];\n\twriteln!(rout, \"{}\", sol).ok();\n}\n", "lang_cluster": "Rust", "tags": ["binary search", "combinatorics"], "code_uid": "a4c67328e1f8213a63d5b5611318c801", "src_uid": "24e2f10463f440affccc2755f4462d8a", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::fmt::Debug;\nuse std::str::FromStr;\n\npub struct TokenReader {\n reader: std::io::Stdin,\n tokens: Vec,\n index: usize,\n}\n\nimpl TokenReader {\n pub fn new() -> Self {\n Self {\n reader: std::io::stdin(),\n tokens: Vec::new(),\n index: 0,\n }\n }\n\n pub fn next(&mut self) -> T\n where\n T: FromStr,\n T::Err: Debug,\n {\n if self.index >= self.tokens.len() {\n self.load_next_line();\n }\n self.index += 1;\n self.tokens[self.index - 1].parse().unwrap()\n }\n\n pub fn vector(&mut self) -> Vec\n where\n T: FromStr,\n T::Err: Debug,\n {\n if self.index >= self.tokens.len() {\n self.load_next_line();\n }\n self.index = self.tokens.len();\n self.tokens.iter().map(|tok| tok.parse().unwrap()).collect()\n }\n\n pub fn load_next_line(&mut self) {\n let mut line = String::new();\n self.reader.read_line(&mut line).unwrap();\n\n self.tokens = line\n .split_whitespace()\n .map(String::from)\n .collect();\n self.index = 0;\n }\n}\n\nconst MOD: i64 = 1e9 as i64 + 7;\n\nfn count_needed(n: i64, pos: i64) -> (i64, i64) {\n let mut l = 0;\n let mut r = n;\n\n let mut smaller = 0;\n let mut greater = 0;\n\n while l < r {\n let m = (l + r) / 2;\n if m < pos {\n smaller += 1;\n l = m + 1;\n } else if m > pos {\n greater += 1;\n r = m;\n } else {\n l = m + 1;\n }\n }\n (smaller, greater)\n}\n\nfn factorial(n: i64) -> i64 {\n let mut res = 1;\n for i in 2..=n {\n res = (res * i) % MOD;\n }\n res\n}\n\nfn permutations(n: i64) -> i64 {\n factorial(n)\n}\n\nfn euclid(a: i64, b: i64) -> (i64, i64) {\n if b == 0 {\n (1, 0)\n } else {\n let (x, y) = euclid(b, a % b);\n (y, x - a / b * y)\n }\n}\n\nfn mod_inv(num: i64) -> i64 {\n let mut inv = euclid(num, MOD).0;\n while inv < 0 {\n inv += MOD;\n }\n inv\n}\n\nfn arrangements(n: i64, k: i64) -> i64 {\n factorial(n) * mod_inv(factorial(n - k)) % MOD\n}\n\nfn solve(n: i64, x: i64, pos: i64) -> i64 {\n let (smaller, greater) = count_needed(n, pos);\n if smaller >= x || greater > (n - x) {\n return 0;\n }\n\n arrangements(x - 1, smaller)\n * arrangements(n - x, greater) % MOD\n * permutations(n - 1 - smaller - greater) % MOD\n\n}\n\nfn main() {\n let mut reader = TokenReader::new();\n let n = reader.next();\n let x = reader.next();\n let pos = reader.next();\n\n let res = solve(n, x, pos);\n println!(\"{}\", res);\n}\n", "lang_cluster": "Rust", "tags": ["binary search", "combinatorics"], "code_uid": "2112b343a181022066c7b16967524b22", "src_uid": "24e2f10463f440affccc2755f4462d8a", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str;\n\npub struct Scanner {\n reader: R,\n buffer: Vec,\n}\n\nimpl Scanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buffer: vec![],\n }\n }\n\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn count_prime_factors(n: i32) -> i32 {\n let mut count = 0;\n let mut factor = 2;\n let mut n = n;\n while factor * factor <= n {\n let mut expo = 0;\n while n % factor == 0 {\n n /= factor;\n expo += 1;\n }\n if expo >= 1 {\n count += 1;\n }\n factor += 1;\n }\n if n > 1 {\n count += 1;\n }\n count\n}\n\nfn solve(scan: &mut Scanner, out: &mut W) {\n let n: i32 = scan.token();\n let mut ans = 0;\n for i in 1..=n {\n let count = count_prime_factors(i);\n if count == 2 {\n ans += 1;\n }\n }\n writeln!(out, \"{}\", ans).ok();\n}\n\nfn main() {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout.lock());\n solve(&mut scan, &mut out);\n}\n", "lang_cluster": "Rust", "tags": ["number theory"], "code_uid": "fb0ea88b7076a32d308e774db5bbf496", "src_uid": "356666366625bc5358bc8b97c8d67bd5", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\nuse std::io::*;\nuse std::str::*;\nuse std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::*;\n#[allow(unused_imports)] use std::collections::*;\n\n#[allow(unused_macros)]\nmacro_rules! a {\n ($c: tt, $x: expr, $y: expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a>, }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).unwrap();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn u(&mut self) -> usize { self.p() }\n fn vi(&mut self, n: usize) -> Vec {\n self.vp::(n)\n }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n\n#[allow(dead_code)]\nfn build_counting_hashmap(i: T) -> HashMap\n where T: Iterator {\n let mut m = HashMap::new();\n for k in i {\n let n = 1 + if let Some(&n) = m.get(&k) { n } else { 0 };\n m.insert(k, n);\n }\n m\n}\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n let res = input.bs().iter().fold(0, |a,&x| match (a,x - b'0') {\n (0...2,1) => 2,\n (y@1...2,4) => y - 1,\n _ => -1,\n }) >= 0;\n if res {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n\n", "lang_cluster": "Rust", "tags": ["brute force", "greedy"], "code_uid": "979813ad40dd7ceba1f31c0bd3488bb8", "src_uid": "3153cfddae27fbd817caaf2cb7a6a4b5", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let s = get_input();\n if is_magic_number(s) {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n \n}\n\nfn is_magic_number(s: String) -> bool {\n if !s.starts_with(\"1\") {\n false\n } else {\n let mut four_count = 0;\n for c in s.chars() {\n if c == '1' {\n four_count = 0;\n } else if c == '4' {\n four_count += 1;\n if four_count > 2 {\n return false;\n }\n } else {\n return false;\n }\n }\n\n true\n }\n}\n\nfn get_input() -> String {\n let mut buffer = String::new();\n std::io::stdin().read_line(&mut buffer).expect(\"Failed\");\n buffer.trim().to_owned()\n}\n\nfn get_input_usize() -> usize {\n get_input().parse().unwrap()\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "greedy"], "code_uid": "98f7029cdb40516b09214c356c1a201b", "src_uid": "3153cfddae27fbd817caaf2cb7a6a4b5", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "\n#![allow(unused_imports)]\nuse std::io;\nuse std::io::prelude::*;\nuse std::io::BufReader;\nuse std::str::FromStr;\n\nfn main() {\n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n let num_squares = get_numbers(&input)[0];\n input.clear();\n io::stdin().read_line(&mut input).unwrap();\n let squares: Vec = input.chars().collect();\n\n let mut numbers = Vec::new();\n let mut n = 0;\n for i in 0..num_squares {\n if squares[i] == 'B' {\n n += 1;\n } else if n > 0 {\n numbers.push(n);\n n = 0;\n }\n }\n if n > 0 {\n numbers.push(n);\n }\n\n if numbers.len() == 0 {\n println!(\"{}\", 0);\n return;\n }\n println!(\"{}\", numbers.len());\n if numbers.len() == 1 {\n println!(\"{}\", numbers[0]);\n return;\n }\n\n for i in 0..(numbers.len()-1) {\n print!(\"{} \", numbers[i])\n }\n println!(\"{}\", numbers[numbers.len()-1]);\n}\n\n// get numbers from line seperated by spaces\nfn get_numbers(line: &str) -> Vec\n where T: FromStr,\n ::Err: std::fmt::Debug,\n{\n line.split_whitespace()\n .map(|chunk| chunk.parse::().expect(\"failed to parse\"))\n .collect()\n}\n\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "27e6584aed8fc2317e0fca3b711122e6", "src_uid": "e4b3a2707ba080b93a152f4e6e983973", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::*;\n#[allow(unused_imports)]\nuse std::collections::*;\nuse std::io::{Write, BufWriter};\n// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\nmacro_rules! input {\n ($($r:tt)*) => {\n let stdin = std::io::stdin();\n let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));\n let mut next = move || -> String{\n bytes\n .by_ref()\n .map(|r|r.unwrap() as char)\n .skip_while(|c|c.is_whitespace())\n .take_while(|c|!c.is_whitespace())\n .collect()\n };\n input_inner!{next, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($next:expr) => {};\n ($next:expr, ) => {};\n\n ($next:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($next:expr, ( $($t:tt),* )) => {\n ( $(read_value!($next, $t)),* )\n };\n\n ($next:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($next, $t)).collect::>()\n };\n\n ($next:expr, chars) => {\n read_value!($next, String).chars().collect::>()\n };\n\n ($next:expr, usize1) => {\n read_value!($next, usize) - 1\n };\n\n ($next:expr, [ $t:tt ]) => {{\n let len = read_value!($next, usize);\n (0..len).map(|_| read_value!($next, $t)).collect::>()\n }};\n\n ($next:expr, $t:ty) => {\n $next().parse::<$t>().expect(\"Parse error\")\n };\n}\n\nfn solve() {\n let out = std::io::stdout();\n let mut out = BufWriter::new(out.lock());\n macro_rules! puts {\n ($($format:tt)*) => (write!(out,$($format)*).unwrap());\n }\n input! {\n x: [i32; 3],\n a: [i32; 3],\n }\n let mut c = 0;\n for i in 0..3 {\n c += a[i];\n if x[i] > c {\n puts!(\"NO\\n\");\n return;\n }\n c -= x[i];\n }\n puts!(\"YES\\n\");\n \n}\n\nfn main() {\n // In order to avoid potential stack overflow, spawn a new thread.\n let stack_size = 104_857_600; // 100 MB\n let thd = std::thread::Builder::new().stack_size(stack_size);\n thd.spawn(|| solve()).unwrap().join().unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "greedy", "implementation"], "code_uid": "129f132db328b747fbc8941522c7b7a7", "src_uid": "d54201591f7284da5e9ce18984439f4e", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "macro_rules! readln {\n () => {{\n use std::io;\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim().to_string()\n }};\n ( $t:ty ) => {{\n let input = readln!();\n input.parse::<$t>().unwrap()\n }};\n ( $( $t:ty ),+ ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n (\n $(\n input.next().unwrap().parse::<$t>().unwrap(),\n )+\n )\n }}\n}\n\nfn main() {\n let (mut x, mut y, mut z) = readln!(i32, i32, i32);\n let (mut a, mut b, mut c) = readln!(i32, i32, i32);\n \n let mut ans = solve(x, y, z, a, b, c);\n println!(\"{}\", [\"YES\", \"NO\"][ans]);\n}\n\nfn solve(x: i32, y: i32, z: i32, a: i32, b: i32, c: i32) -> usize {\n if x > a || x + y > a + b || x + y + z > a + b + c {\n 1\n } else {\n 0\n }\n}\n\n", "lang_cluster": "Rust", "tags": ["brute force", "greedy", "implementation"], "code_uid": "f0f91f7599f3dcf1e50e5ebf5e49b659", "src_uid": "d54201591f7284da5e9ce18984439f4e", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::collections::HashMap;\nuse std::io::{self, BufRead};\nfn main() {\n let mut line = \"\".to_string();\n let stdin = io::stdin();\n stdin.lock().read_line(&mut line).unwrap();\n let (_, limit) = if let [Ok(a), Ok(b)] = &line\n .split_whitespace()\n .map(|s| s.parse::())\n .collect::>()[..]\n {\n (*a, *b)\n } else {\n (0, 0)\n };\n line.clear();\n stdin.lock().read_line(&mut line).unwrap();\n if line\n .bytes()\n .fold(&mut HashMap::new(), |map, s| {\n *map.entry(s).or_insert(0) += 1;\n map\n })\n .iter()\n .filter(|(_, &cnt)| cnt > limit)\n .count()\n > 0\n {\n println!(\"NO\");\n } else {\n println!(\"YES\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "ee5e88c1a59edba28cd32db07dc22654", "src_uid": "ceb3807aaffef60bcdbcc9a17a1391be", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\nuse std::io::{self, BufRead};\nuse std::cmp::*;\nuse std::collections::*;\n\nmacro_rules! scan_to_vec {\n ($count:expr, $t:ty) => ({\n let mut result = Vec::new();\n let stdin = io::stdin();\n let mut handle = stdin.lock();\n\n for _ in 0..$count {\n let mut buffer = String::new();\n handle.read_line(&mut buffer)\n .expect(\"scan_to_vec: failed at `handle.read_line`.\");\n result.push(buffer.trim().parse::<$t>()\n .expect(\"scan_to_vec: failed at `parse::<$t>`.\"));\n }\n result\n })\n}\n\nmacro_rules! scan_line_to_vec {\n ($t:ty) => ({\n let mut result = Vec::new();\n let stdin = io::stdin();\n let mut handle = stdin.lock();\n handle.read_line(&mut buffer)\n .expect(\"scan_line_to_vec: failed at `handle.read_line`.\");\n \n for s in chunks.split_whitespace() {\n result.push(s.parse::<$t>()\n .expect(\"scan_line_to_vec: failed at `parse::<$t>`.\"));\n }\n result\n })\n}\n\nmacro_rules! scan_line {\n () => ({\n let stdin = io::stdin();\n let mut handle = stdin.lock();\n let mut buffer = String::new();\n handle.read_line(&mut buffer)\n .expect(\"scan_line: failed at `handle.read_line`.\");\n buffer\n });\n ( $($t:ty)+ ) => ({\n let stdin = io::stdin();\n let mut handle = stdin.lock();\n let mut buffer = String::new();\n handle.read_line(&mut buffer)\n .expect(\"scan_line: failed at `handle.read_line`.\");\n let mut chunks = buffer.split_whitespace();\n\n ($(\n {\n chunks.next()\n .expect(\"scan_line: failed at `next`, # of space separated strings not equal to requested #\")\n .parse::<$t>()\n .expect(\"scan_line: failed at `parse::<$t>`.\")\n },\n )+)\n })\n}\n\nfn main() {\n let (n, k) = scan_line!(i32 i32);\n let colors = scan_line!();\n let mut color_counts = vec![0; 256];\n\n let mut result = true;\n for c in colors.bytes() {\n color_counts[c as usize] += 1;\n }\n\n for c in color_counts {\n if c > k {\n result = false;\n break;\n }\n }\n\n if result {\n println!(\"YES\")\n } else {\n println!(\"NO\")\n }\n}", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "5fdd80f206afe562585afb0296087d1f", "src_uid": "ceb3807aaffef60bcdbcc9a17a1391be", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::io::BufRead;\n\nfn main() {\n let mut buf = String::new();\n let stdin = io::stdin();\n stdin.read_line(&mut buf).unwrap();\n let n: u32 = buf.trim().parse().unwrap();\n for k in 0..n {\n buf.clear();\n stdin.read_line(&mut buf).unwrap();\n let x: u32 = buf.trim().parse().unwrap();\n let b = x / 7;\n let a = (x % 7) % 3;\n if a == 0 || b >= (3 - a) {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n }\n}", "lang_cluster": "Rust", "tags": ["greedy", "implementation"], "code_uid": "ffc8b9200047cc585af4761ee86aad7f", "src_uid": "cfd1182be98fb5f0c426f8b68e48d452", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n// \u3053\u3053\u307e\u3067\n\nfn run() {\n input! {\n n: u64,\n }\n let ans = (n * (n + 1) / 2) % 2;\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "0d110b7d4acb618ccd19ce31fa24316f", "src_uid": "fa163c5b619d3892e33e1fb9c22043a9", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let n: u64 = scan.next();\n let result = (n * (n + 1) / 2) % 2;\n println!(\"{}\", result);\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "fee6b4d33ab2e6c24c50f8e54e3648ba", "src_uid": "fa163c5b619d3892e33e1fb9c22043a9", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn get_single_number_from_stdin() -> u64 {\n let mut buffer = String::new();\n io::stdin().read_line(&mut buffer).unwrap();\n buffer.trim().parse::().expect(\"Not an integer\")\n}\n\nfn main(){\n let mut dollars = get_single_number_from_stdin();\n let denominations = vec![100,20,10,5,1];\n let mut total_bills = 0;\n for denomination in denominations {\n if dollars == 0 {\n break;\n }\n if dollars >= denomination {\n let q = (dollars/denomination) as u64;\n dollars -= denomination * q;\n total_bills += q;\n }else{\n continue;\n }\n }\n print!(\"{}\",total_bills);\n}", "lang_cluster": "Rust", "tags": ["greedy", "dp"], "code_uid": "566e1780b766e692c9049f9e1da6ced3", "src_uid": "8e81ad7110552c20297f08ad3e5f8ddc", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, stdin};\n\nfn main() -> io::Result<()> {\n let mut buffer = String::new();\n let input = stdin();\n input.read_line(&mut buffer)?;\n let mut money: u32 = buffer.trim().parse().expect(\"Not int\");\n let mut bills = 0;\n let denoms = [100, 20, 10, 5, 1];\n for denom in &denoms {\n bills += money / denom;\n money %= denom;\n if money == 0 {\n break;\n }\n }\n println!(\"{}\", bills);\n Ok(())\n}\n", "lang_cluster": "Rust", "tags": ["greedy", "dp"], "code_uid": "0e8526a1d376cc5a693f8e7ce8d92240", "src_uid": "8e81ad7110552c20297f08ad3e5f8ddc", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::*;\n\nfn read(i: &mut StdinLock) -> T {\n let mut s = String::new();\n i.by_ref().read_line(&mut s).ok();\n s.trim().parse().ok().unwrap()\n}\n\nfn main() {\n // initialize stdin\n let sin = std::io::stdin();\n let mut sin = sin.lock();\n let sin = &mut sin;\n\n let a: i64 = read(sin);\n let b: i64 = read(sin);\n let c: i64 = read(sin);\n\n if b == 1 {\n let ans = if a <= c {\n if c == 1 {\n // a == b == c == 1\n a + b + c\n } else {\n (a + b) * c\n }\n } else {\n a * (b + c)\n };\n println!(\"{}\", ans);\n return;\n }\n\n if c == 1 && a != 1 {\n println!(\"{}\", a * (b + c));\n return;\n }\n\n let pre_val = if a == 1 { a + b } else { a * b };\n let ans = if c == 1 { pre_val + c } else { pre_val * c };\n\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math"], "code_uid": "77fd3b7f22c977320c3f26a56b1e1864", "src_uid": "1cad9e4797ca2d80a12276b5a790ef27", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::str::FromStr;\n \nfn read_str() -> String {\n let mut buffer: String = String::new();\n std::io::stdin().read_line(&mut buffer).expect(\"Error\");\n buffer.trim().to_string()\n}\n \nfn read_int() -> T{\n read_str().parse::().ok().expect(\"Error\")\n}\n \nfn main() {\n let (a, b, c): (u16, u16, u16) = (read_int(), read_int(), read_int());\n \n if a + c == 2 { println!(\"{}\", a + b + c); }\n else if a == 1 || b == 1 || c == 1 {\n if a < c { println!(\"{}\", (a + b) * c); }\n else { println!(\"{}\", a * (b + c)); }\n }\n else { println!(\"{}\", a * b * c); }\n}", "lang_cluster": "Rust", "tags": ["brute force", "math"], "code_uid": "d9f631d2dfb463994f28fbfa01f7b450", "src_uid": "1cad9e4797ca2d80a12276b5a790ef27", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\n#[allow(unused_macros)]\nmacro_rules! a {\n ($c: tt, $x: expr, $y: expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\nuse std::io::*;\nuse std::str::*;\nuse std::fmt::Debug;\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a>, }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).unwrap();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n let n = input.i();\n let a = input.i();\n let b = input.i();\n println!(\"{}\", (n - a).min(b + 1));\n}\n\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "d510f0dd8aed27fc6f8683a0a4cfd35e", "src_uid": "51a072916bff600922a77da0c4582180", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let s = std::io::stdin();\n let mut sc = Scanner { stdin: s.lock() };\n let x: usize = sc.read();\n let mut hh: usize = sc.read();\n let mut mm: usize = sc.read();\n let mut result = 24 * 60;\n for h in 0..24 {\n for m in 0..60 {\n if h == 7 || h == 17 || m == 7 || m == 17 || m == 27 || m == 37 || m == 47 || m == 57 {\n let mut cnt = 0;\n let mut tmp_h = h;\n let mut tmp_m = m;\n while tmp_h != hh || tmp_m != mm {\n tmp_m += x;\n if tmp_m >= 60 {\n tmp_h += 1;\n tmp_m %= 60;\n }\n if tmp_h >= 24 {\n tmp_h = 0;\n }\n cnt += 1;\n if cnt > 24 * 60 {\n break;\n }\n }\n \n result = std::cmp::min(result, cnt);\n }\n }\n }\n println!(\"{}\", result);\n}\n\n//snippet from kenkoooo\npub struct Scanner {\n stdin: R,\n}\n\nimpl Scanner {\n pub fn read(&mut self) -> T {\n use std::io::Read;\n let buf = self\n .stdin\n .by_ref()\n .bytes()\n .map(|b| b.unwrap())\n .skip_while(|&b| b == b' ' || b == b'\\n' || b == b'\\r')\n .take_while(|&b| b != b' ' && b != b'\\n' && b != b'\\r')\n .collect::>();\n unsafe { std::str::from_utf8_unchecked(&buf) }\n .parse()\n .ok()\n .expect(\"Parse error.\")\n }\n pub fn vec(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.read()).collect()\n }\n pub fn chars(&mut self) -> Vec {\n self.read::().chars().collect()\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "implementation"], "code_uid": "7741a90644b924b350b67bacd4090e93", "src_uid": "5ecd569e02e0164a5da9ff549fca3ceb", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "// \u9577\u305510^100 \u306a\u6587\u5b57\u5217T\u304c\u3042\u308b\u3001\u6700\u521d\u5168\u90e80\r\n// \u6587\u5b57\u5217S \u304c\u4e0e\u3048\u3089\u308c\u308b\r\n// S \u3092 T \u306e\u3069\u3053\u304b\u306bxor\u3059\u308b\u307f\u305f\u3044\u306a\u3053\u3068\u304c\u3067\u304d\u308b\r\n// 1\u304c\u4e8c\u3064\u3068\u306a\u308b\u3088\u3046\u306b\u64cd\u4f5c\u3059\u308b\u6642\u51fa\u6765\u4e0a\u304c\u308bT\u306e\u8f9e\u66f8\u9806\u6700\u5927\u3092\u6c42\u3081\u3066\r\n//\r\n// |S| <= 35\r\n//\r\n// \u306a\u3093\u304b\u30b5\u30f3\u30d7\u30eb4\u3067\u3059\u3054\u3044\u6570\u304c\u51fa\u3066\u304d\u3066\u308b\r\n//\r\n// \u4e0d\u53ef\u80fd\u306a\u5834\u5408\u3063\u3066\u4f55\uff1f\r\n// 0\u306e\u307f\u3001\u4e0d\u53ef\u80fd\r\n// \u305d\u308c\u4ee5\u5916\u3067\u4e0d\u53ef\u80fd\u306a\u5834\u5408\u306f\uff1f\r\n// \u308f\u304b\u3089\u3093\r\n// 1\u4e00\u3064, 2\u3064\r\n// \u8a70\u3081\u3066\u7f6e\u3051\u3070\u3044\u3044\r\n// \uff13\u3064\u4ee5\u4e0a\uff1f\r\n// \u6700\u521d\u306e1\u306f\u78ba\u5b9a\u3059\u308b\r\n// \u3068\u3044\u3046\u306e\u6700\u521d\u3092\u4f7f\u3046\u3068\u6700\u521d\u306e\uff11\u306f\u78ba\u5b9a\u3059\u308b\u3057\u3001\u4f7f\u308f\u306a\u3044\u3067\u5f97\u3089\u308c\u305f\u7b54\u3048\u306f\u30b9\u30e9\u30a4\u30c9\u3055\u305b\u3066\u3088\u308a\u5927\u304d\u304f\u3067\u304d\u308b\r\n// \u6b8b\u3063\u305f\u90e8\u5206\u306b\u306a\u3093\u304bxor\u3057\u3066\u3044\u304f\u611f\u3058\r\n// \u3084\u308c\u308b\u3053\u3068\u304c\u524d\u304b\u3089xor\u3057\u3066\u3044\u304f\u3053\u3068\u3057\u304b\u306a\u3044\u304c\r\n//\r\n// S \u306e\u6700\u521d\u3001\u6700\u5f8c\u306e0\u3092\u524a\u3063\u3066\u304a\u304f\r\n// \u306a\u3093\u304b\u30b3\u30f3\u30d1\u30cb\u30aa\u30f3\u884c\u5217\u3092\u304b\u3051\u307e\u304f\u3063\u3066 (0, 0, ..., 1) \u306b\u306a\u308b\u6700\u5c0f\u306e\u6570\r\n// \u307f\u305f\u3044\u306a\u554f\u984c\u306b\u306a\u308b\r\n// \u7dda\u5f62\u4ee3\u6570\u30b2\u30fc\uff1f\u3088\u3046\u308f\u304b\u3089\u3093\r\n// S \u306e1\u6587\u5b57\u76ee\u306e1\u3092\u524a\u3063\u305f\u3084\u3064\u3092s, \u5358\u4f4d\u30d9\u30af\u30c8\u30eb\u3092e_i \u3068\u7f6e\u304f\r\n// k = |S| - 1 \u3068\u3057\u3066\r\n//\r\n// s * mat [s, e_1, .., e_{k - 1}] ^n = e_k\r\n//\r\n// \u3068\u306a\u308b\u3088\u3046\u306an \u306e\u6700\u5c0f\u5024\u3001\u306a\u3044\u306a\u3089\u305d\u308c\u5831\u544a\r\n// \u96e2\u6563\u5bfe\u6570\uff1f\r\n// \u3061\u3087\u3063\u3068\u9593\u306b\u5408\u308f\u306a\u3044\u611f\r\n// \u3044\u30842^18 \u7a0b\u5ea6\u306a\u3089\u9593\u306b\u5408\u3063\u3066\u3082\u3044\u3044\u3093\u3058\u3083\r\n// \u9593\u306b\u5408\u3063\u3066\u3082\u3044\u3044\u6c17\u306f\u3059\u308b\u304c\u306a\u3093\u304b BS-GS \u306b\u6301\u3061\u8fbc\u3081\u306a\u3044\r\n// \u4e0a\u306e\u524d\u51e6\u7406\u3059\u308b\u3068 A \u306f\u9006\u884c\u5217\u3092\u6301\u3064\u3088\u3046\u306b\u306a\u308b\r\n//\r\n// s A^n = e_k\r\n// s A^(qx + r) = e_k\r\n// s A^(qx) = e_k A^(-r)\r\n// \u3053\u308c\u306f\u3044\u3051\u305d\u3046\r\n//\r\n// \u3068\u3053\u308d\u3067\u3001\u6700\u5c0f\u6027\u304c\u554f\u984c\u306b\u306a\u308b\u304c\r\n// \u307e\u3042\u306a\u3093\u3068\u304b\u306a\u308b\u3067\u3057\u3087\u591a\u5206\r\n\r\nuse std::collections::*;\r\nuse std::io::Write;\r\n\r\ntype Map = BTreeMap;\r\ntype Set = BTreeSet;\r\ntype Deque = VecDeque;\r\n\r\nfn run(mut s: Vec) -> Option<(usize, usize)> {\r\n s.iter_mut().for_each(|s| *s -= b'0');\r\n let c = s.iter().filter(|s| **s == 1).count();\r\n if c == 0 {\r\n return None;\r\n }\r\n let f = s.iter().position(|s| *s == 1).unwrap();\r\n if c == 1 {\r\n return Some((f, f + 1));\r\n }\r\n let mut s = s;\r\n s.drain(..=f);\r\n while s.last().map_or(false, |c| *c == 0) {\r\n s.pop();\r\n }\r\n let s = s;\r\n let k = s.len();\r\n let mut a = vec![vec![0u8; k]; k];\r\n for (i, s) in s.iter().enumerate() {\r\n a[0][i] = *s;\r\n }\r\n for i in 1..k {\r\n a[i][i - 1] = 1;\r\n }\r\n let inv_a = inverse_matrix(a.clone()).unwrap();\r\n let mut right = vec![0; k];\r\n right[k - 1] = 1u8;\r\n let sq = 1 << (k / 2 + 1);\r\n let mut map = Map::new();\r\n for i in 0..=sq {\r\n map.entry(right.clone()).or_insert(i);\r\n let mut next = vec![0; k];\r\n for (right, inv_a) in right.iter().zip(inv_a.iter()) {\r\n for (next, inv_a) in next.iter_mut().zip(inv_a.iter()) {\r\n *next ^= *right & *inv_a;\r\n }\r\n }\r\n right = next;\r\n }\r\n let mul = |a: &[Vec], b: &[Vec]| -> Vec> {\r\n let mut c = vec![vec![0; k]; k];\r\n for (c, a) in c.iter_mut().zip(a.iter()) {\r\n for (a, b) in a.iter().zip(b.iter()) {\r\n for (c, b) in c.iter_mut().zip(b.iter()) {\r\n *c ^= *a & *b;\r\n }\r\n }\r\n }\r\n c\r\n };\r\n let mut mat = vec![vec![0; k]; k];\r\n for i in 0..k {\r\n mat[i][i] = 1;\r\n }\r\n for i in (0..20).rev() {\r\n mat = mul(&mat, &mat);\r\n if sq >> i & 1 == 1 {\r\n mat = mul(&mat, &a);\r\n }\r\n }\r\n let rad = mat;\r\n let mut mat = vec![vec![0; k]; k];\r\n for i in 0..k {\r\n mat[i][i] = 1;\r\n }\r\n for i in 0..=sq {\r\n let mut b = vec![0; k];\r\n for (s, mat) in s.iter().zip(mat.iter()) {\r\n for (b, mat) in b.iter_mut().zip(mat.iter()) {\r\n *b ^= *s & *mat;\r\n }\r\n }\r\n if let Some(v) = map.get(&b) {\r\n return Some((f, sq * i + v + f + k));\r\n }\r\n mat = mul(&mat, &rad);\r\n }\r\n None\r\n}\r\n\r\nfn inverse_matrix(mut mat: Vec>) -> Option>> {\r\n let n = mat.len();\r\n assert!(mat.iter().all(|mat| mat.len() == n));\r\n for (i, mat) in mat.iter_mut().enumerate() {\r\n mat.resize(2 * n, 0);\r\n mat[n + i] = 1;\r\n }\r\n for i in 0..n {\r\n let x = (i..n).find(|x| mat[*x][i] != 0)?;\r\n mat.swap(i, x);\r\n let a = std::mem::take(&mut mat[i]);\r\n for mat in mat.iter_mut().filter(|mat| !mat.is_empty()) {\r\n let mul = mat[i];\r\n for (mat, a) in mat[i..].iter_mut().zip(a[i..].iter()) {\r\n *mat ^= mul & *a;\r\n }\r\n }\r\n mat[i] = a;\r\n }\r\n Some(mat.iter().map(|a| Vec::from(&a[n..])).collect())\r\n}\r\n\r\nfn main() {\r\n input! {\r\n s: bytes,\r\n }\r\n if let Some((a, b)) = run(s) {\r\n println!(\"{} {}\", a + 1, b + 1);\r\n } else {\r\n println!(\"-1\");\r\n }\r\n}\r\n\r\n// ---------- begin input macro ----------\r\n// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\r\n#[macro_export]\r\nmacro_rules! input {\r\n (source = $s:expr, $($r:tt)*) => {\r\n let mut iter = $s.split_whitespace();\r\n input_inner!{iter, $($r)*}\r\n };\r\n ($($r:tt)*) => {\r\n let s = {\r\n use std::io::Read;\r\n let mut s = String::new();\r\n std::io::stdin().read_to_string(&mut s).unwrap();\r\n s\r\n };\r\n let mut iter = s.split_whitespace();\r\n input_inner!{iter, $($r)*}\r\n };\r\n}\r\n\r\n#[macro_export]\r\nmacro_rules! input_inner {\r\n ($iter:expr) => {};\r\n ($iter:expr, ) => {};\r\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\r\n let $var = read_value!($iter, $t);\r\n input_inner!{$iter $($r)*}\r\n };\r\n}\r\n\r\n#[macro_export]\r\nmacro_rules! read_value {\r\n ($iter:expr, ( $($t:tt),* )) => {\r\n ( $(read_value!($iter, $t)),* )\r\n };\r\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\r\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\r\n };\r\n ($iter:expr, chars) => {\r\n read_value!($iter, String).chars().collect::>()\r\n };\r\n ($iter:expr, bytes) => {\r\n read_value!($iter, String).bytes().collect::>()\r\n };\r\n ($iter:expr, usize1) => {\r\n read_value!($iter, usize) - 1\r\n };\r\n ($iter:expr, $t:ty) => {\r\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\r\n };\r\n}\r\n// ---------- end input macro ----------\r\n", "lang_cluster": "Rust", "tags": ["math", "bitmasks", "meet-in-the-middle", "matrices", "number theory"], "code_uid": "4542b5cc5c57ea1a95603351de5ac953", "src_uid": "6bf798edef30db7d0ce2130e40084e6b", "difficulty": 2900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str::FromStr;\nuse std::io::prelude::*;\n\nfn get_line() -> String {\n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n input\n}\n\nfn get_vec() -> Vec\nwhere T: FromStr,\n ::Err: std::fmt::Debug,\n{\n get_line().split_whitespace().map(|k| k.parse().unwrap()).collect()\n}\n\nfn main() {\n let (k, p): (usize, usize) = {\n let input = get_line();\n let mut it = input.split_whitespace()\n .map(|x| x.parse().unwrap());\n (\n it.next().unwrap(),\n it.next().unwrap(),\n )\n };\n\n let p = p as u64;\n\n let mul = |a, b| {\n (a * b) % p\n };\n\n let pow10 = |k| {\n let mut ret_val = 1;\n for _ in 0..k {\n ret_val = mul(ret_val, 10);\n }\n ret_val\n };\n\n let mut ans = 0;\n\n for i in (1..).take(k) {\n let s = format!(\"{}\", i);\n let n = s.len() as u64;\n for (ind, d) in s.bytes().enumerate() {\n let d = (d - b'0') as u64;\n let ind = ind as u64;\n ans = (ans + d * pow10(ind)) % p;\n ans = (ans + d * pow10(2 * n - 1 - ind)) % p;\n }\n }\n\n println!(\"{}\", ans);\n}\n\nstruct Solver {\n}\n\nimpl Solver {\n}\n", "lang_cluster": "Rust", "tags": ["brute force"], "code_uid": "902ed727f9bd9812dc82ee33018fb593", "src_uid": "00e90909a77ce9e22bb7cbf1285b0609", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(dead_code, unused_macros, unused_imports)]\nuse std::{cell::{Cell, RefCell, UnsafeCell}, cmp::{Ordering, Reverse, max, min}, collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque, hash_map::{DefaultHasher, RandomState}}, error::Error, fmt::{Display, Write as FmtWrite}, hash::{BuildHasher, Hash, Hasher}, io::{BufWriter, Read, Stdin, Stdout, Write}, iter::{FromIterator, Peekable}, mem::swap, ops::*, process::exit, rc::Rc, str::{FromStr, from_utf8_unchecked}, time::{Duration, Instant}, convert::TryInto};\n\nconst IO_BUF_SIZE: usize = 1 << 16;\ntype Input = Scanner;\ntype Output = BufWriter;\nfn _init_input() -> Input { Scanner::new(std::io::stdin()) }\nfn _init_output() -> Output { BufWriter::with_capacity(IO_BUF_SIZE, std::io::stdout()) }\n\n#[repr(transparent)] struct Unsync(T);\nunsafe impl Sync for Unsync {}\n \ntype BadLazy = Unsync>>;\nimpl BadLazy {\n const fn new() -> Self { Self(UnsafeCell::new(None)) }\n}\n \nstatic INPUT: BadLazy = BadLazy::new();\nstatic OUTPUT: BadLazy = BadLazy::new();\n \nfn inp R, R>(f: F) -> R {\n unsafe { f((&mut *INPUT.0.get()).get_or_insert_with(_init_input)) }\n}\nfn out R, R>(f: F) -> R {\n unsafe { f((&mut *OUTPUT.0.get()).get_or_insert_with(_init_output)) }\n}\n\nmacro_rules! read {\n () => { read() };\n ($t: ty) => { read::<$t>() };\n ($t: ty, $($tt: ty),*) => { (read::<$t>(), $(read::<$tt>(),)*) };\n [$t: ty; $n: expr] => { read_vec::<$t>($n) };\n}\nmacro_rules! println { \n () => { out(|x| { let _ = writeln!(x); }) };\n ($exp: expr) => { out(|x| { let _ = writeln!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = writeln!(x, $fmt, $($arg)*); }) }\n}\nmacro_rules! print { \n ($exp: expr) => { out(|x| { let _ = write!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = write!(x, $fmt, $($arg)*); }) }\n}\n\nfn out_flush() { out(|x| { let _ = x.flush(); }); }\n\nfn input_is_eof() -> bool { inp(|x| x.eof()) }\nfn read_byte() -> u8 { inp(|x| x.byte()) }\nfn read_bytes_no_skip(n: usize) -> Vec { inp(|x| x.bytes_no_skip(n)) }\nfn read_bytes(n: usize) -> Vec { inp(|x| x.bytes(n)) }\nfn read_bytes2(n: usize, m: usize) -> Vec> { inp(|x| x.bytes2(n, m)) }\nfn read_token() -> Vec { inp(|x| x.token_bytes()) }\nfn read_token_str() -> String { unsafe { String::from_utf8_unchecked(read_token()) } }\nfn read_line() -> Vec { inp(|x| x.line_bytes()) }\nfn read_line_str() -> String { unsafe { String::from_utf8_unchecked(read_line()) } }\nfn read() -> T { read_token_str().parse::().ok().expect(\"failed parse\") }\nfn read_vec(n: usize) -> Vec { (0..n).map(|_| read()).collect() }\nfn read_vec2(n: usize, m: usize) -> Vec> { (0..n).map(|_| read_vec(m)).collect() }\n\nstruct Scanner {\n src: R,\n _buf: Vec,\n _pt: usize, // pointer\n _rd: usize, // bytes read\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new(src: R) -> Scanner {\n Scanner { src, _buf: vec![0; IO_BUF_SIZE], _pt: 1, _rd: 1 }\n }\n \n fn _check_buf(&mut self) {\n if self._pt == self._rd {\n self._rd = self.src.read(&mut self._buf).unwrap_or(0);\n self._pt = (self._rd == 0) as usize;\n }\n }\n \n // returns true if end of file\n fn eof(&mut self) -> bool {\n self._check_buf();\n self._rd == 0\n }\n \n // filters \\r, returns \\0 if eof\n fn byte(&mut self) -> u8 {\n loop {\n self._check_buf();\n if self._rd == 0 { return 0; }\n let res = self._buf[self._pt];\n self._pt += 1;\n if res != b'\\r' { return res; }\n }\n }\n\n fn bytes_no_skip(&mut self, n: usize) -> Vec { (0..n).map(|_| self.byte()).collect() }\n fn bytes(&mut self, n: usize) -> Vec {\n let res = self.bytes_no_skip(n);\n self.byte();\n res\n }\n fn bytes2(&mut self, n: usize, m: usize) -> Vec> { (0..n).map(|_| self.bytes(m)).collect() }\n \n fn token_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c <= b' ' {\n if c == b'\\0' { return res; }\n c = self.byte();\n }\n loop {\n res.push(c);\n c = self.byte();\n if c <= b' ' { return res; }\n }\n }\n \n fn line_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c != b'\\n' && c != b'\\0' {\n res.push(c);\n c = self.byte();\n }\n res\n }\n}\n\ntrait JoinToStr { \n fn join_to_str(self, sep: &str) -> String;\n fn concat_to_str(self) -> String;\n}\nimpl> JoinToStr for I { \n fn join_to_str(mut self, sep: &str) -> String {\n match self.next() {\n Some(first) => {\n let mut res = first.to_string();\n while let Some(item) = self.next() {\n res.push_str(sep);\n res.push_str(&item.to_string());\n }\n res\n }\n None => { String::new() }\n }\n }\n \n fn concat_to_str(self) -> String {\n let mut res = String::new();\n for item in self { res.push_str(&item.to_string()); }\n res\n }\n}\ntrait AsStr { fn as_str(&self) -> &str; }\nimpl AsStr for [u8] { fn as_str(&self) -> &str {std::str::from_utf8(self).expect(\"attempt to convert non-UTF8 byte string.\")} }\n\nmacro_rules! veci {\n ($n:expr , $i:ident : $gen:expr) => {{\n let _veci_n = $n;\n let mut _veci_list = Vec::with_capacity(_veci_n);\n for $i in 0.._veci_n {\n _veci_list.push($gen);\n }\n _veci_list\n }};\n ($n:expr , $gen:expr) => { veci!($n, _veci_: $gen) }\n}\n\nfn abs_diff + PartialOrd>(x: T, y: T) -> T {\n if x < y { y - x } else { x - y }\n}\n\ntrait CommonNumExt {\n fn div_ceil(self, b: Self) -> Self;\n fn div_floor(self, b: Self) -> Self;\n fn gcd(self, b: Self) -> Self;\n fn highest_one(self) -> Self;\n fn lowest_one(self) -> Self;\n fn sig_bits(self) -> u32;\n}\n\nmacro_rules! impl_common_num_ext {\n ($($ix:tt = $ux:tt),*) => {\n $(\n impl CommonNumExt for $ux {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { self / b }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self; while a != 0 { swap(&mut a, &mut b); a %= b; }\n b\n }\n #[inline] fn highest_one(self) -> Self { \n if self == 0 { 0 } else { const ONE: $ux = 1; ONE.rotate_right(1) >> self.leading_zeros() } \n }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ux>() as u32 * 8 - self.leading_zeros() }\n }\n\n impl CommonNumExt for $ix {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if self ^ b >= 0 && r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { \n let q = self / b; let r = self % b;\n if self ^ b < 0 && r != 0 { q - 1 } else { q }\n }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self; while a != 0 { swap(&mut a, &mut b); a %= b; }\n b.abs()\n }\n #[inline] fn highest_one(self) -> Self { (self as $ux).highest_one() as _ }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ix>() as u32 * 8 - self.leading_zeros() }\n }\n )*\n }\n}\nimpl_common_num_ext!(i8 = u8, i16 = u16, i32 = u32, i64 = u64, i128 = u128, isize = usize);\n\ntrait ChMaxMin {\n fn chmax(&mut self, v: T) -> bool;\n fn chmin(&mut self, v: T) -> bool;\n}\nimpl ChMaxMin for Option {\n fn chmax(&mut self, v: T) -> bool { if self.is_none() || v > *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if self.is_none() || v < *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n}\nimpl ChMaxMin for T {\n fn chmax(&mut self, v: T) -> bool { if v > *self { *self = v; true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if v < *self { *self = v; true } else { false } }\n}\n\n// * end commons * //\n\n#[macro_use]\n#[allow(dead_code)]\nmod modint {\n use std::{fmt::{Display, Formatter}, marker::PhantomData, mem::swap, ops::*, str::FromStr, cell::Cell};\n use crate::ModInt;\n \n pub trait RemEuclidU32: Copy {\n /// Calculates `self` _mod_ `modulus` losslessly.\n fn rem_euclid_u32(self, modulus: u32) -> u32;\n }\n \n macro_rules! impl_rem_euclid_u32_for_small_signed {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self as i64).rem_euclid(i64::from(modulus)) as _\n }\n }\n )*\n }\n }\n \n impl_rem_euclid_u32_for_small_signed!(i8, i16, i32, i64, isize);\n \n impl RemEuclidU32 for i128 {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self.rem_euclid(i128::from(modulus)) as _\n }\n }\n \n macro_rules! impl_rem_euclid_u32_for_small_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self as u32 % modulus\n }\n }\n )*\n }\n }\n \n macro_rules! impl_rem_euclid_u32_for_large_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self % (modulus as $ty)) as _\n }\n }\n )*\n }\n }\n \n impl_rem_euclid_u32_for_small_unsigned!(u8, u16, u32);\n impl_rem_euclid_u32_for_large_unsigned!(u64, u128);\n \n #[cfg(target_pointer_width = \"32\")]\n impl_rem_euclid_u32_for_small_unsigned!(usize);\n \n #[cfg(target_pointer_width = \"64\")]\n impl_rem_euclid_u32_for_large_unsigned!(usize);\n #[inline]\n pub fn mul_mod_u32(a: u32, b: u32, m: u32) -> u32 {\n (a as u64 * b as u64 % m as u64) as u32\n }\n \n // for a, b < m, unspecified otherwise\n #[inline]\n fn add_mod_raw(a: u32, b: u32, m: u32) -> u32 {\n let (r, c) = a.wrapping_sub(m).overflowing_add(b);\n if c { r } else { a + b }\n }\n #[inline]\n fn sub_mod_raw(a: u32, b: u32, m: u32) -> u32 {\n let (r, c) = a.overflowing_sub(b);\n if c { r.wrapping_add(m) } else { r }\n }\n fn pow_mod_raw(a: u32, mut k: u64, m: u32) -> u32 {\n if m == 1 { return 0; }\n let mut a = a as u64;\n let m = m as u64;\n let mut r: u64 = 1;\n while k > 0 {\n if k & 1 == 1 {\n r = r * a % m;\n }\n k >>= 1;\n a = a * a % m;\n }\n r as u32\n }\n \n /// # Parameters\n /// * `b` `1 <= b`\n /// # Returns\n /// (x, g) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g\n fn inv_gcd(a: i64, b: i64) -> (i64, i64) {\n let a = a.rem_euclid(b);\n if a == 0 { return (0, b); }\n let mut s = b;\n let mut t = a;\n let mut m0 = 0;\n let mut m1 = 1;\n \n while t != 0 {\n let u = s / t;\n s -= t * u;\n m0 -= m1 * u;\n swap(&mut s, &mut t);\n swap(&mut m0, &mut m1);\n }\n \n if m0 < 0 { m0 += b / s; }\n (m0, s)\n }\n \n pub trait Modulus: Copy + Eq {\n fn get_modulus() -> u32;\n }\n \n #[derive(Clone, Copy, PartialEq, Eq, Hash)]\n #[repr(transparent)]\n pub struct ModIntBase { \n val: u32,\n _phantom: PhantomData\n }\n \n impl ModIntBase {\n #[inline(always)]\n pub fn modulus() -> u32 { M::get_modulus() }\n #[inline] pub fn new(val: I) -> Self { Self::raw(val.rem_euclid_u32(Self::modulus())) }\n #[inline] pub fn raw(val: u32) -> Self { Self { val, _phantom: PhantomData } }\n pub fn inv(self) -> Self { \n let (x, gcd) = inv_gcd(self.val.into(), Self::modulus().into());\n debug_assert!(gcd == 1, \"the multiplicative inverse {}^-1 mod {} does not exist\", self.val, Self::modulus());\n Self::raw(x as u32)\n }\n #[inline] pub fn val(self) -> u32 { self.val }\n #[inline] pub fn pow(self, k: u64) -> Self {\n Self::raw(pow_mod_raw(self.val, k, Self::modulus()))\n }\n pub fn powi(self, k: i64) -> Self { if k < 0 { self.inv().pow(-k as _) } else { self.pow(k as _) } }\n pub fn pow_vec(self, n: usize) -> Vec {\n let mut res = vec![Self::raw(0); n+1];\n res[0] += 1;\n for i in 1..=n {\n res[i] = res[i-1] * self;\n }\n res\n }\n \n pub fn invs(a: &[Self]) -> Vec {\n let n = a.len();\n if n == 0 { return vec![]; }\n let mut acc = Self::new(1);\n let mut res = Vec::with_capacity(n);\n for i in 0..n {\n if a[i].val() != 0 { acc *= a[i]; }\n res.push(acc);\n }\n acc = acc.inv();\n for i in (1..n).rev() {\n res[i] = acc * res[i-1];\n if a[i].val() != 0 { acc *= a[i]; }\n }\n res[0] = acc;\n res\n }\n }\n \n #[inline]\n pub fn mi(val: I) -> ModInt { ModIntBase::new(val) }\n #[inline] pub fn mir(v: u32) -> ModInt { ModIntBase::raw(v) }\n \n impl From for ModIntBase {\n #[inline]\n fn from(from: V) -> Self { Self::new(from) }\n }\n impl Default for ModIntBase {\n fn default() -> Self { Self::raw(0) }\n }\n impl FromStr for ModIntBase {\n type Err = std::convert::Infallible;\n #[inline]\n fn from_str(s: &str) -> Result {\n Ok(s.parse::()\n .map(Self::new)\n .unwrap_or_else(|_| todo!(\"parsing as an arbitrary precision integer?\")))\n }\n }\n impl Display for ModIntBase {\n #[inline]\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n self.val.fmt(f)\n }\n }\n impl std::fmt::Debug for ModIntBase {\n #[inline]\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n std::fmt::Debug::fmt(&self.val, f)\n }\n }\n impl Neg for ModIntBase {\n type Output = Self;\n \n #[inline]\n fn neg(self) -> Self::Output {\n Self::raw(0) - self\n }\n }\n \n impl>, M: Modulus> Add for ModIntBase {\n type Output = Self;\n #[inline]\n fn add(self, rhs: V) -> Self::Output {\n Self::raw(add_mod_raw(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Sub for ModIntBase {\n type Output = Self;\n #[inline]\n fn sub(self, rhs: V) -> Self::Output {\n Self::raw(sub_mod_raw(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Mul for ModIntBase {\n type Output = Self;\n #[inline]\n fn mul(self, rhs: V) -> Self::Output {\n Self::raw(mul_mod_u32(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Div for ModIntBase {\n type Output = Self;\n #[inline]\n fn div(self, rhs: V) -> Self::Output { self * rhs.into().inv() }\n }\n \n impl >, M: Modulus> AddAssign for ModIntBase {\n #[inline]\n fn add_assign(&mut self, rhs: V) { *self = *self + rhs; }\n }\n impl >, M: Modulus> SubAssign for ModIntBase {\n #[inline]\n fn sub_assign(&mut self, rhs: V) { *self = *self - rhs; }\n }\n impl >, M: Modulus> MulAssign for ModIntBase {\n #[inline]\n fn mul_assign(&mut self, rhs: V) { *self = *self * rhs; }\n }\n impl >, M: Modulus> DivAssign for ModIntBase {\n #[inline]\n fn div_assign(&mut self, rhs: V) { *self = *self / rhs; }\n }\n \n impl std::iter::Sum for ModIntBase {\n #[inline] fn sum>(iter: I) -> Self {\n iter.fold(Self::raw(0), Add::add)\n }\n }\n impl std::iter::Product for ModIntBase {\n #[inline] fn product>(iter: I) -> Self {\n iter.fold(1.into(), Mul::mul)\n }\n }\n impl<'a, M: Modulus> std::iter::Sum<&'a Self> for ModIntBase {\n #[inline] fn sum>(iter: I) -> ModIntBase {\n iter.fold(Self::raw(0), |a, &b| a + b)\n }\n }\n impl<'a, M: Modulus> std::iter::Product<&'a Self> for ModIntBase {\n #[inline] fn product>(iter: I) -> ModIntBase {\n iter.fold(1.into(), |a, &b| a * b)\n }\n }\n \n macro_rules! const_modulus {\n ($mint: ident, $name: ident, $modulus: expr) => {\n #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]\n pub enum $name {}\n impl Modulus for $name {\n #[inline(always)] fn get_modulus() -> u32 { $modulus }\n }\n pub type $mint = ModIntBase<$name>;\n }\n }\n \n macro_rules! dynamic_modulus {\n ($mint: ident, $name: ident, $modulus: ident) => {\n static $modulus: crate::Unsync> = crate::Unsync(Cell::new(0));\n #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]\n pub enum $name {}\n impl Modulus for $name {\n fn get_modulus() -> u32 { $modulus.0.get() }\n }\n impl $name {\n pub fn set_modulus(val: u32) { $modulus.0.set(val) }\n }\n pub type $mint = ModIntBase<$name>;\n }\n }\n \n const_modulus!(ModInt998_244_353, Mod998_244_353, 998_244_353);\n const_modulus!(ModInt1_000_000_007, Mod1_000_000_007, 1_000_000_007);\n dynamic_modulus!(DynamicModInt, DynamicModulus, DYNAMIC_MODULUS);\n}\n \nuse crate::modint::*;\ntype ModInt = ModInt998_244_353;\n// type ModInt = ModInt1_000_000_007;\n// const_modulus!(ModInt, DefaultModulus, 1_000_000_009);\n// type ModInt = DynamicModInt;\n \n#[allow(non_snake_case, non_upper_case_globals)]\nfn main() {\n let num_cases: usize = 1;//read();\n\n for _case_num in 1..=num_cases {\n let n = read!(usize);\n let a0 = read!(u64);\n let x = read!(u64);\n let y = read!(u64);\n let k = read!(usize);\n let M = read!(u64);\n\n let npow = mir(n as _).pow_vec(k-1);\n\n let mut C = 1usize;\n for i in 2..k {\n C = C / C.gcd(i) * i;\n }\n let mut dp = vec![mi(0); C];\n\n let mut ans = mi(0);\n let mult = mir((k * C) as _) * npow[k-1];\n let mut a = a0;\n for _ in 0..n {\n let q = (a as usize) / C;\n let r = (a as usize) % C;\n\n ans += mir(q as _) * mult;\n dp[r] += 1;\n a = (a * x + y) % M;\n }\n\n for i in 1..=k {\n let mut dn = vec![mi(0); C];\n for j in 0..C {\n ans += dp[j] * npow[k-i] * mir(j as _);\n dn[j] += dp[j] * mir((n-1) as _);\n dn[j - j % i] += dp[j];\n }\n dp = dn;\n }\n\n println!(ans);\n }\n \n out_flush();\n}", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics", "probabilities", "number theory"], "code_uid": "88b719ae6dcd18a12c5bdbf1dcd11e9b", "src_uid": "1d45491e28d24e2b318605cd328d6ecf", "difficulty": 2800.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(dead_code, unused_macros, unused_imports)]\nuse std::{cell::{Cell, RefCell, UnsafeCell}, cmp::{Ordering, Reverse, max, min}, collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque, hash_map::{DefaultHasher, RandomState}}, error::Error, fmt::{Display, Write as FmtWrite}, hash::{BuildHasher, Hash, Hasher}, io::{BufWriter, Read, Stdin, Stdout, Write}, iter::{FromIterator, Peekable}, mem::swap, ops::*, process::exit, rc::Rc, str::{FromStr, from_utf8_unchecked}, time::{Duration, Instant}, convert::TryInto};\n\nconst IO_BUF_SIZE: usize = 1 << 16;\ntype Input = Scanner;\ntype Output = BufWriter;\nfn _init_input() -> Input { Scanner::new(std::io::stdin()) }\nfn _init_output() -> Output { BufWriter::with_capacity(IO_BUF_SIZE, std::io::stdout()) }\n\n#[repr(transparent)] struct Unsync(T);\nunsafe impl Sync for Unsync {}\n \ntype BadLazy = Unsync>>;\nimpl BadLazy {\n const fn new() -> Self { Self(UnsafeCell::new(None)) }\n}\n \nstatic INPUT: BadLazy = BadLazy::new();\nstatic OUTPUT: BadLazy = BadLazy::new();\n \nfn inp R, R>(f: F) -> R {\n unsafe { f((&mut *INPUT.0.get()).get_or_insert_with(_init_input)) }\n}\nfn out R, R>(f: F) -> R {\n unsafe { f((&mut *OUTPUT.0.get()).get_or_insert_with(_init_output)) }\n}\n\nmacro_rules! read {\n () => { read() };\n ($t: ty) => { read::<$t>() };\n ($t: ty, $($tt: ty),*) => { (read::<$t>(), $(read::<$tt>(),)*) };\n [$t: ty; $n: expr] => { read_vec::<$t>($n) };\n}\nmacro_rules! println { \n () => { out(|x| { let _ = writeln!(x); }) };\n ($exp: expr) => { out(|x| { let _ = writeln!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = writeln!(x, $fmt, $($arg)*); }) }\n}\nmacro_rules! print { \n ($exp: expr) => { out(|x| { let _ = write!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = write!(x, $fmt, $($arg)*); }) }\n}\n\nfn out_flush() { out(|x| { let _ = x.flush(); }); }\n\nfn input_is_eof() -> bool { inp(|x| x.eof()) }\nfn read_byte() -> u8 { inp(|x| x.byte()) }\nfn read_bytes_no_skip(n: usize) -> Vec { inp(|x| x.bytes_no_skip(n)) }\nfn read_bytes(n: usize) -> Vec { inp(|x| x.bytes(n)) }\nfn read_bytes2(n: usize, m: usize) -> Vec> { inp(|x| x.bytes2(n, m)) }\nfn read_token() -> Vec { inp(|x| x.token_bytes()) }\nfn read_token_str() -> String { unsafe { String::from_utf8_unchecked(read_token()) } }\nfn read_line() -> Vec { inp(|x| x.line_bytes()) }\nfn read_line_str() -> String { unsafe { String::from_utf8_unchecked(read_line()) } }\nfn read() -> T { read_token_str().parse::().ok().expect(\"failed parse\") }\nfn read_vec(n: usize) -> Vec { (0..n).map(|_| read()).collect() }\nfn read_vec2(n: usize, m: usize) -> Vec> { (0..n).map(|_| read_vec(m)).collect() }\n\nstruct Scanner {\n src: R,\n _buf: Vec,\n _pt: usize, // pointer\n _rd: usize, // bytes read\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new(src: R) -> Scanner {\n Scanner { src, _buf: vec![0; IO_BUF_SIZE], _pt: 1, _rd: 1 }\n }\n \n fn _check_buf(&mut self) {\n if self._pt == self._rd {\n self._rd = self.src.read(&mut self._buf).unwrap_or(0);\n self._pt = (self._rd == 0) as usize;\n }\n }\n \n // returns true if end of file\n fn eof(&mut self) -> bool {\n self._check_buf();\n self._rd == 0\n }\n \n // filters \\r, returns \\0 if eof\n fn byte(&mut self) -> u8 {\n loop {\n self._check_buf();\n if self._rd == 0 { return 0; }\n let res = self._buf[self._pt];\n self._pt += 1;\n if res != b'\\r' { return res; }\n }\n }\n\n fn bytes_no_skip(&mut self, n: usize) -> Vec { (0..n).map(|_| self.byte()).collect() }\n fn bytes(&mut self, n: usize) -> Vec {\n let res = self.bytes_no_skip(n);\n self.byte();\n res\n }\n fn bytes2(&mut self, n: usize, m: usize) -> Vec> { (0..n).map(|_| self.bytes(m)).collect() }\n \n fn token_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c <= b' ' {\n if c == b'\\0' { return res; }\n c = self.byte();\n }\n loop {\n res.push(c);\n c = self.byte();\n if c <= b' ' { return res; }\n }\n }\n \n fn line_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c != b'\\n' && c != b'\\0' {\n res.push(c);\n c = self.byte();\n }\n res\n }\n}\n\ntrait JoinToStr { \n fn join_to_str(self, sep: &str) -> String;\n fn concat_to_str(self) -> String;\n}\nimpl> JoinToStr for I { \n fn join_to_str(mut self, sep: &str) -> String {\n match self.next() {\n Some(first) => {\n let mut res = first.to_string();\n while let Some(item) = self.next() {\n res.push_str(sep);\n res.push_str(&item.to_string());\n }\n res\n }\n None => { String::new() }\n }\n }\n \n fn concat_to_str(self) -> String {\n let mut res = String::new();\n for item in self { res.push_str(&item.to_string()); }\n res\n }\n}\ntrait AsStr { fn as_str(&self) -> &str; }\nimpl AsStr for [u8] { fn as_str(&self) -> &str {std::str::from_utf8(self).expect(\"attempt to convert non-UTF8 byte string.\")} }\n\nmacro_rules! veci {\n ($n:expr , $i:ident : $gen:expr) => {{\n let _veci_n = $n;\n let mut _veci_list = Vec::with_capacity(_veci_n);\n for $i in 0.._veci_n {\n _veci_list.push($gen);\n }\n _veci_list\n }};\n ($n:expr , $gen:expr) => { veci!($n, _veci_: $gen) }\n}\n\nfn abs_diff + PartialOrd>(x: T, y: T) -> T {\n if x < y { y - x } else { x - y }\n}\n\ntrait CommonNumExt {\n fn div_ceil(self, b: Self) -> Self;\n fn div_floor(self, b: Self) -> Self;\n fn gcd(self, b: Self) -> Self;\n fn highest_one(self) -> Self;\n fn lowest_one(self) -> Self;\n fn sig_bits(self) -> u32;\n}\n\nmacro_rules! impl_common_num_ext {\n ($($ix:tt = $ux:tt),*) => {\n $(\n impl CommonNumExt for $ux {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { self / b }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self; while a != 0 { swap(&mut a, &mut b); a %= b; }\n b\n }\n #[inline] fn highest_one(self) -> Self { \n if self == 0 { 0 } else { const ONE: $ux = 1; ONE.rotate_right(1) >> self.leading_zeros() } \n }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ux>() as u32 * 8 - self.leading_zeros() }\n }\n\n impl CommonNumExt for $ix {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if self ^ b >= 0 && r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { \n let q = self / b; let r = self % b;\n if self ^ b < 0 && r != 0 { q - 1 } else { q }\n }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self; while a != 0 { swap(&mut a, &mut b); a %= b; }\n b.abs()\n }\n #[inline] fn highest_one(self) -> Self { (self as $ux).highest_one() as _ }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ix>() as u32 * 8 - self.leading_zeros() }\n }\n )*\n }\n}\nimpl_common_num_ext!(i8 = u8, i16 = u16, i32 = u32, i64 = u64, i128 = u128, isize = usize);\n\ntrait ChMaxMin {\n fn chmax(&mut self, v: T) -> bool;\n fn chmin(&mut self, v: T) -> bool;\n}\nimpl ChMaxMin for Option {\n fn chmax(&mut self, v: T) -> bool { if self.is_none() || v > *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if self.is_none() || v < *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n}\nimpl ChMaxMin for T {\n fn chmax(&mut self, v: T) -> bool { if v > *self { *self = v; true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if v < *self { *self = v; true } else { false } }\n}\n\n// * end commons * //\n\n#[macro_use]\n#[allow(dead_code)]\nmod modint {\n use std::{fmt::{Display, Formatter}, marker::PhantomData, mem::swap, ops::*, str::FromStr, cell::Cell};\n use crate::ModInt;\n \n pub trait RemEuclidU32: Copy {\n /// Calculates `self` _mod_ `modulus` losslessly.\n fn rem_euclid_u32(self, modulus: u32) -> u32;\n }\n \n macro_rules! impl_rem_euclid_u32_for_small_signed {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self as i64).rem_euclid(i64::from(modulus)) as _\n }\n }\n )*\n }\n }\n \n impl_rem_euclid_u32_for_small_signed!(i8, i16, i32, i64, isize);\n \n impl RemEuclidU32 for i128 {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self.rem_euclid(i128::from(modulus)) as _\n }\n }\n \n macro_rules! impl_rem_euclid_u32_for_small_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self as u32 % modulus\n }\n }\n )*\n }\n }\n \n macro_rules! impl_rem_euclid_u32_for_large_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self % (modulus as $ty)) as _\n }\n }\n )*\n }\n }\n \n impl_rem_euclid_u32_for_small_unsigned!(u8, u16, u32);\n impl_rem_euclid_u32_for_large_unsigned!(u64, u128);\n \n #[cfg(target_pointer_width = \"32\")]\n impl_rem_euclid_u32_for_small_unsigned!(usize);\n \n #[cfg(target_pointer_width = \"64\")]\n impl_rem_euclid_u32_for_large_unsigned!(usize);\n #[inline]\n pub fn mul_mod_u32(a: u32, b: u32, m: u32) -> u32 {\n (a as u64 * b as u64 % m as u64) as u32\n }\n \n // for a, b < m, unspecified otherwise\n #[inline]\n fn add_mod_raw(a: u32, b: u32, m: u32) -> u32 {\n let (r, c) = a.wrapping_sub(m).overflowing_add(b);\n if c { r } else { a + b }\n }\n #[inline]\n fn sub_mod_raw(a: u32, b: u32, m: u32) -> u32 {\n let (r, c) = a.overflowing_sub(b);\n if c { r.wrapping_add(m) } else { r }\n }\n fn pow_mod_raw(a: u32, mut k: u64, m: u32) -> u32 {\n if m == 1 { return 0; }\n let mut a = a as u64;\n let m = m as u64;\n let mut r: u64 = 1;\n while k > 0 {\n if k & 1 == 1 {\n r = r * a % m;\n }\n k >>= 1;\n a = a * a % m;\n }\n r as u32\n }\n \n /// # Parameters\n /// * `b` `1 <= b`\n /// # Returns\n /// (x, g) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g\n fn inv_gcd(a: i64, b: i64) -> (i64, i64) {\n let a = a.rem_euclid(b);\n if a == 0 { return (0, b); }\n let mut s = b;\n let mut t = a;\n let mut m0 = 0;\n let mut m1 = 1;\n \n while t != 0 {\n let u = s / t;\n s -= t * u;\n m0 -= m1 * u;\n swap(&mut s, &mut t);\n swap(&mut m0, &mut m1);\n }\n \n if m0 < 0 { m0 += b / s; }\n (m0, s)\n }\n \n pub trait Modulus: Copy + Eq {\n fn get_modulus() -> u32;\n }\n \n #[derive(Clone, Copy, PartialEq, Eq, Hash)]\n #[repr(transparent)]\n pub struct ModIntBase { \n val: u32,\n _phantom: PhantomData\n }\n \n impl ModIntBase {\n #[inline(always)]\n pub fn modulus() -> u32 { M::get_modulus() }\n #[inline] pub fn new(val: I) -> Self { Self::raw(val.rem_euclid_u32(Self::modulus())) }\n #[inline] pub fn raw(val: u32) -> Self { Self { val, _phantom: PhantomData } }\n pub fn inv(self) -> Self { \n let (x, gcd) = inv_gcd(self.val.into(), Self::modulus().into());\n debug_assert!(gcd == 1, \"the multiplicative inverse {}^-1 mod {} does not exist\", self.val, Self::modulus());\n Self::raw(x as u32)\n }\n #[inline] pub fn val(self) -> u32 { self.val }\n #[inline] pub fn pow(self, k: u64) -> Self {\n Self::raw(pow_mod_raw(self.val, k, Self::modulus()))\n }\n pub fn powi(self, k: i64) -> Self { if k < 0 { self.inv().pow(-k as _) } else { self.pow(k as _) } }\n pub fn pow_vec(self, n: usize) -> Vec {\n let mut res = vec![Self::raw(0); n+1];\n res[0] += 1;\n for i in 1..=n {\n res[i] = res[i-1] * self;\n }\n res\n }\n \n pub fn invs(a: &[Self]) -> Vec {\n let n = a.len();\n if n == 0 { return vec![]; }\n let mut acc = Self::new(1);\n let mut res = Vec::with_capacity(n);\n for i in 0..n {\n if a[i].val() != 0 { acc *= a[i]; }\n res.push(acc);\n }\n acc = acc.inv();\n for i in (1..n).rev() {\n res[i] = acc * res[i-1];\n if a[i].val() != 0 { acc *= a[i]; }\n }\n res[0] = acc;\n res\n }\n }\n \n #[inline]\n pub fn mi(val: I) -> ModInt { ModIntBase::new(val) }\n #[inline] pub fn mir(v: u32) -> ModInt { ModIntBase::raw(v) }\n \n impl From for ModIntBase {\n #[inline]\n fn from(from: V) -> Self { Self::new(from) }\n }\n impl Default for ModIntBase {\n fn default() -> Self { Self::raw(0) }\n }\n impl FromStr for ModIntBase {\n type Err = std::convert::Infallible;\n #[inline]\n fn from_str(s: &str) -> Result {\n Ok(s.parse::()\n .map(Self::new)\n .unwrap_or_else(|_| todo!(\"parsing as an arbitrary precision integer?\")))\n }\n }\n impl Display for ModIntBase {\n #[inline]\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n self.val.fmt(f)\n }\n }\n impl std::fmt::Debug for ModIntBase {\n #[inline]\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n std::fmt::Debug::fmt(&self.val, f)\n }\n }\n impl Neg for ModIntBase {\n type Output = Self;\n \n #[inline]\n fn neg(self) -> Self::Output {\n Self::raw(0) - self\n }\n }\n \n impl>, M: Modulus> Add for ModIntBase {\n type Output = Self;\n #[inline]\n fn add(self, rhs: V) -> Self::Output {\n Self::raw(add_mod_raw(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Sub for ModIntBase {\n type Output = Self;\n #[inline]\n fn sub(self, rhs: V) -> Self::Output {\n Self::raw(sub_mod_raw(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Mul for ModIntBase {\n type Output = Self;\n #[inline]\n fn mul(self, rhs: V) -> Self::Output {\n Self::raw(mul_mod_u32(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Div for ModIntBase {\n type Output = Self;\n #[inline]\n fn div(self, rhs: V) -> Self::Output { self * rhs.into().inv() }\n }\n \n impl >, M: Modulus> AddAssign for ModIntBase {\n #[inline]\n fn add_assign(&mut self, rhs: V) { *self = *self + rhs; }\n }\n impl >, M: Modulus> SubAssign for ModIntBase {\n #[inline]\n fn sub_assign(&mut self, rhs: V) { *self = *self - rhs; }\n }\n impl >, M: Modulus> MulAssign for ModIntBase {\n #[inline]\n fn mul_assign(&mut self, rhs: V) { *self = *self * rhs; }\n }\n impl >, M: Modulus> DivAssign for ModIntBase {\n #[inline]\n fn div_assign(&mut self, rhs: V) { *self = *self / rhs; }\n }\n \n impl std::iter::Sum for ModIntBase {\n #[inline] fn sum>(iter: I) -> Self {\n iter.fold(Self::raw(0), Add::add)\n }\n }\n impl std::iter::Product for ModIntBase {\n #[inline] fn product>(iter: I) -> Self {\n iter.fold(1.into(), Mul::mul)\n }\n }\n impl<'a, M: Modulus> std::iter::Sum<&'a Self> for ModIntBase {\n #[inline] fn sum>(iter: I) -> ModIntBase {\n iter.fold(Self::raw(0), |a, &b| a + b)\n }\n }\n impl<'a, M: Modulus> std::iter::Product<&'a Self> for ModIntBase {\n #[inline] fn product>(iter: I) -> ModIntBase {\n iter.fold(1.into(), |a, &b| a * b)\n }\n }\n \n macro_rules! const_modulus {\n ($mint: ident, $name: ident, $modulus: expr) => {\n #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]\n pub enum $name {}\n impl Modulus for $name {\n #[inline(always)] fn get_modulus() -> u32 { $modulus }\n }\n pub type $mint = ModIntBase<$name>;\n }\n }\n \n macro_rules! dynamic_modulus {\n ($mint: ident, $name: ident, $modulus: ident) => {\n static $modulus: crate::Unsync> = crate::Unsync(Cell::new(0));\n #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]\n pub enum $name {}\n impl Modulus for $name {\n fn get_modulus() -> u32 { $modulus.0.get() }\n }\n impl $name {\n pub fn set_modulus(val: u32) { $modulus.0.set(val) }\n }\n pub type $mint = ModIntBase<$name>;\n }\n }\n \n const_modulus!(ModInt998_244_353, Mod998_244_353, 998_244_353);\n const_modulus!(ModInt1_000_000_007, Mod1_000_000_007, 1_000_000_007);\n dynamic_modulus!(DynamicModInt, DynamicModulus, DYNAMIC_MODULUS);\n}\n \nuse crate::modint::*;\ntype ModInt = ModInt998_244_353;\n// type ModInt = ModInt1_000_000_007;\n// const_modulus!(ModInt, DefaultModulus, 1_000_000_009);\n// type ModInt = DynamicModInt;\n \n#[allow(non_snake_case, non_upper_case_globals)]\nfn main() {\n let num_cases: usize = 1;//read();\n\n for _case_num in 1..=num_cases {\n let n = read!(usize);\n let a0 = read!(u64);\n let x = read!(u64);\n let y = read!(u64);\n let k = read!(usize);\n let M = read!(u64);\n\n let npow = mir(n as _).pow_vec(k-1);\n\n let mut C = 1usize;\n for i in 2..k {\n C = C / C.gcd(i) * i;\n }\n let mut dp = vec![mi(0); C];\n\n let mut ans = mi(0);\n let mult = mir(k as _) * npow[k-1];\n let mut a = a0;\n for _ in 0..n {\n let q = (a as usize) / C;\n let r = (a as usize) % C;\n\n ans += mir((q * C) as _) * mult;\n dp[r] += 1;\n a = (a * x + y) % M;\n }\n\n for i in 1..=k {\n let mut dn = vec![mi(0); C];\n for j in 0..C {\n ans += dp[j] * npow[k-i] * mir(j as _);\n dn[j] += dp[j] * mir((n-1) as _);\n dn[j - j % i] += dp[j];\n }\n dp = dn;\n }\n\n println!(ans);\n }\n \n out_flush();\n}", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics", "probabilities", "number theory"], "code_uid": "d4270c3e05bc14948fde2c8a6d9fb657", "src_uid": "1d45491e28d24e2b318605cd328d6ecf", "difficulty": 2800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\n\nfn main() {\n\tlet mut inp = String::new();\n\tstdin().read_line(&mut inp).unwrap();\n\tlet n:u64 = inp.split_whitespace().nth(0).unwrap().parse().unwrap();\n\tlet k:u64 = inp.split_whitespace().nth(1).unwrap().parse().unwrap();\n\t//dbg!(n, k);\n\n\tlet half;\n\tif n%2 == 0 {\n\t\thalf = n/2;\n\t} else {\n\t\t half = n/2 + 1\n\t}\n\tlet out;\n\tif k <= half {\n\t\tout = k*2 - 1;\n\t} else {\n\t\tout = (k - half)*2\n\t}\n\tprintln!(\"{}\", out);\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "e333220c6eb08cf8f2463b3650604f3a", "src_uid": "1f8056884db00ad8294a7cc0be75fe97", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nmacro_rules! rt {\n ( $( $type:ty ),+ ) => ({\n let mut s = String::new();\n io::stdin().read_line(&mut s).unwrap();\n let mut iter = s.split_whitespace();\n (\n $(\n iter.next().unwrap().parse::<$type>().unwrap(),\n )+\n )\n })\n}\n\nfn main() {\n let (n, mut k) = rt!(u128, u128);\n\n let odds_len = (n+1)/2;\n\n if k <= odds_len {\n println!(\"{}\", k*2-1);\n } else {\n k -= odds_len;\n println!(\"{}\", k*2);\n }\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "dcfef99f65951e23a1a8be74de386285", "src_uid": "1f8056884db00ad8294a7cc0be75fe97", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{min,max};\nuse std::io::{BufWriter, stdin, stdout, Write};\n\n#[derive(Default)]\nstruct Scanner {\n buffer: Vec\n}\nimpl Scanner {\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n stdin().read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn main() {\n let mut scan = Scanner::default();\n let out = &mut BufWriter::new(stdout());\n\n\tlet n = 4;\n let mut p = (0..n).map(|_| scan.next::()).collect::>();\n p.sort();\n p.dedup();\n\n writeln!(out, \"{}\", n - p.len()).expect(\"fail\");\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "48e44d54703354915b2d5fa23f27ce49", "src_uid": "38c4864937e57b35d3cce272f655e20f", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::io::Stdin;\nuse std::str::FromStr;\nuse std::collections::HashSet;\n\nfn read_line(stdin: &Stdin, line: &mut String) {\n match stdin.read_line(line) {\n Ok(_) => return,\n Err(msg) => panic!(\"Could not read line! Message: {}.\", msg),\n }\n}\n\nfn parse_t(s: &str) -> T {\n match s.trim().parse() {\n Ok(y) => y,\n Err(_) => panic!(\"Could not read from string!\"),\n }\n}\n\nfn read_ts(stdin: &Stdin, ts: &mut Vec) {\n let mut line = String::new();\n read_line(stdin, &mut line);\n let word_iter = line.split_whitespace();\n for word in word_iter {\n let x = parse_t(word);\n ts.push(x);\n }\n}\n\nfn read_i64(stdin: &Stdin) -> i64 {\n let mut line = String::new();\n read_line(&stdin, &mut line);\n match line.trim().parse() {\n Ok(i) => i,\n Err(e) => {\n panic!(\"Could not read i64!\");\n }\n }\n}\n\nfn main() {\n let stdin = io::stdin();\n let mut v:Vec= vec![];\n read_ts(&stdin, &mut v);\n let mut hs = HashSet::new();\n for i in v {\n hs.insert(i);\n }\n println!(\"{}\", 4 - hs.len());\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "0f3080cc75e738554160ebadf4780233", "src_uid": "38c4864937e57b35d3cce272f655e20f", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(non_snake_case)]\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io::Write;\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($e:expr),*) => {\n #[cfg(debug_assertions)]\n $({\n let (e, mut err) = (stringify!($e), std::io::stderr());\n writeln!(err, \"{} = {:?}\", e, $e).unwrap()\n })*\n };\n}\n\nfn main() {\n let v = read_vec::();\n let (n, p) = (v[0] as usize, v[1]);\n Modulo::set_modulus(p);\n\n let mut fact = vec![Modulo::new(1); n + 1];\n for i in 2..fact.len() {\n fact[i] = fact[i - 1] * Modulo::new(i as i64);\n }\n\n let mut ans = Modulo::new(0);\n for l in 1..n + 1 {\n let place_cand = Modulo::new((n + 1 - l) as i64);\n let num_cand = Modulo::new((n + 1 - l) as i64);\n let inner_permutation = fact[l as usize];\n let outer_permutation = fact[(n - l) as usize];\n ans += place_cand * num_cand * inner_permutation * outer_permutation;\n }\n println!(\"{}\", ans);\n}\n\nfn read() -> T {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).ok();\n s.trim().parse().ok().unwrap()\n}\n\nfn read_vec() -> Vec {\n read::()\n .split_whitespace()\n .map(|e| e.parse().ok().unwrap())\n .collect()\n}\n\n#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]\nstruct Modulo(i64);\nstatic mut MODULUS: i64 = 0;\nimpl Modulo {\n fn set_modulus(m: i64) {\n unsafe {\n MODULUS = m;\n }\n }\n fn get_modulus() -> i64 {\n unsafe { MODULUS }\n }\n fn new(x: i64) -> Modulo {\n let m = Modulo::get_modulus();\n if x < 0 {\n Modulo(x % m + m)\n } else if x < m {\n Modulo(x)\n } else {\n Modulo(x % m)\n }\n }\n fn pow(self, p: i64) -> Modulo {\n if p == 0 {\n Modulo(1)\n } else {\n let mut t = self.pow(p / 2);\n t *= t;\n if p & 1 == 1 {\n t *= self;\n }\n t\n }\n }\n fn inv(self) -> Modulo {\n self.pow(Modulo::get_modulus() - 2)\n }\n}\nimpl std::fmt::Display for Modulo {\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n self.0.fmt(f)\n }\n}\nimpl std::ops::AddAssign for Modulo {\n fn add_assign(&mut self, other: Modulo) {\n let m = Modulo::get_modulus();\n self.0 += other.0;\n if self.0 >= m {\n self.0 -= m;\n }\n }\n}\nimpl std::ops::MulAssign for Modulo {\n fn mul_assign(&mut self, other: Modulo) {\n let m = Modulo::get_modulus();\n self.0 *= other.0;\n self.0 %= m;\n }\n}\nimpl std::ops::SubAssign for Modulo {\n fn sub_assign(&mut self, other: Modulo) {\n let m = Modulo::get_modulus();\n self.0 += m - other.0;\n if self.0 >= m {\n self.0 -= m;\n }\n }\n}\nmacro_rules! impl_modulo_ops {\n ($imp:ident, $method:ident, $assign_imp:ident, $assign_method:ident) => {\n impl<'a> std::ops::$assign_imp<&'a Modulo> for Modulo {\n fn $assign_method(&mut self, other: &'a Modulo) {\n std::ops::$assign_imp::$assign_method(self, *other);\n }\n }\n impl std::ops::$imp for Modulo {\n type Output = Modulo;\n fn $method(self, other: Modulo) -> Modulo {\n let mut x = self;\n std::ops::$assign_imp::$assign_method(&mut x, other);\n x\n }\n }\n impl<'a> std::ops::$imp for &'a Modulo {\n type Output = Modulo;\n fn $method(self, other: Modulo) -> Modulo {\n std::ops::$imp::$method(*self, other)\n }\n }\n impl<'a> std::ops::$imp<&'a Modulo> for Modulo {\n type Output = Modulo;\n fn $method(self, other: &'a Modulo) -> Modulo {\n std::ops::$imp::$method(self, *other)\n }\n }\n impl<'a, 'b> std::ops::$imp<&'b Modulo> for &'a Modulo {\n type Output = Modulo;\n fn $method(self, other: &'b Modulo) -> Modulo {\n std::ops::$imp::$method(*self, *other)\n }\n }\n impl std::ops::$assign_imp for Modulo {\n fn $assign_method(&mut self, other: i64) {\n std::ops::$assign_imp::$assign_method(self, Modulo::new(other));\n }\n }\n impl<'a> std::ops::$assign_imp<&'a i64> for Modulo {\n fn $assign_method(&mut self, other: &'a i64) {\n std::ops::$assign_imp::$assign_method(self, *other);\n }\n }\n impl std::ops::$imp for Modulo {\n type Output = Modulo;\n fn $method(self, other: i64) -> Modulo {\n let mut x = self;\n std::ops::$assign_imp::$assign_method(&mut x, other);\n x\n }\n }\n impl<'a> std::ops::$imp<&'a i64> for Modulo {\n type Output = Modulo;\n fn $method(self, other: &'a i64) -> Modulo {\n std::ops::$imp::$method(self, *other)\n }\n }\n impl<'a> std::ops::$imp for &'a Modulo {\n type Output = Modulo;\n fn $method(self, other: i64) -> Modulo {\n std::ops::$imp::$method(*self, other)\n }\n }\n impl<'a, 'b> std::ops::$imp<&'b i64> for &'a Modulo {\n type Output = Modulo;\n fn $method(self, other: &'b i64) -> Modulo {\n std::ops::$imp::$method(*self, *other)\n }\n }\n };\n}\nimpl_modulo_ops!(Add, add, AddAssign, add_assign);\nimpl_modulo_ops!(Mul, mul, MulAssign, mul_assign);\nimpl_modulo_ops!(Sub, sub, SubAssign, sub_assign);\n", "lang_cluster": "Rust", "tags": ["math", "combinatorics"], "code_uid": "2ccd8f8a94aafd3915abc6ebc95f8694", "src_uid": "020d5dae7157d937c3f58554c9b155f9", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unknown_lints)]\n#![allow(unused_imports, unused_macros, non_snake_case, bare_trait_objects)]\n#![allow(renamed_and_removed_lints, redundant_field_names)]\nuse std::cmp::Ordering::{self, Greater, Less};\nuse std::cmp::{max, min};\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\nuse std::error::Error;\nuse std::io::{self, BufReader, BufWriter, Read, Write};\nuse text_scanner::{scan, scan_iter, scanln, scanln_iter};\nuse utils::adj4_iter;\n\nfn run() {\n let n: i64 = scan();\n let m: i64 = scan();\n let mut perm = vec![1i64; n as usize + 10];\n for i in 1..n + 1 {\n perm[i as usize] = perm[i as usize - 1] * i % m;\n }\n\n let mut ans = 0i64;\n for k in 1..n + 1 {\n let hoge =\n perm[(n - k) as usize] * (n - k + 1) % m * (n - k + 1) % m * perm[k as usize] % m;\n ans += hoge;\n ans %= m;\n }\n\n println!(\"{}\", ans);\n}\n\nfn main() {\n std::thread::Builder::new()\n .name(\"run\".to_string())\n .stack_size(256 * 1024 * 1024)\n .spawn(run)\n .unwrap()\n .join()\n .unwrap()\n}\n\n//{{{ utils\npub mod utils {\n static DY: [isize; 8] = [0, 1, 0, -1, 1, -1, 1, -1];\n static DX: [isize; 8] = [1, 0, -1, 0, 1, 1, -1, -1];\n\n fn try_adj(\n y: usize,\n x: usize,\n dy: isize,\n dx: isize,\n h: usize,\n w: usize,\n ) -> Option<(usize, usize)> {\n let ny = y as isize + dy;\n let nx = x as isize + dx;\n if ny >= 0 && nx >= 0 {\n let ny = ny as usize;\n let nx = nx as usize;\n if ny < h && nx < w {\n Some((ny, nx))\n } else {\n None\n }\n } else {\n None\n }\n }\n\n pub struct Adj4 {\n y: usize,\n x: usize,\n h: usize,\n w: usize,\n r: usize,\n }\n\n impl Iterator for Adj4 {\n type Item = (usize, usize);\n\n fn next(&mut self) -> Option {\n loop {\n if self.r >= 4 {\n return None;\n }\n\n let dy = DY[self.r];\n let dx = DX[self.r];\n self.r += 1;\n\n if let Some((ny, nx)) = try_adj(self.y, self.x, dy, dx, self.h, self.w) {\n return Some((ny, nx));\n }\n }\n }\n }\n\n pub fn adj4_iter(y: usize, x: usize, h: usize, w: usize) -> Adj4 {\n Adj4 {\n y: y,\n x: x,\n h: h,\n w: w,\n r: 0,\n }\n }\n}\npub mod text_scanner {\n use std;\n #[derive(Debug)]\n pub enum Error {\n IoError(std::io::Error),\n EncodingError(std::string::FromUtf8Error),\n ParseError(String),\n Eof,\n }\n\n impl std::fmt::Display for Error {\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n match *self {\n Error::IoError(ref e) => writeln!(f, \"IO Error: {}\", e),\n Error::EncodingError(ref e) => writeln!(f, \"Encoding Error: {}\", e),\n Error::ParseError(ref e) => writeln!(f, \"Parse Error: {}\", e),\n Error::Eof => writeln!(f, \"EOF\"),\n }\n }\n }\n\n impl std::error::Error for Error {\n // dummy implementation for 1.15.1\n fn description(&self) -> &str {\n \"description() is deprecated; use Display\"\n }\n }\n\n pub fn read_line() -> Option {\n let stdin = std::io::stdin();\n let mut stdin = stdin.lock();\n fread_line(&mut stdin).expect(\"IO error\")\n }\n\n pub fn scan() -> T {\n let stdin = std::io::stdin();\n let mut stdin = stdin.lock();\n fscan(&mut stdin).expect(\"IO error\")\n }\n\n pub fn scanln() -> T {\n let stdin = std::io::stdin();\n let mut stdin = stdin.lock();\n fscanln(&mut stdin).expect(\"IO error\")\n }\n\n pub fn scan_iter() -> ScanIter {\n ScanIter {\n item_type: std::marker::PhantomData,\n }\n }\n\n pub fn scanln_iter() -> ScanlnIter {\n let stdin = std::io::stdin();\n let mut stdin = stdin.lock();\n let s = fread_line(&mut stdin)\n .expect(\"IO error\")\n .unwrap_or_else(String::new);\n ScanlnIter {\n cursor: std::io::Cursor::new(s),\n item_type: std::marker::PhantomData,\n }\n }\n\n pub fn fread_line(r: &mut R) -> Result, std::io::Error> {\n let mut buf = String::new();\n let length = r.read_line(&mut buf)?;\n if let Some('\\n') = buf.chars().last() {\n buf.pop();\n }\n if let Some('\\r') = buf.chars().last() {\n buf.pop();\n }\n if length == 0 {\n Ok(None)\n } else {\n Ok(Some(buf))\n }\n }\n\n pub fn fscan(reader: &mut R) -> Result {\n let mut tokenizer = Tokenizer::new(reader);\n FromTokens::from_tokens(&mut tokenizer)\n }\n\n pub fn fscanln(reader: &mut R) -> Result {\n let s = match fread_line(reader) {\n Ok(Some(s)) => s,\n Ok(None) => return Err(Error::Eof),\n Err(e) => return Err(Error::IoError(e)),\n };\n let mut bytes = s.as_bytes();\n let mut tokenizer = Tokenizer::new(&mut bytes);\n FromTokens::from_tokens(&mut tokenizer)\n }\n\n pub fn fscan_iter(reader: &mut R) -> FscanIter {\n FscanIter {\n tokenizer: Tokenizer::new(reader),\n item_type: std::marker::PhantomData,\n }\n }\n\n pub fn fscanln_iter(\n reader: &mut R,\n ) -> Result, Error> {\n let s = match fread_line(reader) {\n Ok(Some(s)) => s,\n Ok(None) => \"\".to_string(),\n Err(e) => return Err(Error::IoError(e)),\n };\n Ok(ScanlnIter {\n cursor: std::io::Cursor::new(s),\n item_type: std::marker::PhantomData,\n })\n }\n\n pub struct ScanIter\n where\n T: FromTokens,\n {\n item_type: std::marker::PhantomData,\n }\n\n impl Iterator for ScanIter {\n type Item = T;\n\n fn next(&mut self) -> Option {\n let stdin = std::io::stdin();\n let mut stdin = stdin.lock();\n let mut tokenizer = Tokenizer::new(&mut stdin);\n match FromTokens::from_tokens(&mut tokenizer) {\n Err(Error::Eof) => None,\n r => Some(r.expect(\"IO error\")),\n }\n }\n }\n\n pub struct FscanIter<'a, R, T>\n where\n R: std::io::Read + 'a,\n T: FromTokens,\n {\n tokenizer: Tokenizer<'a, R>,\n item_type: std::marker::PhantomData,\n }\n\n impl<'a, R: std::io::Read, T: FromTokens> Iterator for FscanIter<'a, R, T> {\n type Item = Result;\n\n fn next(&mut self) -> Option {\n match FromTokens::from_tokens(&mut self.tokenizer) {\n Err(Error::Eof) => None,\n r => Some(r),\n }\n }\n }\n\n pub struct ScanlnIter\n where\n T: FromTokens,\n {\n cursor: std::io::Cursor,\n item_type: std::marker::PhantomData,\n }\n\n impl<'a, T: FromTokens> Iterator for ScanlnIter {\n type Item = T;\n\n fn next(&mut self) -> Option {\n let mut tokenizer = Tokenizer::new(&mut self.cursor);\n match FromTokens::from_tokens(&mut tokenizer) {\n Err(Error::Eof) => None,\n r => Some(r.expect(\"IO error\")),\n }\n }\n }\n\n pub trait FromTokens\n where\n Self: Sized,\n {\n fn from_tokens(\n tokenizer: &mut Iterator>,\n ) -> Result;\n }\n\n macro_rules! from_tokens_primitives {\n ($($t:ty),*) => { $(\n impl FromTokens for $t {\n fn from_tokens(tokenizer: &mut Iterator>) -> Result {\n let token = tokenizer.next();\n match token {\n Some(s) => s?\n .parse::<$t>()\n .map_err(|e| Error::ParseError(format!(\"{}\", e))),\n None => Err(Error::Eof),\n }\n }\n }\n )* }\n}\n\n from_tokens_primitives! {\n String,\n bool,\n f32,\n f64,\n isize,\n i8,\n i16,\n i32,\n i64,\n usize,\n u8,\n u16,\n u32,\n u64\n }\n\n impl FromTokens for Vec {\n fn from_tokens(\n tokenizer: &mut Iterator>,\n ) -> Result {\n Ok(String::from_tokens(tokenizer)?.chars().collect())\n }\n }\n\n impl FromTokens for (T1, T2)\n where\n T1: FromTokens,\n T2: FromTokens,\n {\n fn from_tokens(\n tokenizer: &mut Iterator>,\n ) -> Result {\n Ok((T1::from_tokens(tokenizer)?, T2::from_tokens(tokenizer)?))\n }\n }\n\n impl FromTokens for (T1, T2, T3)\n where\n T1: FromTokens,\n T2: FromTokens,\n T3: FromTokens,\n {\n fn from_tokens(\n tokenizer: &mut Iterator>,\n ) -> Result {\n Ok((\n T1::from_tokens(tokenizer)?,\n T2::from_tokens(tokenizer)?,\n T3::from_tokens(tokenizer)?,\n ))\n }\n }\n\n impl FromTokens for (T1, T2, T3, T4)\n where\n T1: FromTokens,\n T2: FromTokens,\n T3: FromTokens,\n T4: FromTokens,\n {\n fn from_tokens(\n tokenizer: &mut Iterator>,\n ) -> Result {\n Ok((\n T1::from_tokens(tokenizer)?,\n T2::from_tokens(tokenizer)?,\n T3::from_tokens(tokenizer)?,\n T4::from_tokens(tokenizer)?,\n ))\n }\n }\n\n impl FromTokens for (T1, T2, T3, T4, T5)\n where\n T1: FromTokens,\n T2: FromTokens,\n T3: FromTokens,\n T4: FromTokens,\n T5: FromTokens,\n {\n fn from_tokens(\n tokenizer: &mut Iterator>,\n ) -> Result {\n Ok((\n T1::from_tokens(tokenizer)?,\n T2::from_tokens(tokenizer)?,\n T3::from_tokens(tokenizer)?,\n T4::from_tokens(tokenizer)?,\n T5::from_tokens(tokenizer)?,\n ))\n }\n }\n\n impl FromTokens for (T1, T2, T3, T4, T5, T6)\n where\n T1: FromTokens,\n T2: FromTokens,\n T3: FromTokens,\n T4: FromTokens,\n T5: FromTokens,\n T6: FromTokens,\n {\n fn from_tokens(\n tokenizer: &mut Iterator>,\n ) -> Result {\n Ok((\n T1::from_tokens(tokenizer)?,\n T2::from_tokens(tokenizer)?,\n T3::from_tokens(tokenizer)?,\n T4::from_tokens(tokenizer)?,\n T5::from_tokens(tokenizer)?,\n T6::from_tokens(tokenizer)?,\n ))\n }\n }\n\n struct Tokenizer<'a, R: std::io::Read + 'a> {\n reader: &'a mut R,\n }\n\n impl<'a, R: std::io::Read> Tokenizer<'a, R> {\n pub fn new(reader: &'a mut R) -> Self {\n Tokenizer { reader: reader }\n }\n\n pub fn next_token(&mut self) -> Result, Error> {\n use std::io::Read;\n let mut token = Vec::new();\n for b in self.reader.by_ref().bytes() {\n let b = b.map_err(Error::IoError)?;\n match (is_ascii_whitespace(b), token.is_empty()) {\n (false, _) => token.push(b),\n (true, false) => break,\n (true, true) => {}\n }\n }\n if token.is_empty() {\n return Ok(None);\n }\n String::from_utf8(token)\n .map(Some)\n .map_err(Error::EncodingError)\n }\n }\n\n impl<'a, R: std::io::Read> Iterator for Tokenizer<'a, R> {\n type Item = Result;\n fn next(&mut self) -> Option {\n match self.next_token() {\n Ok(Some(s)) => Some(Ok(s)),\n Ok(None) => None,\n Err(e) => Some(Err(e)),\n }\n }\n }\n\n fn is_ascii_whitespace(b: u8) -> bool {\n // Can use u8::is_ascii_whitespace once removing support of 1.15.1\n match b {\n b'\\t' | b'\\n' | b'\\x0C' | b'\\r' | b' ' => true,\n _ => false,\n }\n }\n}\n\npub trait SetMinMax {\n fn set_min(&mut self, v: Self) -> bool;\n fn set_max(&mut self, v: Self) -> bool;\n}\n\nimpl SetMinMax for T\nwhere\n T: PartialOrd,\n{\n fn set_min(&mut self, v: T) -> bool {\n *self > v && {\n *self = v;\n true\n }\n }\n fn set_max(&mut self, v: T) -> bool {\n *self < v && {\n *self = v;\n true\n }\n }\n}\n\n#[derive(PartialEq, Eq, Debug, Copy, Clone, Default, Hash)]\npub struct Reverse(pub T);\n\nimpl PartialOrd for Reverse {\n #[inline]\n fn partial_cmp(&self, other: &Reverse) -> Option {\n other.0.partial_cmp(&self.0)\n }\n\n #[inline]\n fn lt(&self, other: &Self) -> bool {\n other.0 < self.0\n }\n #[inline]\n fn le(&self, other: &Self) -> bool {\n other.0 <= self.0\n }\n #[inline]\n fn ge(&self, other: &Self) -> bool {\n other.0 >= self.0\n }\n #[inline]\n fn gt(&self, other: &Self) -> bool {\n other.0 > self.0\n }\n}\n\nimpl Ord for Reverse {\n #[inline]\n fn cmp(&self, other: &Reverse) -> Ordering {\n other.0.cmp(&self.0)\n }\n}\n\n#[derive(PartialEq, PartialOrd, Debug, Copy, Clone, Default)]\npub struct Num(pub f64);\n\nimpl Eq for Num {}\n\nimpl Ord for Num {\n fn cmp(&self, other: &Num) -> Ordering {\n self.0\n .partial_cmp(&other.0)\n .expect(\"unexpected NaN when compare\")\n }\n}\n\n// See https://docs.rs/superslice/1.0.0/superslice/trait.Ext.html\npub trait SliceExt {\n type Item;\n\n fn lower_bound(&self, x: &Self::Item) -> usize\n where\n Self::Item: Ord;\n\n fn lower_bound_by<'a, F>(&'a self, f: F) -> usize\n where\n F: FnMut(&'a Self::Item) -> Ordering;\n\n fn lower_bound_by_key<'a, K, F>(&'a self, k: &K, f: F) -> usize\n where\n F: FnMut(&'a Self::Item) -> K,\n K: Ord;\n\n fn upper_bound(&self, x: &Self::Item) -> usize\n where\n Self::Item: Ord;\n\n fn upper_bound_by<'a, F>(&'a self, f: F) -> usize\n where\n F: FnMut(&'a Self::Item) -> Ordering;\n\n fn upper_bound_by_key<'a, K, F>(&'a self, k: &K, f: F) -> usize\n where\n F: FnMut(&'a Self::Item) -> K,\n K: Ord;\n}\n\nimpl SliceExt for [T] {\n type Item = T;\n\n fn lower_bound(&self, x: &Self::Item) -> usize\n where\n T: Ord,\n {\n self.lower_bound_by(|y| y.cmp(x))\n }\n\n fn lower_bound_by<'a, F>(&'a self, mut f: F) -> usize\n where\n F: FnMut(&'a Self::Item) -> Ordering,\n {\n let s = self;\n let mut size = s.len();\n if size == 0 {\n return 0;\n }\n let mut base = 0usize;\n while size > 1 {\n let half = size / 2;\n let mid = base + half;\n let cmp = f(unsafe { s.get_unchecked(mid) });\n base = if cmp == Less { mid } else { base };\n size -= half;\n }\n let cmp = f(unsafe { s.get_unchecked(base) });\n base + (cmp == Less) as usize\n }\n\n fn lower_bound_by_key<'a, K, F>(&'a self, k: &K, mut f: F) -> usize\n where\n F: FnMut(&'a Self::Item) -> K,\n K: Ord,\n {\n self.lower_bound_by(|e| f(e).cmp(k))\n }\n\n fn upper_bound(&self, x: &Self::Item) -> usize\n where\n T: Ord,\n {\n self.upper_bound_by(|y| y.cmp(x))\n }\n\n fn upper_bound_by<'a, F>(&'a self, mut f: F) -> usize\n where\n F: FnMut(&'a Self::Item) -> Ordering,\n {\n let s = self;\n let mut size = s.len();\n if size == 0 {\n return 0;\n }\n let mut base = 0usize;\n while size > 1 {\n let half = size / 2;\n let mid = base + half;\n let cmp = f(unsafe { s.get_unchecked(mid) });\n base = if cmp == Greater { base } else { mid };\n size -= half;\n }\n let cmp = f(unsafe { s.get_unchecked(base) });\n base + (cmp != Greater) as usize\n }\n\n fn upper_bound_by_key<'a, K, F>(&'a self, k: &K, mut f: F) -> usize\n where\n F: FnMut(&'a Self::Item) -> K,\n K: Ord,\n {\n self.upper_bound_by(|e| f(e).cmp(k))\n }\n}\n\n//}}}\n", "lang_cluster": "Rust", "tags": ["math", "combinatorics"], "code_uid": "ceda77b3813a0658fe1fce68eba31be0", "src_uid": "020d5dae7157d937c3f58554c9b155f9", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": " \nuse std::io::{self};\n\n#[derive(Copy, Clone)]\nstruct Div3 {\n remain0: i64,\n remain1: i64,\n remain2: i64,\n}\n\nfn main() {\n let mut m = vec![Div3{remain0: 0, remain1: 0, remain2: 0}; 10000005].into_boxed_slice();\n let mut buffer = String::new();\n io::stdin().read_line(&mut buffer).expect(\"???\");\n\n let x = buffer.trim().split(' ').map(|o| o.parse::().unwrap()).collect::>();\n let d = (x[2] - x[1] + 1) / 3;\n let moder: i64 = 1e9 as i64 + 7;\n\n let mut nums = Div3{\n remain0: d,\n remain1: d,\n remain2: d,\n };\n\n if (x[2] - x[1] + 1) % 3 > 0 {\n let t = {if (x[2] - x[1] + 1) % 3 == 2 {1} else {0}};\n if x[1] % 3 == 0 {\n nums.remain0 = nums.remain0 + 1;\n nums.remain1 = nums.remain1 + t;\n } else if x[1] % 3 == 1 {\n nums.remain1 = nums.remain1 + 1;\n nums.remain2 = nums.remain2 + t;\n } else {\n nums.remain2 = nums.remain2 + 1;\n nums.remain0 = nums.remain0 + t;\n }\n }\n\n m[1] = nums.clone();\n\n for i in 2..x[0]+1 {\n let it = i as usize;\n m[it].remain0 = ((m[it - 1].remain0 * nums.remain0) % moder + (m[it - 1].remain1 * nums.remain2) % moder + (m[it - 1].remain2 * nums.remain1) % moder) % moder;\n m[it].remain1 = ((m[it - 1].remain1 * nums.remain0) % moder + (m[it - 1].remain0 * nums.remain1) % moder + (m[it - 1].remain2 * nums.remain2) % moder) % moder;\n m[it].remain2 = ((m[it - 1].remain2 * nums.remain0) % moder + (m[it - 1].remain1 * nums.remain1) % moder + (m[it - 1].remain0 * nums.remain2) % moder) % moder;\n }\n\n println!(\"{}\", m[x[0] as usize].remain0 % moder);\n}", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics"], "code_uid": "08c76f755895cd07077ff537e62a03aa", "src_uid": "4c4852df62fccb0a19ad8bc41145de61", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "use std::io;\nfn main() {\n let mut line = String::new();\n io::stdin()\n .read_line(&mut line)\n .expect(\"Error!\");\n let x: i32 = line.trim().parse().expect(\"Error!\");\n\n for _ in 0..x {\n let mut res = 0;\n let mut line1 = String::new();\n io::stdin()\n .read_line(&mut line1)\n .expect(\"Error!\");\n let b1 = line1.split_whitespace();\n for i in b1 { \n let _num: i32 = i.parse().expect(\"Error\");\n res += _num;\n } \n let mut line2 = String::new();\n io::stdin()\n .read_line(&mut line2)\n .expect(\"Error!\");\n let b2 = line2.split_whitespace();\n for i in b2 {\n let _num: i32 = i.parse().expect(\"Error\");\n res += _num;\n } \n match res {\n 0 => println!(\"0\"),\n 4 => println!(\"2\"),\n _ => println!(\"1\"),\n }\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "b580822f0edc8d82a3ea9a61afcf5f48", "src_uid": "7336b8becd2438f0439240ee8f9610ec", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "use std::{io::{BufRead, BufWriter, Write}, hash::Hash};\r\n#[allow(unused)]\r\nuse std::{{collections::*, mem::swap},cmp::Reverse};\r\n\r\nfn main() {\r\n let sin = std::io::stdin();\r\n let scan = &mut Scanner::new(sin.lock());\r\n let sout = std::io::stdout();\r\n let out = &mut BufWriter::new(sout.lock());\r\n solve_wrapper(scan, out);\r\n}\r\n\r\n#[allow(unused)]\r\n#[macro_export]\r\nmacro_rules! logln {\r\n ($($arg:tt)*) => ({\r\n #[cfg(debug_assertions)]\r\n println!($($arg)*);\r\n })\r\n}\r\n\r\ntrait MapX {\r\n fn update_with V>(&mut self, key:K, get_new_value:F);\r\n}\r\nmacro_rules! update_with { () => {\r\n fn update_with V>(&mut self, key:K, get_new_value:F) {\r\n let v = self.entry(key).or_default();\r\n let nv = get_new_value(v);\r\n *v = nv;\r\n }\r\n} }\r\nimpl MapX for BTreeMap {\r\n update_with!();\r\n}\r\nimpl MapX for HashMap {\r\n update_with!();\r\n}\r\n\r\npub struct Scanner {\r\n reader: R,\r\n buffer: Vec,\r\n}\r\nimpl Scanner {\r\n pub fn new(reader: R) -> Self {\r\n Self { reader, buffer: vec![] }\r\n }\r\n pub fn token(&mut self) -> T {\r\n loop {\r\n if let Some(token) = self.buffer.pop() {\r\n return token.parse().ok().expect(\"Failed parse\");\r\n }\r\n let mut input = String::new();\r\n self.reader.read_line(&mut input).expect(\"Failed read\");\r\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\r\n }\r\n }\r\n pub fn line(&mut self) -> Vec {\r\n if !self.buffer.is_empty() {\r\n panic!(\"Consume token buffer before read a line.\");\r\n }\r\n let mut input = String::new();\r\n self.reader.read_line(&mut input).expect(\"Failed read\");\r\n input.split_whitespace().map(|v| v.parse().ok().expect(\"Failed parse\")).collect()\r\n }\r\n pub fn line_withT>(&mut self, f: F) -> Vec {\r\n return self.line().iter().map(f).collect::>();\r\n }\r\n}\r\n\r\n#[cfg(test)]\r\nmod abc999x {\r\n use super::*;\r\n\r\n macro_rules! test_macro {\r\n ($name:ident, | $input:expr,) => {\r\n #[test]\r\n fn $name() {\r\n let vi = $input.split(\"\\n\").collect::>();\r\n let vi = &vi[1..vi.len()-1];\r\n let mut inp = String::new();\r\n let mut cnt=0;\r\n for &line in vi {\r\n if line.starts_with(\"output\") { break; }\r\n cnt+=1;\r\n if line.starts_with(\"input\") || line.starts_with(\"Copy\") { continue; }\r\n inp+=line; inp+=\"\\n\";\r\n }\r\n let mut exp = String::new();\r\n for &line in &vi[cnt..] {\r\n if line.starts_with(\"output\") || line.starts_with(\"Copy\") { continue; }\r\n exp+=line; exp+=\"\\n\";\r\n }\r\n let output = &mut Vec::new();\r\n let scan = &mut Scanner::new(inp.as_bytes());\r\n solve_wrapper(scan, output);\r\n assert_eq!(exp, std::str::from_utf8(output).unwrap());\r\n }\r\n };\r\n ($name:ident, $($n:ident),*, | $input:expr, $($i:expr),*,) => {\r\n test_macro!($name, | $input,);\r\n test_macro!($($n),*, | $($i),*,);\r\n };\r\n }\r\n\r\n test_macro!(\r\nest0,\r\ntest1,\r\ntest2,\r\ntest3,\r\n|\r\n// Example 0\r\n\"\\\r\ninputCopy\r\n\",\r\n// Example 1\r\n\"\\\r\ninputCopy\r\n3\r\n0 0\r\n0 0\r\n1 0\r\n0 1\r\n1 1\r\n1 1\r\noutputCopy\r\n0\r\n1\r\n2\r\n\",\r\n// Example 2\r\n\"\\\r\ninput\r\n\",\r\n// Example 3\r\n\"\\\r\ninput\r\n\",\r\n);\r\n\r\n}\r\n\r\nfn solve_wrapper(scan: &mut Scanner, out: &mut impl Write) {\r\n //let t = 1;\r\n let t = scan.token::();\r\n for _ in 0..t {\r\n solve(scan,out);\r\n }\r\n}\r\n\r\nfn solve(scan: &mut Scanner, out: &mut impl Write) {\r\n let mut c = 0;\r\n for _ in 0..4 {\r\n let a = scan.token::();\r\n c+=a;\r\n }\r\n if c==0 {\r\n writeln!(out, \"{}\", 0).ok();\r\n } else if c==4 {\r\n writeln!(out, \"{}\", 2).ok();\r\n } else {\r\n writeln!(out, \"{}\", 1).ok();\r\n }\r\n\r\n}\r\n\r\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "7b777b8c11dda2f45270cd275d32caad", "src_uid": "7336b8becd2438f0439240ee8f9610ec", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(dead_code, unused_macros, unused_imports)]\r\nuse std::collections::*;\r\nuse std::error::Error;\r\nuse std::fmt::write;\r\nuse std::hash::Hash;\r\nuse std::io;\r\nuse std::io::prelude::*;\r\nuse std::io::StdinLock;\r\nuse std::io::StdoutLock;\r\nuse std::io::Write;\r\nuse std::io::{stdin, stdout, BufRead, BufWriter};\r\nuse std::ops::Add;\r\n\r\nmacro_rules! fprintvec {\r\n ($dst:expr, $arg:expr) => {{\r\n writeln!(\r\n $dst,\r\n \"{}\",\r\n $arg.iter()\r\n .map(|x| format!(\"{} \", x))\r\n .collect::>()\r\n .join(\"\")\r\n )\r\n .ok();\r\n }};\r\n}\r\n\r\npub struct Scanner {\r\n reader: B,\r\n buf_str: Vec,\r\n buf_iter: std::str::SplitWhitespace<'static>,\r\n}\r\nimpl Scanner {\r\n pub fn new(reader: B) -> Self {\r\n Self {\r\n reader,\r\n buf_str: Vec::new(),\r\n buf_iter: \"\".split_whitespace(),\r\n }\r\n }\r\n pub fn next(&mut self) -> T {\r\n loop {\r\n if let Some(token) = self.buf_iter.next() {\r\n return token.parse().ok().expect(\"Failed parse\");\r\n }\r\n self.buf_str.clear();\r\n self.reader\r\n .read_until(b'\\n', &mut self.buf_str)\r\n .expect(\"Failed read\");\r\n self.buf_iter = unsafe {\r\n let slice = std::str::from_utf8_unchecked(&self.buf_str);\r\n std::mem::transmute(slice.split_whitespace())\r\n }\r\n }\r\n }\r\n\r\n pub fn next_split(&mut self) -> Vec {\r\n loop {\r\n let mut v = Vec::new();\r\n while let Some(token) = self.buf_iter.next() {\r\n v.push(token.parse().ok().expect(\"Failed parse\"));\r\n }\r\n if v.len() > 0 {\r\n return v;\r\n }\r\n\r\n self.buf_str.clear();\r\n self.reader\r\n .read_until(b'\\n', &mut self.buf_str)\r\n .expect(\"Failed read\");\r\n self.buf_iter = unsafe {\r\n let slice = std::str::from_utf8_unchecked(&self.buf_str);\r\n std::mem::transmute(slice.split_whitespace())\r\n }\r\n }\r\n }\r\n}\r\n\r\nfn lcm(first: usize, second: usize) -> usize {\r\n first * second / gcd(first, second)\r\n}\r\n\r\nfn gcd(first: usize, second: usize) -> usize {\r\n let mut max = first;\r\n let mut min = second;\r\n if min > max {\r\n let val = max;\r\n max = min;\r\n min = val;\r\n }\r\n\r\n loop {\r\n let res = max % min;\r\n if res == 0 {\r\n return min;\r\n }\r\n\r\n max = min;\r\n min = res;\r\n }\r\n}\r\n\r\nfn main() -> Result<(), Box> {\r\n let stdout = io::stdout();\r\n let lock = stdout.lock();\r\n let stdin = io::stdin();\r\n let mut ow = io::BufWriter::new(lock);\r\n let mut scan = Scanner::new(stdin.lock());\r\n\r\n let n_tests = scan.next::();\r\n\r\n for t_num in 1..=n_tests {\r\n let n = scan.next::();\r\n let m = scan.next_split::();\r\n let mut c = 1;\r\n let v = m[n - 1];\r\n if v == 0 {\r\n writeln!(ow, \"NO\");\r\n continue;\r\n }\r\n let vv = m[v - 1];\r\n if vv == 0 {\r\n writeln!(ow, \"NO\");\r\n continue;\r\n }\r\n writeln!(ow, \"YES\");\r\n // writeln!(ow, \"{}\", st.highest_bit());\r\n }\r\n Ok(())\r\n}\r\n", "lang_cluster": "Rust", "tags": ["brute force", "greedy", "implementation", "math"], "code_uid": "9a27bd9ef3e8f097a1fd6a8830de2cd0", "src_uid": "5cd113a30bbbb93d8620a483d4da0349", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(unused_imports)]\nuse std::cmp::{max, min, Reverse};\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\nuse std::io::{self, prelude::*};\nuse std::iter::Rev;\nuse std::ops::{Add, AddAssign, Deref};\nuse std::{num, str};\n\n\nfn solve(scan: &mut Scanner, w: &mut W) {\n let tt: usize = scan.token();\n for _ in 0..tt {\n let n: usize = scan.token();\n // let a: Vec = (0..3).map(|_| scan.token()).collect();\n let mut a = Vec::new();\n a.push(0);\n for _ in 0..3 {\n let ai: usize = scan.token();\n a.push(ai);\n }\n let mut vis = Vec::new();\n vis.resize(4, false);\n let mut now = n;\n loop {\n vis[now] = true;\n now = a[now];\n if vis[now] || now == a[now] {\n break;\n }\n }\n if vis[1] && vis[2] && vis[3] {\n writeln!(w, \"YES\");\n } else {\n writeln!(w, \"NO\");\n }\n }\n}\n\nfn main() {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout.lock());\n solve(&mut scan, &mut out);\n}\n\nstruct Scanner {\n reader: R,\n buf_str: Vec,\n buf_iter: str::SplitWhitespace<'static>,\n}\nimpl Scanner {\n fn new(reader: R) -> Self {\n Self {\n reader,\n buf_str: vec![],\n buf_iter: \"\".split_whitespace(),\n }\n }\n fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buf_iter.next() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n self.buf_str.clear();\n self.reader\n .read_until(b'\\n', &mut self.buf_str)\n .expect(\"Failed read\");\n self.buf_iter = unsafe {\n let slice = str::from_utf8_unchecked(&self.buf_str);\n std::mem::transmute(slice.split_whitespace())\n }\n }\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "greedy", "implementation", "math"], "code_uid": "3310c3d2ed6a49d2f715f7d832ba1ee8", "src_uid": "5cd113a30bbbb93d8620a483d4da0349", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn read_line() -> Option {\n let stdin = std::io::stdin();\n let mut line = String::new();\n if stdin.read_line(&mut line).unwrap_or(0) > 0 {\n Some(line.trim().into())\n } else {\n None\n }\n}\n\nfn main() {\n fn should_flip(c: char) -> bool {\n (\n (c.is_digit(10) && (c as u8 - '0' as u8) % 2 == 1) ||\n (['a', 'e', 'i', 'o', 'u'].iter().find(|&&a| a == c).is_some())\n )\n }\n let flips = read_line()\n .expect(\"should have line\")\n .chars()\n .fold(0, |acc, c| if should_flip(c) { acc + 1 } else { acc });\n println!(\"{}\", flips);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "b77cf72468cc789be41e29c0b57387c4", "src_uid": "b4af2b8a7e9844bf58ad3410c2cb5223", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::*;\n#[allow(unused_imports)]\nuse std::collections::*;\nuse std::io::{Write, BufWriter};\n// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\nmacro_rules! input {\n ($($r:tt)*) => {\n let stdin = std::io::stdin();\n let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));\n let mut next = move || -> String{\n bytes\n .by_ref()\n .map(|r|r.unwrap() as char)\n .skip_while(|c|c.is_whitespace())\n .take_while(|c|!c.is_whitespace())\n .collect()\n };\n input_inner!{next, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($next:expr) => {};\n ($next:expr, ) => {};\n ($next:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($next:expr, [graph1; $len:expr]) => {{\n let mut g = vec![vec![]; $len];\n let ab = read_value!($next, [(usize1, usize1)]);\n for (a, b) in ab {\n g[a].push(b);\n g[b].push(a);\n }\n g\n }};\n ($next:expr, ( $($t:tt),* )) => {\n ( $(read_value!($next, $t)),* )\n };\n ($next:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($next, $t)).collect::>()\n };\n ($next:expr, chars) => {\n read_value!($next, String).chars().collect::>()\n };\n ($next:expr, usize1) => (read_value!($next, usize) - 1);\n ($next:expr, [ $t:tt ]) => {{\n let len = read_value!($next, usize);\n read_value!($next, [$t; len])\n }};\n ($next:expr, $t:ty) => ($next().parse::<$t>().expect(\"Parse error\"));\n}\n\n#[allow(unused)]\nmacro_rules! debug {\n ($($format:tt)*) => (write!(std::io::stderr(), $($format)*).unwrap());\n}\n#[allow(unused)]\nmacro_rules! debugln {\n ($($format:tt)*) => (writeln!(std::io::stderr(), $($format)*).unwrap());\n}\n\nfn solve() {\n let out = std::io::stdout();\n let mut out = BufWriter::new(out.lock());\n macro_rules! puts {\n ($($format:tt)*) => (let _ = write!(out,$($format)*););\n }\n input! {\n s: chars,\n }\n let c = s.iter().filter(|&&c| {\n if c <= '9' {\n (c as u8 - b'0') % 2 == 1\n } else {\n ['a', 'e', 'i', 'o', 'u'].iter().find(|&&x| x == c).is_some()\n }\n }).count();\n puts!(\"{}\\n\", c);\n}\n\nfn main() {\n // In order to avoid potential stack overflow, spawn a new thread.\n let stack_size = 104_857_600; // 100 MB\n let thd = std::thread::Builder::new().stack_size(stack_size);\n thd.spawn(|| solve()).unwrap().join().unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "0e7a7490a38de6a262b9bad29a081da9", "src_uid": "b4af2b8a7e9844bf58ad3410c2cb5223", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).expect(\"INPUT:: read line failed\");\n let mut input = input.trim().split(' ');\n\n let mut vec = Vec::new();\n\n for counter in 0..3 {\n let side = input.next().unwrap().parse::().unwrap();\n vec.push(side);\n }\n\n for i in 0_usize..3_usize {\n for j in i..3_usize {\n if vec[i] > vec[j] {\n vec.swap(i,j);\n }\n }\n }\n\n let mut outcome = i32::default();\n outcome = vec[2] - vec[1] - vec[0] + 1;\n\n if outcome < 0 {\n println!(\"0\");\n } else {\n println!(\"{}\", &outcome);\n }\n\n\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "geometry"], "code_uid": "f21a68e842be4eeedd2308eb897fe32d", "src_uid": "3dc56bc08606a39dd9ca40a43c452f09", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\n#[allow(unused_imports)]\nuse std::cmp::{max, min, Ordering};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\n#[allow(unused_imports)]\nuse std::iter::FromIterator;\n#[macro_export]\nmacro_rules ! chmax { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: max ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! chmin { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: min ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! max { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: max ( $ x , max ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! min { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: min ( $ x , min ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! dvec { ( $ t : expr ; $ len : expr ) => { vec ! [ $ t ; $ len ] } ; ( $ t : expr ; $ len : expr , $ ( $ rest : expr ) ,* ) => { vec ! [ dvec ! ( $ t ; $ ( $ rest ) ,* ) ; $ len ] } ; }\n#[doc = \" main\"]\n#[allow(unused_imports)]\nuse std::io::{stdin, stdout, BufWriter, Write};\n#[macro_export]\nmacro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut parser = Parser :: from_str ( $ s ) ; input_inner ! { parser , $ ( $ r ) * } } ; ( parser = $ parser : ident , $ ( $ r : tt ) * ) => { input_inner ! { $ parser , $ ( $ r ) * } } ; ( new_stdin_parser = $ parser : ident , $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let reader = std :: io :: BufReader :: new ( stdin . lock ( ) ) ; let mut $ parser = Parser :: new ( reader ) ; input_inner ! { $ parser , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { input ! { new_stdin_parser = parser , $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! input_inner { ( $ parser : ident ) => { } ; ( $ parser : ident , ) => { } ; ( $ parser : ident , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ parser , $ t ) ; input_inner ! { $ parser $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! read_value { ( $ parser : ident , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ parser , $ t ) ) ,* ) } ; ( $ parser : ident , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ parser , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ parser : ident , chars ) => { read_value ! ( $ parser , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ parser : ident , usize1 ) => { read_value ! ( $ parser , usize ) - 1 } ; ( $ parser : ident , $ t : ty ) => { $ parser . next ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\nuse std::io;\nuse std::io::BufRead;\nuse std::str;\npub struct Parser {\n reader: R,\n buf: Vec,\n pos: usize,\n}\nimpl Parser {\n pub fn from_str(s: &str) -> Parser {\n Parser {\n reader: io::empty(),\n buf: s.as_bytes().to_vec(),\n pos: 0,\n }\n }\n}\nimpl Parser {\n pub fn new(reader: R) -> Parser {\n Parser {\n reader: reader,\n buf: vec![],\n pos: 0,\n }\n }\n pub fn update_buf(&mut self) {\n self.buf.clear();\n self.pos = 0;\n loop {\n let (len, complete) = {\n let buf2 = self.reader.fill_buf().unwrap();\n self.buf.extend_from_slice(buf2);\n let len = buf2.len();\n if len == 0 {\n break;\n }\n (len, buf2[len - 1] <= 0x20)\n };\n self.reader.consume(len);\n if complete {\n break;\n }\n }\n }\n pub fn next(&mut self) -> Result {\n loop {\n let mut begin = self.pos;\n while begin < self.buf.len() && (self.buf[begin] <= 0x20) {\n begin += 1;\n }\n let mut end = begin;\n while end < self.buf.len() && (self.buf[end] > 0x20) {\n end += 1;\n }\n if begin != self.buf.len() {\n self.pos = end;\n return str::from_utf8(&self.buf[begin..end]).unwrap().parse::();\n } else {\n self.update_buf();\n }\n }\n }\n}\n#[allow(unused_macros)]\nmacro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , \" = {:?}, \" ) ,* ) , $ ( $ a ) ,* ) ; } }\n#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\nconst BIG_STACK_SIZE: bool = true;\n#[allow(dead_code)]\nfn main() {\n use std::thread;\n if BIG_STACK_SIZE {\n thread::Builder::new()\n .stack_size(32 * 1024 * 1024)\n .name(\"solve\".into())\n .spawn(solve)\n .unwrap()\n .join()\n .unwrap();\n } else {\n solve();\n }\n}\nfn solve() {\n let out = stdout();\n let mut out = BufWriter::new(out.lock());\n input!{\n n:i64,\n }\n let mut tot = 0;\n for i in 2..=n-1 {\n tot += i * (i+1);\n }\n writeln!(out,\"{}\",tot);\n}", "lang_cluster": "Rust", "tags": ["math", "greedy", "dp"], "code_uid": "1011e182b474ceb3f1cb8de51617d5ab", "src_uid": "1bd29d7a8793c22e81a1f6fd3991307a", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str::FromStr;\n\nuse std::io::prelude::*;\nuse std::io::BufReader;\nuse std::cmp::{max, min};\n\nfn get_line() -> String {\n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n input\n}\n\nfn get_vec() -> Vec\n where T: FromStr,\n ::Err: std::fmt::Debug,\n{\n get_line().split_whitespace().map(|k| k.parse().unwrap()).collect()\n}\n\nfn main() {\n let n: usize = get_line().trim().parse().unwrap();\n\n let mut w: Vec = get_vec();\n\n w.sort();\n\n let mut ans = None;\n\n for i in 0..2 * n {\n for j in i + 1..2 * n {\n let mut v = w.clone();\n v.remove(j);\n v.remove(i);\n let cur = v.into_iter().fold((0, false), |acc, x| {\n (if acc.1 {\n acc.0 + x\n } else {\n acc.0 - x\n },\n !acc.1)\n }).0;\n\n match ans {\n Some(x) if x <= cur => (),\n _ => ans = Some(cur),\n };\n }\n }\n\n println!(\"{}\", ans.unwrap());\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "sortings", "greedy"], "code_uid": "3273627a9007d6e7647126c5748ad9a9", "src_uid": "76659c0b7134416452585c391daadb16", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(dead_code)]\n#![allow(unused_imports)]\n#![allow(unused_macros)]\n#![allow(overflowing_literals)]\n#![allow(unused_must_use)]\n\nuse std::collections::*;\nuse std::io::*;\nuse std::cmp::{min, max};\nuse std::f64::consts::*;\nuse std::mem::swap;\nuse std::fs::File;\nuse std::rc::*;\nuse std::ascii::*;\nuse std::ops::*;\n\nconst INF: i32 = std::i32::MAX;\nconst LINF: i64 = std::i64::MAX;\nconst MOD: usize = 1000000007;\n\n#[derive(PartialEq, PartialOrd, Eq, Ord, Copy, Clone)]\nstruct Pair(A, B);\n\nstruct Input\n{\n\tbuffer: Buf\n}\n\nimpl Input\n{\n\tfn read_line(&mut self) -> String {\n\t\tlet mut v = Vec::new();\n\t\tlet mut x = [255u8];\n\t\tself.buffer.read(&mut x).expect(\"EOF\");\n\t\twhile x[0] < b' ' && x[0] != 255u8 {\n\t\t\tx[0] = 255u8;\n\t\t\tself.buffer.read(&mut x).expect(\"EOF\");\n\t\t}\n\t\twhile x[0] >= b' ' && x[0] != 255u8 {\n\t\t\tv.push(x[0]);\n\t\t\tx[0] = 255u8;\n\t\t\tself.buffer.read(&mut x).expect(\"EOF\");\n\t\t}\n\t\tString::from_utf8(v).unwrap()\n\t}\n\n\tfn read_word(&mut self) -> String {\n\t\tlet mut v = Vec::new();\n\t\tlet mut x = [255u8];\n\t\tself.buffer.read(&mut x).expect(\"EOF\");\n\t\twhile x[0] <= b' ' && x[0] != 255u8 {\n\t\t\tx[0] = 255u8;\n\t\t\tself.buffer.read(&mut x).expect(\"EOF\");\n\t\t}\n\t\twhile x[0] > b' ' && x[0] != 255u8 {\n\t\t\tv.push(x[0]);\n\t\t\tx[0] = 255u8;\n\t\t\tself.buffer.read(&mut x).expect(\"EOF\");\n\t\t}\n\t\tString::from_utf8(v).unwrap()\n\t}\n\t#[inline]\n\tfn read_int(&mut self) -> i32 {\n\t\tself.read_word().parse::().expect(\"Parsing error\")\n\t}\n\t#[inline]\n\tfn read_long(&mut self) -> i64 {\n\t\tself.read_word().parse::().expect(\"Parsing error\")\n\t}\n\t#[inline]\n\tfn read_usize(&mut self) -> usize {\n\t\tself.read_word().parse::().expect(\"Parsing error\")\n\t}\n\t#[inline]\n\tfn read_double(&mut self) -> f64 {\n\t\tself.read_word().parse::().expect(\"Parsing error\")\n\t}\n}\nmacro_rules! read {\n () => {};\n\t($inf:ident,$($t:ty),*) => ({($({$inf.read_word().parse::<$t>().expect(\"Parsing error\")}),*)});\n}\nfn gcd + Copy + Clone>(x: T, y: T) -> T {\n\tlet (mut a, mut b) = (x, y);\n\twhile b > T::from(0) {\n\t\ta %= b;\n\t\tswap(&mut a, &mut b);\n\t}\n\ta\n}\n\nfn main() {\n\tmatch std::env::var(\"home\") {\n\t\tOk(_x) => {\n\t\t\tlet mut inf = Input {\n\t\t\t\tbuffer: BufReader::new(File::open(\"input.txt\").expect(\"File not found\"))\n\t\t\t};\n\t\t\tlet mut ouf = BufWriter::new(stdout());\n\t\t\tsolve(&mut inf, &mut ouf);\n\t\t}\n\t\tErr(_e) => {\n\t\t\tlet mut inf = Input { buffer: BufReader::new(stdin()) };\n\t\t\tlet mut ouf = BufWriter::new(stdout());\n\t\t\tsolve(&mut inf, &mut ouf);\n\t\t}\n\t}\n}\n\nfn solve(inf: &mut Input, ouf: &mut Output)\n{\n\tlet n = read!(inf,usize) * 2;\n\tlet mut w = vec![0usize; n];\n\tfor i in 0..n {\n\t\tw[i] = read!(inf,usize);\n\t}\n\tw.sort();\n\tlet mut ans = MOD;\n\tfor i in 0..n {\n\t\tfor j in i + 1..n {\n\t\t\tlet mut v = Vec::new();\n\t\t\tfor k in 0..n {\n\t\t\t\tif k != i && k != j {\n\t\t\t\t\tv.push(w[k]);\n\t\t\t\t}\n\t\t\t}\n\t\t\tlet mut pos = 0;\n\t\t\tlet mut p = 0;\n\t\t\twhile pos < v.len() {\n\t\t\t\tp += v[pos + 1] - v[pos];\n\t\t\t\tpos += 2;\n\t\t\t}\n\t\t\tans = min(ans, p);\n\t\t}\n\t}\n\twriteln!(ouf, \"{}\", ans);\n}", "lang_cluster": "Rust", "tags": ["brute force", "sortings", "greedy"], "code_uid": "f12b3ff7ebe903850946824c1ca8e745", "src_uid": "76659c0b7134416452585c391daadb16", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "pub mod solution {\n\nuse crate::io::input::Input;\nuse crate::io::output::output;\nuse crate::numbers::mod_int::ModIntF;\nuse crate::numbers::num_traits::as_index::AsIndex;\nuse crate::numbers::num_traits::zero_one::ZeroOne;\nuse crate::numbers::prime_fft::PrimeFFT;\nuse crate::out_line;\n\nfn solve(input: &mut Input, _test_case: usize) {\n let n = input.read_usize();\n let k = input.read_usize();\n let f = input.read_usize();\n\n type Mod = ModIntF;\n let mut fft = PrimeFFT::new();\n let mut a = vec![Mod::one(); k + 1];\n let mut b = fft.multiply(&a, &a);\n for _ in 1..n {\n let mut tail = b.iter().skip(k + 1).fold(Mod::zero(), |acc, &x| acc + x);\n for i in (0..=k).rev() {\n a[i] = tail + b[i] * Mod::from_index(k - i + 1);\n tail += b[i];\n }\n b = fft.multiply(&a, &a);\n }\n if f < b.len() {\n out_line!(b[f]);\n } else {\n out_line!(0);\n }\n}\n\npub(crate) fn run(mut input: Input) -> bool {\n #[allow(dead_code)]\n enum TestType {\n Single,\n MultiNumber,\n MultiEof,\n }\n let test_type = TestType::Single;\n match test_type {\n TestType::Single => solve(&mut input, 1),\n TestType::MultiNumber => {\n let t = input.read();\n for i in 0usize..t {\n solve(&mut input, i + 1);\n }\n }\n TestType::MultiEof => {\n let mut i = 1usize;\n while input.peek().is_some() {\n solve(&mut input, i);\n i += 1;\n }\n }\n }\n output().flush();\n input.skip_whitespace();\n !input.peek().is_some()\n}\n\n}\npub mod collections {\npub mod legacy_fill {\n// 1.50\npub trait LegacyFill {\n fn legacy_fill(&mut self, val: T);\n}\n\nimpl LegacyFill for [T] {\n fn legacy_fill(&mut self, val: T) {\n for el in self.iter_mut() {\n *el = val.clone();\n }\n }\n}\n\nimpl LegacyFill for Vec {\n fn legacy_fill(&mut self, val: T) {\n for el in self.iter_mut() {\n *el = val.clone();\n }\n }\n}\n}\n}\npub mod io {\npub mod input {\nuse crate::numbers::num_traits::add_sub::AddSub;\nuse crate::numbers::num_traits::from_u8::FromU8;\nuse crate::numbers::num_traits::mul_div_rem::Multable;\nuse crate::numbers::num_traits::sign::IsSigned;\nuse crate::numbers::num_traits::zero_one::ZeroOne;\nuse std::fmt::Display;\nuse std::io::Read;\nuse std::marker::PhantomData;\n\nmacro_rules! read_impl {\n ($t: ty, $read_name: ident, $read_vec_name: ident) => {\n pub fn $read_name(&mut self) -> $t {\n self.read()\n }\n\n pub fn $read_vec_name(&mut self, len: usize) -> Vec<$t> {\n self.read_vec(len)\n }\n };\n\n ($t: ty, $read_name: ident, $read_vec_name: ident, $read_pair_vec_name: ident) => {\n read_impl!($t, $read_name, $read_vec_name);\n\n pub fn $read_pair_vec_name(&mut self, len: usize) -> Vec<($t, $t)> {\n self.read_vec(len)\n }\n };\n}\n\npub struct Input<'s> {\n input: &'s mut dyn Read,\n buf: Vec,\n at: usize,\n buf_read: usize,\n}\n\nimpl<'s> Input<'s> {\n const DEFAULT_BUF_SIZE: usize = 4096;\n\n pub fn new(input: &'s mut dyn Read) -> Self {\n Self {\n input,\n buf: vec![0; Self::DEFAULT_BUF_SIZE],\n at: 0,\n buf_read: 0,\n }\n }\n\n pub fn new_with_size(input: &'s mut dyn Read, buf_size: usize) -> Self {\n Self {\n input,\n buf: vec![0; buf_size],\n at: 0,\n buf_read: 0,\n }\n }\n\n pub fn get(&mut self) -> Option {\n if self.refill_buffer() {\n let res = self.buf[self.at];\n self.at += 1;\n Some(res)\n } else {\n None\n }\n }\n\n pub fn peek(&mut self) -> Option {\n if self.refill_buffer() {\n Some(self.buf[self.at])\n } else {\n None\n }\n }\n\n pub fn skip_whitespace(&mut self) {\n while let Some(b) = self.peek() {\n if !char::from(b).is_whitespace() {\n return;\n }\n self.get();\n }\n }\n\n pub fn next_token(&mut self) -> Option> {\n self.skip_whitespace();\n let mut res = Vec::new();\n while let Some(c) = self.get() {\n if char::from(c).is_whitespace() {\n break;\n }\n res.push(c);\n }\n if res.is_empty() {\n None\n } else {\n Some(res)\n }\n }\n\n //noinspection RsSelfConvention\n pub fn is_exhausted(&mut self) -> bool {\n self.peek().is_none()\n }\n\n pub fn read(&mut self) -> T {\n T::read(self)\n }\n\n pub fn read_vec(&mut self, size: usize) -> Vec {\n let mut res = Vec::with_capacity(size);\n for _ in 0usize..size {\n res.push(self.read());\n }\n res\n }\n\n pub fn read_line(&mut self) -> String {\n let mut res = String::new();\n while let Some(c) = self.get() {\n if c == b'\\n' {\n break;\n }\n if c == b'\\r' {\n if self.peek() == Some(b'\\n') {\n self.get();\n }\n break;\n }\n res.push(c.into());\n }\n res\n }\n\n pub fn iter<'t, T: Readable + 't + 's>(&'t mut self) -> InputIterator<'t, 's, T>\n where\n 's: 't,\n {\n InputIterator {\n input: self,\n phantom: Default::default(),\n }\n }\n\n fn read_integer(&mut self) -> T {\n self.skip_whitespace();\n let mut c = self.get().unwrap();\n let sgn = if c == b'-' {\n if !T::SIGNED {\n panic!(\"negative integer\")\n }\n c = self.get().unwrap();\n true\n } else if c == b'+' {\n c = self.get().unwrap();\n false\n } else {\n false\n };\n let mut res = T::zero();\n loop {\n if !c.is_ascii_digit() {\n panic!(\n \"expected integer, found {}{}{}\",\n if sgn { \"-\" } else { \"\" },\n res,\n c as char\n );\n }\n res *= T::from_u8(10);\n res += T::from_u8(c - b'0');\n match self.get() {\n None => {\n break;\n }\n Some(ch) => {\n if char::from(ch).is_whitespace() {\n break;\n } else {\n c = ch;\n }\n }\n }\n }\n if sgn {\n debug_assert!(T::SIGNED);\n res = T::zero() - res\n }\n res\n }\n\n pub fn read_string(&mut self) -> String {\n match self.next_token() {\n None => {\n panic!(\"Input exhausted\");\n }\n Some(res) => unsafe { String::from_utf8_unchecked(res) },\n }\n }\n\n pub fn read_char(&mut self) -> char {\n self.skip_whitespace();\n self.get().unwrap().into()\n }\n\n read_impl!(u8, read_u8, read_u8_vec);\n read_impl!(u16, read_u16, read_u16_vec);\n read_impl!(u32, read_unsigned, read_unsigned_vec);\n read_impl!(u64, read_u64, read_u64_vec);\n read_impl!(u128, read_u128, read_u128_vec);\n read_impl!(usize, read_usize, read_usize_vec, read_usize_pair_vec);\n read_impl!(i8, read_i8, read_i8_vec);\n read_impl!(i16, read_i16, read_i16_vec);\n read_impl!(i32, read_int, read_int_vec, read_int_pair_vec);\n read_impl!(i64, read_long, read_long_vec, read_long_pair_vec);\n read_impl!(i128, read_i128, read_i128_vec);\n read_impl!(isize, read_isize, read_isize_vec);\n read_impl!(f64, read_float, read_float_vec);\n\n fn read_float_impl(&mut self) -> f64 {\n self.read::().parse().unwrap()\n }\n\n fn refill_buffer(&mut self) -> bool {\n if self.at == self.buf_read {\n self.at = 0;\n self.buf_read = self.input.read(&mut self.buf).unwrap();\n self.buf_read != 0\n } else {\n true\n }\n }\n}\n\npub struct InputIterator<'t, 's: 't, T: Readable + 't + 's> {\n input: &'t mut Input<'s>,\n phantom: PhantomData,\n}\n\nimpl<'t, 's: 't, T: Readable + 't + 's> Iterator for InputIterator<'t, 's, T> {\n type Item = T;\n\n fn next(&mut self) -> Option {\n self.input.skip_whitespace();\n self.input.peek().map(|_| self.input.read())\n }\n}\n\npub trait Readable {\n fn read(input: &mut Input) -> Self;\n}\n\nimpl Readable for String {\n fn read(input: &mut Input) -> Self {\n input.read_string()\n }\n}\n\nimpl Readable for char {\n fn read(input: &mut Input) -> Self {\n input.read_char()\n }\n}\n\nimpl Readable for f64 {\n fn read(input: &mut Input) -> Self {\n input.read_float_impl()\n }\n}\n\nimpl Readable for Vec {\n fn read(input: &mut Input) -> Self {\n let size = input.read();\n input.read_vec(size)\n }\n}\n\nmacro_rules! read_integer {\n ($($t:ident)+) => {$(\n impl Readable for $t {\n fn read(input: &mut Input) -> Self {\n input.read_integer()\n }\n }\n )+};\n}\n\nread_integer!(i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize);\n\nmacro_rules! tuple_readable {\n ($($name:ident)+) => {\n impl<$($name: Readable), +> Readable for ($($name,)+) {\n fn read(input: &mut Input) -> Self {\n ($($name::read(input),)+)\n }\n }\n }\n}\n\ntuple_readable! {T}\ntuple_readable! {T U}\ntuple_readable! {T U V}\ntuple_readable! {T U V X}\ntuple_readable! {T U V X Y}\ntuple_readable! {T U V X Y Z}\ntuple_readable! {T U V X Y Z A}\ntuple_readable! {T U V X Y Z A B}\ntuple_readable! {T U V X Y Z A B C}\ntuple_readable! {T U V X Y Z A B C D}\ntuple_readable! {T U V X Y Z A B C D E}\ntuple_readable! {T U V X Y Z A B C D E F}\n}\npub mod output {\nuse std::io::Write;\n\n#[derive(Copy, Clone)]\npub enum BoolOutput {\n YesNo,\n YesNoCaps,\n PossibleImpossible,\n Custom(&'static str, &'static str),\n}\n\nimpl BoolOutput {\n pub fn output(&self, output: &mut Output, val: bool) {\n (if val { self.yes() } else { self.no() }).write(output);\n }\n\n fn yes(&self) -> &str {\n match self {\n BoolOutput::YesNo => \"Yes\",\n BoolOutput::YesNoCaps => \"YES\",\n BoolOutput::PossibleImpossible => \"Possible\",\n BoolOutput::Custom(yes, _) => yes,\n }\n }\n\n fn no(&self) -> &str {\n match self {\n BoolOutput::YesNo => \"No\",\n BoolOutput::YesNoCaps => \"NO\",\n BoolOutput::PossibleImpossible => \"Impossible\",\n BoolOutput::Custom(_, no) => no,\n }\n }\n}\n\npub struct Output {\n output: Box,\n buf: Vec,\n at: usize,\n auto_flush: bool,\n pub bool_output: BoolOutput,\n}\n\nimpl Output {\n const DEFAULT_BUF_SIZE: usize = 4096;\n\n pub fn new(output: Box) -> Self {\n Self {\n output,\n buf: vec![0; Self::DEFAULT_BUF_SIZE],\n at: 0,\n auto_flush: false,\n bool_output: BoolOutput::YesNoCaps,\n }\n }\n\n pub fn new_with_auto_flush(output: Box) -> Self {\n Self {\n output,\n buf: vec![0; Self::DEFAULT_BUF_SIZE],\n at: 0,\n auto_flush: true,\n bool_output: BoolOutput::YesNoCaps,\n }\n }\n\n pub fn flush(&mut self) {\n if self.at != 0 {\n self.output.write_all(&self.buf[..self.at]).unwrap();\n self.output.flush().unwrap();\n self.at = 0;\n }\n }\n\n pub fn print(&mut self, s: &T) {\n s.write(self);\n }\n\n pub fn put(&mut self, b: u8) {\n self.buf[self.at] = b;\n self.at += 1;\n if self.at == self.buf.len() {\n self.flush();\n }\n }\n\n pub fn maybe_flush(&mut self) {\n if self.auto_flush {\n self.flush();\n }\n }\n\n pub fn print_per_line(&mut self, arg: &[T]) {\n for i in arg {\n i.write(self);\n self.put(b'\\n');\n }\n }\n\n pub fn print_iter>(&mut self, iter: I) {\n let mut first = true;\n for e in iter {\n if first {\n first = false;\n } else {\n self.put(b' ');\n }\n e.write(self);\n }\n }\n\n pub fn print_iter_ref<'a, T: 'a + Writable, I: Iterator>(&mut self, iter: I) {\n let mut first = true;\n for e in iter {\n if first {\n first = false;\n } else {\n self.put(b' ');\n }\n e.write(self);\n }\n }\n}\n\nimpl Write for Output {\n fn write(&mut self, buf: &[u8]) -> std::io::Result {\n let mut start = 0usize;\n let mut rem = buf.len();\n while rem > 0 {\n let len = (self.buf.len() - self.at).min(rem);\n self.buf[self.at..self.at + len].copy_from_slice(&buf[start..start + len]);\n self.at += len;\n if self.at == self.buf.len() {\n self.flush();\n }\n start += len;\n rem -= len;\n }\n if self.auto_flush {\n self.flush();\n }\n Ok(buf.len())\n }\n\n fn flush(&mut self) -> std::io::Result<()> {\n self.flush();\n Ok(())\n }\n}\n\npub trait Writable {\n fn write(&self, output: &mut Output);\n}\n\nimpl Writable for &str {\n fn write(&self, output: &mut Output) {\n output.write_all(self.as_bytes()).unwrap();\n }\n}\n\nimpl Writable for String {\n fn write(&self, output: &mut Output) {\n output.write_all(self.as_bytes()).unwrap();\n }\n}\n\nimpl Writable for char {\n fn write(&self, output: &mut Output) {\n output.put(*self as u8);\n }\n}\n\nimpl Writable for &[T] {\n fn write(&self, output: &mut Output) {\n output.print_iter_ref(self.iter());\n }\n}\n\nimpl Writable for &T {\n fn write(&self, output: &mut Output) {\n T::write(self, output)\n }\n}\n\nimpl Writable for Vec {\n fn write(&self, output: &mut Output) {\n (&self[..]).write(output);\n }\n}\n\nmacro_rules! write_to_string {\n ($($t:ident)+) => {$(\n impl Writable for $t {\n fn write(&self, output: &mut Output) {\n self.to_string().write(output);\n }\n }\n )+};\n}\n\nwrite_to_string!(u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize f32 f64);\n\nimpl Writable for (T, U) {\n fn write(&self, output: &mut Output) {\n self.0.write(output);\n output.put(b' ');\n self.1.write(output);\n }\n}\n\nimpl Writable for (T, U, V) {\n fn write(&self, output: &mut Output) {\n self.0.write(output);\n output.put(b' ');\n self.1.write(output);\n output.put(b' ');\n self.2.write(output);\n }\n}\n\nimpl Writable for (T, U, V, W) {\n fn write(&self, output: &mut Output) {\n self.0.write(output);\n output.put(b' ');\n self.1.write(output);\n output.put(b' ');\n self.2.write(output);\n output.put(b' ');\n self.3.write(output);\n }\n}\n\nimpl Writable for (T, U, V, W, X) {\n fn write(&self, output: &mut Output) {\n self.0.write(output);\n output.put(b' ');\n self.1.write(output);\n output.put(b' ');\n self.2.write(output);\n output.put(b' ');\n self.3.write(output);\n output.put(b' ');\n self.4.write(output);\n }\n}\n\nimpl Writable for Option {\n fn write(&self, output: &mut Output) {\n match self {\n None => (-1).write(output),\n Some(t) => t.write(output),\n }\n }\n}\n\nimpl Writable for bool {\n fn write(&self, output: &mut Output) {\n let bool_output = output.bool_output;\n bool_output.output(output, *self)\n }\n}\n\npub static mut OUTPUT: Option = None;\n\npub fn output() -> &'static mut Output {\n unsafe {\n match &mut OUTPUT {\n None => {\n panic!(\"Panic\");\n }\n Some(output) => output,\n }\n }\n}\n\n#[macro_export]\nmacro_rules! out {\n ($first: expr $(,$args:expr )*) => {\n $crate::io::output::output().print(&$first);\n $($crate::io::output::output().put(b' ');\n $crate::io::output::output().print(&$args);\n )*\n $crate::io::output::output().maybe_flush();\n }\n}\n\n#[macro_export]\nmacro_rules! out_line {\n ($first: expr $(, $args:expr )* ) => {\n $crate::out!($first $(,$args)*);\n $crate::io::output::output().put(b'\\n');\n $crate::io::output::output().maybe_flush();\n };\n () => {\n output().put(b'\\n');\n output().maybe_flush();\n };\n}\n}\n}\npub mod misc {\npub mod value {\nuse std::hash::Hash;\n\npub trait Value: Copy + Eq + Hash {\n fn val() -> T;\n}\n\npub trait ConstValue: Value {\n const VAL: T;\n}\n\nimpl> Value for V {\n fn val() -> T {\n Self::VAL\n }\n}\n\n#[macro_export]\nmacro_rules! value {\n ($name: ident: $t: ty = $val: expr) => {\n #[derive(Copy, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]\n pub struct $name {}\n\n impl $crate::misc::value::ConstValue<$t> for $name {\n const VAL: $t = $val;\n }\n };\n}\n\npub trait DynamicValue: Value {\n //noinspection RsSelfConvention\n fn set_val(t: T);\n}\n\n#[macro_export]\nmacro_rules! dynamic_value {\n ($name: ident: $t: ty) => {\n static mut VAL: Option<$t> = None;\n\n #[derive(Copy, Clone, Eq, PartialEq, Hash)]\n struct $name {}\n\n impl $crate::misc::value::DynamicValue<$t> for $name {\n fn set_val(t: $t) {\n unsafe {\n VAL = Some(t);\n }\n }\n }\n\n impl $crate::misc::value::Value<$t> for $name {\n fn val() -> $t {\n unsafe { VAL.unwrap() }\n }\n }\n };\n ($name: ident: $t: ty = $val: expr) => {\n dynamic_value!($name: $t);\n\n $name::set_val($val);\n };\n}\n}\n}\npub mod numbers {\npub mod gcd {\nuse crate::numbers::num_traits::add_sub::AddSub;\nuse crate::numbers::num_traits::mul_div_rem::{MulDivRem, Multable};\nuse crate::numbers::num_traits::wideable::Wideable;\nuse crate::numbers::num_traits::zero_one::ZeroOne;\nuse std::mem::swap;\n\npub fn extended_gcd(\n a: T,\n b: T,\n) -> (T, T::W, T::W)\nwhere\n T::W: Copy + ZeroOne + AddSub + Multable,\n{\n if a == T::zero() {\n (b, T::W::zero(), T::W::one())\n } else {\n let (d, y, mut x) = extended_gcd(b % a, a);\n x -= T::W::from(b / a) * y;\n (d, x, y)\n }\n}\n\npub fn gcd(mut a: T, mut b: T) -> T {\n while b != T::zero() {\n a %= b;\n swap(&mut a, &mut b);\n }\n a\n}\n\npub fn lcm(a: T, b: T) -> T {\n (a / gcd(a, b)) * b\n}\n}\npub mod mod_int {\nuse crate::io::input::{Input, Readable};\nuse crate::io::output::{Output, Writable};\nuse crate::misc::value::Value;\nuse crate::numbers::gcd::extended_gcd;\nuse crate::numbers::num_traits::add_sub::AddSub;\nuse crate::numbers::num_traits::as_index::AsIndex;\nuse crate::numbers::num_traits::from_u8::FromU8;\nuse crate::numbers::num_traits::invertable::Invertable;\nuse crate::numbers::num_traits::mul_div_rem::{MulDiv, MulDivRem};\nuse crate::numbers::num_traits::wideable::Wideable;\nuse crate::numbers::num_traits::zero_one::ZeroOne;\nuse crate::value;\nuse std::collections::HashMap;\nuse std::fmt::{Display, Formatter};\nuse std::hash::Hash;\nuse std::marker::PhantomData;\nuse std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};\n\npub trait BaseModInt:\n AddSub + MulDiv + Neg + Copy + ZeroOne + PartialEq + Invertable\n{\n type W: AddSub + MulDivRem + Copy + ZeroOne + From;\n type T: AddSub + MulDivRem + Copy + PartialEq + ZeroOne + Wideable + Ord;\n\n fn from(v: Self::T) -> Self;\n fn module() -> Self::T;\n}\n\n#[derive(Copy, Clone, Eq, PartialEq, Hash, Default)]\npub struct ModInt> {\n n: T,\n phantom: PhantomData,\n}\n\nimpl> ModInt {\n pub fn val(&self) -> T {\n self.n\n }\n}\n\nimpl> ModInt {\n unsafe fn unchecked_new(n: T) -> Self {\n debug_assert!(n >= T::zero() && n < V::val());\n Self {\n n,\n phantom: Default::default(),\n }\n }\n\n unsafe fn maybe_subtract_mod(mut n: T) -> T {\n debug_assert!(n < V::val() + V::val() && n >= T::zero());\n if n >= V::val() {\n n -= V::val();\n }\n n\n }\n}\n\nimpl> ModInt {\n pub fn new(n: T) -> Self {\n unsafe { Self::unchecked_new(Self::maybe_subtract_mod(n % (V::val()) + V::val())) }\n }\n}\n\nimpl>\n ModInt\nwhere\n T::W: Copy + ZeroOne + AddSub + MulDivRem,\n{\n pub fn log(&self, alpha: Self) -> T {\n let mut base = HashMap::new();\n let mut exp = T::zero();\n let mut pow = Self::one();\n let mut inv = *self;\n let alpha_inv = alpha.inv().unwrap();\n while exp * exp < Self::module() {\n if inv == Self::one() {\n return exp;\n }\n base.insert(inv, exp);\n exp += T::one();\n pow *= alpha;\n inv *= alpha_inv;\n }\n let step = pow;\n let mut i = T::one();\n loop {\n if let Some(b) = base.get(&pow) {\n break exp * i + *b;\n }\n pow *= step;\n i += T::one();\n }\n }\n}\n\nimpl> ModInt\nwhere\n T::W: MulDivRem,\n{\n pub fn new_from_wide(n: T::W) -> Self {\n unsafe {\n Self::unchecked_new(Self::maybe_subtract_mod(\n T::downcast(n % (V::val()).into()) + V::val(),\n ))\n }\n }\n}\n\nimpl> Invertable\n for ModInt\nwhere\n T::W: Copy + ZeroOne + AddSub + MulDivRem,\n{\n type Output = Self;\n\n fn inv(&self) -> Option {\n let (g, x, _) = extended_gcd(self.n, V::val());\n if g != T::one() {\n None\n } else {\n Some(Self::new_from_wide(x))\n }\n }\n}\n\nimpl> BaseModInt\n for ModInt\nwhere\n T::W: AddSub + MulDivRem + Copy + ZeroOne,\n{\n type W = T::W;\n type T = T;\n\n fn from(v: Self::T) -> Self {\n Self::new(v)\n }\n\n fn module() -> T {\n V::val()\n }\n}\n\nimpl> From for ModInt {\n fn from(n: T) -> Self {\n Self::new(n)\n }\n}\n\nimpl> AddAssign for ModInt {\n fn add_assign(&mut self, rhs: Self) {\n self.n = unsafe { Self::maybe_subtract_mod(self.n + rhs.n) };\n }\n}\n\nimpl> Add for ModInt {\n type Output = Self;\n\n fn add(mut self, rhs: Self) -> Self::Output {\n self += rhs;\n self\n }\n}\n\nimpl> SubAssign for ModInt {\n fn sub_assign(&mut self, rhs: Self) {\n self.n = unsafe { Self::maybe_subtract_mod(self.n + V::val() - rhs.n) };\n }\n}\n\nimpl> Sub for ModInt {\n type Output = Self;\n\n fn sub(mut self, rhs: Self) -> Self::Output {\n self -= rhs;\n self\n }\n}\n\nimpl> MulAssign\n for ModInt\nwhere\n T::W: MulDivRem + Copy,\n{\n fn mul_assign(&mut self, rhs: Self) {\n self.n = T::downcast(T::W::from(self.n) * T::W::from(rhs.n) % T::W::from(V::val()));\n }\n}\n\nimpl> Mul for ModInt\nwhere\n T::W: MulDivRem + Copy,\n{\n type Output = Self;\n\n fn mul(mut self, rhs: Self) -> Self::Output {\n self *= rhs;\n self\n }\n}\n\nimpl> DivAssign\n for ModInt\nwhere\n T::W: AddSub + MulDivRem + Copy + ZeroOne,\n{\n #[allow(clippy::suspicious_op_assign_impl)]\n fn div_assign(&mut self, rhs: Self) {\n *self *= rhs.inv().unwrap();\n }\n}\n\nimpl> Div\n for ModInt\nwhere\n T::W: AddSub + MulDivRem + Copy + ZeroOne,\n{\n type Output = Self;\n\n fn div(mut self, rhs: Self) -> Self::Output {\n self /= rhs;\n self\n }\n}\n\nimpl> Neg for ModInt {\n type Output = Self;\n\n fn neg(mut self) -> Self::Output {\n self.n = unsafe { Self::maybe_subtract_mod(V::val() - self.n) };\n self\n }\n}\n\nimpl> Display for ModInt {\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n ::fmt(&self.n, f)\n }\n}\n\nimpl> Readable\n for ModInt\n{\n fn read(input: &mut Input) -> Self {\n Self::new(T::read(input))\n }\n}\n\nimpl> Writable for ModInt {\n fn write(&self, output: &mut Output) {\n self.n.write(output);\n }\n}\n\nimpl> ZeroOne for ModInt {\n fn zero() -> Self {\n unsafe { Self::unchecked_new(T::zero()) }\n }\n\n fn one() -> Self {\n Self::new(T::one())\n }\n}\n\nimpl> Wideable for ModInt {\n type W = Self;\n\n fn downcast(w: Self::W) -> Self {\n w\n }\n}\n\nimpl> FromU8 for ModInt {\n fn from_u8(n: u8) -> Self {\n Self::new(T::from_u8(n))\n }\n}\n\nimpl<\n T: AddSub + MulDivRem + Copy + PartialEq + Wideable + ZeroOne + Ord + Display + FromU8,\n V: Value,\n > std::fmt::Debug for ModInt\nwhere\n T::W: AddSub + MulDivRem + Copy + ZeroOne,\n{\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n let max = T::from_u8(100);\n if self.n <= max {\n write!(f, \"{}\", self.n)\n } else if self.n >= V::val() - max {\n write!(f, \"-{}\", V::val() - self.n)\n } else {\n let mut denominator = T::one();\n while denominator < max {\n let mut num = T::one();\n while num < max {\n if Self::new(num) / Self::new(denominator) == *self {\n return write!(f, \"{}/{}\", num, denominator);\n }\n if -Self::new(num) / Self::new(denominator) == *self {\n return write!(f, \"-{}/{}\", num, denominator);\n }\n num += T::one();\n }\n denominator += T::one();\n }\n write!(f, \"(?? {} ??)\", self.n)\n }\n }\n}\n\nimpl> AsIndex for ModInt {\n fn from_index(idx: usize) -> Self {\n Self::new(T::from_index(idx))\n }\n\n fn to_index(&self) -> usize {\n self.n.to_index()\n }\n}\n\nvalue!(Val7: i32 = 1_000_000_007);\npub type ModInt7 = ModInt;\n\nvalue!(Val9: i32 = 1_000_000_009);\npub type ModInt9 = ModInt;\n\nvalue!(ValF: i32 = 998_244_353);\npub type ModIntF = ModInt;\n}\npub mod num_traits {\npub mod add_sub {\nuse std::ops::{Add, AddAssign, Sub, SubAssign};\n\npub trait Addable: Add + AddAssign + Copy {}\nimpl + AddAssign + Copy> Addable for T {}\n\npub trait AddSub: Addable + Sub + SubAssign {}\nimpl + SubAssign> AddSub for T {}\n}\npub mod as_index {\npub trait AsIndex {\n fn from_index(idx: usize) -> Self;\n fn to_index(&self) -> usize;\n}\n\nmacro_rules! from_index_impl {\n ($($t: ident)+) => {$(\n impl AsIndex for $t {\n fn from_index(idx: usize) -> Self {\n idx as $t\n }\n\n fn to_index(&self) -> usize {\n *self as usize\n }\n }\n )+};\n}\n\nfrom_index_impl!(i128 i64 i32 i16 i8 isize u128 u64 u32 u16 u8 usize);\n}\npub mod from_u8 {\npub trait FromU8 {\n fn from_u8(val: u8) -> Self;\n}\n\nmacro_rules! from_u8_impl {\n ($($t: ident)+) => {$(\n impl FromU8 for $t {\n fn from_u8(val: u8) -> Self {\n val as $t\n }\n }\n )+};\n}\n\nfrom_u8_impl!(i128 i64 i32 i16 i8 isize u128 u64 u32 u16 u8 usize f32 f64);\n}\npub mod invertable {\npub trait Invertable: Sized {\n type Output;\n\n fn inv(&self) -> Option;\n}\n}\npub mod mul_div_rem {\nuse std::ops::{Div, DivAssign, Mul, MulAssign, Rem, RemAssign};\n\npub trait Multable: Mul + MulAssign + Copy {}\nimpl + MulAssign + Copy> Multable for T {}\n\npub trait MulDiv: Multable + Div + DivAssign {}\nimpl + DivAssign> MulDiv for T {}\n\npub trait MulDivRem: MulDiv + Rem + RemAssign {}\nimpl + RemAssign> MulDivRem for T {}\n}\npub mod sign {\npub trait IsSigned {\n const SIGNED: bool;\n}\n\npub trait Signed: IsSigned {}\n\npub trait Unsigned: IsSigned {}\n\nmacro_rules! unsigned_impl {\n ($($t: ident)+) => {$(\n impl Unsigned for $t {}\n\n impl IsSigned for $t {\n const SIGNED: bool = false;\n }\n )+};\n}\n\nunsigned_impl!(u128 u64 u32 u16 u8 usize);\n\nmacro_rules! signed_impl {\n ($($t: ident)+) => {$(\n impl Signed for $t {}\n\n impl IsSigned for $t {\n const SIGNED: bool = true;\n }\n )+};\n}\n\nsigned_impl!(i128 i64 i32 i16 i8 isize f64 f32);\n}\npub mod wideable {\nuse std::convert::From;\n\npub trait Wideable: Sized {\n type W: From;\n\n fn downcast(w: Self::W) -> Self;\n}\n\nmacro_rules! wideable_impl {\n ($($t: ident $w: ident),+) => {$(\n impl Wideable for $t {\n type W = $w;\n\n fn downcast(w: Self::W) -> Self {\n w as $t\n }\n }\n )+};\n}\n\nwideable_impl!(i128 i128, i64 i128, i32 i64, i16 i32, i8 i16, isize isize, u128 u128, u64 u128, u32 u64, u16 u32, u8 u16, usize usize, f64 f64, f32 f64);\n}\npub mod zero_one {\npub trait ZeroOne {\n fn zero() -> Self;\n fn one() -> Self;\n}\n\nmacro_rules! zero_one_integer_impl {\n ($($t: ident)+) => {$(\n impl ZeroOne for $t {\n fn zero() -> Self {\n 0\n }\n\n fn one() -> Self {\n 1\n }\n }\n )+};\n}\n\nzero_one_integer_impl!(i128 i64 i32 i16 i8 isize u128 u64 u32 u16 u8 usize);\n\nmacro_rules! zero_one_float_impl {\n ($($t: ident)+) => {$(\n impl ZeroOne for $t {\n fn zero() -> Self {\n 0.\n }\n\n fn one() -> Self {\n 1.\n }\n }\n )+};\n}\n\nzero_one_float_impl!(f32 f64);\n}\n}\npub mod number_ext {\nuse crate::numbers::num_traits::add_sub::AddSub;\nuse crate::numbers::num_traits::from_u8::FromU8;\nuse crate::numbers::num_traits::mul_div_rem::{MulDiv, MulDivRem, Multable};\nuse crate::numbers::num_traits::zero_one::ZeroOne;\n\npub trait Power {\n #[must_use]\n fn power(&self, exp: T) -> Self;\n}\n\nimpl Power for S {\n fn power(&self, exp: T) -> Self {\n if exp == T::zero() {\n S::one()\n } else if exp % (T::one() + T::one()) == T::zero() {\n let res = self.power(exp / (T::one() + T::one()));\n res * res\n } else {\n self.power(exp - T::one()) * (*self)\n }\n }\n}\n\npub trait NumDigs {\n fn num_digs(&self) -> usize;\n}\n\nimpl NumDigs for S {\n fn num_digs(&self) -> usize {\n let mut copy = *self;\n let ten = S::from_u8(10);\n let mut res = 0;\n while copy != S::zero() {\n copy /= ten;\n res += 1;\n }\n res\n }\n}\n}\npub mod prime_fft {\nuse crate::collections::legacy_fill::LegacyFill;\nuse crate::numbers::mod_int::BaseModInt;\nuse crate::numbers::num_traits::zero_one::ZeroOne;\nuse crate::numbers::number_ext::Power;\n\npub struct PrimeFFT {\n root: M,\n reverse_root: M,\n root_power: M::T,\n aa: Vec,\n bb: Vec,\n}\n\nimpl Default for PrimeFFT {\n fn default() -> Self {\n Self::new()\n }\n}\n\nimpl PrimeFFT {\n pub fn new() -> Self {\n let mut exp = M::T::zero();\n let mut root_power = M::T::one();\n while (M::module() - M::T::one()) % (root_power + root_power) == M::T::zero() {\n exp = root_power;\n root_power += root_power;\n }\n let mut i = M::one() + M::one();\n loop {\n if i.power(exp) != M::one() && i.power(root_power) == M::one() {\n break Self {\n root: i,\n reverse_root: i.inv().unwrap(),\n root_power,\n aa: Vec::new(),\n bb: Vec::new(),\n };\n }\n i += M::one();\n }\n }\n\n pub fn multiply_res(&mut self, a: &[M], b: &[M], res: &mut Vec) {\n if a.is_empty() || b.is_empty() {\n res.legacy_fill(M::zero());\n return;\n }\n let res_len = a.len() + b.len() - 1;\n if res_len <= Self::BORDER_LEN {\n res.legacy_fill(M::zero());\n for (i, f) in a.iter().enumerate() {\n for (j, s) in b.iter().enumerate() {\n res[i + j] += (*f) * (*s);\n }\n }\n return;\n }\n let mut size = 1;\n let mut size_t = M::T::one();\n while size < res_len {\n size *= 2;\n size_t += size_t;\n }\n if self.root_power < size_t {\n panic!(\"unsuitable modulo\");\n }\n if self.aa.len() < size {\n let was_len = self.aa.len();\n self.aa[..was_len.min(a.len())].copy_from_slice(&a[..was_len.min(a.len())]);\n self.aa[was_len.min(a.len())..].legacy_fill(M::zero());\n self.aa.extend_from_slice(&a[was_len.min(a.len())..]);\n self.aa.reserve(size - self.aa.len());\n for _ in self.aa.len()..size {\n self.aa.push(M::zero());\n }\n } else {\n self.aa[..a.len()].copy_from_slice(a);\n self.aa[a.len()..size].legacy_fill(M::zero());\n }\n Self::fft(\n &mut self.aa[..size],\n false,\n self.root,\n self.root_power,\n size_t,\n );\n if a == b {\n for i in self.aa[..size].iter_mut() {\n *i *= *i;\n }\n } else {\n if self.bb.len() < size {\n let was_len = self.bb.len();\n self.bb[..was_len.min(b.len())].copy_from_slice(&b[..was_len.min(b.len())]);\n self.bb[was_len.min(b.len())..].legacy_fill(M::zero());\n self.bb.extend_from_slice(&b[was_len.min(b.len())..]);\n self.bb.reserve(size - self.bb.len());\n for _ in self.bb.len()..size {\n self.bb.push(M::zero());\n }\n } else {\n self.bb[..b.len()].copy_from_slice(b);\n self.bb[b.len()..size].legacy_fill(M::zero());\n }\n Self::fft(\n &mut self.bb[..size],\n false,\n self.root,\n self.root_power,\n size_t,\n );\n for (i, j) in self.aa[..size].iter_mut().zip(self.bb[..size].iter()) {\n *i *= *j;\n }\n }\n Self::fft(\n &mut self.aa[..size],\n true,\n self.reverse_root,\n self.root_power,\n size_t,\n );\n if res.len() < res_len {\n let was_len = res.len();\n res.copy_from_slice(&self.aa[..was_len]);\n res.extend_from_slice(&self.aa[was_len..res_len]);\n } else {\n res.copy_from_slice(&self.aa[..res_len]);\n res[res_len..].legacy_fill(M::zero());\n }\n }\n\n pub fn multiply(&mut self, a: &[M], b: &[M]) -> Vec {\n if a.is_empty() || b.is_empty() {\n Vec::new()\n } else {\n let mut res = vec![M::zero(); a.len() + b.len() - 1];\n self.multiply_res(a, b, &mut res);\n res\n }\n }\n\n const BORDER_LEN: usize = 100;\n\n fn fft(a: &mut [M], invert: bool, root: M, root_power: M::T, size_t: M::T) {\n let mut j = 0usize;\n for i in 1..a.len() {\n let mut bit = a.len() >> 1;\n while j >= bit {\n j -= bit;\n bit >>= 1;\n }\n j += bit;\n if i < j {\n a.swap(i, j);\n }\n }\n\n let mut len = 2;\n let mut len_t = M::T::one() + M::T::one();\n while len <= a.len() {\n let mut w_len = root;\n let mut i = len_t;\n while i < root_power {\n w_len *= w_len;\n i += i;\n }\n let half = len >> 1;\n for i in (0..a.len()).step_by(len) {\n let mut w = M::one();\n for j in 0..half {\n let u = a[i + j];\n let v = a[i + j + half] * w;\n a[i + j] = u + v;\n a[i + j + half] = u - v;\n w *= w_len;\n }\n }\n len <<= 1;\n len_t += len_t;\n }\n if invert {\n let inv_size = M::from(size_t).inv().unwrap();\n for i in a {\n *i *= inv_size;\n }\n }\n }\n}\n}\n}\nfn main() {\n let mut sin = std::io::stdin();\n let input = crate::io::input::Input::new(&mut sin);\n unsafe {\n crate::io::output::OUTPUT = Some(crate::io::output::Output::new(Box::new(std::io::stdout())));\n }\n crate::solution::run(input);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "flows", "math", "dp", "fft", "bitmasks", "graphs", "meet-in-the-middle", "trees"], "code_uid": "4c01248a63b3e36e2ba812532059ccea", "src_uid": "4b8161259545e44c7d1046be2e4fe014", "difficulty": 2500.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#[allow(dead_code)]\nfn scan() -> T\n{\n\tstatic mut BUFFER: Vec = vec![];\n\tloop {\n\t\tif let Some(token) = unsafe { BUFFER.pop() } {\n\t\t\treturn token.parse().ok().unwrap();\n\t\t}\n\t\tlet mut input = String::new();\n\t\tstd::io::stdin().read_line(&mut input).ok();\n\t\tunsafe { BUFFER = input.split_whitespace().rev().map(String::from).collect(); }\n\t}\n}\n\nconst MOD: i64 = (7 * 17 * (1 << 23)) + 1;\n\nfn ntt(a: &mut Vec, dir: bool)\n{\n\tlet w = {\n\t\tlet mut v: Vec = vec![if dir { 31 } else { 128805723 }];\n\t\twhile v.last().unwrap() != &1 {\n\t\t\tv.push(v.last().unwrap().pow(2) % MOD);\n\t\t}\n\t\tv.reverse();\n\t\tv\n\t};\n\n\tfn lg(x: usize) -> usize { (usize::BITS - 1 - x.leading_zeros()) as usize }\n\n\tassert!(a.len().is_power_of_two());\n\tlet n = a.len();\n\tlet lgn = lg(n);\n\n\tlet rev = {\n\t\tlet mut v = vec![0];\n\t\tfor x in 1..n {\n\t\t\tv.push(v[x/2]/2 ^ x%2 << lgn-1);\n\t\t}\n\t\tv\n\t};\n\n\tfor i in 0..n {\n\t\tif i > rev[i] {\n\t\t\ta.swap(i, rev[i]);\n\t\t}\n\t}\n\n\tfor len in (1..=lgn).map(|x| 1<) -> Vec\n{\n\tlet mut ans = a.clone();\n\tans.resize(ans.len().next_power_of_two() * 2, 0);\n\tntt(&mut ans, false);\n\tans = ans.into_iter().map(|x| x*x % MOD).collect();\n\tntt(&mut ans, true);\n\tans.resize(a.len(), 0);\n\tans\n}\n\nfn main()\n{\n\tlet (n, k, f): (usize, usize, usize) = (scan(), scan(), scan());\n\n\tlet mut a = vec![vec![0i64; 2*k+1]; n+1];\n\tlet mut a2 = vec![vec![0i64; 2*k+2]; n+1];\n\tlet mut b = a.clone();\n\tlet mut b2 = a2.clone();\n\n\tfor i in 0..a2[0].len() { a2[0][i] = 1; }\n\tfor i in 0..=k { b[0][i] = 1; b2[0][i] = (k+1 - i) as i64; }\n\t\n\tfor i in 1..=n {\n\t\ta[i] = pow2(&b[i-1]);\n\t\tfor j in (0..=2*k).rev() { a2[i][j] = (a[i][j] + a2[i][j+1]) % MOD; }\n\t\tfor j in 0..=k { b[i][j] = ((k-j) as i64 * a[i][j] + a2[i][j]) % MOD; }\n\t\tfor j in (0..=k).rev() { b2[i][j] = (b[i][j] + b2[i][j+1]) % MOD; }\n\t}\n\n\tprintln!(\"{}\", if f < a[n].len() { a[n][f] } else { 0 });\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "flows", "math", "dp", "fft", "bitmasks", "graphs", "meet-in-the-middle", "trees"], "code_uid": "56dcf0fe445dd744c42804cfdbd00970", "src_uid": "4b8161259545e44c7d1046be2e4fe014", "difficulty": 2500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::cmp::{max, min};\nuse std::io::stdin;\nfn main() {\n let mut text = String::new();\n stdin().read_line(&mut text).unwrap();\n text.clear();\n stdin().read_line(&mut text).unwrap();\n let text: Vec = text\n .trim()\n .split_whitespace()\n .map(|e| e.parse().unwrap())\n .collect();\n let mut v: Vec = vec![];\n for x in 1..(text.len() + 1) {\n let mut value = 0;\n for a in 1..(text.len() + 1) {\n value += (abs(x, a) + abs(1, a) + abs(1, x)) * text[a - 1] * 2\n }\n v.push(value)\n }\n v.sort();\n\n println!(\"{}\", v[0]);\n}\nfn abs(a: usize, b: usize) -> usize {\n max(a, b) - min(a, b)\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "4dc498b5b576bf88783fed58e41c8099", "src_uid": "a5002ddf9e792cb4b4685e630f1e1b8f", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_macros)]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n let mut next = || { iter.next().unwrap() };\n input_inner!{next, $($r)*}\n };\n ($($r:tt)*) => {\n let stdin = std::io::stdin();\n let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));\n let mut next = move || -> String{\n bytes\n .by_ref()\n .map(|r|r.unwrap() as char)\n .skip_while(|c|c.is_whitespace())\n .take_while(|c|!c.is_whitespace())\n .collect()\n };\n input_inner!{next, $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! input_inner {\n ($next:expr) => {};\n ($next:expr, ) => {};\n\n ($next:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! read_value {\n ($next:expr, ( $($t:tt),* )) => {\n ( $(read_value!($next, $t)),* )\n };\n\n ($next:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($next, $t)).collect::>()\n };\n\n ($next:expr, chars) => {\n read_value!($next, String).chars().collect::>()\n };\n\n ($next:expr, usize1) => {\n read_value!($next, usize) - 1\n };\n\n ($next:expr, $t:ty) => {\n $next().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($a:expr),*) => {\n println!(concat!($(stringify!($a), \"={:?} \"),*), $($a),*);\n }\n}\n\n#[allow(unused_imports)]\nuse std::cmp::{min, max};\n\nfn main() {\n input!{\n n: usize,\n aa: [i64; n],\n }\n let mut ans: i64 = 1 << 32;\n for i in 0i64..n as i64 {\n let mut cost = 0;\n for j in 0i64..n as i64 {\n cost += ((j-i).abs() + j + i) * 2 * aa[j as usize] as i64;\n }\n ans = min(cost, ans);\n }\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "752b1979749a85a240c689eaa5321628", "src_uid": "a5002ddf9e792cb4b4685e630f1e1b8f", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin ModInt ----------\nconst MOD: u32 = 1_000_000_007;\n\n#[derive(Clone, Copy)]\nstruct ModInt(u32);\n\nuse std::ops::{Add, AddAssign, Sub, SubAssign, Mul, MulAssign, Neg};\n\nimpl Add for ModInt {\n type Output = ModInt;\n fn add(self, rhs: ModInt) -> Self::Output {\n let mut d = self.0 + rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n\nimpl AddAssign for ModInt {\n fn add_assign(&mut self, rhs: ModInt) {\n *self = *self + rhs;\n }\n}\n\nimpl Sub for ModInt {\n type Output = ModInt;\n fn sub(self, rhs: ModInt) -> Self::Output {\n let mut d = self.0 + MOD - rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n\nimpl SubAssign for ModInt {\n fn sub_assign(&mut self, rhs: ModInt) {\n *self = *self - rhs;\n }\n}\n\nimpl Mul for ModInt {\n type Output = ModInt;\n fn mul(self, rhs: ModInt) -> Self::Output {\n ModInt((self.0 as u64 * rhs.0 as u64 % MOD as u64) as u32)\n }\n}\n\nimpl MulAssign for ModInt {\n fn mul_assign(&mut self, rhs: ModInt) {\n *self = *self * rhs;\n }\n}\n\nimpl Neg for ModInt {\n type Output = ModInt;\n fn neg(self) -> Self::Output {\n ModInt(if self.0 == 0 {0} else {MOD - self.0})\n }\n}\n\n#[allow(dead_code)]\nimpl ModInt {\n pub fn new(n: u32) -> ModInt {\n ModInt(n % MOD)\n }\n pub fn zero() -> ModInt {\n ModInt(0)\n }\n pub fn one() -> ModInt {\n ModInt(1)\n }\n pub fn pow(self, mut n: u32) -> ModInt {\n let mut t = ModInt::one();\n let mut s = self;\n while n > 0 {\n if n & 1 == 1 {\n t *= s;\n }\n s *= s;\n n >>= 1;\n }\n t\n }\n pub fn inv(self) -> ModInt {\n self.pow(MOD - 2)\n }\n pub fn comb(n: u32, k: u32) -> ModInt {\n if k > n {\n return ModInt::zero();\n }\n let k = std::cmp::min(k, n - k);\n let mut nu = ModInt::one();\n let mut de = ModInt::one();\n for i in 0..k {\n nu *= ModInt(n - i);\n de *= ModInt(i + 1);\n }\n nu * de.inv()\n }\n}\n\n#[allow(dead_code)]\nstruct Precalc {\n inv: Vec,\n fact: Vec,\n ifact: Vec,\n}\n\n#[allow(dead_code)]\nimpl Precalc {\n pub fn new(n: usize) -> Precalc {\n let mut inv = vec![ModInt::one(); n + 1];\n let mut fact = vec![ModInt::one(); n + 1];\n let mut ifact = vec![ModInt::one(); n + 1];\n for i in 2..(n + 1) {\n inv[i] = -inv[MOD as usize % i] * ModInt(MOD / i as u32);\n fact[i] = fact[i - 1] * ModInt(i as u32);\n ifact[i] = ifact[i - 1] * inv[i];\n }\n Precalc {\n inv: inv,\n fact: fact,\n ifact: ifact,\n }\n }\n pub fn inv(&self, n: usize) -> ModInt {\n self.inv[n]\n }\n pub fn fact(&self, n: usize) -> ModInt {\n self.fact[n]\n }\n pub fn ifact(&self, n: usize) -> ModInt {\n self.ifact[n]\n }\n pub fn comb(&self, n: usize, k: usize) -> ModInt {\n if k > n {\n return ModInt::zero();\n }\n self.fact[n] * self.ifact[k] * self.ifact[n - k]\n }\n}\n// ---------- end ModInt ----------\n\nfn run() {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).unwrap();\n let mut it = s.trim().split_whitespace();\n let mut n: u64 = it.next().unwrap().parse().unwrap();\n let k: usize = it.next().unwrap().parse().unwrap();\n let pc = Precalc::new(50);\n let mut ans = ModInt::one();\n let mut d = 2u64;\n while d * d <= n {\n if n % d == 0 {\n let mut c = 0;\n while n % d == 0 {\n c += 1;\n n /= d;\n }\n let mut dp = vec![ModInt::zero(); c + 1];\n dp[c] = ModInt::one();\n for _ in 0..k {\n let mut next = vec![ModInt::zero(); c + 1];\n for i in 0..=c {\n next[i] += dp[i] * pc.inv(i + 1);\n }\n for i in (0..c).rev() {\n next[i] = next[i] + next[i + 1];\n }\n dp = next;\n }\n let mut s = ModInt::zero();\n let mut f = 1u64;\n for i in 0..=c {\n s += ModInt((f % MOD as u64) as u32) * dp[i];\n f *= d;\n }\n ans *= s;\n }\n d += 1;\n }\n if n > 1 {\n let p = pc.inv(2).pow(k as u32);\n ans *= (ModInt::one() - p) + ModInt((n % MOD as u64) as u32) * p;\n }\n println!(\"{}\", ans.0);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp", "probabilities", "number theory"], "code_uid": "e75493100f802712d6e8364376a7712d", "src_uid": "dc466d9c24b7dcb37c0e99337b4124d2", "difficulty": 2200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "macro_rules! debug {\n ( $x:expr ) => {\n if cfg!(debug_assertions) {\n println!(\"{}:{} {} = {:?}\", line!(), column!(), stringify!($x), $x);\n }\n };\n}\n\nmacro_rules! array {\n ( $t:ty ; $size:expr ) => {\n [<$t>::default(); $size]\n };\n}\n\nmod my {\n pub mod io {\n use std::io::{BufRead, ErrorKind};\n\n pub fn read_word(r: &mut R, buf: &mut Vec)\n -> std::io::Result {\n let mut read = 0;\n loop {\n let (done, used) = {\n let available = match r.fill_buf() {\n Ok(n) => n,\n Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,\n Err(e) => return Err(e)\n };\n match available.iter().position(|&x| x == b'\\n' || x == b' ') {\n Some(i) => {\n buf.extend_from_slice(&available[..i]);\n (true, i + 1)\n }\n None => {\n buf.extend_from_slice(available);\n (false, available.len())\n }\n }\n };\n r.consume(used);\n read += used;\n if done || used == 0 {\n return Ok(read);\n }\n }\n }\n\n pub struct InputReader {\n reader: R,\n buf: Vec,\n }\n\n impl InputReader {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buf: Vec::::new(),\n }\n }\n\n pub fn read_word(&mut self) {\n read_word(&mut self.reader, &mut self.buf);\n }\n \n pub fn read(&mut self) -> T\n where T: std::str::FromStr,\n T::Err: std::fmt::Debug\n {\n self.buf.clear();\n self.read_word();\n std::str::from_utf8(&self.buf).unwrap().trim().parse().unwrap()\n }\n }\n }\n}\n\nfn main() {\n let stdin = std::io::stdin();\n let mut stdin = my::io::InputReader::new(stdin.lock());\n\n let table: String;\n let mut hands = Vec::::new();\n\n table = stdin.read();\n for i in 0..5 {\n hands.push(stdin.read());\n }\n\n let mut result = false;\n for i in 0..5 {\n if table.bytes().zip(hands[i].bytes()).any(|(x, y)| x == y) {\n result = true;\n break;\n }\n }\n println!(\"{}\", if result { \"YES\" } else { \"NO\" });\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "2ca8c59c1d3c768f7769032c7482835b", "src_uid": "699444eb6366ad12bc77e7ac2602d74b", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\n#[allow(unused_macros)]\nmacro_rules! a {\n ($c: tt, $x: expr, $y: expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\nuse std::io::*;\nuse std::str::*;\nuse std::fmt::Debug;\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a>, }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).unwrap();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n let s = input.s();\n println!(\"{}\", if (0..5).any(|_| {\n let t = input.s();\n s.bytes().zip(t.bytes()).any(|(a,b)| a == b)\n }) {\n \"YES\"\n } else {\n \"NO\"\n });\n}\n\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "1570c3ca12a0464e1f3cc85a27a9d0b4", "src_uid": "699444eb6366ad12bc77e7ac2602d74b", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::Read;\n\nconst days: &[u8] = &[\n 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,\n 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,\n 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,\n 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,\n 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,\n 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,\n];\n\nfn user_input() -> Vec\n where ::Err: std::fmt::Debug\n{\n let mut text = String::new();\n std::io::stdin()\n .read_to_string(&mut text);\n text\n .split_whitespace()\n .map(|e| e.parse().unwrap())\n .collect()\n}\n\nfn main() {\n let mut input = user_input::().into_iter();\n let count = input.next().unwrap().to_owned() as usize;\n \n let pattern = input.collect::>();\n let mut matches = false;\n for i in 0..(days.len() - count) {\n if days[i..(i+count)] == pattern[..] {\n matches = true;\n break;\n }\n }\n \n if matches {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "2fa389c1e0e78b4d5620c9d8d416607e", "src_uid": "d60c8895cebcc5d0c6459238edbdb945", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max, min, Ordering};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\n#[allow(unused_imports)]\nuse std::iter::FromIterator;\n#[allow(unused_imports)]\nuse std::io::stdin;\n\nmod util {\n use std::io::stdin;\n use std::str::FromStr;\n use std::fmt::Debug;\n\n #[allow(dead_code)]\n pub fn line() -> String {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n line.trim().to_string()\n }\n\n #[allow(dead_code)]\n pub fn gets() -> Vec\n where\n ::Err: Debug,\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n line.split_whitespace()\n .map(|t| t.parse().unwrap())\n .collect()\n }\n}\n\n#[allow(unused_macros)]\nmacro_rules! get {\n ($t:ty) => {\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n line.trim().parse::<$t>().unwrap()\n }\n };\n ($($t:ty),*) => {\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n $(iter.next().unwrap().parse::<$t>().unwrap(),)*\n )\n }\n };\n ($t:ty; $n:expr) => {\n (0..$n).map(|_|\n get!($t)\n ).collect::>()\n };\n ($($t:ty),*; $n:expr) => {\n (0..$n).map(|_|\n get!($($t),*)\n ).collect::>()\n };\n ($t:ty ;;) => {\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n line.split_whitespace()\n .map(|t| t.parse::<$t>().unwrap())\n .collect::>()\n }\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($a:expr),*) => {\n println!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);\n }\n}\n\nfn main() {\n let n_leap = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\n let leap = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\n\n let table: Vec = n_leap\n .iter()\n .chain(n_leap.iter())\n .chain(leap.iter())\n .chain(n_leap.iter())\n .chain(n_leap.iter())\n .cloned()\n .collect();\n\n let n = get!(usize);\n let ms = get!(usize;;);\n\n if (0..table.len() - n).any(|i| &table[i..i + n] == &ms[..]) {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "9320a7b76bc64c1fee2a729ed7220630", "src_uid": "d60c8895cebcc5d0c6459238edbdb945", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn read_line() -> String {\n let mut line = String::new();\n io::stdin().read_line(&mut line).unwrap();\n line\n}\n\nfn main() {\n if read_line().chars().any(|c| \"HQ9\".find(c).is_some()) {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "7a68088a8b91ea068ca57b48958b846e", "src_uid": "1baf894c1c7d5aeea01129c7900d3c12", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).unwrap();\n\n let mut ans = \"NO\";\n for ch in s.chars() {\n match ch {\n 'H' | 'Q' | '9' => {\n ans = \"YES\";\n break;\n }\n _ => {\n continue;\n }\n }\n }\n\n println!(\"{}\", ans);\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "93a3076d259adf6e8f1565dec9290c81", "src_uid": "1baf894c1c7d5aeea01129c7900d3c12", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str;\n\npub struct Scanner {\n reader: R,\n buffer: Vec,\n}\n\nimpl Scanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buffer: vec![],\n }\n }\n\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn digit_sum(n: u32) -> u32 {\n let mut ans = 0;\n let mut n = n;\n while n > 0 {\n ans += n % 10;\n n /= 10;\n }\n ans\n}\n\nfn solve(scan: &mut Scanner, out: &mut W) {\n\n let mut k: usize = scan.token();\n let mut num = 0;\n while k > 0 {\n num += 1;\n if digit_sum(num) == 10 {\n k -= 1;\n }\n }\n writeln!(out, \"{}\", num).ok();\n}\n\nfn main() {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout.lock());\n solve(&mut scan, &mut out);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "dp", "binary search", "implementation", "number theory"], "code_uid": "e5e41b5d827ccbf7e1def067c09412a5", "src_uid": "0a98a6a15e553ce11cb468d3330fc86a", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\n\nfn read_line() -> String {\n let mut input_line = String::new();\n io::stdin().read_line(&mut input_line).unwrap();\n return String::from(input_line.trim());\n}\n\nfn b(n: u32) -> bool {\n let mut sum = 0;\n let mut k = n;\n while k > 0 {\n sum += k % 10;\n k /= 10;\n }\n return sum == 10;\n}\n\nfn main() {\n let mut k: u32 = read_line().parse().unwrap();\n let mut i = 0u32;\n while k > 0 {\n i += 1;\n if b(i) {\n k -= 1;\n }\n }\n\n println!(\"{}\", i);\n \n\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "dp", "binary search", "implementation", "number theory"], "code_uid": "dbea9c601df2dba638fc3add6224908d", "src_uid": "0a98a6a15e553ce11cb468d3330fc86a", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, bytes) => {\n read_value!($iter, String).bytes().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n//\n\n// \u7570\u306a\u308b\u5024\u304c\u542b\u307e\u308c\u308b\u3084\u3064\u306f\u3069\u3063\u3061\u304c\u3069\u3063\u3061\u304b\u308f\u304b\u3089\u306a\u3044\u306e\u3067\u4e0d\u53ef\u80fd\n// \u540c\u3058\u5024\u306e\u307f\u3092\u805e\u304d\u51fa\u3059\u6226\u7565\n// \u540c\u3058\u5024\u306e\u307f\u3092\u6b8b\u305b\u308b\u3088\u3046\u306b\u805e\u304f\u6226\u7565\n// \u540c\u3058\u5024\u3092\u6b8b\u305b\u308b\u3088\u3046\u306b\u805e\u304f\u6226\u7565\u304c\u3067\u304d\u308b\u306a\u3089\u306e\u307f\u3092\u805e\u304d\u51fa\u3059\u3053\u3068\u3082\u53ef\u80fd\n//\n// \u540c\u3058\u5024\u306e\u307f\u3092\u6b8b\u3059\n// a \u3092k \u500b\u805e\u304d\u51fa\u305b\u308b\u6761\u4ef6\u306f\n// a\u3092\u4f7f\u308f\u306a\u3044\u3067(k - i) * a \u3092\u4f5c\u308c\u306a\u3044\u3053\u3068\n// \u5206\u5272\u7d71\u6cbbbitset?\n\nuse std::cmp::*;\n\nfn run() {\n input! {\n n: usize,\n a: [usize; n],\n }\n let mut a = a.into_iter().map(|a| (a, 1)).collect::>();\n a.sort();\n a.dedup_by(|a, b| {\n a.0 == b.0 && {\n b.1 += a.1;\n true\n }\n });\n if a.len() <= 2 {\n println!(\"{}\", n);\n return;\n }\n let w = a.iter().fold(0, |s, a| s + a.0 * a.1);\n let mut dp = vec![vec![0u8; w + 1]; n + 1];\n dp[0][0] = 1;\n for &(a, c) in a.iter() {\n for i in (1..=n).rev() {\n for j in a..=w {\n let mut v = dp[i][j];\n for k in 1..=min(j / a, min(i, c)) {\n v = v.saturating_add(dp[i - k][j - k * a]);\n }\n dp[i][j] = v;\n }\n }\n }\n /*\n for i in 0..=n {\n for j in 0..=w {\n print!(\"{} \", dp[i][j]);\n }\n println!();\n }\n */\n let mut ans = 1;\n for &(a, c) in a.iter() {\n for k in 2..=c {\n if dp[k][k * a] == 1 || dp[n - k][w - k * a] == 1 {\n ans = max(ans, k);\n }\n }\n }\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp"], "code_uid": "90e41586c4cbc8906ff4cec701f223cd", "src_uid": "ccc4b27889598266e8efe73b8aa3666c", "difficulty": 2100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin BitSet ----------\n#[derive(Clone)]\nstruct BitSet {\n size: usize,\n a: Vec,\n}\n\nfn bit_size() -> usize {\n 8 * std::mem::size_of::()\n}\n\nfn quot_rem(n: usize) -> (usize, usize) {\n let w = bit_size();\n (n / w, n % w)\n}\n\n#[allow(dead_code)]\nimpl BitSet {\n fn new(size: usize) -> Self {\n let w = bit_size();\n BitSet {\n size: size,\n a: vec![0; (size + w - 1) / w],\n }\n }\n fn set_at(&mut self, x: usize) {\n assert!(x < self.size);\n let (q, r) = quot_rem(x);\n self.a[q] |= 1 << r;\n }\n fn clear_at(&mut self, x: usize) {\n assert!(x < self.size);\n let (q, r) = quot_rem(x);\n self.a[q] &= !(1 << r);\n }\n fn get_at(&self, x: usize) -> bool {\n if x >= self.size {\n return false;\n }\n let (q, r) = quot_rem(x);\n (self.a[q] >> r) & 1 == 1\n }\n fn any(&self) -> bool {\n self.a.iter().any(|a| *a != 0)\n }\n fn fix(&mut self) {\n let (q, r) = quot_rem(self.size);\n if r != 0 {\n self.a[q] &= (1 << r) - 1;\n }\n }\n fn clear(&mut self) {\n let len = self.a.len();\n self.a.clear();\n self.a.resize(len, 0);\n }\n fn truncate(&mut self, len: usize) {\n if len >= self.size {\n return;\n }\n let w = bit_size();\n self.a.truncate((len + w - 1) / w);\n self.size = len;\n self.fix();\n }\n fn popcnt(&self) -> usize {\n self.a.iter().fold(0, |s, a| s + a.count_ones() as usize)\n }\n fn shift_left(&self, rhs: usize) -> Self {\n let (q, r) = quot_rem(rhs);\n let mut ans = BitSet::new(self.size + rhs);\n if r == 0 {\n for (x, y) in ans.a[q..].iter_mut().zip(self.a.iter()) {\n *x = *y;\n }\n } else {\n let w = bit_size();\n let mut prev = 0;\n for (x, y) in ans.a[q..].iter_mut().zip(self.a.iter()) {\n *x = (*y << r) | (prev >> (w - r));\n prev = *y;\n }\n *ans.a.last_mut().unwrap() |= prev >> (w - r);\n }\n ans.fix();\n ans\n }\n fn shift_right(&self, rhs: usize) -> Self {\n if rhs >= self.size {\n return BitSet::new(1);\n }\n let (q, r) = quot_rem(rhs);\n let mut ans = BitSet::new(self.size - rhs);\n if r == 0 {\n for (x, y) in ans.a.iter_mut().zip(self.a[q..].iter()) {\n *x = *y;\n }\n } else {\n let w = bit_size();\n let mut prev = 0;\n for (x, y) in ans.a.iter_mut().zip(self.a[q..].iter()).rev() {\n *x |= (*y >> r) | (prev << (w - r));\n prev = *y;\n }\n }\n ans.fix();\n ans\n }\n fn bitwise_or(&self, rhs: &Self) -> Self {\n let (x, y) = if self.size >= rhs.size {\n (self, rhs)\n } else {\n (rhs, self)\n };\n let mut a = x.a.clone();\n for (a, y) in a.iter_mut().zip(y.a.iter()) {\n *a |= *y;\n }\n BitSet { size: x.size, a: a }\n }\n fn bitwise_and(&self, rhs: &Self) -> Self {\n let (x, y) = if self.size <= rhs.size {\n (self, rhs)\n } else {\n (rhs, self)\n };\n let mut a = x.a.clone();\n for (a, y) in a.iter_mut().zip(y.a.iter()) {\n *a &= *y;\n }\n BitSet { size: x.size, a: a }\n }\n fn bitwise_xor(&self, rhs: &Self) -> Self {\n let (x, y) = if self.size >= rhs.size {\n (self, rhs)\n } else {\n (rhs, self)\n };\n let mut a = x.a.clone();\n for (a, y) in a.iter_mut().zip(y.a.iter()) {\n *a ^= *y;\n }\n BitSet { size: x.size, a: a }\n }\n fn bitwise_or_assign(&mut self, rhs: &Self) {\n if self.size < rhs.size {\n self.size = rhs.size;\n self.a.resize(rhs.a.len(), 0);\n }\n for (a, b) in self.a.iter_mut().zip(rhs.a.iter()) {\n *a |= *b;\n }\n }\n fn bitwise_and_assign(&mut self, rhs: &Self) {\n if self.size > rhs.size {\n self.size = rhs.size;\n self.a.resize(rhs.a.len(), 0);\n }\n for (a, b) in self.a.iter_mut().zip(rhs.a.iter()) {\n *a &= *b;\n }\n }\n fn bitwise_xor_assign(&mut self, rhs: &Self) {\n if self.size < rhs.size {\n self.size = rhs.size;\n self.a.resize(rhs.a.len(), 0);\n }\n for (a, b) in self.a.iter_mut().zip(rhs.a.iter()) {\n *a ^= *b;\n }\n }\n}\n// ---------- end BitSet ----------\n//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, bytes) => {\n read_value!($iter, String).bytes().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n//\n\n// \u7570\u306a\u308b\u5024\u304c\u542b\u307e\u308c\u308b\u3084\u3064\u306f\u3069\u3063\u3061\u304c\u3069\u3063\u3061\u304b\u308f\u304b\u3089\u306a\u3044\u306e\u3067\u4e0d\u53ef\u80fd\n// \u540c\u3058\u5024\u306e\u307f\u3092\u805e\u304d\u51fa\u3059\u6226\u7565\n// \u540c\u3058\u5024\u306e\u307f\u3092\u6b8b\u305b\u308b\u3088\u3046\u306b\u805e\u304f\u6226\u7565\n// \u540c\u3058\u5024\u3092\u6b8b\u305b\u308b\u3088\u3046\u306b\u805e\u304f\u6226\u7565\u304c\u3067\u304d\u308b\u306a\u3089\u306e\u307f\u3092\u805e\u304d\u51fa\u3059\u3053\u3068\u3082\u53ef\u80fd\n//\n// \u540c\u3058\u5024\u306e\u307f\u3092\u6b8b\u3059\n// a \u3092k \u500b\u805e\u304d\u51fa\u305b\u308b\u6761\u4ef6\u306f\n// a\u3092\u4f7f\u308f\u306a\u3044\u3067(k - i) * a \u3092\u4f5c\u308c\u306a\u3044\u3053\u3068\n// \u5206\u5272\u7d71\u6cbbbitset?\n\nfn calc(a: &[(usize, usize)], dp: &[BitSet]) -> usize {\n let n = a.len();\n if n == 1 {\n let (a, c) = a[0];\n let mut ans = 1;\n for k in 2..=c {\n let mut ok = true;\n for j in 0..k {\n ok &= !dp[k - j].get_at(a * (k - j));\n }\n if ok {\n ans = k;\n }\n }\n return ans;\n }\n let (l, r) = a.split_at(n / 2);\n let mut p = vec![];\n p.extend_from_slice(dp);\n for &(a, c) in l.iter() {\n for _ in 0..c {\n for i in (1..dp.len()).rev() {\n let mut set = p[i].bitwise_or(&p[i - 1].shift_left(a));\n set.truncate(dp[0].size);\n p[i] = set;\n }\n }\n }\n let a = calc(r, &p);\n let mut p = vec![];\n p.extend_from_slice(dp);\n for &(a, c) in r.iter() {\n for _ in 0..c {\n for i in (1..dp.len()).rev() {\n let mut set = p[i].bitwise_or(&p[i - 1].shift_left(a));\n set.truncate(dp[0].size);\n p[i] = set;\n }\n }\n }\n std::cmp::max(a, calc(l, &p))\n}\n\nfn run() {\n input! {\n n: usize,\n a: [usize; n],\n }\n let mut a = a.into_iter().map(|a| (a, 1)).collect::>();\n a.sort();\n a.dedup_by(|a, b| {\n a.0 == b.0 && {\n b.1 += a.1;\n true\n }\n });\n if a.len() <= 2 {\n println!(\"{}\", n);\n return;\n }\n let w = n * 100;\n let mut dp = vec![BitSet::new(w + 1); n + 1];\n dp[0].set_at(0);\n let ans = calc(&a, &dp);\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp"], "code_uid": "a57d6183b7551e3218a4ba90aa1b5a22", "src_uid": "ccc4b27889598266e8efe73b8aa3666c", "difficulty": 2100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str::FromStr;\n\nuse std::io::prelude::*;\nuse std::io::BufReader;\nuse std::cmp::{max, min};\n\nfn get_line() -> String {\n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n input\n}\n\nfn get_vec(s: String) -> Vec\n where T: FromStr,\n ::Err: std::fmt::Debug,\n{\n s.split_whitespace().map(|k| k.parse().unwrap()).collect()\n}\n\nfn euclid(a: u64, b: u64) -> u64 {\n if b == 0 {\n a\n } else {\n euclid(b, a % b)\n }\n}\n\nfn main() {\n let (n, k): (u64, u64) = {\n let input = get_line();\n let mut it = input.split_whitespace().map(|k| k.parse().unwrap());\n (\n it.next().unwrap(),\n it.next().unwrap(),\n )\n };\n\n // ppcm ?\n\n let m: u64 = 10u64.pow(k as u32);\n let g = euclid(n, m);\n let s = n * m / g;\n\n println!(\"{}\", s);\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "41460e9801f56ed43be24c1ca7566819", "src_uid": "73566d4d9f20f7bbf71bc06bc9a4e9f3", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str;\n\npub struct Scanner {\n reader: R,\n buffer: Vec,\n}\n\nimpl Scanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buffer: vec![],\n }\n }\n\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn gcd(a: i64, b: i64) -> i64 {\n if b == 0 {\n a\n } else {\n gcd(b, a % b)\n }\n}\n\nfn lcm(a: i64, b: i64) -> i64 {\n a / gcd(a, b) * b\n}\n\nfn solve(scan: &mut Scanner, out: &mut W) {\n let n: i64 = scan.token();\n let k: i64 = scan.token();\n\n let ans = lcm(n, 10i64.pow(k as u32));\n writeln!(out, \"{}\", ans).ok();\n}\n\nfn main() {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout.lock());\n solve(&mut scan, &mut out);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "number theory"], "code_uid": "9b6c18bf4ea98c14bb7de306e100e211", "src_uid": "73566d4d9f20f7bbf71bc06bc9a4e9f3", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\r\nuse std::cmp::*;\r\n#[allow(unused_imports)]\r\nuse std::collections::*;\r\n#[allow(unused_imports)]\r\nuse std::io;\r\n#[allow(unused_imports)]\r\nuse std::iter::*;\r\n#[allow(unused_imports)]\r\nuse std::mem::*;\r\n#[allow(unused_imports)]\r\nuse std::str::*;\r\n#[allow(unused_imports)]\r\nuse std::usize;\r\n\r\n// vec with some initial value\r\n#[allow(unused_macros)]\r\nmacro_rules! vvec {\r\n ($($x:expr),+; $y:expr; $n:expr) => {{\r\n let mut v = vec![$y; $n];\r\n\r\n let mut it = v.iter_mut();\r\n $(\r\n *it.next().unwrap() = $x;\r\n )+\r\n\r\n v\r\n }}\r\n}\r\n\r\n#[allow(unused_macros)]\r\nmacro_rules! it {\r\n ($x:expr) => {\r\n once($x)\r\n };\r\n ($first:expr,$($x:expr),+) => {\r\n chain(\r\n once($first),\r\n it!($($x),+)\r\n )\r\n }\r\n}\r\n\r\n#[allow(unused_macros)]\r\nmacro_rules! pushed {\r\n ($c:expr, $x:expr) => {{\r\n let mut c = $c;\r\n c.push($x);\r\n c\r\n }};\r\n}\r\n\r\n#[allow(unused_macros)]\r\nmacro_rules! inserted {\r\n ($c:expr, $($x:expr),*) => {{\r\n let mut c = $c;\r\n c.insert($($x),*);\r\n c\r\n }};\r\n}\r\n\r\n#[allow(unused_macros)]\r\nmacro_rules! read_tuple {\r\n ($($t:ty),+) => {{\r\n let mut line = String::new();\r\n io::stdin().read_line(&mut line).unwrap();\r\n\r\n let mut it = line.trim()\r\n .split_whitespace();\r\n\r\n ($(\r\n it.next().unwrap().parse::<$t>().ok().unwrap()\r\n ),+)\r\n }}\r\n}\r\n\r\n#[allow(dead_code)]\r\nfn read() -> T {\r\n let mut line = String::new();\r\n io::stdin().read_line(&mut line).unwrap();\r\n line.trim().to_string().parse().ok().unwrap()\r\n}\r\n\r\n#[allow(dead_code)]\r\nfn read_str() -> Vec {\r\n read::().chars().collect()\r\n}\r\n\r\n#[allow(dead_code)]\r\nfn read_row() -> Vec {\r\n let mut line = String::new();\r\n io::stdin().read_line(&mut line).unwrap();\r\n\r\n line.trim()\r\n .split_whitespace()\r\n .map(|s| s.parse().ok().unwrap())\r\n .collect()\r\n}\r\n\r\n#[allow(dead_code)]\r\nfn read_col(n: usize) -> Vec {\r\n (0..n).map(|_| read()).collect()\r\n}\r\n\r\n#[allow(dead_code)]\r\nfn read_mat(n: usize) -> Vec> {\r\n (0..n).map(|_| read_row()).collect()\r\n}\r\n\r\n#[allow(dead_code)]\r\nfn read_vec R>(n: usize, mut f: F) -> Vec {\r\n (0..n).map(|_| f()).collect()\r\n}\r\n\r\ntrait IterCopyExt<'a, T>: IntoIterator + Sized\r\nwhere\r\n T: 'a + Copy,\r\n{\r\n fn citer(self) -> std::iter::Copied {\r\n self.into_iter().copied()\r\n }\r\n}\r\n\r\nimpl<'a, T, I> IterCopyExt<'a, T> for I\r\nwhere\r\n I: IntoIterator,\r\n T: 'a + Copy,\r\n{\r\n}\r\n\r\nconst B: i32 = 250;\r\nconst C: i32 = 25;\r\n\r\nfn main() {\r\n let n = read::()\r\n .chars()\r\n .map(|c| c.to_digit(10).unwrap() as i32)\r\n .collect::>();\r\n\r\n let dp = n.citer().fold(\r\n (-C..=C)\r\n .map(|t| {\r\n (0..B)\r\n .map(|i| {\r\n if i < t {\r\n vec![i32::MAX; B as usize]\r\n } else {\r\n vec![t; B as usize]\r\n }\r\n })\r\n .collect::>()\r\n })\r\n .collect::>(),\r\n |prev, d| {\r\n // eprintln!(\"{:?}\", prev);\r\n (-C..=C)\r\n .map(|t| {\r\n let d = d + t;\r\n let mut dp = (0..B)\r\n .map(|i| {\r\n let mut v = vec![i32::MAX; B as usize];\r\n\r\n (-C..=C).for_each(|c| {\r\n if i + 10 * c >= d && i + 10 * c < B + d {\r\n let j = i + 10 * c - d;\r\n v[j as usize] = prev[(c + C) as usize][i as usize][j as usize]\r\n .saturating_add(i + j);\r\n }\r\n });\r\n\r\n v\r\n })\r\n .collect::>();\r\n for i in 0..B {\r\n for j in 0..B {\r\n if i > 0 {\r\n dp[i as usize][j as usize] =\r\n min(dp[i as usize][j as usize], dp[i as usize - 1][j as usize]);\r\n }\r\n if j > 0 {\r\n dp[i as usize][j as usize] =\r\n min(dp[i as usize][j as usize], dp[i as usize][j as usize - 1]);\r\n }\r\n }\r\n }\r\n dp\r\n })\r\n .collect::>()\r\n },\r\n );\r\n let ans = dp[0 + C as usize][B as usize - 1][B as usize - 1];\r\n println!(\"{}\", ans);\r\n}\r\n", "lang_cluster": "Rust", "tags": ["greedy", "dp", "shortest paths"], "code_uid": "0549d4f47bc1283c4b18318c7a774e3f", "src_uid": "1961e7c9120ff652b15cad5dd5ca0907", "difficulty": 2900.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "// ---------- begin chmin, chmax ----------\r\npub trait ChangeMinMax {\r\n fn chmin(&mut self, x: Self) -> bool;\r\n fn chmax(&mut self, x: Self) -> bool;\r\n}\r\n\r\nimpl ChangeMinMax for T {\r\n fn chmin(&mut self, x: Self) -> bool {\r\n *self > x && {\r\n *self = x;\r\n true\r\n }\r\n }\r\n fn chmax(&mut self, x: Self) -> bool {\r\n *self < x && {\r\n *self = x;\r\n true\r\n }\r\n }\r\n}\r\n// ---------- end chmin, chmax ----------\r\n// ---------- begin input macro ----------\r\n// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\r\nmacro_rules! input {\r\n (source = $s:expr, $($r:tt)*) => {\r\n let mut iter = $s.split_whitespace();\r\n input_inner!{iter, $($r)*}\r\n };\r\n ($($r:tt)*) => {\r\n let s = {\r\n use std::io::Read;\r\n let mut s = String::new();\r\n std::io::stdin().read_to_string(&mut s).unwrap();\r\n s\r\n };\r\n let mut iter = s.split_whitespace();\r\n input_inner!{iter, $($r)*}\r\n };\r\n}\r\n\r\nmacro_rules! input_inner {\r\n ($iter:expr) => {};\r\n ($iter:expr, ) => {};\r\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\r\n let $var = read_value!($iter, $t);\r\n input_inner!{$iter $($r)*}\r\n };\r\n}\r\n\r\nmacro_rules! read_value {\r\n ($iter:expr, ( $($t:tt),* )) => {\r\n ( $(read_value!($iter, $t)),* )\r\n };\r\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\r\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\r\n };\r\n ($iter:expr, chars) => {\r\n read_value!($iter, String).chars().collect::>()\r\n };\r\n ($iter:expr, bytes) => {\r\n read_value!($iter, String).bytes().collect::>()\r\n };\r\n ($iter:expr, usize1) => {\r\n read_value!($iter, usize) - 1\r\n };\r\n ($iter:expr, $t:ty) => {\r\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\r\n };\r\n}\r\n// ---------- end input macro ----------\r\n\r\nuse std::collections::*;\r\nuse std::io::Write;\r\n\r\ntype Map = BTreeMap;\r\n\r\n// \u4e0b\u306e\u6841\u304b\u3089dp\u3063\u307d\u304f?\r\n// +\u304c\u3044\u304f\u3064\u3001-\u304c\u3044\u304f\u3064\u3001\u66ab\u5b9acarry\u304c\u3044\u304f\u3064\r\n// \u3053\u306e\u66421\u3092\u5e7e\u3064\u3067\u5408\u308f\u305b\u3089\u308c\u308b\u304b\u7684\u306a\r\n// MLE\r\n// \u306a\u3093\u304b\u72b6\u614b\u591a\u3044\u3063\u307d\u3044\u304c\r\n//\r\n//\r\n\r\nconst INF: i32 = 100000;\r\n\r\nfn run() {\r\n input!(s: bytes);\r\n let m = 200;\r\n let geta = m / 9 + 1;\r\n let mut dp = vec![vec![vec![INF; m + 1]; m + 1]; 2 * geta + 1];\r\n dp[geta] = vec![vec![0; m + 1]; m + 1];\r\n for &s in s.iter().rev() {\r\n let s = (s - b'0') as i32;\r\n let mut next = vec![vec![vec![INF; m + 1]; m + 1]; 2 * geta + 1];\r\n for (carry, dp) in dp.iter().enumerate() {\r\n for (add, dp) in dp.iter().enumerate() {\r\n for (sub, dp) in dp.iter().enumerate() {\r\n if *dp == INF {\r\n continue;\r\n }\r\n let carry = carry as i32 - geta as i32;\r\n let d = add as i32 - sub as i32 + carry;\r\n if d.rem_euclid(10) != s {\r\n continue;\r\n }\r\n let carry = (d.div_euclid(10) + geta as i32) as usize;\r\n next[carry][add][sub].chmin(*dp + (add + sub) as i32);\r\n }\r\n }\r\n }\r\n dp = next;\r\n for dp in dp.iter_mut() {\r\n for i in (0..m).rev() {\r\n for j in (0..m).rev() {\r\n dp[i][j] = dp[i][j].min(dp[i + 1][j]).min(dp[i][j + 1]);\r\n }\r\n }\r\n }\r\n }\r\n let mut ans = INF;\r\n for (carry, dp) in dp.iter().enumerate() {\r\n for (add, dp) in dp.iter().enumerate() {\r\n for (sub, dp) in dp.iter().enumerate() {\r\n let carry = carry as i32 - geta as i32;\r\n let add = add as i32;\r\n let sub = sub as i32;\r\n let mut v = *dp;\r\n if carry == 0 {\r\n } else if carry > 0 && sub >= carry {\r\n v += carry;\r\n } else if carry < 0 && add >= -carry {\r\n v += -carry;\r\n } else {\r\n v += INF;\r\n }\r\n ans.chmin(v);\r\n }\r\n }\r\n }\r\n println!(\"{}\", ans);\r\n}\r\n\r\nfn main() {\r\n run();\r\n}\r\n", "lang_cluster": "Rust", "tags": ["greedy", "dp", "shortest paths"], "code_uid": "cdb7ae99908d717987aa9b0e41f3d822", "src_uid": "1961e7c9120ff652b15cad5dd5ca0907", "difficulty": 2900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut s = String::new();\n io::stdin().read_line(&mut s).unwrap();\n let n : i32 = s.trim().parse().unwrap();\n for i in n+1.. {\n let a = i / 1000;\n let b = i / 100 % 10;\n let c = i / 10 % 10;\n let d = i % 10;\n if a!=b && a!=c && a!=d && b!=c && b!=d && c!=d {\n println!(\"{}\", i);\n ::std::process::exit(0);\n }\n }\n}", "lang_cluster": "Rust", "tags": ["brute force"], "code_uid": "5008553640bfa9dd2b6200e5938e99f6", "src_uid": "d62dabfbec52675b7ed7b582ad133acd", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::collections::HashSet;\n\nfn main() {\n let mut year = String::new();\n\n io::stdin()\n .read_line(&mut year)\n .unwrap();\n\n let mut year: i64 = year.trim().parse().unwrap();\n \n loop {\n year += 1;\n\n let name = year.to_string();\n let size = name.len();\n\n let mut characters = HashSet::new();\n\n for ch in name.chars() {\n characters.insert(ch);\n }\n\n if characters.len() == size {\n println!(\"{}\", name);\n break;\n }\n }\n}\n\n", "lang_cluster": "Rust", "tags": ["brute force"], "code_uid": "5c5bfa5d27ffdab5558ebfef89c146c5", "src_uid": "d62dabfbec52675b7ed7b582ad133acd", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ____ _ _ _ _\n// | _ \\ _ _ ___| |_ ___ _ __ | |_ ___ _ __ ___ _ __ | | __ _| |_ ___\n// | |_) | | | / __| __| / __| '_ \\ | __/ _ \\ '_ ` _ \\| '_ \\| |/ _` | __/ _ \\\n// | _ <| |_| \\__ \\ |_ | (__| |_) | | || __/ | | | | | |_) | | (_| | || __/\n// |_| \\_\\\\__,_|___/\\__| \\___| .__/___\\__\\___|_| |_| |_| .__/|_|\\__,_|\\__\\___|\n// |_| |_____| |_|\n\n//https://github.com/manta1130/Competitive_Programming_Template_Rust\n\n#[macro_use]\nmod input {\n\n use std;\n use std::io;\n\n const SPLIT_DELIMITER: char = ' ';\n\n #[macro_export]\n #[allow(unused_macros)]\n macro_rules! input {\n ( $($x:expr ),*) => {\n {\n let temp_str = input_line_str();\n let mut split_result_iter = temp_str.split_whitespace();\n $(\n let buf_split_result = split_result_iter.next();\n let buf_split_result = buf_split_result.unwrap();\n ($x) = buf_split_result.parse().unwrap();\n )*\n }\n };\n}\n\n #[allow(dead_code)]\n pub fn input_line_str() -> String {\n let mut s = String::new();\n io::stdin().read_line(&mut s).unwrap();\n s.trim().to_string()\n }\n\n #[allow(dead_code)]\n pub fn p(t: T)\n where\n T: std::fmt::Display,\n {\n println!(\"{}\", t);\n }\n\n #[allow(dead_code)]\n pub fn input_vector2d(line: usize) -> Vec>\n where\n T: std::str::FromStr,\n {\n let mut v: Vec> = Vec::new();\n\n for _ in 0..line {\n let vec_line = input_vector();\n v.push(vec_line);\n }\n v\n }\n\n #[allow(dead_code)]\n pub fn input_vector() -> Vec\n where\n T: std::str::FromStr,\n {\n let mut v: Vec = Vec::new();\n\n let s = input_line_str();\n let split_result = s.split(SPLIT_DELIMITER);\n for z in split_result {\n let buf = match z.parse() {\n Ok(r) => r,\n Err(_) => panic!(\"Parse Error\"),\n };\n v.push(buf);\n }\n v\n }\n\n #[allow(dead_code)]\n pub fn input_vector_row(n: usize) -> Vec\n where\n T: std::str::FromStr,\n {\n let mut v = Vec::with_capacity(n);\n for _ in 0..n {\n let buf = match input_line_str().parse() {\n Ok(r) => r,\n Err(_) => panic!(\"Parse Error\"),\n };\n v.push(buf);\n }\n v\n }\n\n pub trait ToCharVec {\n fn to_charvec(&self) -> Vec;\n }\n\n impl ToCharVec for String {\n fn to_charvec(&self) -> Vec {\n self.to_string().chars().collect::>()\n }\n }\n}\nuse input::*;\n\nfn main() {\n let (mut a, mut b): (u64, u64);\n input!(a, b);\n\n while !(a == 0) && !(b == 0) {\n if a >= 2 * b {\n let buf = a / (2 * b);\n a = a - 2 * b * buf;\n } else if b >= 2 * a {\n let buf = b / (2 * a);\n b = b - 2 * a * buf;\n } else {\n break;\n }\n }\n println!(\"{} {}\", a, b);\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "6a87b66be50ff5032b65ea0689cf002d", "src_uid": "1f505e430eb930ea2b495ab531274114", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str;\n\npub struct Scanner {\n reader: R,\n buffer: Vec,\n}\n\nimpl Scanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buffer: vec![],\n }\n }\n\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn brute_force(a: i64, b: i64) -> (i64, i64) {\n let mut a = a;\n let mut b = b;\n while a > 0 && b > 0 {\n if a >= 2 * b {\n a = a % (2 * b);\n } else if b >= 2 * a {\n b = b % (2 * a);\n }\n else {\n return (a, b);\n }\n }\n (a, b)\n}\n\nfn solve(scan: &mut Scanner, out: &mut W) {\n let a: i64 = scan.token();\n let b: i64 = scan.token();\n let (a, b) = brute_force(a, b);\n writeln!(out, \"{} {}\", a, b).ok();\n}\n\nfn main() {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout.lock());\n solve(&mut scan, &mut out);\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "bdb9a986392ca9b3e1083a3e185f5254", "src_uid": "1f505e430eb930ea2b495ab531274114", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_variables)]\n#![allow(unused_must_use)]\nuse std::io::{self, prelude::*};\nuse std::cmp::min;\n\n\nfn gcd(a: i64, b: i64) -> i64 {\n if b == 0 {\n return a\n }\n return gcd(b, a%b)\n\n}\nfn solve(mut input: FastInput, mut w: W) {\n let a: i64 = input.token();\n let b: i64 = input.token();\n let mut x: i64 = input.token();\n let mut y: i64 = input.token();\n let g = gcd(x,y);\n x = x / g;\n y = y / g;\n write!(w, \"{}\\n\", min(a/x, b/y));\n\n \n}\n \n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let input = FastInput::from(stdin.lock());\n let output = io::BufWriter::new(stdout.lock());\n solve(input, output)\n}\n\ntrait TokenStream {\n fn token(&mut self) -> T;\n}\n \nstruct FastInput {\n stdin: R,\n pos: usize,\n}\n \nimpl From for FastInput {\n fn from(r: R) -> Self {\n FastInput { stdin: r, pos: 0 }\n }\n}\n \nimpl TokenStream for FastInput {\n fn token(&mut self) -> u8 {\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n while self.pos < buf.len() {\n self.pos += 1;\n if buf[self.pos - 1] > 32 {\n return buf[self.pos - 1];\n }\n }\n if self.pos == 0 {\n return 0;\n }\n } else {\n return 0;\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n \nimpl TokenStream> for FastInput {\n fn token(&mut self) -> Vec {\n let mut ans = Vec::new();\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans.push(buf[self.pos]);\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n \nmacro_rules! impl_token_stream {\n ($($t:ident),+) => {$(\n impl TokenStream<$t> for FastInput {\n fn token(&mut self) -> $t {\n let mut ans = 0;\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans = ans * 10 + (buf[self.pos] - b'0') as $t;\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n }\n )+}\n}\n\n\nimpl_token_stream!(i64);", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "aecef191772e9e4ecd41b2b1b08dcba5", "src_uid": "907ac56260e84dbb6d98a271bcb2d62d", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{stdin, Read, StdinLock};\nuse std::str::FromStr;\nuse std::iter::FromIterator;\n\n#[allow(unused_macros)]\nmacro_rules! vecs {\n ($init:expr; $($dim:expr);*) => {\n vecs!($($dim);* => $init)\n };\n ($head:expr; $($tail:expr);* => $init:expr) => {\n vec![vecs!($($tail);* => $init); $head]\n };\n ($head:expr => $init:expr) => {\n vec![$init; $head]\n };\n}\n\nfn main() {\n let cin = stdin();\n let mut scan = Scanner::new(cin.lock());\n let n = scan.read::();\n let k = scan.read::();\n let d = scan.read::();\n let mut env = Env {k: k, d: d, memo: vecs![None;n+1;2]};\n env.memo[0][1] = Some(1.into());\n println!(\"{}\", env.need(n));\n}\n\nstruct Env {\n k: usize,\n d: usize,\n memo: Vec>>\n}\n\nimpl Env {\n fn need(&mut self, n: usize) -> Co {\n if let Some(d) = self.memo[n][0] {\n return d;\n }\n let mut sum = Co(0);\n for i in 1..self.k+1 {\n if n>=i {\n if i>=self.d {sum += self.all(n-i);}\n else {sum += self.need(n-i);}\n }\n }\n self.memo[n][0] = Some(sum);\n sum\n }\n\n fn all(&mut self, n: usize) -> Co {\n if let Some(d) = self.memo[n][1] {\n return d;\n }\n let mut sum = Co(0);\n for i in 1..self.k + 1 {\n if n>=i {sum += self.all(n-i);}\n }\n self.memo[n][1] = Some(sum);\n sum\n }\n}\n\n#[allow(dead_code)]\nconst M: i64 = 1_000_000_007;\n\n// region modulo\n#[allow(dead_code)]\nuse std::ops::*;\n\n#[allow(dead_code)]\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\npub struct Co (pub i64);\n\n#[allow(dead_code)]\nimpl Co {\n pub fn pow(self, mut n: i64) -> Self {\n let mut a = self;\n let mut res = Co(1);\n while n > 0 {\n if n & 1 == 1 {\n res *= a;\n }\n a = a * a;\n n >>= 1;\n }\n res\n }\n}\n\n#[allow(dead_code)]\nimpl std::fmt::Display for Co {\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n}\n\n#[allow(dead_code)]\nimpl From for Co {\n fn from(value: i32) -> Self {\n Co((value as i64 % M + M) % M)\n }\n}\n#[allow(dead_code)]\nimpl From for Co {\n fn from(value: i64) -> Self {\n Co((value as i64 % M + M) % M)\n }\n}\n#[allow(dead_code)]\nimpl From for Co {\n fn from(value: usize) -> Self {\n Co((value as i64 % M + M) % M)\n }\n}\n#[allow(dead_code)]\nimpl AddAssign for Co {\n fn add_assign(&mut self, other: Self) {\n *self = self.add(other);\n }\n}\n#[allow(dead_code)]\nimpl Add for Co {\n type Output = Self;\n fn add(self, other: Self) -> Self {\n Co::from((self.0).add(other.0))\n }\n}\n#[allow(dead_code)]\nimpl SubAssign for Co {\n fn sub_assign(&mut self, other: Self) {\n *self = self.sub(other);\n }\n}\n#[allow(dead_code)]\nimpl Sub for Co {\n type Output = Self;\n fn sub(self, other: Self) -> Self {\n Co::from((self.0).sub(other.0))\n }\n}\n#[allow(dead_code)]\nimpl MulAssign for Co {\n fn mul_assign(&mut self, other: Self) {\n *self = self.mul(other);\n }\n}\n#[allow(dead_code)]\nimpl Mul for Co {\n type Output = Self;\n fn mul(self, other: Self) -> Self {\n Co::from((self.0).mul(other.0))\n }\n}\n#[allow(dead_code)]\nimpl DivAssign for Co {\n fn div_assign(&mut self, other: Self) {\n *self = self.div(other);\n }\n}\n#[allow(dead_code)]\nimpl Div for Co {\n type Output = Self;\n fn div(self, rhs: Self) -> Self {\n self * rhs.pow((M - 2) as i64)\n }\n}\n// endregion\n\n// region template\n#[allow(dead_code)]\nfn iu(i: isize) -> usize { i as usize }\n\n#[allow(dead_code)]\nfn ui(i: usize) -> isize { i as isize }\n\n#[allow(dead_code, deprecated)]\nfn join(slice: &[T], sep: &str) -> String {\n let strings = slice.iter().map(|t| format!(\"{}\", t)).collect::>();\n strings.connect(sep)\n}\n\n#[allow(dead_code)]\nfn arr<'a, S, T>(n: usize, mut f: S) -> Vec where S: FnMut(usize) -> T + 'a {\n (0..n).map(|i| f(i)).collect::>()\n}\n\n#[allow(dead_code)]\nfn alt(v: Vec) -> T where T: FromIterator {\n v.into_iter().collect::()\n}\n\n#[allow(dead_code)]\nfn dup(v: &[S]) -> T where T: FromIterator, S: Clone {\n v.iter().cloned().collect::()\n}\n\nstruct Scanner<'a> {\n cin: StdinLock<'a>,\n}\n\n#[allow(dead_code)]\nimpl<'a> Scanner<'a> {\n fn new(cin: StdinLock<'a>) -> Scanner<'a> {\n Scanner { cin: cin }\n }\n\n fn read1(&mut self) -> Option {\n let token = self.cin.by_ref().bytes().map(|c| c.unwrap() as char)\n .skip_while(|c| c.is_whitespace())\n .take_while(|c| !c.is_whitespace())\n .collect::();\n token.parse::().ok()\n }\n\n fn read(&mut self) -> T {\n self.read1().unwrap()\n }\n\n fn readn(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.read::()).collect()\n }\n\n fn chars(&mut self) -> Vec {\n self.read::().chars().collect()\n }\n}\n// endregion", "lang_cluster": "Rust", "tags": ["dp", "implementation", "trees"], "code_uid": "88ea57e6d4a4f4f685e65d0f4625771e", "src_uid": "894a58c9bba5eba11b843c5c5ca0025d", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\n#[allow(unused_imports)]\nuse std::cmp::{max, min, Ordering};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\n#[allow(unused_imports)]\nuse std::io::{stdin, stdout, BufWriter, Write};\n#[allow(unused_imports)]\nuse std::iter::FromIterator;\n#[macro_export]\nmacro_rules ! chmax { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: max ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! chmin { ( $ x : expr , $ ( $ v : expr ) ,+ ) => { $ ( $ x = std :: cmp :: min ( $ x ,$ v ) ; ) + } ; }\n#[macro_export]\nmacro_rules ! max { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: max ( $ x , max ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! min { ( $ x : expr ) => ( $ x ) ; ( $ x : expr , $ ( $ xs : expr ) ,+ ) => { std :: cmp :: min ( $ x , min ! ( $ ( $ xs ) ,+ ) ) } ; }\n#[macro_export]\nmacro_rules ! dvec { ( $ t : expr ; $ len : expr ) => { vec ! [ $ t ; $ len ] } ; ( $ t : expr ; $ len : expr , $ ( $ rest : expr ) ,* ) => { vec ! [ dvec ! ( $ t ; $ ( $ rest ) ,* ) ; $ len ] } ; }\n#[allow(unused_macros)]\nmacro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , \" = {:?}, \" ) ,* ) , $ ( $ a ) ,* ) ; } }\n#[macro_export]\nmacro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut parser = Parser :: from_str ( $ s ) ; input_inner ! { parser , $ ( $ r ) * } } ; ( parser = $ parser : ident , $ ( $ r : tt ) * ) => { input_inner ! { $ parser , $ ( $ r ) * } } ; ( new_stdin_parser = $ parser : ident , $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let reader = std :: io :: BufReader :: new ( stdin . lock ( ) ) ; let mut $ parser = Parser :: new ( reader ) ; input_inner ! { $ parser , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { input ! { new_stdin_parser = parser , $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! input_inner { ( $ parser : ident ) => { } ; ( $ parser : ident , ) => { } ; ( $ parser : ident , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ parser , $ t ) ; input_inner ! { $ parser $ ( $ r ) * } } ; }\n#[macro_export]\nmacro_rules ! read_value { ( $ parser : ident , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ parser , $ t ) ) ,* ) } ; ( $ parser : ident , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ parser , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ parser : ident , chars ) => { read_value ! ( $ parser , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ parser : ident , usize1 ) => { read_value ! ( $ parser , usize ) - 1 } ; ( $ parser : ident , $ t : ty ) => { $ parser . next ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\nuse std::io;\nuse std::io::BufRead;\nuse std::str;\npub struct Parser {\n reader: R,\n buf: Vec,\n pos: usize,\n}\nimpl Parser {\n pub fn from_str(s: &str) -> Parser {\n Parser {\n reader: io::empty(),\n buf: s.as_bytes().to_vec(),\n pos: 0,\n }\n }\n}\nimpl Parser {\n pub fn new(reader: R) -> Parser {\n Parser {\n reader: reader,\n buf: vec![],\n pos: 0,\n }\n }\n pub fn update_buf(&mut self) {\n self.buf.clear();\n self.pos = 0;\n loop {\n let (len, complete) = {\n let buf2 = self.reader.fill_buf().unwrap();\n self.buf.extend_from_slice(buf2);\n let len = buf2.len();\n if len == 0 {\n break;\n }\n (len, buf2[len - 1] <= 0x20)\n };\n self.reader.consume(len);\n if complete {\n break;\n }\n }\n }\n pub fn next(&mut self) -> Result {\n loop {\n let mut begin = self.pos;\n while begin < self.buf.len() && (self.buf[begin] <= 0x20) {\n begin += 1;\n }\n let mut end = begin;\n while end < self.buf.len() && (self.buf[end] > 0x20) {\n end += 1;\n }\n if begin != self.buf.len() {\n self.pos = end;\n return str::from_utf8(&self.buf[begin..end]).unwrap().parse::();\n } else {\n self.update_buf();\n }\n }\n }\n}\n#[allow(unused_macros)]\nmacro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , \" = {:?}, \" ) ,* ) , $ ( $ a ) ,* ) ; } }\n#[doc = \" https://github.com/hatoo/competitive-rust-snippets\"]\nconst BIG_STACK_SIZE: bool = true;\n#[allow(dead_code)]\nfn main() {\n use std::thread;\n if BIG_STACK_SIZE {\n thread::Builder::new()\n .stack_size(32 * 1024 * 1024)\n .name(\"solve\".into())\n .spawn(solve)\n .unwrap()\n .join()\n .unwrap();\n } else {\n solve();\n }\n}\nfn solve() {\n let out = stdout();\n let mut out = BufWriter::new(out.lock());\n\n input!{\n a:usize,\n b:usize,\n c:usize,\n d:usize,\n e:usize,\n f:usize,\n }\n\n let mut maxcost = 0;\n for i in 0..d+1 {\n let mut cost = 0;\n if a < i {\n continue;\n }\n cost += e*i;\n\n let rest = d-i;\n let mut j = min(min(b,c),rest);\n\n cost += f*j;\n\n chmax!(maxcost, cost);\n }\n println!(\"{}\", maxcost);\n}", "lang_cluster": "Rust", "tags": ["math", "greedy", "brute force"], "code_uid": "ff505c8ce79df5511b0be655b08e16a7", "src_uid": "84d9e7e9c9541d997e6573edb421ae0a", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::io::prelude::*;\n\nfn get_line() -> String {\n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n input\n}\n\nfn main() {\n let (n, t, k, d) = {\n let input = get_line();\n let mut it = input.split_whitespace().map(|k| k.parse::().unwrap());\n (\n it.next().unwrap(),\n it.next().unwrap(),\n it.next().unwrap(),\n it.next().unwrap(),\n )\n };\n\n let t1 = (n - 1) / k + 1;\n\n let ta = d / t;\n\n if t1 > ta + 1 {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "24abc9ec731c3419dd0a25528af5ae71", "src_uid": "32c866d3d394e269724b4930df5e4407", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//! http://codeforces.com/contest/799/problem/A\n\nfn single_oven_time(n: u32, t: u32, k: u32) -> u64 {\n let mut cakes = 0;\n let mut time = 0;\n while cakes < n {\n cakes += k;\n time += t as u64;\n }\n time\n}\n\nfn double_oven_time(n: u32, t: u32, k: u32, d: u32) -> u64 {\n let mut has_oven = false;\n let mut cakes = 0;\n let mut time = 0u64;\n while cakes < n {\n time += 1;\n if time % (t as u64) == 0 { cakes += k; }\n if let (n, false) = time.overflowing_sub(d as u64) {\n if n % (t as u64) == 0 && has_oven { cakes += k; }\n }\n if time == d as u64 { has_oven = true; }\n }\n time\n}\n\nfn main() {\n use std::io;\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n let mut ns = buf.split(\" \")\n .map(|str| str.trim().parse::().unwrap());\n let n = ns.next().unwrap();\n let t = ns.next().unwrap();\n let k = ns.next().unwrap();\n let d = ns.next().unwrap();\n if double_oven_time(n, t, k, d) < single_oven_time(n, t, k) {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "fb3fec68e1e6563aec74a2f81d446f05", "src_uid": "32c866d3d394e269724b4930df5e4407", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn gcd(a: i32, b: i32) -> i32 {\n let (mut a, mut b) = if a > b { (b, a) } else { (a, b) };\n while a != 0 {\n let tmp = a;\n a = b % a;\n b = tmp;\n }\n return b;\n}\n\nfn main() {\n let v: Vec = {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().split(\" \").map(|s| s.parse::().unwrap()).collect()\n };\n let (a, b, mut n) = (v[0], v[1], v[2]);\n\n loop {\n n -= gcd(a, n);\n if n == 0 {\n println!(\"0\");\n break;\n }\n n -= gcd(b, n);\n if n == 0 {\n println!(\"1\");\n break;\n \n }\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "23818fb60cc2085a26c3a1153a2359c8", "src_uid": "0bd6fbb6b0a2e7e5f080a70553149ac2", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn input() -> (u8, u8, u8) {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n let buf: Vec = buf\n .trim()\n .split_whitespace()\n .map(|elem| elem.parse().unwrap())\n .collect();\n (buf[0], buf[1], buf[2])\n}\n\nfn gcd(x: u8, n: u8) -> u8 {\n if n == 0 {\n return x;\n }\n gcd(n, x % n)\n}\n\nfn main() {\n let (a, b, mut n) = input();\n let mut simons_turn = true;\n\n loop {\n let x = if simons_turn { a } else { b };\n let gcd = gcd(x, n);\n\n if gcd <= n {\n simons_turn = !simons_turn;\n n -= gcd;\n } else {\n break;\n }\n }\n\n println!(\"{}\", if simons_turn { 1 } else { 0 });\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "f2d3e5677d586f019b9ee0fa414b73a5", "src_uid": "0bd6fbb6b0a2e7e5f080a70553149ac2", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "/// Codeforces Round #663 (Div. 2)\n/// https://codeforces.com/contest/1391/problem/C\n\nuse std::io::{self, BufWriter, Read, Write};\n\nfn main() {\n let stdout = io::stdout();\n let mut output = BufWriter::new(stdout.lock());\n let mut stdin = io::stdin();\n let mut input_string = String::new();\n stdin.read_to_string(&mut input_string).unwrap();\n let mut input_iter = input_string.split_whitespace();\n\n macro_rules! read(() => (input_iter.next().unwrap().parse().unwrap()));\n macro_rules! println(( $( $x:expr ),* ) => (writeln!(output, $( $x, )*).unwrap()));\n\n let n: usize = read!();\n let modulo = 1_000_000_007;\n let mut solution: u64 = 1;\n let mut power_of_2: u64 = 1;\n\n for i in 2..(n + 1) {\n solution = (solution * i as u64) % modulo;\n power_of_2 = (power_of_2 * 2) % modulo;\n }\n\n if solution < power_of_2 {\n solution += modulo;\n }\n\n solution = (solution - power_of_2) % modulo;\n\n println!(\"{}\", solution);\n}\n\n", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics", "graphs"], "code_uid": "830021a0aad97106214732da107ee618", "src_uid": "3dc1ee09016a25421ae371fa8005fce1", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::Read;\n\nfn read() -> T {\n let token: String = std::io::stdin()\n .bytes()\n .map(|c| c.ok().unwrap() as char)\n .skip_while(|c| c.is_whitespace())\n .take_while(|c| !c.is_whitespace())\n .collect();\n token.parse().ok().unwrap()\n}\n\nmod mint {\n use std::ops::{Add, BitAnd, Div, Mul, Rem, Shr, Sub};\n\n #[derive(Copy, Clone)]\n pub struct Mint {\n x: T,\n mo: T,\n }\n impl Mint\n where\n T: Copy,\n {\n pub fn new(x: T, mo: T) -> Mint {\n Mint { x, mo }\n }\n }\n impl Mint\n where\n T: Copy,\n {\n pub fn val(&self) -> T {\n self.x\n }\n pub fn mo(&self) -> T {\n self.mo\n }\n }\n impl Add for Mint\n where\n T: Copy,\n T: Add,\n T: Rem,\n {\n type Output = Mint;\n fn add(self, rhs: T) -> Mint {\n Mint::new((self.val() + rhs % self.mo()) % self.mo(), self.mo())\n }\n }\n impl Add> for Mint\n where\n T: Copy,\n Mint: Add>,\n {\n type Output = Mint;\n fn add(self, rhs: Mint) -> Mint {\n self + rhs.val()\n }\n }\n impl Sub for Mint\n where\n T: Copy,\n T: Add,\n T: Sub,\n T: Rem,\n {\n type Output = Mint;\n fn sub(self, rhs: T) -> Mint {\n Mint::new(\n (self.val() + self.mo() - rhs % self.mo()) % self.mo(),\n self.mo(),\n )\n }\n }\n impl Sub> for Mint\n where\n T: Copy,\n Mint: Sub>,\n {\n type Output = Mint;\n fn sub(self, rhs: Mint) -> Mint {\n self - rhs.val()\n }\n }\n impl Mul for Mint\n where\n T: Copy,\n T: Mul,\n T: Rem,\n {\n type Output = Mint;\n fn mul(self, rhs: T) -> Mint {\n Mint::new((self.val() * rhs % self.mo()) % self.mo(), self.mo())\n }\n }\n impl Mul> for Mint\n where\n T: Copy,\n Mint: Mul>,\n {\n type Output = Mint;\n fn mul(self, rhs: Mint) -> Mint {\n self * rhs.val()\n }\n }\n\n impl Mint\n where\n T: Copy,\n T: Sub,\n T: Div,\n T: PartialOrd,\n T: PartialEq,\n T: BitAnd,\n T: Shr,\n Mint: Mul>,\n {\n pub fn pow(self, y: T) -> Mint {\n let one = self.mo() / self.mo();\n let zero = self.mo() - self.mo();\n let mut res = Mint::one(self.mo());\n let mut base = self;\n let mut exp = y;\n while exp > zero {\n if (exp & one) == one {\n res = res * base;\n }\n base = base * base;\n exp = exp >> one;\n }\n res\n }\n }\n impl Div for Mint\n where\n T: Copy,\n T: Sub,\n T: Div,\n T: PartialOrd,\n T: PartialEq,\n T: BitAnd,\n T: Shr,\n Mint: Mul>,\n {\n type Output = Mint;\n fn div(self, rhs: T) -> Mint {\n let one = self.mo() / self.mo();\n self * Mint::new(rhs, self.mo()).pow(self.mo() - one - one)\n }\n }\n impl Div> for Mint\n where\n T: Copy,\n Mint: Div>,\n {\n type Output = Mint;\n fn div(self, rhs: Mint) -> Mint {\n self / rhs.val()\n }\n }\n impl Mint\n where\n T: Copy,\n T: Div,\n Mint: Div>,\n {\n pub fn inv(self) -> Mint {\n Mint::one(self.mo()) / self\n }\n }\n impl std::fmt::Display for Mint\n where\n T: Copy + std::fmt::Display,\n {\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n write!(f, \"{}\", self.val())\n }\n }\n impl Mint\n where\n T: Copy,\n T: Sub,\n {\n pub fn zero(mo: T) -> Mint {\n Mint { x: mo - mo, mo }\n }\n }\n impl Mint\n where\n T: Copy,\n T: Div,\n {\n pub fn one(mo: T) -> Mint {\n Mint { x: mo / mo, mo }\n }\n }\n}\n\nuse mint::Mint;\n\nfn factorials(n: usize, mo: u64) -> (Vec>, Vec>) {\n let mut fac = vec![Mint::new(0, mo); n];\n let mut fac_inv = vec![Mint::new(0, mo); n];\n fac[0] = Mint::new(1, mo);\n for i in 1..n {\n fac[i] = fac[i - 1] * (i as u64);\n }\n fac_inv[n - 1] = fac[n - 1].inv();\n for i in (0..n - 1).rev() {\n fac_inv[i] = fac_inv[i + 1] * ((i + 1) as u64);\n }\n (fac, fac_inv)\n}\n\nfn main() {\n let n: usize = read();\n let mo = 1000000007;\n let (fac, _) = factorials(n + 1, mo);\n let mut ans = fac[n];\n ans = ans - Mint::new(2, mo).pow(n as u64 - 1);\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics", "graphs"], "code_uid": "487dbf63c7547a92da0b3781411e5011", "src_uid": "3dc1ee09016a25421ae371fa8005fce1", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "macro_rules! parse_line {\n ($t: ty) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let a_str = a_str.trim();\n a_str.parse::<$t>().expect(\"parse error\")\n });\n ($($t: ty),+) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let mut a_iter = a_str.split_whitespace();\n (\n $(\n a_iter.next().unwrap().parse::<$t>().expect(\"parse error\"),\n )+\n )\n })\n}\n\nmacro_rules! parse_line_to_vec {\n ($t: ty) => {{\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n (a_str\n .split_whitespace()\n .map(|x| x.parse::<$t>().unwrap())\n .collect::>())\n }};\n}\n\nfn resolve(hy: i64, ay: i64, dy: i64, hm: i64, am: i64, dm: i64) -> bool {\n let ay = ay - dm;\n let am = am - dy;\n if ay <= 0 {\n return false;\n }\n if am <= 0 {\n return true;\n }\n let yt = (hy - 1) / am;\n let mt = (hm - 1) / ay;\n yt > mt\n}\n\nfn solve() {\n let (hy, ay, dy) = parse_line!(i64, i64, i64);\n let (hm, am, dm) = parse_line!(i64, i64, i64);\n let (h, a, d) = parse_line!(i64, i64, i64);\n let mut ans = std::i64::MAX;\n for aadd in 0..200 {\n for dadd in 0..100 {\n let ay = ay + aadd;\n let dy = dy + dadd;\n let mut l: i64 = -1;\n let mut r: i64 = 10001;\n if !resolve(hy + r, ay, dy, hm, am, dm) {\n continue;\n }\n while r - l > 1 {\n let m = (l + r) / 2;\n let hy = hy + m;\n if resolve(hy, ay, dy, hm, am, dm) {\n r = m;\n }else{\n l = m;\n }\n }\n let cost = aadd * a + dadd * d + r * h;\n if cost < ans {\n ans = cost;\n }\n }\n }\n println!(\"{}\", ans);\n}\n\nfn main() {\n let tests = 1; // parse_line!(usize);\n for _ in 0..tests {\n solve();\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation", "binary search"], "code_uid": "325314933cf66d18d879550d51d1b88d", "src_uid": "bf8a133154745e64a547de6f31ddc884", "difficulty": 1800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, Stdin};\nuse std::str::{self, FromStr};\nuse std::error::Error;\nuse std::thread;\n\nfn exec() {\n let mut sc = Scanner::new();\n let k: i64 = sc.ne();\n let a: i64 = sc.ne();\n let b: i64 = sc.ne();\n let aw = a / k;\n let bw = b / k;\n let mut ok = true;\n if aw == 0 && bw == 0 {\n ok = false;\n } else if aw == 0 {\n ok = b % k == 0;\n } else if bw == 0 {\n ok = a % k == 0;\n }\n if ok {\n println!(\"{}\", aw + bw);\n } else {\n println!(\"-1\");\n }\n}\n\nfn main() {\n const DEFAULT_STACK: usize = 16 * 1024 * 1024;\n let builder = thread::Builder::new();\n let th = builder.stack_size(DEFAULT_STACK);\n let handle = th.spawn(|| { exec(); }).unwrap();\n let _ = handle.join();\n}\n\n#[allow(dead_code)]\nstruct Scanner {\n stdin: Stdin,\n id: usize,\n buf: Vec,\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new() -> Scanner {\n Scanner {\n stdin: io::stdin(),\n id: 0,\n buf: Vec::new(),\n }\n }\n fn next_line(&mut self) -> Option {\n let mut res = String::new();\n match self.stdin.read_line(&mut res) {\n Ok(0) => return None,\n Ok(_) => Some(res),\n Err(why) => panic!(\"error in read_line: {}\", why.description()),\n }\n }\n fn next(&mut self) -> Option {\n while self.buf.len() == 0 {\n self.buf = match self.next_line() {\n Some(r) => {\n self.id = 0;\n r.trim().as_bytes().to_owned()\n }\n None => return None,\n };\n }\n let l = self.id;\n assert!(self.buf[l] != b' ');\n let n = self.buf.len();\n let mut r = l;\n while r < n && self.buf[r] != b' ' {\n r += 1;\n }\n let res = match str::from_utf8(&self.buf[l..r]).ok().unwrap().parse::() {\n Ok(s) => Some(s),\n Err(_) => panic!(\"parse error\"),\n };\n while r < n && self.buf[r] == b' ' {\n r += 1;\n }\n if r == n {\n self.buf.clear();\n } else {\n self.id = r;\n }\n res\n }\n fn ne(&mut self) -> T {\n self.next::().unwrap()\n }\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "a9f72ebe93ec88575ce05e03ba4fac88", "src_uid": "6e3b8193d1ca1a1d449dc7a4ad45b8f2", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin ModInt ----------\nconst MOD: u32 = 998_244_353;\n\n#[derive(Clone, Copy)]\nstruct ModInt(u32);\n\nimpl std::ops::Add for ModInt {\n type Output = ModInt;\n fn add(self, rhs: ModInt) -> Self::Output {\n let mut d = self.0 + rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n\nimpl std::ops::AddAssign for ModInt {\n fn add_assign(&mut self, rhs: ModInt) {\n *self = *self + rhs;\n }\n}\n\nimpl std::ops::Sub for ModInt {\n type Output = ModInt;\n fn sub(self, rhs: ModInt) -> Self::Output {\n let mut d = self.0 + MOD - rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n\nimpl std::ops::SubAssign for ModInt {\n fn sub_assign(&mut self, rhs: ModInt) {\n *self = *self - rhs;\n }\n}\n\nimpl std::ops::Mul for ModInt {\n type Output = ModInt;\n fn mul(self, rhs: ModInt) -> Self::Output {\n ModInt((self.0 as u64 * rhs.0 as u64 % MOD as u64) as u32)\n }\n}\n\nimpl std::ops::MulAssign for ModInt {\n fn mul_assign(&mut self, rhs: ModInt) {\n *self = *self * rhs;\n }\n}\n\nimpl std::ops::Neg for ModInt {\n type Output = ModInt;\n fn neg(self) -> Self::Output {\n ModInt(if self.0 == 0 {0} else {MOD - self.0})\n }\n}\n\nimpl std::fmt::Display for ModInt {\n fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n}\n\nimpl std::str::FromStr for ModInt {\n type Err = std::num::ParseIntError;\n fn from_str(s: &str) -> Result {\n let val = s.parse::()?;\n Ok(ModInt::new(val))\n }\n}\n\nimpl From for ModInt {\n fn from(val: usize) -> ModInt {\n ModInt((val % MOD as usize) as u32)\n }\n}\n\n#[allow(dead_code)]\nimpl ModInt {\n pub fn new(n: u32) -> ModInt {\n ModInt(n % MOD)\n }\n pub fn zero() -> ModInt {\n ModInt(0)\n }\n pub fn one() -> ModInt {\n ModInt(1)\n }\n pub fn pow(self, mut n: u32) -> ModInt {\n let mut t = ModInt::one();\n let mut s = self;\n while n > 0 {\n if n & 1 == 1 {\n t *= s;\n }\n s *= s;\n n >>= 1;\n }\n t\n }\n pub fn inv(self) -> ModInt {\n assert!(self.0 > 0);\n self.pow(MOD - 2)\n }\n}\n// ---------- end ModInt ----------\n// ---------- begin Precalc ----------\n#[allow(dead_code)]\nstruct Precalc {\n inv: Vec,\n fact: Vec,\n ifact: Vec,\n}\n\n#[allow(dead_code)]\nimpl Precalc {\n pub fn new(n: usize) -> Precalc {\n let mut inv = vec![ModInt::one(); n + 1];\n let mut fact = vec![ModInt::one(); n + 1];\n let mut ifact = vec![ModInt::one(); n + 1];\n for i in 2..(n + 1) {\n inv[i] = -inv[MOD as usize % i] * ModInt(MOD / i as u32);\n fact[i] = fact[i - 1] * ModInt(i as u32);\n ifact[i] = ifact[i - 1] * inv[i];\n }\n Precalc {\n inv: inv,\n fact: fact,\n ifact: ifact,\n }\n }\n pub fn inv(&self, n: usize) -> ModInt {\n self.inv[n]\n }\n pub fn fact(&self, n: usize) -> ModInt {\n self.fact[n]\n }\n pub fn ifact(&self, n: usize) -> ModInt {\n self.ifact[n]\n }\n pub fn comb(&self, n: usize, k: usize) -> ModInt {\n if k > n {\n return ModInt::zero();\n }\n self.fact[n] * self.ifact[k] * self.ifact[n - k]\n }\n}\n// ---------- end Precalc ----------\n//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n// \u3053\u3053\u307e\u3067\n\nfn run() {\n input! {\n n: usize,\n m: u64,\n }\n if m > n as u64 - 1 {\n println!(\"0\");\n return;\n }\n let m = m as usize;\n let pc = Precalc::new(n + m);\n if m == 0 {\n println!(\"{}\", pc.fact(n));\n return;\n }\n let mut ans = ModInt::zero();\n let mut sign = ModInt::one();\n for i in (1..=(n - m)).rev() {\n ans += sign * pc.comb(n - m, i) * ModInt::from(i).pow(n as u32);\n sign = -sign;\n }\n ans *= pc.comb(n, n - m) * ModInt(2);\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["math", "combinatorics", "fft"], "code_uid": "6c7fe22ee12dc4ca5fcee7bc57d01caa", "src_uid": "6c1a9aaa7bdd7de97220b8c6d35740cc", "difficulty": 2300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin ModInt ----------\nconst MOD: u32 = 998_244_353;\n \n#[derive(Clone, Copy)]\nstruct ModInt(u32);\n \nimpl std::ops::Add for ModInt {\n type Output = ModInt;\n fn add(self, rhs: ModInt) -> Self::Output {\n let mut d = self.0 + rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n \nimpl std::ops::AddAssign for ModInt {\n fn add_assign(&mut self, rhs: ModInt) {\n *self = *self + rhs;\n }\n}\n \nimpl std::ops::Sub for ModInt {\n type Output = ModInt;\n fn sub(self, rhs: ModInt) -> Self::Output {\n let mut d = self.0 + MOD - rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n \nimpl std::ops::SubAssign for ModInt {\n fn sub_assign(&mut self, rhs: ModInt) {\n *self = *self - rhs;\n }\n}\n \nimpl std::ops::Mul for ModInt {\n type Output = ModInt;\n fn mul(self, rhs: ModInt) -> Self::Output {\n ModInt((self.0 as u64 * rhs.0 as u64 % MOD as u64) as u32)\n }\n}\n \nimpl std::ops::MulAssign for ModInt {\n fn mul_assign(&mut self, rhs: ModInt) {\n *self = *self * rhs;\n }\n}\n \nimpl std::ops::Neg for ModInt {\n type Output = ModInt;\n fn neg(self) -> Self::Output {\n ModInt(if self.0 == 0 {0} else {MOD - self.0})\n }\n}\n \nimpl std::fmt::Display for ModInt {\n fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n}\n \nimpl std::str::FromStr for ModInt {\n type Err = std::num::ParseIntError;\n fn from_str(s: &str) -> Result {\n let val = s.parse::()?;\n Ok(ModInt::new(val))\n }\n}\n \nimpl From for ModInt {\n fn from(val: usize) -> ModInt {\n ModInt((val % MOD as usize) as u32)\n }\n}\n \n#[allow(dead_code)]\nimpl ModInt {\n pub fn new(n: u32) -> ModInt {\n ModInt(n % MOD)\n }\n pub fn zero() -> ModInt {\n ModInt(0)\n }\n pub fn one() -> ModInt {\n ModInt(1)\n }\n pub fn pow(self, mut n: u32) -> ModInt {\n let mut t = ModInt::one();\n let mut s = self;\n while n > 0 {\n if n & 1 == 1 {\n t *= s;\n }\n s *= s;\n n >>= 1;\n }\n t\n }\n pub fn inv(self) -> ModInt {\n assert!(self.0 > 0);\n self.pow(MOD - 2)\n }\n}\n// ---------- end ModInt ----------\n// ---------- begin Precalc ----------\n#[allow(dead_code)]\nstruct Precalc {\n inv: Vec,\n fact: Vec,\n ifact: Vec,\n}\n \n#[allow(dead_code)]\nimpl Precalc {\n pub fn new(n: usize) -> Precalc {\n let mut inv = vec![ModInt::one(); n + 1];\n let mut fact = vec![ModInt::one(); n + 1];\n let mut ifact = vec![ModInt::one(); n + 1];\n for i in 2..(n + 1) {\n inv[i] = -inv[MOD as usize % i] * ModInt(MOD / i as u32);\n fact[i] = fact[i - 1] * ModInt(i as u32);\n ifact[i] = ifact[i - 1] * inv[i];\n }\n Precalc {\n inv: inv,\n fact: fact,\n ifact: ifact,\n }\n }\n pub fn inv(&self, n: usize) -> ModInt {\n self.inv[n]\n }\n pub fn fact(&self, n: usize) -> ModInt {\n self.fact[n]\n }\n pub fn ifact(&self, n: usize) -> ModInt {\n self.ifact[n]\n }\n pub fn comb(&self, n: usize, k: usize) -> ModInt {\n if k > n {\n return ModInt::zero();\n }\n self.fact[n] * self.ifact[k] * self.ifact[n - k]\n }\n}\n// ---------- end Precalc ----------\n//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n \nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n \nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\nfn run() {\n input! {\n n: usize,\n m: u64,\n }\n if m > n as u64 - 1 {\n println!(\"0\");\n return;\n }\n let m = m as usize;\n let pc = Precalc::new(n + m);\n if m == 0 {\n println!(\"{}\", pc.fact(n));\n return;\n }\n let mut ans = ModInt::zero();\n let mut sign = ModInt::one();\n for i in (1..=(n - m)).rev() {\n ans += sign * pc.comb(n - m, i) * ModInt::from(i).pow(n as u32);\n sign = -sign;\n }\n ans *= pc.comb(n, n - m) * ModInt(2);\n println!(\"{}\", ans);\n}\nfn main() {\n run();\n}", "lang_cluster": "Rust", "tags": ["math", "combinatorics", "fft"], "code_uid": "a1a1d10fcdf455045d63fb29d4d81cc6", "src_uid": "6c1a9aaa7bdd7de97220b8c6d35740cc", "difficulty": 2300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// https://codeforces.com/problemset/problem/732/A\nuse std::io;\n\nfn main() {\n let mut line = String::new();\n\n io::stdin()\n .read_line(&mut line)\n .unwrap();\n\n let words: Vec =\n line\n .split_whitespace()\n .map(|x| x.parse().unwrap())\n .collect();\n\n let k = words[0];\n let r = words[1];\n\n for i in 1..=9 {\n if i*k%10 == r || i*k%10 == 0 {\n println!(\"{}\", i);\n break;\n }\n }\n}\n\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "constructive algorithms", "implementation"], "code_uid": "24bb0499b4985e19040b2895796e8e35", "src_uid": "18cd1cd809df4744bb7bcd7cad94e2d3", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin input macro ----------\n// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, bytes) => {\n read_value!($iter, String).bytes().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n// ---------- end input macro ----------\n\nfn run() {\n input! {\n n: usize,\n l: u64,\n }\n let mut dp = vec![1u64; n + 1];\n for i in 2..=n {\n dp[i] = dp[i - 1] + dp[i - 2];\n }\n let mut ans = vec![];\n let mut l = l - 1;\n let mut s = 1;\n while s <= n {\n if dp[n - s] > l {\n ans.push(s);\n s += 1;\n } else {\n l -= dp[n - s];\n ans.push(s + 1);\n ans.push(s);\n s += 2;\n }\n }\n let mut s = String::new();\n for a in ans {\n s.push_str(&format!(\"{} \", a));\n }\n s.pop();\n println!(\"{}\", s);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["constructive algorithms", "math", "combinatorics", "binary search", "greedy", "implementation"], "code_uid": "2bc2bb06b22704823f1b43ccbb7e494b", "src_uid": "e03c6d3bb8cf9119530668765691a346", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nfn main() {\n let mut n = String::new();\n io::stdin().read_line(&mut n).expect(\"failed to read\");\n let n :u64 = n.trim().parse().expect(\"failed to parse\");\n let counter:u64 = n/2520;\n println!(\"{}\", counter);\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "ba877165177e90443766fba961732784", "src_uid": "8551308e5ff435e0fc507b89a912408a", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::cmp::{max, min};\nuse std::io::{stdin, stdout, BufWriter, Write};\n\n#[derive(Default)]\nstruct Scanner {\n buffer: Vec,\n}\nimpl Scanner {\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n stdin().read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn main() {\n let mut scanner = Scanner::default();\n let info: Vec = (0..2).map(|_| scanner.next()).collect();\n let arr: Vec = scanner.next::().chars().collect();\n let mut dp = vec![false; arr.len()];\n dp[0] = true;\n dp[arr.len() - 1] = true;\n\n let mut count = 1;\n let mut current_pos = info[1];\n\n while !dp[std::cmp::min(current_pos, arr.len() - 1)] {\n dp[current_pos] = true;\n match arr[current_pos] {\n '1' => {\n current_pos += info[1];\n count += 1;\n }\n '0' => current_pos -= 1,\n _ => (),\n }\n }\n if current_pos >= arr.len() - 1 {\n println!(\"{}\", count);\n } else {\n println!(\"-1\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["dfs and similar", "greedy", "dp", "implementation"], "code_uid": "938657a3fbb11c86d84190d122a3f24c", "src_uid": "c08d2ecdfc66cd07fbbd461b1f069c9e", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, Stdin};\nuse std::str::{self, FromStr};\nuse std::error::Error;\nuse std::thread;\n\nfn exec() {\n let mut sc = Scanner::new();\n let n: i64 = sc.ne();\n let m: usize = 100;\n let inf = 1e18 as i64 * 2;\n let mut dp = vec![inf; m];\n dp[0] = 1;\n dp[1] = 2;\n for i in 2..m {\n dp[i] = dp[i - 1] + dp[i - 2];\n if dp[i] > inf {\n break;\n }\n }\n let pos = dp.iter().position(|&x| x > n).unwrap();\n // for i in 0..m {\n // println!(\"{} {}\", i, dp[i]);\n // }\n println!(\"{}\", pos - 1);\n}\nconst DEFAULT_STACK: usize = 16 * 1024 * 1024;\nfn main() {\n let builder = thread::Builder::new();\n let th = builder.stack_size(DEFAULT_STACK);\n let handle = th.spawn(|| { exec(); }).unwrap();\n let _ = handle.join();\n}\n\n#[allow(dead_code)]\nstruct Scanner {\n stdin: Stdin,\n id: usize,\n buf: Vec,\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new() -> Scanner {\n Scanner {\n stdin: io::stdin(),\n id: 0,\n buf: Vec::new(),\n }\n }\n fn next_line(&mut self) -> Option {\n let mut res = String::new();\n match self.stdin.read_line(&mut res) {\n Ok(0) => return None,\n Ok(_) => Some(res),\n Err(why) => panic!(\"error in read_line: {}\", why.description()),\n }\n }\n fn next(&mut self) -> Option {\n while self.buf.len() == 0 {\n self.buf = match self.next_line() {\n Some(r) => {\n self.id = 0;\n r.trim().as_bytes().to_owned()\n }\n None => return None,\n };\n }\n let l = self.id;\n assert!(self.buf[l] != b' ');\n let n = self.buf.len();\n let mut r = l;\n while r < n && self.buf[r] != b' ' {\n r += 1;\n }\n let res = match str::from_utf8(&self.buf[l..r]).ok().unwrap().parse::() {\n Ok(s) => Some(s),\n Err(_) => panic!(\"parse error\"),\n };\n while r < n && self.buf[r] == b' ' {\n r += 1;\n }\n if r == n {\n self.buf.clear();\n } else {\n self.id = r;\n }\n res\n }\n fn ne(&mut self) -> T {\n self.next::().unwrap()\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "greedy", "constructive algorithms", "combinatorics"], "code_uid": "12ca7ed7c05e8c1ea934b2457094ebfa", "src_uid": "3d3432b4f7c6a3b901161fa24b415b14", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(dead_code, unused_macros, unused_imports)]\nuse std::collections::*;\nuse std::io;\nuse std::io::Write;\nmacro_rules! fprintln {\n ($dst:expr) => (\n $dst.write(\"\\n\".as_bytes()).unwrap();\n );\n ($dst:expr, $($arg:tt)*) => ( {\n $dst.write_fmt(format_args!($($arg)*)).unwrap();\n $dst.write(\"\\n\".as_bytes()).unwrap();\n }\n );\n}\n\nmacro_rules! fprintvec {\n ($dst:expr, $arg:expr) => {{\n fprintln!(\n $dst,\n \"{}\",\n $arg.iter()\n .map(|x| format!(\"{}\", x))\n .collect::>()\n .join(\" \")\n );\n }};\n}\n\nmacro_rules! parse_input {\n ($t:ident) => {{\n let mut input_line = String::new();\n io::stdin().read_line(&mut input_line).unwrap();\n input_line\n .trim_end_matches(\"\\n\")\n .trim_end_matches(\"\\r\")\n .parse::<$t>()\n .unwrap()\n }};\n}\n\nmacro_rules! split_input {\n ($t:ident) => {{\n parse_input!(String)\n .split(\" \")\n .map(|z| z.parse::<$t>().unwrap())\n .collect::>()\n }};\n}\n\nfn depth(t: i64, k: i64, start: i64) -> i64 {\n let v;\n let t = t % (2 * k);\n if t <= k {\n v = t;\n } else {\n v = k - (t - k);\n }\n v + start\n}\n\nfn slow(depths: &Vec, k: i64, l: i64) -> bool {\n let mut valid = (0..=2 * k).collect::>();\n for p in depths.iter() {\n let mut next = HashSet::new();\n for z in valid.iter() {\n for x in 1..=(2 * k) {\n if depth(z + x, k, *p) <= l {\n next.insert((z + x) % (2 * k));\n } else {\n break;\n }\n }\n }\n valid = next;\n }\n valid.len() > 0\n}\n\nfn main() {\n let stdout = io::stdout();\n let lock = stdout.lock();\n let mut w = io::BufWriter::new(lock);\n let num_tests = parse_input!(usize);\n // let num_tests = 1;\n for _ in 0..num_tests {\n let limits = split_input!(i64);\n let n = limits[0];\n let k = limits[1];\n let l = limits[2];\n let vals = split_input!(i64);\n let mut start = -k;\n let mut valid = true;\n // for (p, &d) in vals.iter().enumerate() {\n // if d > l {\n // valid = false;\n // break;\n // }\n // if d + k <= l {\n // start = -k;\n // } else {\n // let nt = start + 1;\n // let bad = (l - d) + 1;\n // let good = -bad;\n // if nt >= bad {\n // valid = false;\n // break;\n // }\n // start = std::cmp::max(nt, good);\n // }\n // dbg!(start);\n // }\n valid = slow(&vals, k, l);\n if valid {\n fprintln!(w, \"YES\");\n } else {\n fprintln!(w, \"NO\");\n }\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "greedy", "dp"], "code_uid": "ea61bbd25ec357eba2d56fbf47c43207", "src_uid": "4941b0a365f86b2e2cf686cdf5d532f8", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(dead_code, unused_imports)]\n\nuse std::fmt::Debug;\nuse std::str::FromStr;\n\nfn read_stdin() -> String {\n let mut s = String::new();\n std::io::stdin()\n .read_line(&mut s)\n .expect(\"cannot read stdin\");\n s.trim().to_string()\n}\n\nfn read() -> T\nwhere\n T: FromStr,\n ::Err: Debug,\n{\n read_stdin().parse::().unwrap()\n}\n\nfn read_usize() -> usize {\n read::()\n}\n\nfn read_2() -> (A, B)\nwhere\n A: FromStr,\n ::Err: Debug,\n B: FromStr,\n ::Err: Debug,\n{\n let s = read_stdin();\n let mut s = s.split_whitespace();\n let a = s.next().unwrap().parse::().unwrap();\n let b = s.next().unwrap().parse::().unwrap();\n (a, b)\n}\n\nfn read_3() -> (A, B, C)\nwhere\n A: FromStr,\n ::Err: Debug,\n B: FromStr,\n ::Err: Debug,\n C: FromStr,\n ::Err: Debug,\n{\n let s = read_stdin();\n let mut s = s.split_whitespace();\n let a = s.next().unwrap().parse::().unwrap();\n let b = s.next().unwrap().parse::().unwrap();\n let c = s.next().unwrap().parse::().unwrap();\n (a, b, c)\n}\n\nfn read_4() -> (A, B, C, D)\nwhere\n A: FromStr,\n ::Err: Debug,\n B: FromStr,\n ::Err: Debug,\n C: FromStr,\n ::Err: Debug,\n D: FromStr,\n ::Err: Debug,\n{\n let s = read_stdin();\n let mut s = s.split_whitespace();\n let a = s.next().unwrap().parse::().unwrap();\n let b = s.next().unwrap().parse::().unwrap();\n let c = s.next().unwrap().parse::().unwrap();\n let d = s.next().unwrap().parse::().unwrap();\n (a, b, c, d)\n}\n\nfn read_multiple() -> Vec\nwhere\n ::Err: Debug,\n{\n read_stdin()\n .split_whitespace()\n .map(|x| x.parse::().expect(\"cannot parse stdin\"))\n .collect()\n}\n\n/// NOTE: sort iter beforehand if required\nfn count(iter: &mut impl Iterator) -> Vec<(T, usize)>\nwhere\n T: std::cmp::Ord,\n{\n let iter = iter.collect::>();\n //iter.sort();\n let (mut v, o, c) =\n iter.into_iter()\n .fold((Vec::new(), None, 0), |(mut v, last, count), item| {\n if let Some(o) = last {\n if item == o {\n (v, Some(o), count + 1)\n } else {\n v.push((o, count));\n (v, Some(item), 1)\n }\n } else {\n (v, Some(item), 1)\n }\n });\n if let Some(i) = o {\n v.push((i, c));\n }\n v\n}\n\nfn max_subarray(v: impl Iterator) -> (i64, (usize, usize)) {\n //assert!(v.len() > 0);\n let mut best_sum = 0;\n let (mut best_start, mut best_end) = (0, 0);\n let mut current_sum = 0;\n let mut current_start = 0;\n for (end, val) in v.enumerate() {\n if current_sum <= 0 {\n current_start = end;\n current_sum = val;\n } else {\n current_sum += val;\n }\n if current_sum > best_sum {\n best_sum = current_sum;\n best_start = current_start;\n best_end = end + 1;\n }\n }\n (best_sum, (best_start, best_end))\n}\n\nfn gcd(a: u64, b: u64) -> u64 {\n let mut a = a;\n let mut b = b;\n while a != b {\n if a > b {\n a = a - b\n } else {\n b = b - a\n }\n }\n a\n}\n\nfn factorize(mut n: u64) -> Vec {\n if n <= 3 {\n return vec![n];\n }\n let mut v = Vec::new();\n while n % 2 == 0 {\n n /= 2;\n v.push(2);\n }\n while n % 3 == 0 {\n n /= 3;\n v.push(3);\n }\n let mut f = 6;\n while (f - 1) * (f - 1) <= n {\n while n % (f - 1) == 0 {\n n /= f - 1;\n v.push(f - 1);\n }\n while n % (f + 1) == 0 {\n n /= f + 1;\n v.push(f + 1);\n }\n f += 6;\n }\n if n > 1 {\n v.push(n);\n }\n v\n}\n\nfn compact_factors(n: u64) -> Vec<(u64, usize)> {\n count(&mut factorize(n).into_iter())\n}\n\nfn all_factors(n: u64) -> Vec {\n let factors = compact_factors(n);\n let mut v = vec![1];\n for (fac, num) in factors {\n let ori = v.clone();\n for i in 1..num + 1 {\n v.append(\n &mut ori\n .clone()\n .into_iter()\n .map(|f| f * fac.pow(i as u32))\n .collect::>(),\n )\n }\n }\n v.sort();\n v\n}\n\nuse std::cmp::{max, min};\nuse std::collections::VecDeque;\n\nfn first_factor(n: u32) -> u32 {\n if n % 2 == 0 {\n return 2;\n }\n if n % 3 == 0 {\n return 3;\n }\n let mut f = 6;\n while (f - 1) * (f - 1) <= n {\n if n % (f - 1) == 0 {\n return f - 1;\n }\n if n % (f + 1) == 0 {\n return f + 1;\n }\n f += 6;\n }\n return n;\n}\n\nfn found(d: Vec, k: u16, limit: u16) -> bool {\n if d.is_empty() {\n return true;\n }\n let p = (0..k).chain((1..k + 1).rev()).collect::>();\n for start in 0..p.len() {\n if d.iter()\n .enumerate()\n .map(|(i, di)| di + p[(i + start) % p.len()])\n .all(|di| di <= limit)\n {\n return true;\n }\n }\n false\n}\n\nfn main() -> Result<(), Box> {\n for _ in 0..read_usize() {\n let (_n, k, l) = read_3::();\n let d = read_multiple();\n let mut dead = false;\n let mut gap = Vec::new();\n for di in d {\n if k + di <= l {\n if !found(gap, k, l) {\n dead = true\n }\n gap = Vec::new();\n } else {\n gap.push(di)\n }\n }\n if !found(gap, k, l) {\n dead = true\n }\n if dead {\n println!(\"No\")\n } else {\n println!(\"Yes\")\n }\n }\n Ok(())\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "greedy", "dp"], "code_uid": "5fd0c75de5c827a32500a779d7792110", "src_uid": "4941b0a365f86b2e2cf686cdf5d532f8", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn is_palindrome(x: &str) -> bool {\n if x.len() <= 1 {\n return true;\n }\n let b = x.as_bytes();\n let mut index = 0;\n while index < (x.len() / 2) {\n if b[index] != b[x.len() - index - 1] {\n return false;\n }\n index = index + 1;\n }\n true\n}\n\nfn is_quasi_palindrome(x: &str) -> bool {\n let mut k = String::from(x);\n let mut count = 0;\n while count < 10 {\n if is_palindrome(k.as_str()) {\n return true;\n }\n k = String::from(\"0\") + &k;\n count = count + 1;\n }\n false\n}\n\nfn main() {\n let mut input = String::new();\n io::stdin().read_line(&mut input).expect(\"io error\");\n\n match is_quasi_palindrome(input.trim_right()) {\n true => println!(\"YES\"),\n false => println!(\"NO\"),\n }\n\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "1f4e6b2827243c2305f9d579398ab50c", "src_uid": "d82278932881e3aa997086c909f29051", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\nuse std::io::*;\nuse std::str::*;\nuse std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::*;\n#[allow(unused_imports)] use std::collections::*;\n\n#[allow(unused_macros)]\nmacro_rules! a {\n ($c: tt, $x: expr, $y: expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a>, }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).ok();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn u(&mut self) -> usize { self.p() }\n fn vi(&mut self, n: usize) -> Vec {\n self.vp::(n)\n }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n\n#[allow(dead_code)]\nfn build_counting_hashmap(i: T) -> HashMap\n where T: Iterator {\n let mut m = HashMap::new();\n for k in i {\n let n = 1 + if let Some(&n) = m.get(&k) { n } else { 0 };\n m.insert(k, n);\n }\n m\n}\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n let n = input.i();\n let a = input.i();\n let b = input.i();\n println!(\"{}\", ((a - 1 + b) % n + n) % n + 1);\n}\n\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "d1614154a77e75644cb61d1b114ea95c", "src_uid": "cd0e90042a6aca647465f1d51e6dffc4", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "const MOD: i64 = 998244353;\r\n\r\nfn main() {\r\n input! {\r\n n: usize,\r\n m: i64,\r\n }\r\n let mut ans = 0;\r\n for i in 1..=n {\r\n ans += modpow(m, i as i64);\r\n ans %= MOD;\r\n }\r\n let mut p = vec![true; n + 1];\r\n p[0] = false;\r\n p[1] = false;\r\n for i in 2..=n {\r\n if p[i] && i * i <= n {\r\n for j in (i * i..=n).step_by(i) {\r\n p[j] = false;\r\n }\r\n }\r\n }\r\n let mut dp = vec![0; n];\r\n let mut f = 1;\r\n for i in 0..n {\r\n if p[i + 1] {\r\n f *= (i + 1) as i64;\r\n f = f.min(m + 1);\r\n }\r\n dp[i] = m / f % MOD;\r\n if i > 0 {\r\n dp[i] *= dp[i - 1];\r\n dp[i] %= MOD;\r\n }\r\n ans += MOD - dp[i];\r\n ans %= MOD;\r\n }\r\n println!(\"{}\", ans);\r\n}\r\n\r\npub fn modpow(mut base: i64, mut exp: i64) -> i64 {\r\n let mut ans = 1;\r\n base %= MOD;\r\n while exp > 0 {\r\n if exp % 2 == 1 {\r\n ans = ans * base % MOD;\r\n }\r\n base = base * base % MOD;\r\n exp >>= 1;\r\n }\r\n ans\r\n}\r\n\r\nmod io {\r\n use std::cell::RefCell;\r\n use std::io::*;\r\n\r\n std::thread_local! {\r\n pub static STDIN: RefCell = RefCell::new(stdin());\r\n pub static STDOUT: RefCell> = RefCell::new(BufWriter::new(stdout()));\r\n }\r\n\r\n #[macro_export]\r\n macro_rules! input {\r\n () => {};\r\n (mut $var:ident: $t:tt, $($rest:tt)*) => {\r\n let mut $var = __input_inner!($t);\r\n input!($($rest)*)\r\n };\r\n ($var:ident: $t:tt, $($rest:tt)*) => {\r\n let $var = __input_inner!($t);\r\n input!($($rest)*)\r\n };\r\n (mut $var:ident: $t:tt) => {\r\n let mut $var = __input_inner!($t);\r\n };\r\n ($var:ident: $t:tt) => {\r\n let $var = __input_inner!($t);\r\n };\r\n }\r\n\r\n #[macro_export]\r\n macro_rules! __input_inner {\r\n (($($t:tt),*)) => {\r\n ($(__input_inner!($t)),*)\r\n };\r\n ([$t:tt; $n:expr]) => {\r\n (0..$n).map(|_| __input_inner!($t)).collect::>()\r\n };\r\n ([$t:tt]) => {{\r\n let n = __input_inner!(usize);\r\n (0..n).map(|_| __input_inner!($t)).collect::>()\r\n }};\r\n (chars) => {\r\n __input_inner!(String).chars().collect::>()\r\n };\r\n (bytes) => {\r\n __input_inner!(String).into_bytes()\r\n };\r\n (usize1) => {\r\n __input_inner!(usize) - 1\r\n };\r\n ($t:ty) => {\r\n $crate::io::STDIN.with(|r| {\r\n use std::io::BufRead;\r\n let r = r.borrow_mut();\r\n let mut r = r.lock();\r\n let mut s = vec![];\r\n loop {\r\n let buf = r.fill_buf().unwrap();\r\n if buf.is_empty() {\r\n break;\r\n }\r\n if let Some(i) = buf.iter().position(u8::is_ascii_whitespace) {\r\n s.extend_from_slice(&buf[..i]);\r\n r.consume(i + 1);\r\n if !s.is_empty() {\r\n break;\r\n }\r\n } else {\r\n s.extend_from_slice(buf);\r\n let n = buf.len();\r\n r.consume(n);\r\n }\r\n }\r\n std::str::from_utf8(&s).unwrap().parse::<$t>().unwrap()\r\n })\r\n };\r\n }\r\n\r\n #[macro_export]\r\n macro_rules! println {\r\n () => {\r\n $crate::io::STDOUT.with(|w| {\r\n use std::io::Write;\r\n std::writeln!(w.borrow_mut()).unwrap()\r\n })\r\n };\r\n ($($arg:tt)*) => {\r\n $crate::io::STDOUT.with(|w| {\r\n use std::io::Write;\r\n std::writeln!(w.borrow_mut(), $($arg)*).unwrap()\r\n })\r\n };\r\n }\r\n\r\n #[macro_export]\r\n macro_rules! print {\r\n ($($arg:tt)*) => {\r\n $crate::io::STDOUT.with(|w| {\r\n use std::io::Write;\r\n std::write!(w.borrow_mut(), $($arg)*).unwrap()\r\n })\r\n };\r\n }\r\n\r\n #[macro_export]\r\n macro_rules! flush {\r\n () => {\r\n $crate::io::STDOUT.with(|w| {\r\n use std::io::Write;\r\n w.borrow_mut().flush().unwrap()\r\n })\r\n };\r\n }\r\n}\r\n", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics", "number theory"], "code_uid": "18e4c658dd7ba0d730b0eb7dc3602be3", "src_uid": "0fdd91ed33431848614075ebe9d2ee68", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "use std::collections::VecDeque;\nuse std::fmt::{Display, Formatter};\nuse std::io::{Read, stdin};\nuse std::marker::PhantomData;\nuse std::ops::{Add, Mul, Range, RangeBounds, Sub};\n\nfn main() {\n let mut scan = Scanner::default();\n\n let n = scan.next_usize();\n let m = scan.next_usize();\n\n let mut sum = M::<998244353>(0);\n let mut prod = M::<998244353>(1);\n\n let mut pos_factor = 1;\n for i in 1..=n {\n if is_prime(i) {\n pos_factor *= i;\n }\n let pos_count = m / pos_factor;\n if pos_count == 0 { break; }\n prod = prod * M(pos_count);\n sum = sum + prod;\n }\n\n let mut total = M(0);\n for i in 1..=n {\n total = total + M(m).pow(M(i));\n }\n let amb = total - sum;\n\n println!(\"{}\", amb);\n}\n\n\nstruct PrimeIterator {\n primes: Vec\n}\n\nfn primes() -> PrimeIterator {\n PrimeIterator{ primes: Vec::new() }\n}\n\nimpl Iterator for PrimeIterator {\n type Item = usize;\n\n fn next(&mut self) -> Option {\n for i in self.primes.last().map(|x| *x + 1).unwrap_or(2).. {\n if self.primes.iter().all(|prime| i % prime != 0) {\n self.primes.push(i);\n return Some(i)\n }\n }\n unreachable!()\n }\n}\n\nfn firstfac(x: usize) -> usize {\n if x % 2 == 0 {\n return 2;\n };\n for n in (1..).map(|m| 2 * m + 1).take_while(|m| m * m <= x) {\n if x % n == 0 {\n return n;\n };\n }\n x\n}\n\npub fn is_prime(n: usize) -> bool {\n if n <= 1 { return false }\n firstfac(n) == n\n}\n\n#[derive(Clone, Copy)]\nstruct M(usize);\n\nimpl Add for M

{\n type Output = M

;\n\n #[inline(always)]\n fn add(self, rhs: Self) -> Self::Output {\n let mut v = self.0 + rhs.0;\n if v >= P {\n v -= P\n }\n M(v)\n }\n}\n\nimpl Sub for M

{\n type Output = M

;\n\n #[inline(always)]\n fn sub(self, rhs: Self) -> Self::Output {\n let mut v = self.0.wrapping_sub(rhs.0);\n if v >= P {\n v = v.wrapping_add(P)\n }\n M(v)\n }\n}\n\nimpl Mul for M

{\n type Output = M

;\n\n #[inline(always)]\n fn mul(self, rhs: Self) -> Self::Output {\n M(((self.0 as u128 * rhs.0 as u128) % P as u128) as usize)\n }\n}\n\n\nimpl Display for M

{\n #[inline(always)]\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n Display::fmt(&self.0, f)\n }\n}\n\nimpl M

{\n #[inline(always)]\n pub fn pow(mut self, n: Self) -> Self {\n let mut n = n.0;\n let mut res: Self = Self(1);\n while n > 0 {\n if n % 2 == 1 { res = res * self }\n self = self * self;\n n /= 2;\n }\n\n res\n }\n\n #[inline(always)]\n pub fn inv(self) -> Self {\n self.pow(M(P - 2))\n }\n}\n\n\n#[derive(Default)]\nstruct Scanner {\n buffer: Vec,\n}\nimpl Scanner {\n fn next_usize(&mut self) -> usize {\n self.next()\n }\n\n fn next_string(&mut self) -> String {\n self.next()\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n stdin().read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n\n fn iter(&mut self) -> ScannerIter {\n ScannerIter {\n phantom: Default::default(),\n scanner: self,\n }\n }\n}\n\nstruct ScannerIter<'a, T: std::str::FromStr> {\n phantom: PhantomData,\n scanner: &'a mut Scanner,\n}\n\nimpl<'a, T: std::str::FromStr> Iterator for ScannerIter<'a, T> {\n type Item = T;\n\n fn next(&mut self) -> Option {\n Some(self.scanner.next())\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics", "number theory"], "code_uid": "45adbc9855c8281164b2926ba5b331ea", "src_uid": "0fdd91ed33431848614075ebe9d2ee68", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n// \u3053\u3053\u307e\u3067\n\nfn run() {\n input! {\n n: u64,\n }\n if n <= 2 {\n println!(\"1\");\n return;\n }\n let mut m = 4;\n let mut d = 1;\n while m + 1 < n {\n m = 2 * (m + 1) - d;\n d ^= 1;\n }\n if m == n || m + 1 == n {\n println!(\"1\");\n } else {\n println!(\"0\");\n }\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp"], "code_uid": "2f78d2683d5f4267ff4a020fca1ace44", "src_uid": "821409c1b9bdcd18c4dcf35dc5116501", "difficulty": 2400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::str::FromStr;\n\nfn read_str() -> String {\n let mut buffer: String = String::new();\n std::io::stdin().read_line(&mut buffer).expect(\"Error\");\n buffer.trim().to_string()\n}\n\nfn read_int() -> T{\n read_str().parse::().ok().expect(\"Error\")\n}\n\nfn main() {\n let n: u16 = read_int();\n for &divisor in &[4, 7, 47, 74, 444, 447, 474, 477, 744, 747, 777] {\n if divisor > n { break; }\n if n % divisor == 0 {\n println!(\"YES\");\n std::process::exit(0);\n }\n }\n println!(\"NO\");\n}", "lang_cluster": "Rust", "tags": ["brute force", "number theory"], "code_uid": "5197229abc41c5c017ea8476ec7b1232", "src_uid": "78cf8bc7660dbd0602bf6e499bc6bb0d", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut s = String::new();\n io::stdin().read_line(&mut s).unwrap();\n\n if permute()\n .into_iter()\n .any(|n| s.trim().parse::().unwrap() % n == 0)\n {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n\nfn permute() -> Vec {\n let arr: [usize; 2] = [4, 7];\n let mut vec = vec![4, 7];\n\n let mut from = 0;\n let mut to = vec.len();\n 'outer: loop {\n for n in arr.iter() {\n for i in from..to {\n let cur = cat(*n, vec[i]);\n if cur < 1000 {\n vec.push(cat(*n, vec[i]));\n } else {\n break 'outer;\n }\n }\n }\n from = to;\n to = vec.len();\n }\n vec\n}\n\nfn cat(left: usize, right: usize) -> usize {\n let right_f = right as f64;\n let mult_left_by: usize = 10_usize.pow(right_f.log10() as u32 + 1_u32);\n (left * mult_left_by) + right\n}", "lang_cluster": "Rust", "tags": ["brute force", "number theory"], "code_uid": "2e9b38ef47b5d1164e5c1f0ff3eedf8b", "src_uid": "78cf8bc7660dbd0602bf6e499bc6bb0d", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\n\nfn main() {\n let mut arr: [i16; 101] = [0; 101];\n let mut inp = String::with_capacity(500);\n for _ in 1..3 {\n stdin().read_line(&mut inp).unwrap();\n }\n let mut inp = inp.split_whitespace();\n let _ = inp.next().unwrap();\n let mut i: usize;\n for num in inp {\n i = num.parse().unwrap();\n arr[i] += 1;\n }\n let mut max = arr[0];\n i = 1;\n while i < arr.len() {\n if arr[i] > max {\n max = arr[i];\n }\n i += 1;\n }\n println!(\"{}\",max);\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "7478f422ba96aba6add51e8f42461dbc", "src_uid": "f30329023e84b4c50b1b118dc98ae73c", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports, unused_macros, dead_code)]\n\nmacro_rules! min {\n (.. $x:expr) => {{\n let mut it = $x.iter();\n it.next().map(|z| it.fold(z, |x, y| min!(x, y)))\n }};\n ($x:expr) => ($x);\n ($x:expr, $($ys:expr),*) => {{\n let t = min!($($ys),*);\n if $x < t { $x } else { t }\n }}\n}\nmacro_rules! max {\n (.. $x:expr) => {{\n let mut it = $x.iter();\n it.next().map(|z| it.fold(z, |x, y| max!(x, y)))\n }};\n ($x:expr) => ($x);\n ($x:expr, $($ys:expr),*) => {{\n let t = max!($($ys),*);\n if $x > t { $x } else { t }\n }}\n}\n\n\nmacro_rules! ewriteln {\n ($($args:expr),*) => { let _ = writeln!(&mut std::io::stderr(), $($args),*); };\n}\nmacro_rules! trace {\n ($x:expr) => { ewriteln!(\">>> {} = {:?}\", stringify!($x), $x) };\n ($($xs:expr),*) => { trace!(($($xs),*)) }\n}\nmacro_rules! put {\n (.. $x:expr) => {{\n let mut it = $x.iter();\n if let Some(x) = it.next() { print!(\"{}\", x); }\n for x in it { print!(\" {}\", x); }\n println!(\"\");\n }};\n ($x:expr) => { println!(\"{}\", $x) };\n ($x:expr, $($xs:expr),*) => { print!(\"{} \", $x); put!($($xs),*) }\n}\n\nconst M: i64 = 1_000_000_007;\n\nfn primes(x: i64) -> Vec {\n let mut x = x;\n let mut ret = vec![];\n for p in 2..x+1 {\n if x % p == 0 {\n ret.push(p);\n while x % p == 0 { x /= p; }\n if x == 1 { break }\n }\n if p * p > x && x > 1 {\n ret.push(x);\n break;\n }\n }\n return ret;\n}\n\nfn pow(p: i64, count: i64) -> i64 {\n if count == 0 {\n 1\n } else {\n let a = pow((p * p) % M, count / 2) % M;\n if count % 2 == 0 {\n a\n } else {\n (a * p) % M\n }\n }\n}\n\nfn main() {\n let mut sc = Scanner::new();\n let x: i64 = sc.cin();\n let n: i64 = sc.cin();\n let ps = primes(x);\n let mut ans = 1;\n // trace!(&ps);\n for &p in ps.iter() {\n let mut count = 0;\n let mut z = n;\n while z >= p {\n count += z / p;\n z /= p;\n }\n // trace!(p, count, pow(p%M,count));\n ans *= pow(p % M, count);\n ans %= M;\n }\n put!(ans);\n}\n\nuse std::io::{self, Write};\nuse std::str::FromStr;\nuse std::collections::VecDeque;\n\nstruct Scanner { stdin: io::Stdin, buffer: VecDeque, }\nimpl Scanner {\n fn new() -> Self { Scanner { stdin: io::stdin(), buffer: VecDeque::new() } }\n fn cin(&mut self) -> T {\n while self.buffer.len() == 0 {\n let mut line = String::new();\n let _ = self.stdin.read_line(&mut line);\n for w in line.split_whitespace() {\n self.buffer.push_back(String::from(w));\n }\n }\n self.buffer.pop_front().unwrap().parse::().ok().unwrap()\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "f8c375b588503c59a872698f5b5fbfc0", "src_uid": "04610fbaa746c083dda30e21fa6e1a0c", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::BufRead;\n\nconst MODULO: u128 = 1000000007;\n\nfn delta_greater(a: usize, b: usize, c: usize) -> bool {\n if a > b {\n return (a - b) > c;\n } else {\n return (b - a) > c;\n }\n}\n\nfn sqrt_int(x: usize) -> usize {\n if x == 0 {\n return 0;\n }\n let mut value: usize = x + 2;\n let mut value1: usize = x;\n while delta_greater(value, value1, 1) {\n value = value1;\n value1 = (value + (x / value)) / 2;\n }\n value1 = (value1 + (x / value1)) / 2;\n return value1;\n}\n\nfn get_power_value(base: u128, power: u128) -> u128 {\n let mut value: u128 = 1;\n let mut z: u128 = base;\n let mut power_of_2: u128 = 1;\n let mut power_tmp: u128 = power;\n for _ in 0..127 {\n if (power_tmp & 1) != 0 {\n value *= z;\n value %= MODULO;\n }\n\n z *= z;\n z %= MODULO;\n\n power_of_2 <<= 1;\n power_tmp >>= 1;\n if power_of_2 > power {\n break;\n }\n }\n return value;\n}\n\nfn get_prime_divider_power(value: u128, divider: u128) -> u128 {\n let mut power: u128 = 0;\n let mut divider_tmp: u128 = divider;\n while divider_tmp <= value {\n power += value / divider_tmp;\n divider_tmp *= divider;\n }\n return power;\n}\n\nfn func_g1_mod(n: u128, p: u128) -> u128 {\n let power: u128 = get_prime_divider_power(n, p);\n return get_power_value(p, power);\n}\n\nfn func_f1_mod(x: usize, n: u128) -> u128 {\n let mut value: u128 = 1;\n\n let mut x_tmp: usize = x;\n for i in 2..(sqrt_int(x) + 1) {\n if (x_tmp % i) == 0 {\n value *= func_g1_mod(n, i as u128);\n value %= MODULO;\n }\n while (x_tmp % i) == 0 {\n x_tmp /= i;\n }\n }\n if x_tmp > 1 {\n value *= func_g1_mod(n, x_tmp as u128);\n value %= MODULO;\n }\n\n return value;\n}\n\n#[cfg(test)]\nmod tests {\n use super::{func_f1_mod, get_power_value, sqrt_int};\n\n #[test]\n fn test_a1() {\n assert_eq!(sqrt_int(0), 0);\n assert_eq!(sqrt_int(1), 1);\n assert_eq!(sqrt_int(2), 1);\n assert_eq!(sqrt_int(3), 1);\n assert_eq!(sqrt_int(4), 2);\n assert_eq!(sqrt_int(5), 2);\n assert_eq!(sqrt_int(6), 2);\n assert_eq!(sqrt_int(7), 2);\n assert_eq!(sqrt_int(8), 2);\n assert_eq!(sqrt_int(9), 3);\n assert_eq!(sqrt_int(10), 3);\n }\n\n #[test]\n fn test_b1() {\n assert_eq!(get_power_value(0, 1), 0);\n assert_eq!(get_power_value(0, 2), 0);\n assert_eq!(get_power_value(0, 3), 0);\n assert_eq!(get_power_value(1, 0), 1);\n assert_eq!(get_power_value(1, 1), 1);\n assert_eq!(get_power_value(1, 2), 1);\n assert_eq!(get_power_value(1, 3), 1);\n assert_eq!(get_power_value(2, 0), 1);\n assert_eq!(get_power_value(2, 1), 2);\n assert_eq!(get_power_value(2, 2), 4);\n assert_eq!(get_power_value(2, 3), 8);\n assert_eq!(get_power_value(3, 0), 1);\n assert_eq!(get_power_value(3, 1), 3);\n assert_eq!(get_power_value(3, 2), 9);\n assert_eq!(get_power_value(3, 3), 27);\n }\n\n #[test]\n fn test_c1() {\n assert_eq!(func_f1_mod(10, 2), 2);\n }\n #[test]\n fn test_c2() {\n assert_eq!(func_f1_mod(20190929, 1605), 363165664);\n }\n #[test]\n fn test_c3() {\n assert_eq!(func_f1_mod(947, 987654321987654321), 593574252);\n }\n}\n\nfn read_usize_u128_pair(stdin_lock: &mut std::io::StdinLock) -> (usize, u128) {\n let mut line1: String = String::new();\n stdin_lock.read_line(&mut line1).unwrap();\n let mut line1_values = line1.trim().split(\" \");\n let value1: usize = line1_values.next().unwrap().parse::().unwrap();\n let value2: u128 = line1_values.next().unwrap().parse::().unwrap();\n return (value1, value2);\n}\n\nfn main() {\n let stdin: std::io::Stdin = std::io::stdin();\n let mut stdin_lock: std::io::StdinLock = stdin.lock();\n\n let (x, n): (usize, u128) = read_usize_u128_pair(&mut stdin_lock);\n\n let func_value: u128 = func_f1_mod(x, n);\n\n println!(\"{}\", func_value);\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "b051c73d24fd25cd5a7c1bf51207abf1", "src_uid": "04610fbaa746c083dda30e21fa6e1a0c", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_variables)]\n#![allow(unused_must_use)]\n \nuse std::io::{self, prelude::*};\n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let mut input = Input::new(stdin.lock());\n let mut output = io::BufWriter::new(stdout.lock());\n macro_rules! puts {\n ($($format:tt)*) => (write!(output, $($format)*).unwrap());\n }\n \n let n: usize = input.next();\n let mut a: Vec = input.iter().take(n).collect();\n a.sort();\n let mut cur = Vec::new();\n let mut ans = 0usize;\n for x in a {\n if !cur.iter().any(|&y| x % y == 0) {\n cur.push(x);\n ans += 1;\n }\n }\n puts!(\"{}\\n\", ans);\n}\n \nstruct Input {\n lines: io::Lines,\n cur: String,\n split: std::str::SplitAsciiWhitespace<'static>, //'\n}\n \nimpl Input {\n fn new(reader: R) -> Input {\n use std::mem::transmute;\n \n let mut lines = reader.lines();\n let cur = lines.next().unwrap().unwrap();\n let split = unsafe { transmute(cur.split_ascii_whitespace()) };\n Input { lines, cur, split }\n }\n fn update(&mut self) {\n use std::mem::transmute;\n self.cur = self.lines.next().unwrap().unwrap();\n unsafe { self.split = transmute(self.cur.split_ascii_whitespace()) };\n }\n fn next(&mut self) -> F {\n loop {\n if let Some(thing) = self.split.next() {\n return thing.parse().ok().unwrap();\n }\n self.update();\n }\n }\n fn iter(&mut self) -> InputIter {\n InputIter {\n input: self,\n _phantom: std::marker::PhantomData,\n }\n }\n}\n \nstruct InputIter<'a, R, I> {\n input: &'a mut Input,\n _phantom: std::marker::PhantomData,\n}\n \nimpl<'a, R, I> Iterator for InputIter<'a, R, I>\nwhere\n R: BufRead,\n I: std::str::FromStr,\n{\n type Item = I;\n fn next(&mut self) -> Option {\n Some(self.input.next())\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "greedy", "implementation"], "code_uid": "77808bc050b5f32c8ca5e2a8d0e35781", "src_uid": "63d9b7416aa96129c57d20ec6145e0cd", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ____ _ _ _ _\n// | _ \\ _ _ ___| |_ ___ _ __ | |_ ___ _ __ ___ _ __ | | __ _| |_ ___\n// | |_) | | | / __| __| / __| '_ \\ | __/ _ \\ '_ ` _ \\| '_ \\| |/ _` | __/ _ \\\n// | _ <| |_| \\__ \\ |_ | (__| |_) | | || __/ | | | | | |_) | | (_| | || __/\n// |_| \\_\\\\__,_|___/\\__| \\___| .__/___\\__\\___|_| |_| |_| .__/|_|\\__,_|\\__\\___|\n// |_| |_____| |_|\n\n// _ _ _ _____ ___\n// _ __ ___ __ _ _ __ | |_ __ _/ / |___ / / _ \\\n// | '_ ` _ \\ / _` | '_ \\| __/ _` | | | |_ \\| | | |\n// | | | | | | (_| | | | | || (_| | | |___) | |_| |\n// |_| |_| |_|\\__,_|_| |_|\\__\\__,_|_|_|____/ \\___/\n\n//https://github.com/manta1130/Competitive_Programming_Template_Rust\n\n#[macro_use]\nmod input {\n\n use std;\n use std::io;\n\n const SPLIT_DELIMITER: char = ' ';\n\n #[macro_export]\n #[allow(unused_macros)]\n macro_rules! input {\n ( $($x:expr ),*) => {\n {\n let temp_str = input_line_str();\n let mut split_result_iter = temp_str.split_whitespace();\n $(\n let buf_split_result = split_result_iter.next();\n let buf_split_result = buf_split_result.unwrap();\n ($x) = buf_split_result.parse().unwrap();\n )*\n }\n };\n}\n\n #[allow(dead_code)]\n pub fn input_line_str() -> String {\n let mut s = String::new();\n io::stdin().read_line(&mut s).unwrap();\n s.trim().to_string()\n }\n\n #[allow(dead_code)]\n pub fn p(t: T)\n where\n T: std::fmt::Display,\n {\n println!(\"{}\", t);\n }\n\n #[allow(dead_code)]\n pub fn input_vector2d(line: usize) -> Vec>\n where\n T: std::str::FromStr,\n {\n let mut v: Vec> = Vec::new();\n\n for _ in 0..line {\n let vec_line = input_vector();\n v.push(vec_line);\n }\n v\n }\n\n #[allow(dead_code)]\n pub fn input_vector() -> Vec\n where\n T: std::str::FromStr,\n {\n let mut v: Vec = Vec::new();\n\n let s = input_line_str();\n let split_result = s.split(SPLIT_DELIMITER);\n for z in split_result {\n let buf = match z.parse() {\n Ok(r) => r,\n Err(_) => panic!(\"Parse Error\"),\n };\n v.push(buf);\n }\n v\n }\n\n #[allow(dead_code)]\n pub fn input_vector_row(n: usize) -> Vec\n where\n T: std::str::FromStr,\n {\n let mut v = Vec::with_capacity(n);\n for _ in 0..n {\n let buf = match input_line_str().parse() {\n Ok(r) => r,\n Err(_) => panic!(\"Parse Error\"),\n };\n v.push(buf);\n }\n v\n }\n\n pub trait ToCharVec {\n fn to_charvec(&self) -> Vec;\n }\n\n impl ToCharVec for String {\n fn to_charvec(&self) -> Vec {\n self.to_string().chars().collect::>()\n }\n }\n}\n\nuse input::*;\n\nfn main() {\n let n: usize;\n input!(n);\n let mut v = input_vector::();\n v.sort();\n let mut flag = vec![false; n];\n let mut ans = 0;\n for i in 0..n {\n if flag[i] {\n continue;\n }\n ans += 1;\n flag[i] = true;\n for j in i + 1..n {\n if v[j] % v[i] == 0 {\n flag[j] = true;\n }\n }\n }\n p(ans);\n}\n", "lang_cluster": "Rust", "tags": ["math", "greedy", "implementation"], "code_uid": "be856c3e92989a787b85d0e0dc45b34b", "src_uid": "63d9b7416aa96129c57d20ec6145e0cd", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(non_snake_case)]\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io::Write;\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($e:expr),*) => {\n #[cfg(debug_assertions)]\n $({\n let (e, mut err) = (stringify!($e), std::io::stderr());\n writeln!(err, \"{} = {:?}\", e, $e).unwrap()\n })*\n };\n}\n\nfn main() {\n let t = read::();\n for _ in 0..t {\n let v = read_vec::();\n let a = read_vec::()\n .iter()\n .map(|&x| x - 1)\n .collect::>();\n let (n, k, d) = (v[0], v[1], v[2]);\n let mut count = vec![0; k];\n let mut current_using = HashSet::new();\n for i in 0..d {\n count[a[i]] += 1;\n current_using.insert(a[i]);\n }\n let mut ans = current_using.len();\n\n for i in d..n {\n count[a[i - d]] -= 1;\n if count[a[i - d]] == 0 {\n current_using.remove(&a[i - d]);\n }\n count[a[i]] += 1;\n current_using.insert(a[i]);\n ans = min(ans, current_using.len());\n }\n println!(\"{}\", ans);\n }\n}\n\nfn read() -> T {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).ok();\n s.trim().parse().ok().unwrap()\n}\n\nfn read_vec() -> Vec {\n read::()\n .split_whitespace()\n .map(|e| e.parse().ok().unwrap())\n .collect()\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "2bab2d7122ac88bac045b06a87761f36", "src_uid": "56da4ec7cd849c4330d188d8c9bd6094", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::cmp::Ordering;\nuse std::collections::*;\nuse std::io::prelude::*;\nfn main() {\n let mut buf = String::new();\n let stdin = std::io::stdin();\n let mut handle = stdin.lock();\n handle.read_to_string(&mut buf).unwrap();\n let mut entries = buf.split_whitespace();\n let num_cases: usize = entries.next().unwrap().parse().unwrap();\n for _ in 0..num_cases {\n let n: usize = entries.next().unwrap().parse().unwrap();\n let k: usize = entries.next().unwrap().parse().unwrap();\n\n let d: usize = entries.next().unwrap().parse().unwrap();\n let mut a = Vec::with_capacity(n);\n for _ in 0..n {\n let ai: usize = entries.next().unwrap().parse().unwrap();\n a.push(ai);\n }\n let res = solve(&mut a, d, k);\n println!(\"{}\", res);\n }\n}\n\nfn solve(a: &mut [usize], d: usize, k: usize) -> usize {\n let k = k + 1;\n let mut cache = vec![0; k];\n for i in 0..d {\n cache[a[i]] += 1;\n }\n let mut res = find_min(a, &mut cache, d);\n for i in d..a.len() {\n cache[a[i]] += 1;\n cache[a[i - d]] -= 1;\n let new_res = find_min(a, &mut cache, d);\n if new_res < res {\n res = new_res\n }\n }\n res\n // for i in d..a.len() {\n // let a_to_inc = a[i];\n // let a_to_inc_in_index = indexes.binary_search(a_to_inc).unwrap();\n // if (a_to_inc_in_index > 0) {\n // let mut next_entry = a_to_inc_in_index - 1;\n // while (cache[next_entry] == cache[a_to_inc_in_index]) && (next_entry > 0) {\n // next_entry -= 1;\n // }\n // cache[a_to_inc_in_index] += 1;\n // indexes.swap(a_to_inc_in_index, next_entry);\n // }\n\n // let a_to_dec = a[i - d];\n // let a_to_dec_in_index = indexes.binary_search(a_to_dec).unwrap();\n // if (a_to_dec_in_index < a.len() - 1) {\n // let mut next_entry = a_to_dec_in_index + 1;\n // while (cache[next_entry] == cache[a_to_dec_in_index]) && (next_entry < a.len() - 1) {\n // next_entry += 1;\n // }\n // cache[a_to_dec_in_index] += 1;\n // indexes.swap(a_to_dec_in_index, next_entry);\n // }\n // }\n}\n\nfn find_min(a: &mut [usize], cache: &mut [usize], d: usize) -> usize {\n let mut indexes: Vec = (0..cache.len()).into_iter().collect();\n indexes.sort_by(|i, j| match cache[*i] as isize - cache[*j] as isize {\n x if x < 0 => Ordering::Greater,\n x if x == 0 => Ordering::Equal,\n _ => Ordering::Less,\n });\n let mut score = 0;\n let mut i = 0;\n while score < d {\n score += cache[indexes[i]];\n i += 1;\n }\n i\n}\n\n#[cfg(test)]\nmod tests {\n use super::*;\n // #[test]\n // fn test1() {\n // assert_eq!(solve(&mut [1, 2, 1, 2, 1], 2, 2), 2);\n // }\n\n #[test]\n fn test2() {\n assert_eq!(solve(&mut [10, 8, 6, 4], 4, 10), 4);\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "1314952f1f83216805ad76cc16369751", "src_uid": "56da4ec7cd849c4330d188d8c9bd6094", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nfn main() {\n let mut buf = String::new();\n // pass nubmer of chars\n io::stdin().read_line(&mut buf).unwrap();\n io::stdin().read_line(&mut buf).unwrap();\n let v: u32 = buf.split_whitespace()\n .map(|word| {\n word.chars()\n .map(|c| if c.is_uppercase() {1} else {0})\n .sum()\n })\n .max().unwrap();\n println!(\"{}\", v);\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "8d6f8717fdd8b5e1dc06f3acc272d644", "src_uid": "d3929a9acf1633475ab16f5dfbead13c", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut x = String::new();\n std::io::stdin().read_line(&mut x).unwrap();\n let x: u8 = x.trim().parse().unwrap();\n\n let (a, category) = match x % 4 {\n 0 => (1, 'A'),\n 1 => (0, 'A'),\n 2 => (1, 'B'),\n 3 => (2, 'A'),\n _ => unreachable!()\n };\n\n println!(\"{} {}\", a, category);\n}", "lang_cluster": "Rust", "tags": ["brute force"], "code_uid": "80cf32d4a16382c317be6cec9dd57946", "src_uid": "488e809bd0c55531b0b47f577996627e", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rusT\nuse std::io::*;\nuse std::str::{self,*};\nuse std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::{self,*};\n#[allow(unused_imports)] use std::ops::{self,*};\n#[allow(unused_imports)] use std::iter::{self,*};\n#[allow(unused_imports)] use std::collections::*;\n#[allow(unused_macros)]\nmacro_rules! m {\n ($c:tt, $x:expr, $y:expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\n#[allow(unused_macros)]\nmacro_rules! l {\n ($($v:ident),* = $i:ident.$f:ident $a:tt) => {\n $( let $v = $i.$f$a; )*\n };\n ($($v:ident),*:$t:ty = $i:ident.$f:ident $a:tt) => {\n $( let $v:$t = $i.$f$a; )*\n };\n}\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a> }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).ok();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn f(&mut self) -> f64 { self.p() }\n fn u(&mut self) -> usize { self.p() }\n fn sk(&mut self, n: usize) { self.it.nth(n - 1); }\n fn ii(&mut self, n: usize) -> impl Iterator {\n self.ip(n).into_iter()\n }\n fn vi(&mut self, n: usize) -> Vec {\n self.vp::(n)\n }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn ip(&mut self, n: usize) -> impl Iterator where T::Err: Debug {\n self.vp(n).into_iter()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n//------------------- End rusT\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n let x = input.u();\n let a = [3,0,2,1];\n let mut soli = 0;\n let mut sola = a[x % 4];\n for i in 1..=2 {\n let x = x + i;\n if m!(<,sola,a[x % 4]) {\n soli = i;\n }\n }\n println!(\"{} {}\", soli, (sola + b'A') as char);\n}\n\n", "lang_cluster": "Rust", "tags": ["brute force"], "code_uid": "4c733d9fab1b2d99682f9f51d2603ac7", "src_uid": "488e809bd0c55531b0b47f577996627e", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max, min, Ordering};\n#[allow(unused_imports)]\nuse std::collections::{HashMap, HashSet, BinaryHeap, VecDeque, BTreeSet, BTreeMap};\n#[allow(unused_imports)]\nuse std::iter::FromIterator;\n#[allow(unused_imports)]\nuse std::io::stdin;\n\nmod util {\n use std::io::stdin;\n use std::str::FromStr;\n use std::fmt::Debug;\n\n #[allow(dead_code)]\n pub fn line() -> String {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n line.trim().to_string()\n }\n\n #[allow(dead_code)]\n pub fn gets() -> Vec\n where\n ::Err: Debug,\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n line.split_whitespace()\n .map(|t| t.parse().unwrap())\n .collect()\n }\n}\n\n#[allow(unused_macros)]\nmacro_rules! get {\n ($t:ty) => {\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n line.trim().parse::<$t>().unwrap()\n }\n };\n ($($t:ty),*) => {\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n $(iter.next().unwrap().parse::<$t>().unwrap(),)*\n )\n }\n };\n ($t:ty; $n:expr) => {\n (0..$n).map(|_|\n get!($t)\n ).collect::>()\n };\n ($($t:ty),*; $n:expr) => {\n (0..$n).map(|_|\n get!($($t),*)\n ).collect::>()\n };\n ($t:ty ;;) => {\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n line.split_whitespace()\n .map(|t| t.parse::<$t>().unwrap())\n .collect::>()\n }\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($a:expr),*) => {\n println!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);\n }\n}\n\nfn f(i: usize, k: u64, ll: &Vec) -> char {\n let mut i = i;\n let mut k = k;\n\n loop {\n if i == 0 {\n let f0 = \"What are you doing at the end of the world? Are you busy? Will you save us?\";\n return if f0.len() as u64 > k {\n f0.chars().nth(k as usize).unwrap()\n } else {\n '.'\n };\n } else {\n if k < 34 {\n let s1 = \"What are you doing while sending \\\"\";\n return s1.chars().nth(k as usize).unwrap();\n } else if k < 34 + ll[i - 1] {\n // f(i - 1, k - 34, ll)\n i -= 1;\n k -= 34;\n } else if k < 34 + ll[i - 1] + 32 {\n let s2 = \"\\\"? Are you busy? Will you send \\\"\";\n return s2.chars().nth((k - 34 - ll[i - 1]) as usize).unwrap();\n } else if k < 34 + ll[i - 1] + 32 + ll[i - 1] {\n // f(i - 1, k - 34 - ll[i - 1] - 32, ll)\n k -= 34 + ll[i - 1] + 32;\n i -= 1;\n } else if k < 34 + ll[i - 1] + 32 + ll[i - 1] + 2 {\n let s3 = \"\\\"?\";\n return s3.chars()\n .nth((k - 34 - ll[i - 1] - 32 - ll[i - 1]) as usize)\n .unwrap();\n } else {\n return '.';\n }\n }\n }\n\n}\n\nfn main() {\n let k_max: u64 = 1000000000000000000;\n\n let mut ll = Vec::new();\n ll.push(75u64);\n let mut n = 0;\n for i in 1..100001 {\n n = ll[i - 1] * 2 + 68;\n ll.push(n);\n if n > k_max {\n break;\n }\n }\n while ll.len() < 100001 {\n ll.push(n);\n }\n\n let mut ans = Vec::new();\n\n let n = get!(usize);\n\n for _ in 0..n {\n let (n, k) = get!(usize, u64);\n ans.push(f(n, k - 1, &ll));\n }\n\n println!(\"{}\", ans.into_iter().collect::());\n}\n", "lang_cluster": "Rust", "tags": ["math", "binary search", "combinatorics"], "code_uid": "dff3fa5898eb614f14e6a654c7bf5acc", "src_uid": "da09a893a33f2bf8fd00e321e16ab149", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let n:i64 = {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line);\n line.trim().parse().unwrap()\n };\n\n if n % 2 == 0 {\n println!(\"{:?}\", n / 2);\n } else {\n println!(\"{:?}\", n / 2 - n); \n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "ca8c43deeb9dd5f64d2bd54860ff02e1", "src_uid": "689e7876048ee4eb7479e838c981f068", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::mem;\nuse std::io;\nuse std::string;\nuse std::cmp::*;\nuse std::collections::*;\n\nfn load() -> Vec {\n let mut line = String::new();\n io::stdin().read_line(&mut line).expect(\"Failed to read line\");\n let vec: Vec<&str> = line.split(\" \").collect();\n let mut data : Vec = Vec::new();\n for i in vec {\n let el : i64 = i.trim().parse().unwrap();\n data.push(el);\n }\n data\n}\n\nfn main() {\n let s = load()[0];\n println!(\"{}\", ((s+1)/2)*(1-2*(s%2)));\n}\n// min, max\n// HashSet, insert, contains\n// Vec, len, sort\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "9eaf3d4ea64372440ad30946eb1c77c3", "src_uid": "689e7876048ee4eb7479e838c981f068", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::*;\n#[allow(unused_imports)]\nuse std::collections::*;\nuse std::io::*;\n#[allow(dead_code)]\nfn getline() -> String {\n let mut ret = String::new();\n std::io::stdin().read_line(&mut ret).ok();\n return ret;\n}\nfn get_word() -> String {\n let mut stdin = std::io::stdin();\n let mut u8b: [u8; 1] = [0];\n loop {\n let mut buf: Vec = Vec::with_capacity(16);\n loop {\n let res = stdin.read(&mut u8b);\n if res.is_err() || res.ok().unwrap() == 0 || u8b[0] <= ' ' as u8 {\n break;\n } else {\n buf.push(u8b[0]);\n }\n }\n if buf.len() >= 1 {\n let ret = std::string::String::from_utf8(buf).unwrap();\n return ret;\n }\n }\n}\nfn parse(s: &str) -> T { s.parse::().ok().unwrap() }\n\n#[allow(dead_code)]\nfn get() -> T { parse(&get_word()) }\n\nfn main() {\n let n: usize = get();\n let m: usize = get();\n let k: usize = get();\n println!(\"{} {} {}\",\n (k - 1) / (2 * m) + 1,\n ((k - 1) % (2 * m)) / 2 + 1,\n if k % 2 == 1 { \"L\" } else { \"R\" });\n}\n", "lang_cluster": "Rust", "tags": ["math", "constructive algorithms"], "code_uid": "21a1fb2af96249bb8f855a62bb42d1a7", "src_uid": "d6929926b44c2d5b1a8e6b7f965ca1bb", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nmacro_rules! except {\n ($result: expr) => {\n match $result {\n Err(e) => panic!(\"{}\", e),\n Ok(m) => m,\n }\n };\n ($result: expr, $msg: expr) => {\n match $result {\n Err(e) => panic!(\"{}: {}\", $msg, e),\n Ok(m) => m,\n }\n };\n}\n\nfn parse_line() -> Vec {\n let mut input = String::new();\n except!(io::stdin().read_line(&mut input));\n input.trim().split_whitespace()\n .map(|x| except!(x.parse::()))\n .collect()\n}\n\n\nfn main() {\n let nm = parse_line();\n let (n, m) = (nm[0], nm[1]);\n if n > m {\n println!(\"0\");\n return\n }\n let a = parse_line();\n let mut counts = a.iter().fold(vec![0u8; 101], |mut v, &x| {v[x as usize] += 1; v});\n counts.sort_unstable_by(|x, y| y.cmp(x));\n let mut nums = vec![0u8; n as usize];\n for _ in 0..n {\n let (index, _) = nums.iter().enumerate()\n .max_by_key(|&(i, v)| counts[i] / (v + 1)).unwrap();\n nums[index] += 1;\n }\n let (index, _) = nums.iter().enumerate().filter(|&(_, v)| *v != 0)\n .min_by_key(|&(i, v)| counts[i] / v).unwrap();\n //println!(\"{:?}\", counts);\n //println!(\"{:?}\", nums);\n //println!(\"{}\", index); \n println!(\"{}\", counts[index] / nums[index]);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation", "binary search"], "code_uid": "9dcbc16f1492b82ca4c5813b51909057", "src_uid": "b7ef696a11ff96f2e9c31becc2ff50fe", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nmacro_rules! except {\n ($result: expr) => {\n match $result {\n Err(e) => panic!(\"{}\", e),\n Ok(m) => m,\n }\n };\n ($result: expr, $msg: expr) => {\n match $result {\n Err(e) => panic!(\"{}: {}\", $msg, e),\n Ok(m) => m,\n }\n };\n}\n\nfn parse_line() -> Vec {\n let mut input = String::new();\n except!(io::stdin().read_line(&mut input));\n input.trim().split_whitespace()\n .map(|x| except!(x.parse::()))\n .collect()\n}\n\n\nfn main() {\n let nm = parse_line();\n let (n, m) = (nm[0], nm[1]);\n if n > m {\n println!(\"0\");\n return\n }\n let a = parse_line();\n let mut counts = a.iter().fold([0u8; 101], |mut v, &x| {v[x as usize] += 1; v});\n counts.sort_unstable_by(|x, y| y.cmp(x));\n let mut nums = vec![0u8; n as usize];\n for _ in 0..n {\n let (index, _) = nums.iter().enumerate()\n .max_by_key(|&(i, v)| counts[i] / (v + 1)).unwrap();\n nums[index] += 1;\n }\n let (index, _) = nums.iter().enumerate().filter(|&(_, v)| *v != 0)\n .min_by_key(|&(i, v)| counts[i] / v).unwrap();\n println!(\"{}\", counts[index] / nums[index]);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation", "binary search"], "code_uid": "c3a10604c7d644fb0d9746c35c4ffceb", "src_uid": "b7ef696a11ff96f2e9c31becc2ff50fe", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// https://codeforces.com/problemset/problem/520/B\nuse std::io;\nuse std::collections::VecDeque;\n\nfn main() {\n let mut line = String::new();\n\n io::stdin()\n .read_line(&mut line)\n .unwrap();\n\n let words: Vec =\n line\n .split_whitespace()\n .map(|x| x.parse().unwrap())\n .collect();\n\n let n = words[0];\n let m = words[1];\n\n let mut distance = [1<<30;1000005];\n distance[n as usize] = 0;\n\n let mut q = VecDeque::::new();\n q.push_back(n);\n\n while !q.is_empty() {\n let u = q.pop_front().unwrap();\n let v = (2*u) as usize;\n let x = (u-1) as usize;\n\n\n if distance[v] == 1<<30 && (v as i64) < 2*m {\n distance[v] = distance[u as usize] + 1;\n q.push_back(v as i64);\n }\n\n if distance[x] == 1<<30 && x > 0 {\n distance[x] = distance[u as usize] + 1;\n q.push_back(u-1);\n }\n }\n println!(\"{}\", distance[m as usize]);\n}\n\n", "lang_cluster": "Rust", "tags": ["dfs and similar", "shortest paths", "math", "graphs", "greedy", "implementation"], "code_uid": "88a1d3d58c2c91226f27fb0f5775cba1", "src_uid": "861f8edd2813d6d3a5ff7193a804486f", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\n#[allow(unused_macros)]\nmacro_rules! a {\n ($c: tt, $x: expr, $y: expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\nuse std::str::*;\nuse std::fmt::Debug;\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a>, }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).unwrap();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, std::io::stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n\nfn main() {\n let mut buffer = String::new();\n let mut input = WordReader::from_stdin(&mut buffer);\n\n use std::collections::VecDeque;\n let a: usize = input.p();\n let b: usize = input.p();\n let mut dist = vec![-1; 20000];\n {\n let mut q = VecDeque::new();\n q.push_back(a as i32);\n dist[a] = 0;\n while let Some(p) = q.pop_front() {\n let d = dist[p as usize] + 1;\n let mut push = |q: &mut VecDeque<_>, p: i32, d: i32| {\n if let Some(x @ &mut -1) = dist.get_mut(p as usize) {\n *x = d;\n q.push_back(p);\n }\n };\n push(&mut q, 2 * p, d);\n push(&mut q, p - 1, d);\n }\n }\n println!(\"{}\", dist[b]);\n}\n\n", "lang_cluster": "Rust", "tags": ["dfs and similar", "shortest paths", "math", "graphs", "greedy", "implementation"], "code_uid": "6e7df2c4e0d78557868716d84cf2bc10", "src_uid": "861f8edd2813d6d3a5ff7193a804486f", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\nfn main() {\n let (mut h, m) = parse();\n let e = h;\n while reverse_number(h) > 59 || (reverse_number(h) <= m && h == e) {\n h += 1;\n }\n\n if h >= 24 {\n println!(\"00:00\")\n } else {\n print_it(h, reverse_number(h));\n }\n}\n\nfn parse() -> (usize, usize) {\n let mut entry = String::new();\n let mut hours = String::new();\n let mut minutes = String::new();\n let mut b = false;\n stdin().read_line(&mut entry).unwrap();\n\n for i in entry.trim().chars() {\n if i == ':' {\n b = true;\n } else if b {\n minutes.push(i);\n } else {\n hours.push(i);\n };\n }\n (hours.parse().unwrap(), minutes.parse().unwrap())\n}\n\nfn reverse_number(val: usize) -> usize {\n ((val % 10) * 10) + ((val - (val % 10)) / 10)\n}\n\nfn print_it(a: usize, b: usize) {\n let hours: String;\n let minutes: String;\n\n if a < 10 {\n hours = format!(\"0{}\", a);\n } else {\n hours = format!(\"{}\", a);\n };\n if b < 10 {\n minutes = format!(\"0{}\", b);\n } else {\n minutes = format!(\"{}\", b);\n };\n println!(\"{}:{}\", hours, minutes);\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "3064745a3b9c29661e97bae47d963c2b", "src_uid": "158eae916daa3e0162d4eac0426fa87f", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next_line(&self) -> String {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n line\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let line = self.next_line();\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let n: usize = scan.next();\n let mut m: usize = scan.next();\n let circle = n * (n + 1) / 2;\n m %= circle;\n for i in 1..n {\n if i <= m {\n m -= i;\n } else {\n break;\n }\n }\n println!(\"{}\", m);\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "3547c60e317bd7395e7e1fba1e3bd3d2", "src_uid": "5dd5ee90606d37cae5926eb8b8d250bb", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::cmp;\n\nfn readstring() -> String {\n read_string_from_buffer(&io::stdin())\n}\n\nfn readint() -> i32 {\n read_int_from_buffer(&io::stdin())\n}\n\nfn read_string_from_buffer(buf: &io::Stdin) -> String {\n let mut input_text = String::new();\n buf.read_line(&mut input_text)\n .expect(\"failed to read from stdin\");\n input_text.trim_right().to_string()\n}\n\nfn read_int_from_buffer(buf: &io::Stdin) -> i32 {\n read_string_from_buffer(buf)\n .parse::()\n .expect(\"couldn't parse data to an integer\")\n}\n\nfn read_line_of_integers() -> Vec {\n readstring()\n .split_whitespace()\n .map(|x| x.parse::().unwrap())\n .collect()\n}\n\nfn read_line_of_longs() -> Vec {\n readstring()\n .split_whitespace()\n .map(|x| x.parse::().unwrap())\n .collect()\n}\n\nfn h(par: &mut Vec, d: &mut Vec, i: i32) -> i32 {\n if i == 1 {\n return -1;\n }\n let p = par[i as usize - 2];\n if d[i as usize - 2] == 0 {\n d[i as usize - 2] = h(par, d, p) + 1\n }\n d[i as usize - 2]\n}\n\nfn main() {\n let v = read_line_of_integers();\n let (a, b) = (cmp::min(v[0], v[1]), cmp::max(v[0], v[1]));\n if a + v[2] <= b {\n println!(\"{}\", 2 * (a + v[2]));\n } else {\n println!(\"{}\", 2 * b + ((v[2] - (b - a)) / 2) * 2);\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "1612ac7839cfe5fa7048954ea02ad2c0", "src_uid": "e8148140e61baffd0878376ac5f3857c", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::cmp;\n\nfn read_line() -> String {\n let mut buffer = String::new();\n io::stdin().read_line(&mut buffer).expect(\"Input error\");\n buffer\n}\n\nfn string_to_integer_iterator(string: String) -> Vec {\n string.split(' ')\n .map(|s| s.trim())\n .filter(|s| !s.is_empty())\n .map(|s| s.parse().unwrap()).collect()\n}\n\nfn main() {\n let vector = string_to_integer_iterator(read_line());\n let min = cmp::min(vector[0], vector[1]);\n let max = cmp::max(vector[0], vector[1]);\n let poten_max = min + vector[2];\n\n let result = (poten_max + cmp::min(poten_max, max)) >> 1 << 1;\n\n println!(\"{}\", result);\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "2f72b4bf0b099201f6fefd549778c468", "src_uid": "e8148140e61baffd0878376ac5f3857c", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "pub fn main() {\n let mut input = io::Input::new();\n\n let _n = input.next::();\n let s = input.next::();\n\n let mut count = 0;\n\n for xxx in s.split(|c| c != 'x') {\n if xxx.len() > 2 {\n count += xxx.len() - 2;\n }\n }\n\n println!(\"{}\", count);\n}\n\n#[allow(unused)]\npub mod io {\n\n const BUFFER_SIZE: usize = 8192;\n\n use std::collections::VecDeque;\n use std::str::FromStr;\n use std::io;\n use std::io::Read;\n\n type AsciiStr = Vec;\n\n pub struct Input {\n token_buffer: VecDeque,\n remaining: String,\n }\n\n impl Input {\n\n pub fn new() -> Input {\n Input {\n token_buffer: VecDeque::with_capacity(100),\n remaining: String::new(),\n }\n }\n\n pub fn next(&mut self) -> T\n where T::Err: ::std::fmt::Debug\n {\n self.fill_buffer();\n self.token_buffer.pop_front().unwrap().parse().unwrap()\n }\n\n pub fn next_ascii_string(&mut self) -> AsciiStr {\n self.fill_buffer();\n Vec::from(self.token_buffer.pop_front().unwrap().as_bytes())\n }\n\n fn fill_buffer(&mut self) {\n while self.token_buffer.is_empty() {\n let mut minibuffer = [0u8; BUFFER_SIZE];\n let size = io::stdin().read(&mut minibuffer[..]).unwrap();\n\n self.remaining += &String::from_utf8_lossy(&minibuffer[..size]);\n\n if self.remaining.trim().len() > 0 {\n for token in self.remaining.trim().split_whitespace() {\n self.token_buffer.push_back(String::from(token))\n }\n\n if size > 0 && ! self.remaining.ends_with(|c: char|char::is_ascii_whitespace(&c)) {\n self.remaining = self.token_buffer.pop_back().unwrap();\n } else {\n self.remaining.clear();\n }\n\n } else if size == 0 {\n panic!(\"EOF\");\n }\n }\n }\n }\n}\n", "lang_cluster": "Rust", "tags": ["greedy", "strings"], "code_uid": "fb3a248a4e0152ab338bf742de8b6478", "src_uid": "8de14db41d0acee116bd5d8079cb2b02", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::*;\n#[allow(unused_imports)]\nuse std::collections::*;\nuse std::io::{Read, Write, BufWriter};\n#[allow(dead_code)]\nfn getline() -> String {\n let mut ret = String::new();\n std::io::stdin().read_line(&mut ret).ok().unwrap();\n ret\n}\nfn get_word() -> String {\n let mut stdin = std::io::stdin();\n let mut u8b: [u8; 1] = [0];\n loop {\n let mut buf: Vec = Vec::with_capacity(16);\n loop {\n let res = stdin.read(&mut u8b);\n if res.unwrap_or(0) == 0 || u8b[0] <= b' ' {\n break;\n } else {\n buf.push(u8b[0]);\n }\n }\n if buf.len() >= 1 {\n let ret = String::from_utf8(buf).unwrap();\n return ret;\n }\n }\n}\n\n#[allow(dead_code)]\nfn get() -> T { get_word().parse().ok().unwrap() }\n\nfn solve() {\n let out = std::io::stdout();\n let mut out = BufWriter::new(out.lock());\n macro_rules! puts {\n ($format:expr) => (write!(out,$format).unwrap());\n ($format:expr, $($args:expr),+) => (write!(out,$format,$($args),*).unwrap())\n }\n let n: usize = get();\n let s: Vec<_> = get_word().chars().collect();\n let mut tot = 0;\n let mut cur = 0;\n for i in 0 .. n + 1 {\n if i == n || s[i] != 'x' {\n tot += max(0, cur - 2);\n cur = 0;\n } else {\n cur += 1;\n }\n }\n puts!(\"{}\\n\", tot);\n}\n\nfn main() {\n // In order to avoid potential stack overflow, spawn a new thread.\n let stack_size = 104_857_600; // 100 MB\n let thd = std::thread::Builder::new().stack_size(stack_size);\n thd.spawn(|| solve()).unwrap().join().unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["greedy", "strings"], "code_uid": "3f7cfe297e8eef0a55a306e3a85775da", "src_uid": "8de14db41d0acee116bd5d8079cb2b02", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//! http://codeforces.com/contest/266/problem/A\n\nfn main() {\n use std::io;\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.clear();\n io::stdin().read_line(&mut buf).unwrap();\n let rocks = buf.trim().as_bytes();\n let mut last = rocks[0];\n let mut remove = 0;\n for &rock in &rocks[1..] {\n if rock == last { remove += 1; }\n else { last = rock; }\n }\n println!(\"{}\", remove);\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "04e4c8cf4d7d06ed6401560f6fe56d14", "src_uid": "d561436e2ddc9074b98ebbe49b9e27b8", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "/*\n Implementation - https://codeforces.com/problemset/problem/1030/A\n Completed: 2/7/20 21:20\n*/\n\nuse std::io;\n\nfn main() {\n let mut first_input = String::new();\n io::stdin().read_line(&mut first_input).unwrap();\n\n let mut last_input = String::new();\n io::stdin().read_line(&mut last_input).unwrap();\n\n let mut byte: &u8 = &0;\n let mut out_value = 0;\n\n for letter in last_input.as_bytes() {\n if letter == byte {\n out_value += 1;\n }\n byte = letter;\n }\n\n println!(\"{}\", out_value);\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "5b85dc4ef15913e64466a84b7270a42c", "src_uid": "d561436e2ddc9074b98ebbe49b9e27b8", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin input macro ----------\n// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, bytes) => {\n read_value!($iter, String).bytes().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n// ---------- end input macro ----------\n\n// \u9577\u30553\u307e\u3067\u3057\u304b\u306a\u3055\u305d\u3046\n// 1~3\u307e\u3067\u3092\u305d\u308c\u305e\u308c\u6570\u3048\u3089\u308c\u308c\u3070\u3044\u3044\n// \u9577\u30551\n// gcd > 1 \u306a\u30da\u30a2\u306e\u6570\n// \u9577\u30552\n// gcd = 1 \u3067\u6700\u5c0f\u7d20\u56e0\u6570\u306e\u7a4d\u304cN \u4ee5\u4e0b\u306a\u3082\u306e\n// \u9577\u30553\n// \u6700\u5c0f\u7d20\u56e0\u6570\u306e\u7a4d\u304cN\u3092\u8d85\u3048\u308b\u3084\u3064\n// \u3069\u3046\u6570\u3048\u308b\n// 1\n// \u5305\u9664\u539f\u7406\u3067\u3044\u3051\u308b\u306f\u305a\n// 2, 3\n// \u6700\u5c0f\u7d20\u56e0\u6570\u3067\u5206\u985e\u3059\u308c\u3070\u306a\u3093\u3068\u304b\u306a\u308b?\n// 2 * p > N \u306a\u7d20\u6570\u306f\u524a\u9664\u3057\u3066\u304a\u304f\n// \u4e92\u3044\u306b\u7d20\u306e\u6761\u4ef6\u3092\u6271\u3048\u3066\u306a\u304b\u3063\u305f...\n// \u6700\u5c0f\u7d20\u56e0\u6570\u306e\u7a4d\u304cN\u3092\u8d85\u3048\u3066\u308b\u306a\u3089\u4e92\u3044\u306b\u7d20\u306b\u306a\u308b\n// \u8d85\u3048\u306a\u3044\u306a\u3089\uff1f\n// \u4e8b\u524d\u306b\u30e1\u30e2\u3063\u3066\u304a\u3051\u3070\u3044\u3044\u611f\u3058\u304b?\n// \u3084\u3084\u3053\u3057\u3044\n// \u6700\u5c0f\u7d20\u56e0\u6570\u304c\u7570\u306a\u308b\u304b\u3064\u7a4d\u304cN\u4ee5\u4e0b\u304b\u3064\u4e92\u3044\u306b\u7d20\u3058\u3083\u306a\u3044\u30da\u30a2\u306e\u6570\n\nfn run() {\n input! {\n n: usize,\n }\n let mut factor = (0..=n).collect::>();\n let mut mobius = vec![1i8; n + 1];\n let mut prime = vec![];\n let mut cnt = vec![];\n for i in 2..=n {\n if i == factor[i] {\n prime.push(i);\n let mut c = 0;\n for j in 1..=(n / i) {\n let p = &mut factor[j * i];\n if i <= *p {\n *p = i;\n c += 1;\n }\n mobius[j * i] *= -1;\n }\n cnt.push(c);\n let pp = i.saturating_mul(i);\n for j in 1..=(n / pp) {\n mobius[j * pp] = 0;\n }\n }\n }\n while prime.last().map_or(false, |p| 2 * *p > n) {\n prime.pop();\n cnt.pop();\n }\n let mut all = cnt.iter().sum::();\n all = all * (all - 1) / 2;\n let mut ans = 0i64;\n for (i, mobius) in mobius.iter().enumerate().skip(2) {\n let s = *mobius as i64;\n if s != 0 {\n let cnt = (n / i) as i64;\n all += s * cnt * (cnt - 1) / 2;\n ans -= cnt * (cnt - 1) / 2 * s;\n }\n }\n let mut sum = 0;\n let mut x = 0;\n let mut two = 0;\n for (i, (c, p)) in cnt.iter().zip(prime.iter()).enumerate() {\n while x < i && *p * prime[x] <= n {\n two += cnt[x];\n x += 1;\n }\n while x > 0 && *p * prime[x - 1] > n {\n x -= 1;\n two -= cnt[x];\n }\n ans += (sum - two) * *c * 3;\n all -= (sum - two) * *c;\n sum += *c;\n }\n ans += 2 * all;\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["sortings", "number theory"], "code_uid": "3bac886cd8e00a988ba086541f5ea34c", "src_uid": "bb1bd5d8bab7d79e514281230d484996", "difficulty": 2700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scanner<'a, T: std::io::Read> {\n reader: &'a mut T,\n buffer: [u8; 4096],\n position: usize,\n size: usize\n}\n\nimpl<'a, T: std::io::Read> Scanner<'a, T> {\n const SPACES: [i32; 4] = [\n ' ' as i32,\n '\\n' as i32,\n '\\t' as i32,\n '\\r' as i32];\n const ZERO: i32 = '0' as i32;\n const NINE: i32 = '9' as i32;\n const NEG: i32 = '-' as i32;\n const EOF: i32 = -1;\n\n fn new(reader: &'a mut T) -> Scanner<'a, T> {\n Scanner {\n reader,\n buffer: [0; 4096],\n position: 0,\n size: 0\n }\n }\n\n fn read_block(&mut self) {\n self.size = self.reader.read(&mut self.buffer).unwrap();\n self.position = 0;\n }\n\n fn read_char(&mut self) -> i32 {\n if self.position >= self.size {\n self.read_block();\n if self.position >= self.size {\n return Scanner::::EOF;\n }\n }\n \n let ch = self.buffer[self.position];\n self.position += 1;\n \n ch as i32\n }\n \n fn read_char_skip_ws(&mut self) -> i32 {\n let mut ch = self.read_char();\n while ch != Scanner::::EOF && Scanner::::SPACES.contains(&ch) {\n ch = self.read_char();\n }\n\n if ch == Scanner::::EOF {\n return Scanner::::EOF;\n }\n\n return ch;\n }\n\n fn read_int(&mut self) -> Option {\n let mut ch = self.read_char_skip_ws();\n if ch == Scanner::::EOF {\n return None;\n }\n\n let mut negative = false;\n if ch == Scanner::::NEG {\n negative = true;\n ch = self.read_char();\n }\n\n let mut result = 0;\n while ch != Scanner::::EOF && ch >= Scanner::::ZERO && ch <= Scanner::::NINE {\n result = result * 10 + ch - Scanner::::ZERO;\n ch = self.read_char();\n }\n\n Some(if negative {\n -result\n } else {\n result\n })\n }\n\n fn read_str(&mut self, s: &mut String) -> bool {\n let mut ch = self.read_char_skip_ws();\n if ch == Scanner::::EOF {\n return false;\n }\n \n while !Scanner::::SPACES.contains(&ch) {\n s.push(std::char::from_u32(ch as u32).unwrap());\n ch = self.read_char();\n }\n \n return true;\n }\n}\n\nfn main() {\n let mut stdin = std::io::stdin();\n let mut reader = Scanner::new(&mut stdin);\n\n let n = reader.read_int().unwrap() as i64;\n let k = reader.read_int().unwrap() as i64;\n \n let y = ((-3f64 + ((9 + 8 * (n + k)) as f64).sqrt()) / 2f64) as i64;\n let x = n - y;\n\n println!(\"{}\", x);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "binary search"], "code_uid": "8ed80a96aa9a4834adec59e015a6d625", "src_uid": "17b5ec1c6263ef63c668c2b903db1d77", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//! http://codeforces.com/contest/405/problem/A\n\nfn main() {\n use std::io;\n let mut buf = String::new();\n let mut rows: Vec = Vec::with_capacity(100);\n let cols: Vec;\n io::stdin().read_line(&mut buf).unwrap();\n let n = buf.trim().parse::().unwrap();\n buf.clear();\n io::stdin().read_line(&mut buf).unwrap();\n cols = buf.split(\" \")\n .map(|str| str.trim().parse::().unwrap())\n .collect();\n for i in 1..101 {\n let mut row = 0;\n for j in 0..(n as usize) {\n if cols[j] >= i {\n row += 1;\n }\n } \n rows.push(row);\n }\n let mut res: Vec = Vec::with_capacity(n as usize);\n for i in 1..(n as usize + 1) {\n let mut col = 0;\n for j in 0..100 {\n if rows[j] >= i as u32 {\n col += 1;\n }\n }\n res.push(col);\n }\n res.reverse();\n for i in 0..n as usize {\n if i != 0 { print!(\" \"); }\n print!(\"{}\", res[i]);\n }\n println!();\n}\n", "lang_cluster": "Rust", "tags": ["sortings", "implementation", "greedy"], "code_uid": "b5580f790df6bd8cf5f08c817bf2124b", "src_uid": "ae20712265d4adf293e75d016b4b82d8", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, BufRead};\n\nfn main() {\n let stdin = io::stdin();\n let mut iterator = stdin.lock().lines();\n\n let _first = iterator.next().unwrap().unwrap();\n let second = iterator.next().unwrap().unwrap();\n\n let mut numbers: Vec = second\n .split_whitespace()\n .map(|s| s.parse().unwrap())\n .collect();\n\n numbers.sort();\n\n let strings: Vec = numbers\n .iter()\n .map(|s| s.to_string())\n .collect();\n println!(\"{}\", strings.join(\" \"));\n}", "lang_cluster": "Rust", "tags": ["sortings", "implementation", "greedy"], "code_uid": "8b365d59042b78884a3c0429a84c8a18", "src_uid": "ae20712265d4adf293e75d016b4b82d8", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::*;\n#[allow(unused_imports)]\nuse std::collections::*;\nuse std::io::*;\n#[allow(dead_code)]\nfn getline() -> String {\n let mut ret = String::new();\n std::io::stdin().read_line(&mut ret).ok();\n return ret;\n}\nfn get_word() -> String {\n let mut stdin = std::io::stdin();\n let mut u8b: [u8; 1] = [0];\n loop {\n let mut buf: Vec = Vec::with_capacity(16);\n loop {\n let res = stdin.read(&mut u8b);\n if res.unwrap_or(0) == 0 || u8b[0] <= b' ' {\n break;\n } else {\n buf.push(u8b[0]);\n }\n }\n if buf.len() >= 1 {\n let ret = std::string::String::from_utf8(buf).unwrap();\n return ret;\n }\n }\n}\nfn parse(s: &str) -> T { s.parse::().ok().unwrap() }\n\n#[allow(dead_code)]\nfn get() -> T { parse(&get_word()) }\n\nfn main() {\n let v: Vec = get_word().bytes().collect();\n let mut ok = true;\n let mut used = [false; 26];\n let n = v.len();\n for i in 0 .. n {\n let idx = (v[i] - b'a') as usize;\n for j in 0 .. idx {\n if !used[j] {\n ok = false;\n }\n }\n used[idx] = true;\n }\n println!(\"{}\", if ok { \"YES\" } else { \"NO\" });\n}\n", "lang_cluster": "Rust", "tags": ["greedy", "strings", "implementation"], "code_uid": "64d686da9f9723ddc7583f11762e6510", "src_uid": "c4551f66a781b174f95865fa254ca972", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin ModInt ----------\r\nmod modint {\r\n\r\n #[allow(dead_code)]\r\n pub struct Mod;\r\n impl ConstantModulo for Mod {\r\n const MOD: u32 = 1_000_000_007;\r\n }\r\n\r\n #[allow(dead_code)]\r\n pub struct StaticMod;\r\n static mut STATIC_MOD: u32 = 0;\r\n impl Modulo for StaticMod {\r\n fn modulo() -> u32 {\r\n unsafe { STATIC_MOD }\r\n }\r\n }\r\n\r\n #[allow(dead_code)]\r\n impl StaticMod {\r\n pub fn set_modulo(p: u32) {\r\n unsafe {\r\n STATIC_MOD = p;\r\n }\r\n }\r\n }\r\n\r\n use std::marker::*;\r\n use std::ops::*;\r\n\r\n pub trait Modulo {\r\n fn modulo() -> u32;\r\n }\r\n\r\n pub trait ConstantModulo {\r\n const MOD: u32;\r\n }\r\n\r\n impl Modulo for T\r\n where\r\n T: ConstantModulo,\r\n {\r\n fn modulo() -> u32 {\r\n T::MOD\r\n }\r\n }\r\n\r\n pub struct ModInt(pub u32, PhantomData);\r\n\r\n impl Clone for ModInt {\r\n fn clone(&self) -> Self {\r\n ModInt::new_unchecked(self.0)\r\n }\r\n }\r\n\r\n impl Copy for ModInt {}\r\n\r\n impl Add for ModInt {\r\n type Output = ModInt;\r\n fn add(self, rhs: Self) -> Self::Output {\r\n let mut d = self.0 + rhs.0;\r\n if d >= T::modulo() {\r\n d -= T::modulo();\r\n }\r\n ModInt::new_unchecked(d)\r\n }\r\n }\r\n\r\n impl AddAssign for ModInt {\r\n fn add_assign(&mut self, rhs: Self) {\r\n *self = *self + rhs;\r\n }\r\n }\r\n\r\n impl Sub for ModInt {\r\n type Output = ModInt;\r\n fn sub(self, rhs: Self) -> Self::Output {\r\n let mut d = T::modulo() + self.0 - rhs.0;\r\n if d >= T::modulo() {\r\n d -= T::modulo();\r\n }\r\n ModInt::new_unchecked(d)\r\n }\r\n }\r\n\r\n impl SubAssign for ModInt {\r\n fn sub_assign(&mut self, rhs: Self) {\r\n *self = *self - rhs;\r\n }\r\n }\r\n\r\n impl Mul for ModInt {\r\n type Output = ModInt;\r\n fn mul(self, rhs: Self) -> Self::Output {\r\n let v = self.0 as u64 * rhs.0 as u64 % T::modulo() as u64;\r\n ModInt::new_unchecked(v as u32)\r\n }\r\n }\r\n\r\n impl MulAssign for ModInt {\r\n fn mul_assign(&mut self, rhs: Self) {\r\n *self = *self * rhs;\r\n }\r\n }\r\n\r\n impl Neg for ModInt {\r\n type Output = ModInt;\r\n fn neg(self) -> Self::Output {\r\n if self.0 == 0 {\r\n Self::zero()\r\n } else {\r\n Self::new_unchecked(T::modulo() - self.0)\r\n }\r\n }\r\n }\r\n\r\n impl std::fmt::Display for ModInt {\r\n fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {\r\n write!(f, \"{}\", self.0)\r\n }\r\n }\r\n\r\n impl std::fmt::Debug for ModInt {\r\n fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {\r\n write!(f, \"{}\", self.0)\r\n }\r\n }\r\n\r\n impl std::str::FromStr for ModInt {\r\n type Err = std::num::ParseIntError;\r\n fn from_str(s: &str) -> Result {\r\n let val = s.parse::()?;\r\n Ok(ModInt::new(val))\r\n }\r\n }\r\n\r\n impl From for ModInt {\r\n fn from(val: usize) -> ModInt {\r\n ModInt::new_unchecked((val % T::modulo() as usize) as u32)\r\n }\r\n }\r\n\r\n impl From for ModInt {\r\n fn from(val: u64) -> ModInt {\r\n ModInt::new_unchecked((val % T::modulo() as u64) as u32)\r\n }\r\n }\r\n\r\n impl From for ModInt {\r\n fn from(val: i64) -> ModInt {\r\n let m = T::modulo() as i64;\r\n ModInt::new((val % m + m) as u32)\r\n }\r\n }\r\n\r\n #[allow(dead_code)]\r\n impl ModInt {\r\n pub fn new_unchecked(d: u32) -> Self {\r\n ModInt(d, PhantomData)\r\n }\r\n pub fn zero() -> Self {\r\n ModInt::new_unchecked(0)\r\n }\r\n pub fn one() -> Self {\r\n ModInt::new_unchecked(1)\r\n }\r\n pub fn is_zero(&self) -> bool {\r\n self.0 == 0\r\n }\r\n }\r\n\r\n #[allow(dead_code)]\r\n impl ModInt {\r\n pub fn new(d: u32) -> Self {\r\n ModInt::new_unchecked(d % T::modulo())\r\n }\r\n pub fn pow(&self, mut n: u64) -> Self {\r\n let mut t = Self::one();\r\n let mut s = *self;\r\n while n > 0 {\r\n if n & 1 == 1 {\r\n t *= s;\r\n }\r\n s *= s;\r\n n >>= 1;\r\n }\r\n t\r\n }\r\n pub fn inv(&self) -> Self {\r\n assert!(self.0 != 0);\r\n self.pow(T::modulo() as u64 - 2)\r\n }\r\n }\r\n}\r\n// ---------- end ModInt ----------\r\n// ---------- begin Precalc ----------\r\nmod precalc {\r\n use super::modint::*;\r\n #[allow(dead_code)]\r\n pub struct Precalc {\r\n inv: Vec>,\r\n fact: Vec>,\r\n ifact: Vec>,\r\n }\r\n #[allow(dead_code)]\r\n impl Precalc {\r\n pub fn new(n: usize) -> Precalc {\r\n let mut inv = vec![ModInt::one(); n + 1];\r\n let mut fact = vec![ModInt::one(); n + 1];\r\n let mut ifact = vec![ModInt::one(); n + 1];\r\n for i in 2..(n + 1) {\r\n fact[i] = fact[i - 1] * ModInt::new_unchecked(i as u32);\r\n }\r\n ifact[n] = fact[n].inv();\r\n if n > 0 {\r\n inv[n] = ifact[n] * fact[n - 1];\r\n }\r\n for i in (1..n).rev() {\r\n ifact[i] = ifact[i + 1] * ModInt::new_unchecked((i + 1) as u32);\r\n inv[i] = ifact[i] * fact[i - 1];\r\n }\r\n Precalc {\r\n inv: inv,\r\n fact: fact,\r\n ifact: ifact,\r\n }\r\n }\r\n pub fn inv(&self, n: usize) -> ModInt {\r\n assert!(n > 0);\r\n self.inv[n]\r\n }\r\n pub fn fact(&self, n: usize) -> ModInt {\r\n self.fact[n]\r\n }\r\n pub fn ifact(&self, n: usize) -> ModInt {\r\n self.ifact[n]\r\n }\r\n pub fn perm(&self, n: usize, k: usize) -> ModInt {\r\n if k > n {\r\n return ModInt::zero();\r\n }\r\n self.fact[n] * self.ifact[n - k]\r\n }\r\n pub fn comb(&self, n: usize, k: usize) -> ModInt {\r\n if k > n {\r\n return ModInt::zero();\r\n }\r\n self.fact[n] * self.ifact[k] * self.ifact[n - k]\r\n }\r\n }\r\n}\r\n// ---------- end Precalc ----------\r\n\r\nuse modint::*;\r\ntype M = ModInt;\r\n\r\n// ---------- begin input macro ----------\r\n// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\r\nmacro_rules! input {\r\n (source = $s:expr, $($r:tt)*) => {\r\n let mut iter = $s.split_whitespace();\r\n input_inner!{iter, $($r)*}\r\n };\r\n ($($r:tt)*) => {\r\n let s = {\r\n use std::io::Read;\r\n let mut s = String::new();\r\n std::io::stdin().read_to_string(&mut s).unwrap();\r\n s\r\n };\r\n let mut iter = s.split_whitespace();\r\n input_inner!{iter, $($r)*}\r\n };\r\n}\r\n\r\nmacro_rules! input_inner {\r\n ($iter:expr) => {};\r\n ($iter:expr, ) => {};\r\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\r\n let $var = read_value!($iter, $t);\r\n input_inner!{$iter $($r)*}\r\n };\r\n}\r\n\r\nmacro_rules! read_value {\r\n ($iter:expr, ( $($t:tt),* )) => {\r\n ( $(read_value!($iter, $t)),* )\r\n };\r\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\r\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\r\n };\r\n ($iter:expr, chars) => {\r\n read_value!($iter, String).chars().collect::>()\r\n };\r\n ($iter:expr, bytes) => {\r\n read_value!($iter, String).bytes().collect::>()\r\n };\r\n ($iter:expr, usize1) => {\r\n read_value!($iter, usize) - 1\r\n };\r\n ($iter:expr, $t:ty) => {\r\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\r\n };\r\n}\r\n// ---------- end input macro ----------\r\n\r\nuse std::io::Write;\r\n\r\n// \u96fb\u6e90\u3092on \u306b\u3059\u308b\u3082\u306e\u56fa\u5b9a\u3059\u308b\u3068\r\n// 2\u3064\u98db\u3070\u3057\u306f\u7121\u7406\r\n// 3\u3064\u4ee5\u4e0a\u9023\u7d9a\u3059\u308b\u90e8\u5206\u306f\u5de6\u304b\u3089or\u53f3\u304b\u3089\u5358\u8abf\u306b\u64cd\u4f5c\u3057\u306a\u3051\u308c\u3070\u306a\u3089\u306a\u3044\r\n// \u6700\u5f8c\u306b\u7f6e\u3044\u305f\u7a7a\u767d\u3067DP?\r\n\r\nfn run() {\r\n input! {\r\n n: usize,\r\n m: u32,\r\n }\r\n StaticMod::set_modulo(m);\r\n let pc = precalc::Precalc::new(n);\r\n let mut pow = vec![M::one(); n + 1];\r\n let two = M::new(2);\r\n for i in 1..=n {\r\n pow[i] = pow[i - 1] * two;\r\n }\r\n // dp[a][b]: \u6700\u5f8c\u306e\u7a7a\u767d\u304ca, b\u500b\u7f6e\u3044\u305f\r\n let mut dp = vec![vec![M::zero(); n + 2]; n + 2];\r\n dp[0][0] = M::one();\r\n for i in 0..=(n + 1) {\r\n for j in 0..=(n + 1) {\r\n let way = dp[i][j];\r\n if way.is_zero() {\r\n continue;\r\n }\r\n for k in 1.. {\r\n if i + k + 1 > n + 1 {\r\n break;\r\n }\r\n if k > 1 {\r\n dp[i + k + 1][j + k] += pow[k - 1] * way * pc.comb(j + k, j);\r\n } else {\r\n dp[i + k + 1][j + k] += way * pc.comb(j + k, j);\r\n }\r\n }\r\n }\r\n }\r\n let mut ans = M::zero();\r\n for dp in dp[n + 1].iter() {\r\n ans += *dp;\r\n }\r\n println!(\"{}\", ans);\r\n}\r\n\r\nfn main() {\r\n run();\r\n}\r\n", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics"], "code_uid": "6a7362f6f51d1cb891da84ddc10db330", "src_uid": "4f0e0d1deef0761a46b64de3eb98e774", "difficulty": 2200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str;\n\nfn count_divisors(n: i64) -> i64 {\n let mut n = n;\n let mut d = 2;\n let mut ans = 1;\n while d * d <= n && n > 1 {\n let mut expo = 0;\n while n % d == 0 {\n n /= d;\n expo += 1;\n }\n ans *= expo + 1;\n d += 1;\n }\n if n > 1 {\n ans *= 2;\n }\n ans\n}\n\nfn solve(scan: &mut Scanner, out: &mut W) {\n let b: i64 = scan.token();\n let ans = count_divisors(b);\n writeln!(out, \"{}\", ans).ok();\n}\n\nfn main() {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout.lock());\n solve(&mut scan, &mut out);\n}\n\npub struct Scanner {\n reader: R,\n buffer: Vec,\n}\n\nimpl Scanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buffer: vec![],\n }\n }\n\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n\n pub fn tokens(&mut self) -> Vec {\n assert!(self.buffer.is_empty());\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n input\n .split_whitespace()\n .map(|x| x.parse().ok().expect(\"Failed parse\"))\n .collect()\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "2a29b5f07a6e563db64b6418e1f5f8b2", "src_uid": "7fc9e7d7e25ab97d8ebc10ed8ae38fd1", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\n// use proconio::input;\nuse std::cmp::{Ordering::*, Reverse};\nuse std::collections::{BTreeMap, BTreeSet};\nuse std::io::{self, BufWriter, Write};\nuse std::str::{self, SplitAsciiWhitespace};\n\n// I have no idea what I'm doing\n\nmacro_rules! answer {\n ($out:ident, $ans:expr) => {\n writeln!($out, \"{}\", $ans)\n };\n}\n\nfn main() -> Result<(), io::Error> {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = UnsafeScanner::new(stdin.lock());\n let mut out = BufWriter::new(stdout.lock());\n\n let (n, m) = scan.pair::();\n\n if n == 1 {\n return answer!(out, 1);\n }\n \n answer!(out, if m-1 < n-m {\n m+1 \n } else {\n m-1\n })\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////////////\n\n/// Mostly copied from https://github.com/EbTech/rust-algorithms/blob/master/src/scanner.rs\n/// Same API as Scanner but nearly twice as fast, using horribly unsafe dark arts\n/// **REQUIRES** Rust 1.34 or higher\npub struct UnsafeScanner {\n reader: R,\n buf_str: Vec,\n buf_iter: SplitAsciiWhitespace<'static>,\n}\n\nimpl UnsafeScanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buf_str: vec![],\n buf_iter: \"\".split_ascii_whitespace(),\n }\n }\n\n /// This function should be marked unsafe, but noone has time for that in a\n /// programming contest. Use at your own risk!\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buf_iter.next() {\n return token.parse().ok().expect(\"Failed parse [Scanner]\");\n }\n self.buf_str.clear();\n self.reader\n .read_until(b'\\n', &mut self.buf_str)\n .expect(\"Failed read\");\n self.buf_iter = unsafe {\n let slice = str::from_utf8_unchecked(&self.buf_str);\n std::mem::transmute(slice.split_ascii_whitespace())\n }\n }\n }\n\n pub fn pair(&mut self) -> (T, T) {\n (self.token(), self.token())\n }\n}\n\n// aka #![feature(bool_to_option)]\ntrait BoolThen {\n fn then_(self, f: impl FnOnce() -> T) -> Option;\n}\n\nimpl BoolThen for bool {\n fn then_(self, f: impl FnOnce() -> T) -> Option {\n if self {\n Some(f())\n } else {\n None\n }\n }\n}\n\ntrait BoolToYes {\n fn yes(self) -> &'static str;\n}\n\nimpl BoolToYes for bool {\n fn yes(self) -> &'static str {\n match self {\n true => \"YES\",\n false => \"NO\",\n }\n }\n}\n", "lang_cluster": "Rust", "tags": ["constructive algorithms", "games", "math", "greedy", "implementation"], "code_uid": "31aa53d673bf236f72c5510fd2ea15c3", "src_uid": "f6a80c0f474cae1e201032e1df10e9f7", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::cmp::min;\nuse std::io;\n\nfn read() -> i32 {\n let mut line = String::new();\n io::stdin().read_line(&mut line).unwrap();\n let n: i32 = line.trim().parse().unwrap();\n n\n}\n\nfn main() {\n let mut n = read();\n if n >= 0 {\n println!(\"{}\", n);\n } else {\n n = -n;\n let last_digit = n % 10;\n let before_last_digit = (n / 10) % 10;\n let n_without_last_two_digits = n / 100;\n let ans = -(n_without_last_two_digits * 10 + min(last_digit, before_last_digit));\n println!(\"{}\", ans);\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation", "number theory"], "code_uid": "29b08ddca9f1f7575f4455f8ad074463", "src_uid": "4b0a8798a6d53351226d4f06e3356b1e", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// 2018-10-12 10:25\nfn main() {\n let n: i32 = {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).unwrap();\n line.trim().parse().unwrap()\n };\n if n >= 0 {\n println!(\"{:?}\", n);\n } else {\n let x = n / 10;\n let y = n % 10 + n / 100 * 10;\n println!(\"{:?}\", std::cmp::max(x, y));\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation", "number theory"], "code_uid": "c5d424f29e56c0b9c8aa812cafa261c9", "src_uid": "4b0a8798a6d53351226d4f06e3356b1e", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::cmp::{\n min,\n max\n};\n\nmacro_rules! readln {\n () => {{\n use std::io;\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim().to_string()\n }};\n ( $t:ty ) => {{\n let input = readln!();\n input.parse::<$t>().unwrap()\n }};\n ( $( $t:ty ),+ ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n (\n $(\n input.next().unwrap().parse::<$t>().unwrap(),\n )+\n )\n }}\n}\n\nfn main() {\n let (nodes, edges) = readln!(i64, i64);\n\n let (min_isolated, max_isolated) = if edges == 0 {\n (nodes, nodes)\n } else {\n (\n if nodes % 2 == 0 {\n max(0, ((nodes + 1) / 2 - edges) * 2)\n } else {\n max(0, ((nodes + 1) / 2 - edges) * 2 - 1)\n },\n nodes - ((1.0 + (8.0 * edges as f64 + 1.0).sqrt()) / 2.0).ceil() as i64\n )\n };\n\n\n println!(\"{} {}\", min_isolated, max_isolated);\n}", "lang_cluster": "Rust", "tags": ["constructive algorithms", "graphs"], "code_uid": "debe87228c1c825a49801071fef73bfe", "src_uid": "daf0dd781bf403f7c1bb668925caa64d", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused)] use std::io::*;\n#[allow(unused)] macro_rules! scan { ($($x:ty), +) => {{\n let mut inp = String::new(); stdin().read_line(&mut inp).ok();\n let s = inp.split(' ').map(|x| x.trim()).filter(|x| x.len() != 0).collect();\n let mut cnt : usize = 0;\n fn next(cnt: &mut usize, p: &Vec<&str>) -> T where T:std::str::FromStr\n { *cnt += 1; p[*cnt-1].parse().ok().unwrap() }\n ($(next::<$x>(&mut cnt, &s)), +)\n }}; \n}\n\n#[allow(unused)] macro_rules! arr { ($($n:expr, $T:ty), +) => {{\n let mut inp = String::new(); stdin().read_line(&mut inp).ok();\n let mut s = inp.split(' ').map(|x| x.trim()).filter(|x| x.len() != 0);\n ($({let mut v = Vec::new(); v.reserve(($n) as usize);\n for _ in 0..$n { let t = s.next(); if t == None { break; }\n v.push(t.unwrap().parse::<$T>().unwrap()); } v }),+)\n }}; \n}\n\nfn bin_search bool>(first: i64, last: i64, func: T) -> i64 {\n let mut l = first;\n let mut r = last;\n let dir = func(l);\n\n while l + 1 < r {\n let mid = (l + r) / 2;\n if func(mid) == dir {\n l = mid;\n } else {\n r = mid;\n }\n }\n\n return l\n}\n\nfn main() {\n let (nodes, edges) = scan!(i64, i64);\n let min_graph_size = bin_search(0, nodes + 1, |n| n * (n - 1) / 2 < edges) + 1;\n\n let min_single = if edges == 0 {\n nodes\n } else if 2 * edges >= nodes {\n 0\n } else {\n nodes - 2 * edges\n };\n\n let max_single = if edges == 0 {\n nodes\n } else {\n nodes - min_graph_size\n };\n\n println!(\"{} {}\", min_single, max_single);\n}\n", "lang_cluster": "Rust", "tags": ["constructive algorithms", "graphs"], "code_uid": "2eaed6fb391ccbba960bd89ec7122bb4", "src_uid": "daf0dd781bf403f7c1bb668925caa64d", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\n#[allow(unused_macros)]\nmacro_rules! a {\n ($c: tt, $x: expr, $y: expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\nuse std::io::*;\nuse std::str::*;\nuse std::fmt::Debug;\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a>, }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).unwrap();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n println!(\"{}\", (1..1 + (input.i().min(input.i()) as i64))\n .product::());\n}\n\n", "lang_cluster": "Rust", "tags": ["math", "implementation", "number theory"], "code_uid": "f97050fe5c01e5dd6452e6a6b663893f", "src_uid": "7bf30ceb24b66d91382e97767f9feeb6", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::cmp::min;\nuse std::io;\n\nfn factorial(n: u32) -> u32 {\n (1..=n).fold(1, |acc, x| acc * x)\n}\n\nfn main() {\n let mut line = String::new();\n io::stdin().read_line(&mut line).unwrap();\n let numbers: Vec = line\n .split_whitespace()\n .map(|s| s.parse().unwrap())\n .collect();\n let a = numbers[0];\n let b = numbers[1];\n let ans = factorial(min(a, b));\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation", "number theory"], "code_uid": "dce934661d9e139c7b2c098c47ff5ed5", "src_uid": "7bf30ceb24b66d91382e97767f9feeb6", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max,min};\n#[allow(unused_imports)]\nuse std::collections::{HashMap,HashSet,VecDeque};\n\n#[allow(unused_macros)]\nmacro_rules! readln {\n () => {{\n use std::io;\n \n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim().to_string()\n }};\n ( $t:ty ) => {{\n let input = readln!();\n input.parse::<$t>().unwrap()\n }};\n ( $( $t:ty ),+ ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n (\n $(\n input.next().unwrap().parse::<$t>().unwrap(),\n )+\n )\n }}\n}\n\n#[allow(unused_macros)]\nmacro_rules! readvec {\n ( $t:ty ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n let mut result = Vec::new();\n for elem in input {\n result.push(elem.parse::<$t>().unwrap());\n }\n result\n }}\n}\n\nfn main() {\nlet (n,k) = readln!(i64,i64);\nprintln!(\"{}\",if (n/k)%2 == 0 { \"NO\" } else { \"YES\" });\n}\n", "lang_cluster": "Rust", "tags": ["math", "games"], "code_uid": "42984ff66638efc9a1ef8b7cb0101244", "src_uid": "05fd61dd0b1f50f154eec85d8cfaad50", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\n\nfn main() { \n let stdin = stdin();\n let mut s = String::new();\n stdin.read_line(&mut s).unwrap();\n let vec = s.split_whitespace().map(|x| x.parse::().expect(\"number parse error\")).collect::>();\n if (vec[0] / vec[1])&1 > 0 {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "games"], "code_uid": "5cf0193175d393a035d55b79b1c6ead8", "src_uid": "05fd61dd0b1f50f154eec85d8cfaad50", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// https://codeforces.com/contest/1271/problem/E\n//\n#![allow(unused_imports)]\nuse std::io::*;\nuse std::fmt::*;\nuse std::str::*;\nuse std::cmp::*;\nuse std::collections::*;\n\n#[allow(unused_macros)]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n\n ($iter:expr, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n\n ($iter:expr, [ next / $t:tt ]) => {\n {\n let len = read_value!($iter, usize);\n (0..len).map(|_| read_value!($iter, $t)).collect::>()\n }\n };\n\n ($iter:expr, switch) => {\n {\n let ty = read_value!($iter, i32);\n if ty == 1 {\n vec![ty, read_value!($iter, i32), read_value!($iter, i32)]\n } else if ty == 2 {\n vec![ty, read_value!($iter, i32)]\n } else {\n vec![ty, read_value!($iter, i32)]\n }\n }\n };\n\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! dvec {\n ($t:expr ; $len:expr) => {\n vec![$t; $len]\n };\n\n ($t:expr ; $len:expr, $($rest:expr),*) => {\n vec![dvec!($t; $($rest),*); $len]\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! ifv {\n ($t:expr, $a:expr, $b: expr) => {\n if $t { $a } else { $b }\n }\n}\n\n#[allow(unused_macros)]\nmacro_rules! fill {\n ($t:expr, $v:expr) => {\n for i in 0..$t.len() {\n $t[i] = $v;\n }\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! join {\n ($t:expr, $glue:expr) => {\n $t.into_iter().map(|w| w.to_string()).collect::>().join($glue)\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($a:expr),*) => {\n println!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);\n }\n}\n\nfn exp(upto: usize, k: usize) {\n let mut cnt = vec![0; upto];\n for w in 1..upto {\n let mut ww = w;\n loop {\n cnt[ww] += 1;\n if ww == 1 {\n break;\n }\n if ww % 2 == 0 {\n ww /= 2;\n } else {\n ww -= 1;\n }\n }\n }\n let mut up = 0;\n for w in (1..upto).rev() {\n if cnt[w] > up {\n up = cnt[w];\n // debug!(w, up);\n }\n }\n for w in (1..upto).rev() {\n if cnt[w] >= k {\n println!(\"{}\", w);\n break;\n }\n }\n}\n\nfn main() {\n input! {\n n: i64, k: i64\n };\n\n if n <= 100 {\n exp((n+1) as usize, k as usize);\n return;\n }\n\n let mut ans = -1;\n let mut tbl = vec![(n, 1), (n-1, ifv!(n % 2 == 0, 1, 2)), (n-2, ifv!(n % 2 == 0, 2, 1))];\n loop {\n // debug!(tbl);\n for &(f, l) in &tbl {\n if k <= l {\n ans = f;\n break;\n }\n }\n if tbl[0].0 <= 1 {\n break;\n }\n if ans != -1 {\n break;\n }\n\n\n let mut ntbl: Vec<(i64, i64)> = vec![];\n let tn = tbl.len();\n for nex in 0..4 {\n let to = tbl[0].0 / 2 - nex;\n let mut add = 1;\n\n // find 2*to\n {\n let mut f2 = false;\n for f in 0..tn {\n if tbl[f].0 == 2*to {\n add += tbl[f].1;\n f2 = true;\n break;\n }\n }\n if !f2 {\n for f in 0..nex {\n if ntbl[f as usize].0 == 2*to {\n add += ntbl[f as usize].1;\n f2 = true;\n break;\n }\n }\n }\n\n if !f2 {\n for f in (0..tn).rev() {\n if tbl[f].0 % 2 == 0 {\n add += tbl[f].1;\n break;\n }\n }\n }\n }\n\n // find to+1\n if to % 2 == 0 {\n // we already have that one...\n if nex >= 1 {\n add += ntbl[(nex-1) as usize].1;\n } else {\n for f in (0..tn).rev() {\n if tbl[f].0 % 2 == 1 {\n add += tbl[f].1;\n break;\n }\n }\n }\n }\n ntbl.push((to, add));\n }\n tbl = ntbl;\n }\n\n // exp((n+1) as usize);\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["math", "binary search", "dp", "combinatorics"], "code_uid": "8ccc6835da056fe3737eee1cb3538144", "src_uid": "783c4b3179c558369f94f4a16ac562d4", "difficulty": 2100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max,min};\n\ntype GenError = Box;\ntype GenResult = Result;\n\nstruct Reader {\n\n}\n\nimpl Reader{\n #[allow(unused)]\n fn read_string() -> GenResult {\n let mut string: String = String::new();\n std::io::stdin().read_line(&mut string)?;\n Ok(string.trim().to_string())\n }\n\n #[allow(unused)]\n fn read_tokens() -> GenResult> {\n let mut string: String = String::new();\n std::io::stdin().read_line(&mut string)?;\n let mut v = Vec::new();\n for value in string.split_whitespace() {\n v.push(value.to_string());\n }\n Ok(v)\n }\n}\n\nfn main() {\n\n let tokens = Reader::read_tokens().unwrap();\n let n: i32 = tokens[0].parse().unwrap();\n let m: i32 = tokens[1].parse().unwrap();\n let k: i32 = tokens[2].parse().unwrap();\n\n let mut ans = 1000000;\n let mut index = 1;\n for value in Reader::read_tokens().unwrap() {\n let value : i32 = value.parse().unwrap();\n if value > 0 && value <= k {\n ans = min(ans, 10 * (index - m).abs());\n }\n index += 1;\n }\n println!(\"{}\", ans);\n}", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "616acaf9bb2df9225beb625e83e3d903", "src_uid": "57860e9a5342a29257ce506063d37624", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\n\n#[derive(Default)]\nstruct Scanner {\n buffer: Vec,\n}\n\nimpl Scanner {\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n stdin().read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn main() {\n let mut scan = Scanner::default();\n let n = scan.next::();\n let mut a = vec![0; n];\n for i in 0..n {\n a[i] = scan.next::();\n }\n let mut b = vec![0; n];\n for i in 0..n {\n b[i] = scan.next::();\n }\n let mut num_a = 0;\n let mut num_b = 0;\n for i in 0..n {\n if a[i] == 1 && b[i] == 0 {\n num_a += 1;\n } else if a[i] == 0 && b[i] == 1 {\n num_b += 1;\n }\n }\n let ans = {\n if num_a == 0 {\n -1\n } else {\n let mut x = 1;\n while num_a * x <= num_b {\n x += 1;\n }\n x\n }\n };\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["greedy"], "code_uid": "8f434d686ef7266cf713240640f3784e", "src_uid": "b62338bff0cbb4df4e5e27e1a3ffaa07", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\n#![allow(dead_code)]\n#![allow(unused_labels)]\n\nuse std::char::*;\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io::*;\nuse std::str::FromStr;\n\nmacro_rules! debug {($($a:expr),*) => {eprintln!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);}}\nmacro_rules! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }\nmacro_rules! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }\nmacro_rules! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\n\n\nfn read() -> T {\n let stdin = stdin();\n let stdin = stdin.lock();\n let token: String = stdin\n .bytes()\n .map(|c| c.expect(\"failed to read char\") as char)\n .skip_while(|c| c.is_whitespace())\n .take_while(|c| !c.is_whitespace())\n .collect();\n token.parse().ok().expect(\"failed to parse token\")\n}\n\nuse std::f64;\n\nfn min(a:T, b:T) -> T {\n if a < b { a }\n else { b }\n}\n\nfn max(a:T, b:T) -> T {\n if a < b { b }\n else { a }\n}\n\nconst MAX:usize = 30;\nconst INF:i64 = std::i64::MAX;\nconst MOD:i64 = 1e9 as i64 + 7;\n\nstruct Graph {\n e: Vec>,\n v: Vec,\n u: Vec,\n f: Vec,\n c: i64,\n vc: Vec,\n}\n\nimpl Graph {\n fn new(n:usize) -> Self {\n Graph {\n e: vec![vec![];n],\n v: vec![],\n u: vec![n;n],\n f: vec![false;n],\n c: 0,\n vc: vec![0;n],\n }\n }\n\n fn dfs(&mut self, crt: usize) {\n if self.f[crt] { return; }\n self.c += 1;\n self.f[crt] = true;\n self.v.push(crt);\n self.vc[crt] = self.c;\n self.u[crt] = self.v.len()-1;\n for i in 0..self.e[crt].len() {\n self.dfs(self.e[crt][i]);\n }\n //debug!(crt, self.c, self.vc[crt]);\n self.vc[crt] = self.c - self.vc[crt];\n }\n}\n\nfn binary_search(s: &Vec, v:i64) -> usize {\n let mut left = 0;\n let mut right = s.len();\n\n while right-left > 1 {\n let mid = (right+left)/2;\n //debug!(left,mid,right,s[mid]);\n if s[mid] < v { left = mid; }\n else { right = mid; }\n }\n left\n}\n\nfn main() {\n //let t:usize = read();\n\n //'outer: for _ in 0..t {\n let n:usize = read();\n let m:usize = read();\n let mut p:Vec<(usize,usize,i64,usize)> = (0..m).map(|i| (read::()-1,read::()-1,read(),i)).collect();\n\n let mut v = vec![];\n\n let mut f = vec![false;m];\n let mut c = vec![0;m];\n for i in 0..m { c[i] = p[i].2; }\n\n for i in 0..n {\n // exam\u304c\u3042\u308c\u3070\u5b9f\u884c\n let mut idx = m;\n for j in 0..m {\n if p[j].1 == i {\n idx = j;\n }\n }\n if idx != m {\n if c[idx] == 0 {\n v.push(m+1);\n continue;\n } else {\n println!(\"-1\");\n return;\n }\n }\n // \u53ef\u80fd\u306a\u30bf\u30b9\u30af\u306e\u4e2d\u3067\u7de0\u3081\u5207\u308a\u306e\u8fd1\u3044\u3082\u306e\u3092\u6c42\u3081\u308b\n let mut idx = m;\n let mut dead = n;\n for j in 0..m {\n if !f[j] && p[j].0 <= i && i < p[j].1 {\n if dead > p[j].1 {\n dead = p[j].1;\n idx = j;\n }\n }\n }\n\n // \u53ef\u80fd\u306a\u30bf\u30b9\u30af\u304c\u306a\u3044\u5834\u5408\u306f\u4f11\u3080\n if idx == m {\n v.push(0);\n continue;\n }\n\n // \u30bf\u30b9\u30af\u3092\u5b9f\u884c\n v.push(idx+1);\n c[idx] -= 1;\n if c[idx] == 0 {\n f[idx] = true;\n }\n\n }\n\n for e in v {print!(\"{} \", e);} println!();\n\n //}\n}\n\n/*\n\n\n*/\n", "lang_cluster": "Rust", "tags": ["sortings", "implementation", "greedy"], "code_uid": "54c3350b958b9845bca6895d605e3bb9", "src_uid": "02d8d403eb60ae77756ff96f71b662d3", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\r\nuse std::cmp::{max, min};\r\nuse std::io::{stdin, stdout, BufWriter, Write};\r\n\r\n// code from https://codeforces.com/blog/entry/67391, modified by rkm0959\r\n\r\n#[derive(Default)]\r\nstruct UnkScanner {\r\n buffer: Vec,\r\n}\r\n\r\nimpl UnkScanner {\r\n fn next(&mut self) -> Option {\r\n loop {\r\n if let Some(token) = self.buffer.pop() {\r\n return token.parse().ok();\r\n }\r\n let mut input = String::new();\r\n match stdin().read_line(&mut input) {\r\n Ok(0) => return None,\r\n Err(_) => return None,\r\n _ => self.buffer = input.split_whitespace().rev().map(String::from).collect(),\r\n }\r\n }\r\n }\r\n}\r\n\r\n/*\r\n\r\nn even\r\nfirst \"all common\" at t\r\nfor all t+1 ~ k-1, even number gets it (not n)\r\n-> kills at t as well, sice\r\n\r\nn odd\r\nfirst \"all common\" at t\r\nall common or even gets it for each k\r\n\r\n*/\r\n\r\nfn exp(mut x: i64, mut y: i64, md: i64) -> i64 {\r\n let mut ret: i64 = 1;\r\n while y > 0 {\r\n if y % 2 == 1 {\r\n ret = (ret * x) % md;\r\n }\r\n x = (x * x) % md;\r\n y = y / 2;\r\n }\r\n return ret;\r\n}\r\n\r\nfn main() {\r\n let mut scan = UnkScanner::default();\r\n let out = &mut BufWriter::new(stdout());\r\n let tc: usize = scan.next::().expect(\"\");\r\n let md: i64 = 1_000_000_007;\r\n for _ in 0..tc {\r\n let n = scan.next::().expect(\"\");\r\n let k = scan.next::().expect(\"\");\r\n if k == 0 {\r\n writeln!(out, \"1\").ok();\r\n continue;\r\n }\r\n if n % 2 == 0 {\r\n let mut ans: i64 = 0;\r\n let v1 = exp(2, n - 1, md) - 1;\r\n let v2 = exp(2, n, md);\r\n for i in 0..k {\r\n // i+1 ~ k-1 2^(n-1) - 1\r\n // 0, ... i-1 ~ 2^n\r\n let add: i64 = (exp(v2, i, md) * exp(v1, k - i - 1, md)) % md;\r\n ans += add;\r\n if ans >= md {\r\n ans -= md;\r\n }\r\n }\r\n let add = exp(v1, k, md);\r\n ans += add;\r\n if ans >= md {\r\n ans -= md;\r\n }\r\n writeln!(out, \"{}\", ans).ok();\r\n } else {\r\n let v1 = exp(2, n - 1, md) + 1;\r\n let ans = exp(v1, k, md);\r\n writeln!(out, \"{}\", ans).ok();\r\n }\r\n }\r\n return;\r\n}\r\n", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics", "bitmasks", "matrices"], "code_uid": "24145afccdbc202b46504083788b4416", "src_uid": "02f5fe43ea60939dd4a53299b5fa0881", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\r\n\r\nconst N : usize = 200006;\r\nconst P : u64 = 1000000007;\r\ntype Farr = [[u64; 4]; N];\r\ntype Garr = [u64; N];\r\n\r\nfn preprocess(f : &mut Farr, g : &mut Garr) {\r\n f[0][2] = 1;\r\n g[0] = 1;\r\n for i in 0..N-1 {\r\n f[i+1][3] = f[i][2];\r\n f[i+1][2] = f[i][3];\r\n f[i+1][1] = ((f[i][0] + f[i][1]) % P + f[i][3]) % P;\r\n f[i+1][0] = ((f[i][0] + f[i][1]) % P + f[i][2]) % P;\r\n g[i+1] = (g[i] + g[i]) % P;\r\n }\r\n\r\n}\r\n\r\nfn solve(f : &Farr, g : &Garr) {\r\n let mut a_str = String::new();\r\n io::stdin().read_line(&mut a_str).expect(\"read error\");\r\n let vec = a_str.split_whitespace().map(|x| x.parse::().unwrap()).collect::>();\r\n let n = vec[0] as usize;\r\n let k = vec[1] as usize;\r\n let mut win : u64 = 0;\r\n let mut tie : u64 = 1;\r\n for _ in 0..k {\r\n win = (win * g[n] % P + tie * f[n][2]) % P;\r\n tie = ((f[n][0] + f[n][3]) % P * tie) % P;\r\n }\r\n let ans = (win + tie) % P;\r\n println!(\"{}\", ans);\r\n}\r\n\r\nfn main() {\r\n let mut str = String::new();\r\n io::stdin().read_line(&mut str).expect(\"read error\");\r\n let mut f : Farr = [[0u64; 4]; N];\r\n let mut g : Garr = [0u64; N];\r\n preprocess(&mut f, &mut g);\r\n if let Some(s) = str.split_whitespace().next() {\r\n let tests = s.parse::().unwrap();\r\n for _ in 0..tests {\r\n solve(&f, &g);\r\n }\r\n }\r\n}", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics", "bitmasks", "matrices"], "code_uid": "6ab952e597c2c497f3da2a258a8fa96a", "src_uid": "02f5fe43ea60939dd4a53299b5fa0881", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\n\nfn main() {\n stdin().read_line(&mut String::new());\n\n let mut a = String::new();\n stdin().read_line(&mut a).unwrap();\n let a = a.trim();\n\n let mut a: Vec = a\n .chars()\n .filter(|x| x != &'0' && x != &'1')\n .collect();\n\n let mut c = String::new();\n\n for i in a {\n if i == '4' {\n c.push_str(\"223\");\n } else if i == '6' {\n c.push_str(\"53\");\n } else if i == '8' {\n c.push_str(\"7222\");\n } else if i == '9' {\n c.push_str(\"2337\");\n } else {\n c.push(i);\n }\n }\n\n let mut c: Vec = c.chars().map(|x| x.to_digit(10 as u32).unwrap()).collect();\n\n c.sort();\n c.reverse();\n\n for i in c {\n print!(\"{}\", i);\n }\n println!();\n}\n", "lang_cluster": "Rust", "tags": ["math", "sortings", "greedy"], "code_uid": "8f0ce6051eb57b560941fb527527795f", "src_uid": "60dbfc7a65702ae8bd4a587db1e06398", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let _: usize = scan.next();\n let num: String = scan.next();\n let mut cnt = [0usize; 10];\n for c in num.chars() {\n match c {\n '2' => {\n cnt[2] += 1;\n }\n '3' => {\n cnt[3] += 1;\n }\n '4' => {\n cnt[2] += 2;\n cnt[3] += 1;\n }\n '5' => {\n cnt[5] += 1;\n }\n '6' => {\n cnt[3] += 1;\n cnt[5] += 1;\n }\n '7' => {\n cnt[7] += 1;\n }\n '8' => {\n cnt[2] += 3;\n cnt[7] += 1;\n }\n '9' => {\n cnt[2] += 1;\n cnt[3] += 2;\n cnt[7] += 1;\n }\n _ => {}\n }\n }\n for i in (2..10).rev() {\n for _ in 0..cnt[i] {\n print!(\"{}\", i);\n }\n }\n println!();\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["math", "sortings", "greedy"], "code_uid": "b73440d5c35efbe0bedc2ea1666e6778", "src_uid": "60dbfc7a65702ae8bd4a587db1e06398", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn is_prime(x: usize) -> bool {\n for i in 2..=((x as f64).sqrt() as usize) {\n if x % i == 0 {\n return false;\n }\n }\n return true;\n}\n\nfn next_prime(x: usize) -> usize {\n let mut aux = x + 1;\n while !is_prime(aux) {\n aux += 1;\n }\n aux\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let n: usize = scan.next();\n let m: usize = scan.next();\n let result = next_prime(n) == m;\n println!(\"{}\", if result { \"YES\" } else { \"NO\" });\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["brute force"], "code_uid": "3e4c5d9f17e510622983f7cfdb613dd4", "src_uid": "9d52ff51d747bb59aa463b6358258865", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// A. Chess Placing http://codeforces.com/contest/985/problem/A\n\nfn main() {\n let stdin = std::io::stdin();\n let mut buf = String::new();\n stdin.read_line(&mut buf).unwrap(); // discard\n buf.clear();\n stdin.read_line(&mut buf).unwrap();\n let mut arr: Vec = buf.split_whitespace()\n .map(|s| s.parse().unwrap())\n .collect();\n arr[..].sort_unstable();\n let f = |mut m: i32| {\n let mut total = 0;\n for n in &arr {\n total += (n - m).abs();\n m += 2;\n }\n total\n };\n let ans: i32 = vec![1, 2].into_iter().map(f).min().unwrap();\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "1dc8c56bdb34f8693c653e75b7e8d1c4", "src_uid": "0efe9afd8e6be9e00f7949be93f0ca1a", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use io::*;\n\nfn main() {\n let con = read_string();\n let mut sc = Scanner::new(&con);\n\n let n: usize = sc.next();\n let mut ps: Vec = sc.next_vec(n / 2);\n ps.sort();\n\n let mut acc_b = 0;\n let mut acc_w = 0;\n for i in 0..n / 2 {\n acc_b += (ps[i] - 1 - i as i64 * 2).abs();\n acc_w += (ps[i] - 1 - i as i64 * 2 - 1).abs();\n }\n\n println!(\"{}\", acc_b.min(acc_w));\n}\n\n//-----\n\npub mod io {\n use std;\n use std::str::FromStr;\n\n pub struct Scanner<'a> {\n iter: std::str::SplitWhitespace<'a>,\n }\n\n impl<'a> Scanner<'a> {\n pub fn new(s: &'a str) -> Scanner<'a> {\n Scanner {\n iter: s.split_whitespace(),\n }\n }\n\n pub fn next(&mut self) -> T {\n let s = self.iter.next().unwrap();\n if let Ok(v) = s.parse::() {\n v\n } else {\n panic!(\"Parse error\")\n }\n }\n\n pub fn next_vec_len(&mut self) -> Vec {\n let n: usize = self.next();\n self.next_vec(n)\n }\n\n pub fn next_vec(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.next()).collect()\n }\n }\n\n pub fn read_string() -> String {\n use std::io::Read;\n\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n }\n\n pub fn read_line() -> String {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).unwrap();\n s.trim_right().to_owned()\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "0ade5aa0feefd2f570dae67746f8c0c2", "src_uid": "0efe9afd8e6be9e00f7949be93f0ca1a", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let (n, l): (usize, i64) = readln();\n let c: Vec = readln();\n\n let mut rest: i64 = l;\n let mut answer = i64::max_value();\n let mut used: i64 = 0;\n while rest > 0 {\n let over_cost = (0..n).filter(|x| rest <= (1i64 << x)).map(|x| c[x]).min();\n if let Some(over_cost) = over_cost {\n answer = min(answer, used + over_cost);\n }\n let last_idx = (0..n).filter(|x| rest >= (1i64 << x)).last().unwrap();\n let cost = (0..last_idx + 1)\n .map(|x| (1i64 << (last_idx - x)) * c[x])\n .min()\n .unwrap();\n let last_pow = (0..36).filter(|x| rest >= (1i64 << x)).last().unwrap();\n used += cost * 1i64 << (last_pow - last_idx);\n rest -= 1i64 << last_pow;\n }\n answer = min(answer, used);\n println!(\"{}\", answer);\n}\n\n// --- template ---\n#[allow(unused_imports)]\nuse std::cmp::{max, min};\n#[allow(unused_imports)]\nuse std::collections::HashSet;\n\npub trait FromLn {\n fn fromln(s: &str) -> Self;\n}\npub fn readln() -> T {\n let mut buf = String::new();\n let _ = ::std::io::stdin().read_line(&mut buf).unwrap();\n T::fromln(buf.trim())\n}\npub fn readlns(n: usize) -> Vec {\n let mut vs = vec![];\n for _ in 0..n {\n vs.push(readln());\n }\n vs\n}\nmacro_rules! fromln_primitives {\n ($($t:ty),*) => { $(\n impl FromLn for $t {\n fn fromln(s: &str) -> $t {\n s.parse().unwrap()\n }\n }\n )* }\n}\nfromln_primitives!(\n String,\n bool,\n f32,\n f64,\n isize,\n i8,\n i16,\n i32,\n i64,\n usize,\n u8,\n u16,\n u32,\n u64\n);\nimpl FromLn for Vec\nwhere\n T: FromLn,\n{\n fn fromln(s: &str) -> Vec {\n s.split_whitespace().map(T::fromln).collect()\n }\n}\nimpl FromLn for Vec {\n fn fromln(s: &str) -> Vec {\n s.chars().collect()\n }\n}\nmacro_rules! fromln_tuple {\n ($($t:ident),*) => {\n impl<$($t),*> FromLn for ($($t),*) where $($t: FromLn),* {\n fn fromln(s: &str) -> ($($t),*) {\n let mut it = s.split_whitespace();\n let t = ($($t::fromln(it.next().unwrap())),*);\n assert_eq!(it.next(), None);\n t\n }\n }\n }\n}\nfromln_tuple!(A, B);\nfromln_tuple!(A, B, C);\nfromln_tuple!(A, B, C, D);\nfromln_tuple!(A, B, C, D, E);\nfromln_tuple!(A, B, C, D, E, F);\n", "lang_cluster": "Rust", "tags": ["greedy", "dp", "bitmasks"], "code_uid": "421765f8a6564f49bc0693dd7878d541", "src_uid": "04ca137d0383c03944e3ce1c502c635b", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\nuse std::io::{StdinLock, stdin, BufRead};\nuse std::collections::*;\nuse std::cmp::*;\n\nfn scan_helper(lock : &mut StdinLock) -> String {\n let mut buffer = String::new();\n lock.read_line(&mut buffer).ok();\n buffer\n}\n\nmacro_rules! scan {\n ($lock:ident, $t:ty) => ({\n scan_helper(&mut $lock).split_whitespace()\n .next().unwrap()\n .parse::<$t>().unwrap()\n });\n ($lock:ident, $($t:ty),+) => ({\n let buffer = scan_helper(&mut $lock);\n let mut iter = buffer.split_whitespace();\n ($(\n {\n iter.next().unwrap()\n .parse::<$t>().unwrap()\n },\n )+)\n })\n}\n\nmacro_rules! scan_iter {\n ($lock:ident, $t:ty) => ({\n scan_helper(&mut $lock).split_whitespace()\n .map(|x| x.parse::<$t>().unwrap())\n .collect()\n })\n}\n\ntrait Ext {\n fn idx(&self) -> usize;\n fn num(&self) -> i64;\n}\n\nmacro_rules! ext {\n ($t:ty) => (\n impl Ext for $t {\n #[inline]\n fn idx(&self) -> usize {\n *self as usize\n }\n\n #[inline]\n fn num(&self) -> i64 {\n *self as i64\n }\n }\n )\n}\next!(i64);\next!(usize);\n\n\n#[derive(Copy, Clone, Debug)]\nstruct Pair {\n i : usize,\n cost : i64\n}\nimpl PartialOrd for Pair {\n fn partial_cmp(&self, other : &Pair) -> Option {\n Some(self.cost.cmp(&other.cost))\n }\n}\n\nimpl Ord for Pair {\n fn cmp(&self, other : &Pair) -> Ordering {\n self.partial_cmp(other).unwrap()\n }\n}\n\nimpl PartialEq for Pair {\n fn eq(&self, other : &Pair) -> bool {\n self.cost == other.cost\n }\n}\nimpl Eq for Pair {}\n\nfn main() {\n let stdin = stdin();\n let mut s = stdin.lock();\n let (n, k) = scan!(s, usize, i64);\n let mut remaining = 4*60 - k;\n let mut count = 0;\n \n for i in 1..(n+1) {\n if remaining >= 5*i.num() {\n count += 1;\n remaining -= 5*i.num();\n } else {\n break;\n }\n }\n \n println!(\"{}\", count);\n}", "lang_cluster": "Rust", "tags": ["brute force", "math", "implementation", "binary search"], "code_uid": "fe263bf16b5b14c9988136b8d2c9ddff", "src_uid": "41e554bc323857be7b8483ee358a35e2", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut input = String::new();\n io::stdin().read_line(&mut input)\n .expect(\"Failed to read line\");\n\n let split_input : Vec<&str> = input.as_str().split(' ').collect();\n let n : i32 = split_input[0].trim().parse().expect(\"en\"); \n let k : i32 = split_input[1].trim().parse().expect(\"en\"); \n let m : i32 = 240 - k; // left time\n let mut sum : i32 = 0;\n let mut counter : i32 = 0;\n for i in 1 .. (n + 1) {\n if sum + i * 5 > m {\n break;\n } else {\n sum += i * 5;\n counter += 1;\n }\n }\n println!(\"{}\", counter);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "implementation", "binary search"], "code_uid": "26b08c776981bc13e22fb9f8103b36f0", "src_uid": "41e554bc323857be7b8483ee358a35e2", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, BufRead, Write};\n\nfn solve(mut input: I, mut output: O) {\n let from = read_time(&mut input);\n let to = read_time(&mut input);\n let from_minutes = from.0 * 60 + from.1;\n let to_minutes = to.0 * 60 + to.1;\n let mid_minutes = (to_minutes + from_minutes) / 2;\n let mid = (mid_minutes / 60, mid_minutes % 60);\n writeln!(output, \"{:02}:{:02}\", mid.0, mid.1).unwrap();\n}\n\nfn read_time(mut input: I) -> (i32, i32) {\n let mut time = String::new();\n input.read_line(&mut time).unwrap();\n let time: Vec = time.split(':').map(|x| x.trim().parse().unwrap()).collect();\n (time[0], time[1])\n}\n\n#[cfg(test)]\nmod tests {\n #[test]\n fn example1() {\n assert_eq!(solve(\"10:00\\n11:00\\n\"), \"10:30\\n\");\n }\n\n #[test]\n fn example2() {\n assert_eq!(solve(\"11:10\\n11:12\\n\"), \"11:11\\n\");\n }\n\n #[test]\n fn example3() {\n assert_eq!(solve(\"01:02\\n03:02\\n\"), \"02:02\\n\");\n }\n\n fn solve(input: &str) -> String {\n let mut output = Vec::new();\n super::solve(input.as_bytes(), &mut output);\n String::from_utf8(output).unwrap()\n }\n}\n\nfn main() {\n let input = io::stdin();\n let input = input.lock();\n let output = io::stdout();\n let output = output.lock();\n solve(input, output)\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "3acbf8fb34d100ea118080ba02634e96", "src_uid": "f7a32a8325ce97c4c50ce3a5c282ec50", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[derive(Debug, Eq, PartialEq, Clone, Copy)]\nstruct Time {\n h: u16,\n m: u16\n}\n\nfn parse_time(s: &str) -> Option::Err: Debug,\n B: FromStr,\n ::Err: Debug,\n{\n let s = read_stdin();\n let mut s = s.split_whitespace();\n let a = s.next().unwrap().parse::().unwrap();\n let b = s.next().unwrap().parse::().unwrap();\n (a, b)\n}\n\nfn read_3() -> (A, B, C)\nwhere\n A: FromStr,\n ::Err: Debug,\n B: FromStr,\n ::Err: Debug,\n C: FromStr,\n ::Err: Debug,\n{\n let s = read_stdin();\n let mut s = s.split_whitespace();\n let a = s.next().unwrap().parse::().unwrap();\n let b = s.next().unwrap().parse::().unwrap();\n let c = s.next().unwrap().parse::().unwrap();\n (a, b, c)\n}\n\nfn read_4() -> (A, B, C, D)\nwhere\n A: FromStr,\n ::Err: Debug,\n B: FromStr,\n ::Err: Debug,\n C: FromStr,\n ::Err: Debug,\n D: FromStr,\n ::Err: Debug,\n{\n let s = read_stdin();\n let mut s = s.split_whitespace();\n let a = s.next().unwrap().parse::().unwrap();\n let b = s.next().unwrap().parse::().unwrap();\n let c = s.next().unwrap().parse::().unwrap();\n let d = s.next().unwrap().parse::().unwrap();\n (a, b, c, d)\n}\n\nfn read_multiple() -> Vec\nwhere\n ::Err: Debug,\n{\n read_stdin()\n .split_whitespace()\n .map(|x| x.parse::().expect(\"cannot parse stdin\"))\n .collect()\n}\n\n/// NOTE: sort iter beforehand if required\nfn count(iter: &mut impl Iterator) -> Vec<(T, usize)>\nwhere\n T: std::cmp::Ord,\n{\n let iter = iter.collect::>();\n //iter.sort();\n let (mut v, o, c) =\n iter.into_iter()\n .fold((Vec::new(), None, 0), |(mut v, last, count), item| {\n if let Some(o) = last {\n if item == o {\n (v, Some(o), count + 1)\n } else {\n v.push((o, count));\n (v, Some(item), 1)\n }\n } else {\n (v, Some(item), 1)\n }\n });\n if let Some(i) = o {\n v.push((i, c));\n }\n v\n}\n\nfn max_subarray(v: impl Iterator) -> (i64, (usize, usize)) {\n //assert!(v.len() > 0);\n let mut best_sum = 0;\n let (mut best_start, mut best_end) = (0, 0);\n let mut current_sum = 0;\n let mut current_start = 0;\n for (end, val) in v.enumerate() {\n if current_sum <= 0 {\n current_start = end;\n current_sum = val;\n } else {\n current_sum += val;\n }\n if current_sum > best_sum {\n best_sum = current_sum;\n best_start = current_start;\n best_end = end + 1;\n }\n }\n (best_sum, (best_start, best_end))\n}\n\nfn gcd(mut a: u64, mut b: u64) -> u64 {\n while a != 0 {\n let old_m = a;\n a = b % a;\n b = old_m;\n }\n b\n}\n\n/// returns gcd, and pair (x, y), such that x * a + b * y == gcd\nfn egcd(a: i64, b: i64) -> (i64, i64, i64) {\n if a == 0 {\n (b, 0, 1)\n } else {\n let (g, x, y) = egcd(b % a, a);\n (g, y - (b / a) * x, x)\n }\n}\n\nfn factorize(mut n: u64) -> Vec {\n if n <= 3 {\n return vec![n];\n }\n let mut v = Vec::new();\n while n % 2 == 0 {\n n /= 2;\n v.push(2);\n }\n while n % 3 == 0 {\n n /= 3;\n v.push(3);\n }\n let mut f = 6;\n while (f - 1) * (f - 1) <= n {\n while n % (f - 1) == 0 {\n n /= f - 1;\n v.push(f - 1);\n }\n while n % (f + 1) == 0 {\n n /= f + 1;\n v.push(f + 1);\n }\n f += 6;\n }\n if n > 1 {\n v.push(n);\n }\n v\n}\n\nfn compact_factors(n: u64) -> Vec<(u64, usize)> {\n count(&mut factorize(n).into_iter())\n}\n\nfn all_factors(n: u64) -> Vec {\n if n == 0 {\n return vec![0];\n } else if n == 1 {\n return vec![1];\n }\n let factors = compact_factors(n);\n let mut v = vec![1];\n for (fac, num) in factors {\n let ori = v.clone();\n for i in 1..num + 1 {\n v.append(\n &mut ori\n .clone()\n .into_iter()\n .map(|f| f * fac.pow(i as u32))\n .collect::>(),\n )\n }\n }\n v.sort();\n v\n}\n\nfn abs_diff(a: T, b: T) -> T\nwhere\n T: PartialOrd + std::ops::Sub,\n{\n if a > b {\n a - b\n } else {\n b - a\n }\n}\n\nstruct Permutations {\n inner: Vec,\n state: Vec,\n i: usize,\n start: bool,\n}\n\nimpl Permutations {\n fn new(inner: Vec) -> Self {\n Self {\n state: vec![0; inner.len()],\n i: 0,\n start: true,\n inner,\n }\n }\n}\n\n/*impl From for Permutations\nwhere\n X: IntoIterator,\n{\n fn from(f: X) -> Self {\n Self::new(f.into_iter().collect::>())\n }\n}*/\n\nimpl Iterator for Permutations\nwhere\n T: Clone,\n{\n type Item = Vec;\n fn next(&mut self) -> Option {\n if self.start {\n self.start = false;\n return Some(self.inner.clone());\n }\n while self.i < self.inner.len() {\n if self.state[self.i] < self.i {\n if self.i % 2 == 0 {\n self.inner.swap(0, self.i)\n } else {\n self.inner.swap(self.state[self.i], self.i)\n }\n self.state[self.i] += 1;\n self.i = 0;\n return Some(self.inner.clone());\n } else {\n self.state[self.i] = 0;\n self.i += 1;\n }\n }\n None\n }\n}\n\nuse std::cmp::{max, min, Ord, Ordering};\nuse std::collections::{BinaryHeap, VecDeque};\nuse std::mem::swap;\n\nfn main() -> Result<(), Box> {\n let s = read_stdin().chars().collect::>();\n let t = read_stdin().chars().collect::>();\n let mut front = Vec::new();\n let mut pointer = 0;\n for c in t.iter() {\n while s[pointer] != *c {\n pointer += 1;\n }\n front.push(pointer);\n pointer += 1;\n }\n let mut back = Vec::new();\n let mut pointer = s.len() - 1;\n for c in t.iter().rev() {\n while s[pointer] != *c {\n pointer -= 1;\n }\n back.push(pointer);\n if pointer > 0 {\n pointer -= 1;\n }\n }\n back.reverse();\n //println!(\"{:?}\", front);\n //println!(\"{:?}\", back);\n let mut res = s.len() - front.last().unwrap() - 1;\n // println!(\"{} {}\", res, back[0]);\n res = max(res, back[0]);\n for (f, b) in front.into_iter().zip(back.into_iter().skip(1)) {\n //println!(\"{} {}\", b, f);\n res = max(res, b - f - 1)\n }\n println!(\"{}\", res);\n Ok(())\n}\n", "lang_cluster": "Rust", "tags": ["greedy", "implementation"], "code_uid": "28849069ccc80d252e61dc6ffdf3eb2a", "src_uid": "0fd33e1bdfd6c91feb3bf00a2461603f", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\nuse std::collections;\nuse std::io;\n\nstruct Input {\n buffer: collections::VecDeque,\n}\n\nimpl Input {\n fn new() -> Input {\n Input {\n buffer: collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n while self.buffer.len() == 0 {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).ok();\n for word in line.split_whitespace() {\n self.buffer.push_back(word.to_string())\n }\n }\n\n let front = self.buffer.pop_front().unwrap();\n front.parse::().ok().unwrap()\n }\n}\n\nfn main() {\n let mut input = Input::new();\n let rook_str: String = input.next();\n let knight_str: String = input.next();\n\n let rook_pos = (\n rook_str.chars().nth(0).unwrap() as i32 - 'a' as i32,\n rook_str.chars().nth(1).unwrap() as i32 - '1' as i32,\n );\n\n let knight_pos = (\n knight_str.chars().nth(0).unwrap() as i32 - 'a' as i32,\n knight_str.chars().nth(1).unwrap() as i32 - '1' as i32,\n );\n\n let mut count = 8 * 8;\n\n for j in 0..8 {\n for k in 0..8 {\n if rook_pos.0 == j || rook_pos.1 == k {\n count -= 1;\n } else if knight_pos.0 == j && knight_pos.1 == k {\n count -= 1;\n } else if (rook_pos.0 - j).abs() == 2 && (rook_pos.1 - k).abs() == 1 {\n count -= 1;\n } else if (rook_pos.0 - j).abs() == 1 && (rook_pos.1 - k).abs() == 2 {\n count -= 1;\n } else if (knight_pos.0 - j).abs() == 2 && (knight_pos.1 - k).abs() == 1 {\n count -= 1;\n } else if (knight_pos.0 - j).abs() == 1 && (knight_pos.1 - k).abs() == 2 {\n count -= 1;\n }\n }\n }\n\n println!(\"{:?}\", count);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "implementation"], "code_uid": "f50ebbfd392f5ea4d327f76ec2fb01e8", "src_uid": "073023c6b72ce923df2afd6130719cfc", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan { buffer: std::collections::VecDeque::new() }\n }\n\n fn next(&mut self)-> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n\n fn next_n(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.next::()).collect()\n }\n\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let k: usize = scan.next();\n let mut arr: Vec = scan.next_n(12);\n arr.sort();\n arr.reverse();\n let mut index = 1;\n let mut acc = arr[0];\n while acc < k && index < 12 {\n acc += arr[index];\n index += 1;\n }\n if acc < k {\n println!(\"-1\");\n } else if k == 0 {\n println!(\"0\");\n } else {\n println!(\"{}\", index);\n }\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1<<23).spawn(_main).unwrap().join().unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["sortings", "implementation", "greedy"], "code_uid": "b3358f3f1ba73324c7855ab38f127360", "src_uid": "59dfa7a4988375febc5dccc27aca90a8", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\n#[allow(unused_macros)]\nmacro_rules! a {\n ($c: tt, $x: expr, $y: expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\nuse std::str::*;\nuse std::fmt::Debug;\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a>, }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).unwrap();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, std::io::stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n\nfn main() {\n let mut buffer = String::new();\n let mut input = WordReader::from_stdin(&mut buffer);\n\n let k = input.i();\n let mut a = input.vp::(12);\n a.sort();\n a.reverse();\n let sol = (|| {\n if k == 0 { return 0; }\n let mut sum = 0;\n for i in 0..12 {\n sum += a[i as usize];\n if sum >= k {\n return i + 1;\n }\n }\n -1\n })();\n println!(\"{}\", sol);\n}\n\n", "lang_cluster": "Rust", "tags": ["sortings", "implementation", "greedy"], "code_uid": "3e36cfb8f152ab4fcab4e8757b8e9901", "src_uid": "59dfa7a4988375febc5dccc27aca90a8", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n\tlet mut k = String::new();\n\tio::stdin().read_line(&mut k).unwrap();\n\tlet k: i32 = k.trim().parse().unwrap();\n\n\tlet mut l = String::new();\n\tio::stdin().read_line(&mut l).unwrap();\n\tlet l: i32 = l.trim().parse().unwrap();\n\n\tlet mut m = String::new();\n\tio::stdin().read_line(&mut m).unwrap();\n\tlet m: i32 = m.trim().parse().unwrap();\n\n\tlet mut n = String::new();\n\tio::stdin().read_line(&mut n).unwrap();\n\tlet n: i32 = n.trim().parse().unwrap();\n\n\tlet mut d = String::new();\n\tio::stdin().read_line(&mut d).unwrap();\n\tlet d: i32 = d.trim().parse().unwrap();\n\n\tlet mut ans = 0;\n\tfor i in 1..=d {\n\t\tif i % k == 0 || i % l == 0 || i % m == 0 || i % n == 0 {\n\t\t\tans += 1;\n\t\t}\n\t}\n\n\tprintln!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["math", "constructive algorithms", "implementation"], "code_uid": "2bb228ec77b02bca439637840b44efc8", "src_uid": "46bfdec9bfc1e91bd2f5022f3d3c8ce7", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{min,max};\nuse std::io::{BufWriter, stdin, stdout, Write};\n\n#[derive(Default)]\nstruct Scanner {\n buffer: Vec\n}\nimpl Scanner {\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n stdin().read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn main() {\n let mut scan = Scanner::default();\n let out = &mut BufWriter::new(stdout());\n\n\tlet k = scan.next::();\n\tlet l = scan.next::();\n\tlet m = scan.next::();\n\tlet n = scan.next::();\n\tlet d = scan.next::();\n\n let res = (1..=d).filter(|x| x % k == 0 || x % l == 0 || x % m == 0 || x % n == 0).count();\n writeln!(out, \"{}\", res).expect(\"fail\");\n}\n", "lang_cluster": "Rust", "tags": ["math", "constructive algorithms", "implementation"], "code_uid": "cb3ab7ca3cd79fdef9ac4bc45adef34d", "src_uid": "46bfdec9bfc1e91bd2f5022f3d3c8ce7", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::BufRead;\n\nfn read_problem(br: R) -> Vec {\n let mut lines = br.lines();\n\n let node_ct: usize = str::parse(&lines.next().unwrap().unwrap()).unwrap();\n let mut nodes = Vec::::with_capacity(node_ct);\n nodes.extend(lines.next().unwrap().unwrap().split_whitespace()\n .map(str::parse::)\n .map(|n| n.unwrap()-1));\n assert!(nodes.len() == node_ct);\n assert!(lines.next().is_none());\n nodes\n}\n\nfn gcd(mut a: u64, mut b: u64) -> u64 {\n if a == 0 || b == 0 {\n return a | b;\n }\n let shift = (a|b).trailing_zeros();\n a >>= a.trailing_zeros();\n while b != 0 {\n b >>= b.trailing_zeros();\n if a > b {\n std::mem::swap(&mut a, &mut b);\n }\n b -= a;\n }\n return a << shift;\n}\n\nfn solve(nodes: Vec) -> u64 {\n let mut state = nodes.iter().map(|_| false).collect::>();\n let mut solution = 1u64;\n\n // state is (cycle#,index); cycle# starts at 1; 0 is uninitialized\n for start in 0..state.len() {\n if state[start] {\n continue;\n }\n let mut index = start;\n let mut len = 0u64;\n while !state[index] {\n state[index] = true;\n index = nodes[index];\n len += 1;\n }\n if index != start {\n return 0;\n }\n if len&1 == 0 {\n len >>= 1;\n }\n solution = solution/gcd(solution,len) * len;\n }\n\n solution\n}\n\nfn main() {\n let stdin = std::io::stdin();\n let nodes = read_problem(stdin.lock());\n let sol = solve(nodes);\n if sol == 0 {\n println!(\"-1\");\n } else {\n println!(\"{}\", sol);\n }\n}\n", "lang_cluster": "Rust", "tags": ["dfs and similar", "math"], "code_uid": "9d3afa6f2fc62eb49ace1fd1301be4b5", "src_uid": "149221131a978298ac56b58438df46c9", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_macros)]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n let mut next = || { iter.next().unwrap() };\n input_inner!{next, $($r)*}\n };\n ($($r:tt)*) => {\n let stdin = std::io::stdin();\n let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));\n let mut next = move || -> String{\n bytes\n .by_ref()\n .map(|r|r.unwrap() as char)\n .skip_while(|c|c.is_whitespace())\n .take_while(|c|!c.is_whitespace())\n .collect()\n };\n input_inner!{next, $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! input_inner {\n ($next:expr) => {};\n ($next:expr, ) => {};\n\n ($next:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n\n ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! read_value {\n ($next:expr, ( $($t:tt),* )) => {\n ( $(read_value!($next, $t)),* )\n };\n\n ($next:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($next, $t)).collect::>()\n };\n\n ($next:expr, chars) => {\n read_value!($next, String).chars().collect::>()\n };\n\n ($next:expr, usize1) => {\n read_value!($next, usize) - 1\n };\n\n ($next:expr, $t:ty) => {\n $next().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($a:expr),*) => {\n #[cfg(debug_assertions)]\n writeln!(&mut std::io::stderr(), concat!(\"[DEBUG] \", $(stringify!($a), \"={:?} \"),*), $($a),*);\n }\n}\n\n#[allow(unused_imports)]\nuse std::cmp::{min, max};\n\n#[allow(unused_imports)]\nuse std::io::Write;\ntype I = usize;\n\nfn main() {\n input!{\n n: usize,\n s: chars,\n }\n\n let mut cur = 0i64;\n for i in 0..n {\n if s[i] == '+' {\n cur += 1;\n } else {\n cur = max(cur-1, 0);\n }\n }\n println!(\"{}\", cur);\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "bf7cc8ab13ebddbf8e95b3969a52e48c", "src_uid": "a593016e4992f695be7c7cd3c920d1ed", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{stdin, Read, StdinLock};\nuse std::str::FromStr;\n#[allow(unused_imports)]\nuse std::cmp;\n\nstruct Scanner<'a> {\n cin : StdinLock<'a>,\n}\n\nimpl<'a> Scanner<'a> {\n fn new(cin : StdinLock<'a>) -> Scanner<'a> {\n Scanner { cin: cin }\n }\n\n fn read1(&mut self) -> Option {\n let token = self.cin.by_ref().bytes().map(|c| c.unwrap() as char)\n .skip_while(|c| c.is_whitespace())\n .take_while(|c| !c.is_whitespace())\n .collect::();\n token.parse::().ok()\n }\n\n fn read(&mut self) -> T {\n self.read1().unwrap()\n }\n}\n\nfn main(){\n\tlet cin = stdin();\n\tlet cin = cin.lock();\n\tlet mut sc = Scanner::new(cin);\n\tlet _ : usize = sc.read();\n let s : String = sc.read();\n let mut ans : usize = 0;\n for i in s.chars() {\n match i {\n '+' => ans += 1,\n '-' => if ans != 0 { ans -= 1; },\n _ => (),\n }\n }\n println!(\"{}\", ans);\n \n\n\n\n}\n\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "5f90815f7198c0e45182e32ae9041f88", "src_uid": "a593016e4992f695be7c7cd3c920d1ed", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_macros)]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n let mut next = || { iter.next().unwrap() };\n input_inner!{next, $($r)*}\n };\n ($($r:tt)*) => {\n let stdin = std::io::stdin();\n let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));\n let mut next = move || -> String{\n bytes\n .by_ref()\n .map(|r|r.unwrap() as char)\n .skip_while(|c|c.is_whitespace())\n .take_while(|c|!c.is_whitespace())\n .collect()\n };\n input_inner!{next, $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! input_inner {\n ($next:expr) => {};\n ($next:expr, ) => {};\n\n ($next:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n\n ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {\n let mut $var = read_value!($next, $t);\n input_inner!{$next $($r)*}\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! read_value {\n ($next:expr, ( $($t:tt),* )) => {\n ( $(read_value!($next, $t)),* )\n };\n\n ($next:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($next, $t)).collect::>()\n };\n\n ($next:expr, chars) => {\n read_value!($next, String).chars().collect::>()\n };\n\n ($next:expr, usize1) => {\n read_value!($next, usize) - 1\n };\n\n ($next:expr, $t:ty) => {\n $next().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($($a:expr),*) => {\n #[cfg(debug_assertions)]\n writeln!(&mut std::io::stderr(), concat!(\"[DEBUG] \", $(stringify!($a), \"={:?} \"),*), $($a),*);\n }\n}\n\n#[allow(unused_imports)]\nuse std::cmp::{min, max};\n#[allow(unused_imports)]\nuse std::io::{stdout, stdin, BufWriter, Write};\n\nfn main() {\n let out = std::io::stdout();\n let mut out = BufWriter::new(out.lock());\n macro_rules! puts {\n ($($format:tt)*) => (write!(out,$($format)*).unwrap());\n }\n\n input!{\n mut s: chars,\n }\n s.reverse();\n\n let mut ans = 0;\n let mut ones = 0;\n for i in 0..s.len() {\n if s[i] == '1' {\n ones += 1;\n }\n }\n let mut ans = (s.len() + 1) / 2;\n if s.len()%2 == 1 {\n if ones <= 1 {\n ans -= 1;\n }\n }\n puts!(\"{}\\n\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "84c4eb16e20af70d898997e0645bc130", "src_uid": "d8ca1c83b431466eff6054d3b422ab47", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, Stdin};\nuse std::str::{self, FromStr};\nuse std::error::Error;\n\nfn exec() {\n let mut sc = Scanner::new();\n let a: u64 = sc.ne();\n let b: u64 = sc.ne();\n let mut cnt = 0;\n for i in 0..64 {\n let k = (1 << i) - 1;\n for j in 0..i - 1 {\n let aim = k ^ (1 << j);\n // println!(\"{:b}\", aim);\n if a <= aim && aim <= b {\n cnt += 1;\n }\n }\n }\n println!(\"{}\", cnt);\n}\n\nfn main() {\n const STACK: usize = 16 * 1024 * 1024;\n let _ = std::thread::Builder::new()\n .stack_size(STACK)\n .spawn(|| { exec(); })\n .unwrap()\n .join()\n .unwrap();\n}\n\n#[allow(dead_code)]\nstruct Scanner {\n stdin: Stdin,\n id: usize,\n buf: Vec,\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new() -> Scanner {\n Scanner {\n stdin: io::stdin(),\n id: 0,\n buf: Vec::new(),\n }\n }\n fn next_line(&mut self) -> Option {\n let mut res = String::new();\n match self.stdin.read_line(&mut res) {\n Ok(0) => None,\n Ok(_) => Some(res),\n Err(why) => panic!(\"error in read_line: {}\", why.description()),\n }\n }\n fn next(&mut self) -> Option {\n while self.buf.len() == 0 {\n self.buf = match self.next_line() {\n Some(r) => {\n self.id = 0;\n r.trim().as_bytes().to_owned()\n }\n None => return None,\n };\n }\n let l = self.id;\n assert!(self.buf[l] != b' ');\n let n = self.buf.len();\n let mut r = l;\n while r < n && self.buf[r] != b' ' {\n r += 1;\n }\n let res = match str::from_utf8(&self.buf[l..r]).ok().unwrap().parse::() {\n Ok(s) => Some(s),\n Err(_) => {\n panic!(\"parse error, {:?}\",\n String::from_utf8(self.buf[l..r].to_owned()))\n }\n };\n while r < n && self.buf[r] == b' ' {\n r += 1;\n }\n if r == n {\n self.buf.clear();\n } else {\n self.id = r;\n }\n res\n }\n fn ne(&mut self) -> T {\n self.next::().unwrap()\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation", "bitmasks"], "code_uid": "5ef100f4c90a88b576f98f425bf052d5", "src_uid": "581f61b1f50313bf4c75833cefd4d022", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn input_sum() -> f32 {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n buf.trim()\n .split_whitespace()\n .map(|elem| elem.parse::().unwrap())\n .sum()\n}\n\nfn main() {\n print!(\n \"{}\",\n if (input_sum() / 5f32).ceil() + (input_sum() / 10f32).ceil() <= input_sum() {\n \"YES\"\n } else {\n \"NO\"\n }\n )\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "584cfd760caf3238b27da3fe8a84e1e6", "src_uid": "fe6301816dea7d9cea1c3a06a7d1ea7e", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut input = String::new();\n use std::io;\n use std::io::prelude::*;\n io::stdin().read_to_string(&mut input).unwrap();\n\n let n: u64 = input.trim().parse().unwrap();\n\n let bc = n.next_power_of_two().trailing_zeros();\n\n let mut cb = 1;\n let mut ans = 0;\n for _ in 0..bc {\n let t = cb * ((n - 1 + cb) / (cb << 1));\n ans += t;\n cb <<= 1;\n }\n\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp", "bitmasks", "graphs", "implementation"], "code_uid": "cb81937bb4585e29471d57961d9939d5", "src_uid": "a98f0d924ea52cafe0048f213f075891", "difficulty": 1900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut kbd = String::new();\n\n io::stdin().read_line(&mut kbd).expect(\"WHY!\");\n\n let kbd:u64 = kbd.trim().parse().expect(\"WHY!\");\n\n if kbd > 0 {\n println!(\"25\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["number theory"], "code_uid": "57b507d9890aa441ae2bc135b27d84d9", "src_uid": "dcaff75492eafaf61d598779d6202c9d", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max,min};\n#[allow(unused_imports)]\nuse std::collections::{HashMap,HashSet,VecDeque};\n\n#[allow(unused_macros)]\nmacro_rules! readln {\n () => {{\n use std::io;\n \n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim().to_string()\n }};\n ( $t:ty ) => {{\n let input = readln!();\n input.parse::<$t>().unwrap()\n }};\n ( $( $t:ty ),+ ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n (\n $(\n input.next().unwrap().parse::<$t>().unwrap(),\n )+\n )\n }}\n}\n\n#[allow(unused_macros)]\nmacro_rules! readvec {\n ( $t:ty ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n let mut result = Vec::new();\n for elem in input {\n result.push(elem.parse::<$t>().unwrap());\n }\n result\n }}\n}\n\nfn main() {\n let (a,b,s) = readln!(i32,i32,i32);\n println!(\"{}\", if s >= a.abs()+b.abs() && ((s-(a.abs()+b.abs()))%2) == 0 { \"Yes\" } else { \"No\" });\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "39caf1c293f6cfdd9462c779ad1e76d4", "src_uid": "9a955ce0775018ff4e5825700c13ed36", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str;\n\npub struct Scanner {\n reader: R,\n buffer: Vec,\n}\n\nimpl Scanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buffer: vec![],\n }\n }\n\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn is_prime(n: i64) -> bool {\n let mut d = 2;\n while d * d <= n {\n if n % d == 0 {\n return false;\n }\n d += 1;\n }\n true\n}\n\nfn solve(scan: &mut Scanner, out: &mut W) {\n let t: u32 = scan.token();\n for _ in 0..t {\n let a: i64 = scan.token();\n let b: i64 = scan.token();\n if a - b == 1 && is_prime(a + b) {\n writeln!(out, \"YES\").ok();\n } else {\n writeln!(out, \"NO\").ok();\n }\n }\n}\n\nfn main() {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout.lock());\n solve(&mut scan, &mut out);\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "b2e0d483c720829f046dd76101a117f6", "src_uid": "5a052e4e6c64333d94c83df890b1183c", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\nuse std::io::{StdinLock, stdin, BufRead};\nuse std::collections::*;\nuse std::cmp::*;\n\nfn scan_helper(lock : &mut StdinLock) -> String {\n let mut buffer = String::new();\n lock.read_line(&mut buffer).ok();\n buffer\n}\n\nmacro_rules! scan {\n ($lock:ident, $t:ty) => ({\n scan_helper(&mut $lock).split_whitespace()\n .next().unwrap()\n .parse::<$t>().unwrap()\n });\n ($lock:ident, $($t:ty),+) => ({\n let buffer = scan_helper(&mut $lock);\n let mut iter = buffer.split_whitespace();\n ($(\n {\n iter.next().unwrap()\n .parse::<$t>().unwrap()\n },\n )+)\n })\n}\n\nmacro_rules! scan_iter {\n ($lock:ident, $t:ty) => ({\n scan_helper(&mut $lock).split_whitespace()\n .map(|x| x.parse::<$t>().unwrap())\n .collect()\n })\n}\n\ntrait Ext {\n fn idx(&self) -> usize;\n fn num(&self) -> i64;\n}\n\nmacro_rules! ext {\n ($t:ty) => (\n impl Ext for $t {\n #[inline]\n fn idx(&self) -> usize {\n *self as usize\n }\n\n #[inline]\n fn num(&self) -> i64 {\n *self as i64\n }\n }\n )\n}\next!(i64);\next!(usize);\n\n\nfn main() {\n let stdin = stdin();\n let mut s = stdin.lock();\n let (m, s) = scan!(s, usize, i64);\n let mut smallest = vec![0; m];\n let mut largest = vec![0; m];\n let lower_bound = if m == 1 { 0 } else { 1 };\n let upper_bound = (9*m).num();\n\n if s >= lower_bound && s <= upper_bound {\n let mut temp = s;\n for i in 0..m {\n if temp > 9 {\n largest[i] = 9;\n temp -= 9;\n } else {\n largest[i] = temp;\n break;\n }\n }\n\n temp = s;\n for i in (0..m).rev() {\n if temp > 9 {\n smallest[i] = 9;\n temp -= 9;\n } else {\n smallest[i] = temp - 1;\n smallest[0] += 1;\n break;\n }\n }\n\n let mut flag = false;\n for i in 0..m {\n if smallest[i] != 0 || flag {\n flag = true;\n print!(\"{}\", smallest[i]);\n } \n }\n if !flag {\n print!(\"0\");\n }\n print!(\" \");\n\n flag = false;\n for i in 0..m {\n if largest[i] != 0 || flag {\n flag = true;\n print!(\"{}\", largest[i]);\n }\n }\n if !flag {\n print!(\"0\");\n }\n } else {\n println!(\"-1 -1\");\n }\n}", "lang_cluster": "Rust", "tags": ["greedy", "dp", "implementation"], "code_uid": "d6151f0b18d722ffcc23b2e4d26f3788", "src_uid": "75d062cece5a2402920d6706c655cad7", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::collections::HashMap;\n\nfn main() {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).unwrap();\n let n : i64 = s.trim().parse().unwrap();\n s = String::new();\n std::io::stdin().read_line(&mut s).unwrap();\n let m : i64 = s.trim().parse().unwrap();\n let mut count = 0;\n let mut a = n;\n let mut ispower = true;\n let mut log = 0;\n let mut dp = HashMap::new();\n dp.insert(1,0);\n loop {\n if (m%a!=0) {\n ispower = false;\n break;\n }\n \n count+=1;\n if (m/a,\n}\n\nimpl Scanner {\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn main() {\n let mut scanner = Scanner::default();\n let braille: std::collections::HashMap, &str> = vec![\n (vec![1, 0, 0, 1, 0], \"a\"),\n (vec![1, 1, 0, 2, 0], \"b\"),\n (vec![2, 0, 0, 1, 1], \"c\"),\n (vec![2, 1, 0, 1, 2], \"d\"),\n (vec![1, 1, 0, 1, 1], \"e\"),\n (vec![2, 1, 0, 2, 1], \"f\"),\n (vec![2, 2, 0, 2, 2], \"g\"),\n (vec![1, 2, 0, 2, 1], \"h\"),\n (vec![1, 2, 0, 1, 2], \"j\"),\n (vec![1, 0, 1, 2, 0], \"k\"),\n (vec![1, 1, 1, 3, 0], \"l\"),\n (vec![2, 0, 1, 2, 1], \"m\"),\n (vec![2, 1, 1, 2, 2], \"n\"),\n (vec![1, 1, 1, 2, 1], \"o\"),\n (vec![2, 1, 1, 3, 1], \"p\"),\n (vec![2, 2, 1, 3, 2], \"q\"),\n (vec![1, 2, 1, 3, 1], \"r\"),\n (vec![1, 2, 1, 2, 2], \"t\"),\n (vec![1, 0, 2, 2, 1], \"u\"),\n (vec![1, 1, 2, 3, 1], \"v\"),\n (vec![2, 0, 2, 2, 2], \"x\"),\n (vec![2, 1, 2, 2, 3], \"y\"),\n (vec![1, 1, 2, 2, 2], \"z\"),\n (vec![0, 0, 0, 0, 0], \" \"),\n (vec![1, 2, 1, 1, 3], \"w\"),\n (vec![1, 0, 1, 1, 1], \"ch\"),\n (vec![2, 0, 1, 1, 2], \"sh\"),\n (vec![2, 1, 1, 1, 3], \"th\"),\n (vec![1, 1, 1, 1, 2], \"wh\"),\n (vec![2, 2, 1, 2, 3], \"er\"),\n ]\n .into_iter()\n .collect();\n let n = scanner.next();\n println!(\n \"{}\",\n (0..n)\n .map(\n |_| braille[&(0..5).map(|_| scanner.next::()).collect::>()]\n .to_string()\n )\n .collect::>()\n .join(\"\")\n )\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "07b8dfed76524b0c27b8c6bce6b3ccad", "src_uid": "a3603f5ed0d8bdb7fe829342991b78e6", "difficulty": 2600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).expect(\"input: read line failed\");\n\n let vec = input.trim().split_whitespace().map(|item| {\n item.parse::().unwrap()\n }).collect::>();\n\n if vec[0] > vec[1] + vec[2] {\n println!(\"+\");\n } else if vec[0] + vec[2] < vec[1] {\n println!(\"-\");\n } else if vec[0] == vec[1] && vec[2] == 0 {\n println!(\"0\");\n } else {\n println!(\"?\");\n }\n}", "lang_cluster": "Rust", "tags": ["greedy"], "code_uid": "5d51ca5c3f7b890de8b4acf9c2e8a084", "src_uid": "66398694a4a142b4a4e709d059aca0fa", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\r\n #![allow(unused_imports, unused_macros)]\r\n prepare_io!(_in_buf, scanner, _out);\r\n macro_rules ! print { ($ ($ arg : tt) *) => (:: std :: write ! (_out , $ ($ arg) *) . expect (\"io error\")) }\r\n macro_rules ! println { ($ ($ arg : tt) *) => (:: std :: writeln ! (_out , $ ($ arg) *) . expect (\"io error\")) }\r\n scan!(scanner, n);\r\n let pt = PrimeTable::new(n as _);\r\n let mut ans = M::zero();\r\n let mut acc = M::zero();\r\n for i in 1..=n {\r\n let c = pt.count_divisors(i as _);\r\n ans = acc + M::from(c);\r\n acc += ans;\r\n }\r\n println!(\"{}\", ans);\r\n}\r\npub type M = mint_basic::MInt998244353;\r\n#[macro_export]\r\nmacro_rules! prepare_io {\r\n ($ in_buf : ident , $ scanner : ident , $ out : ident) => {\r\n use std::io::{stdout, BufWriter, Write as _};\r\n let $in_buf = read_stdin_all_unchecked();\r\n let mut $scanner = Scanner::new(&$in_buf);\r\n let $out = stdout();\r\n let mut $out = BufWriter::new($out.lock());\r\n };\r\n}\r\npub fn echo(\r\n mut writer: impl std::io::Write,\r\n iter: impl IntoIterator,\r\n sep: impl std::fmt::Display,\r\n) -> std::io::Result<()> {\r\n let mut iter = iter.into_iter();\r\n if let Some(item) = iter.next() {\r\n write!(writer, \"{}\", item)?;\r\n }\r\n for item in iter {\r\n write!(writer, \"{}{}\", sep, item)?;\r\n }\r\n writeln!(writer)\r\n}\r\npub fn read_stdin_all_unchecked() -> String {\r\n use std::io::Read as _;\r\n let mut buf = Vec::new();\r\n std::io::stdin().read_to_end(&mut buf).expect(\"io error\");\r\n unsafe { String::from_utf8_unchecked(buf) }\r\n}\r\npub fn read_stdin_line() -> String {\r\n let mut s = String::new();\r\n std::io::stdin().read_line(&mut s).expect(\"io error\");\r\n s\r\n}\r\npub use scanner_impls::{IterScan, MarkedIterScan, Scanner};\r\nmod scanner_impls {\r\n pub trait IterScan: Sized {\r\n type Output;\r\n fn scan<'a, I: Iterator>(iter: &mut I) -> Option;\r\n }\r\n pub trait MarkedIterScan: Sized {\r\n type Output;\r\n fn mscan<'a, I: Iterator>(self, iter: &mut I) -> Option;\r\n }\r\n #[derive(Clone, Debug)]\r\n pub struct Scanner<'a> {\r\n iter: std::str::SplitAsciiWhitespace<'a>,\r\n }\r\n impl<'a> Scanner<'a> {\r\n #[inline]\r\n pub fn new(s: &'a str) -> Self {\r\n let iter = s.split_ascii_whitespace();\r\n Self { iter }\r\n }\r\n #[inline]\r\n pub fn scan(&mut self) -> ::Output\r\n where\r\n T: IterScan,\r\n {\r\n ::scan(&mut self.iter).expect(\"scan error\")\r\n }\r\n #[inline]\r\n pub fn mscan(&mut self, marker: T) -> ::Output\r\n where\r\n T: MarkedIterScan,\r\n {\r\n marker.mscan(&mut self.iter).expect(\"scan error\")\r\n }\r\n #[inline]\r\n pub fn scan_vec(&mut self, size: usize) -> Vec<::Output>\r\n where\r\n T: IterScan,\r\n {\r\n (0..size)\r\n .map(|_| ::scan(&mut self.iter).expect(\"scan error\"))\r\n .collect()\r\n }\r\n #[inline]\r\n pub fn iter<'b, T>(&'b mut self) -> ScannerIter<'a, 'b, T>\r\n where\r\n T: IterScan,\r\n {\r\n ScannerIter {\r\n inner: self,\r\n _marker: std::marker::PhantomData,\r\n }\r\n }\r\n }\r\n macro_rules ! iter_scan_impls { ($ ($ t : ty) *) => { $ (impl IterScan for $ t { type Output = Self ; # [inline] fn scan <'a , I : Iterator < Item = &'a str >> (iter : & mut I) -> Option < Self > { iter . next () ?. parse ::<$ t > () . ok () } }) * } ; }\r\n iter_scan_impls ! (char u8 u16 u32 u64 usize i8 i16 i32 i64 isize f32 f64 u128 i128 String);\r\n macro_rules ! iter_scan_tuple_impl { ($ ($ T : ident) *) => { impl <$ ($ T : IterScan) ,*> IterScan for ($ ($ T ,) *) { type Output = ($ (<$ T as IterScan >:: Output ,) *) ; # [inline] fn scan <'a , It : Iterator < Item = &'a str >> (_iter : & mut It) -> Option < Self :: Output > { Some (($ (<$ T as IterScan >:: scan (_iter) ?,) *)) } } } ; }\r\n iter_scan_tuple_impl!();\r\n iter_scan_tuple_impl!(A);\r\n iter_scan_tuple_impl ! (A B);\r\n iter_scan_tuple_impl ! (A B C);\r\n iter_scan_tuple_impl ! (A B C D);\r\n iter_scan_tuple_impl ! (A B C D E);\r\n iter_scan_tuple_impl ! (A B C D E F);\r\n iter_scan_tuple_impl ! (A B C D E F G);\r\n iter_scan_tuple_impl ! (A B C D E F G H);\r\n iter_scan_tuple_impl ! (A B C D E F G H I);\r\n iter_scan_tuple_impl ! (A B C D E F G H I J);\r\n iter_scan_tuple_impl ! (A B C D E F G H I J K);\r\n pub struct ScannerIter<'a, 'b, T> {\r\n inner: &'b mut Scanner<'a>,\r\n _marker: std::marker::PhantomData T>,\r\n }\r\n impl<'a, 'b, T> Iterator for ScannerIter<'a, 'b, T>\r\n where\r\n T: IterScan,\r\n {\r\n type Item = ::Output;\r\n #[inline]\r\n fn next(&mut self) -> Option {\r\n ::scan(&mut self.inner.iter)\r\n }\r\n }\r\n}\r\npub use marker_impls::{CharWithBase, Chars, CharsWithBase, Collect, SizedCollect, Usize1};\r\nmod marker_impls {\r\n use super::*;\r\n use std::{\r\n iter::{repeat_with, FromIterator},\r\n marker::PhantomData,\r\n };\r\n #[derive(Debug, Copy, Clone)]\r\n pub struct Usize1;\r\n impl IterScan for Usize1 {\r\n type Output = usize;\r\n #[inline]\r\n fn scan<'a, I: Iterator>(iter: &mut I) -> Option {\r\n ::scan(iter)?.checked_sub(1)\r\n }\r\n }\r\n #[derive(Debug, Copy, Clone)]\r\n pub struct CharWithBase(pub char);\r\n impl MarkedIterScan for CharWithBase {\r\n type Output = usize;\r\n #[inline]\r\n fn mscan<'a, I: Iterator>(self, iter: &mut I) -> Option {\r\n Some((::scan(iter)? as u8 - self.0 as u8) as usize)\r\n }\r\n }\r\n #[derive(Debug, Copy, Clone)]\r\n pub struct Chars;\r\n impl IterScan for Chars {\r\n type Output = Vec;\r\n #[inline]\r\n fn scan<'a, I: Iterator>(iter: &mut I) -> Option {\r\n Some(iter.next()?.chars().collect())\r\n }\r\n }\r\n #[derive(Debug, Copy, Clone)]\r\n pub struct CharsWithBase(pub char);\r\n impl MarkedIterScan for CharsWithBase {\r\n type Output = Vec;\r\n #[inline]\r\n fn mscan<'a, I: Iterator>(self, iter: &mut I) -> Option {\r\n Some(\r\n iter.next()?\r\n .chars()\r\n .map(|c| (c as u8 - self.0 as u8) as usize)\r\n .collect(),\r\n )\r\n }\r\n }\r\n #[derive(Debug, Copy, Clone)]\r\n pub struct Collect::Output>>\r\n where\r\n T: IterScan,\r\n B: FromIterator<::Output>,\r\n {\r\n size: usize,\r\n _marker: PhantomData (T, B)>,\r\n }\r\n impl Collect\r\n where\r\n T: IterScan,\r\n B: FromIterator<::Output>,\r\n {\r\n pub fn new(size: usize) -> Self {\r\n Self {\r\n size,\r\n _marker: PhantomData,\r\n }\r\n }\r\n }\r\n impl MarkedIterScan for Collect\r\n where\r\n T: IterScan,\r\n B: FromIterator<::Output>,\r\n {\r\n type Output = B;\r\n #[inline]\r\n fn mscan<'a, I: Iterator>(self, iter: &mut I) -> Option {\r\n repeat_with(|| ::scan(iter))\r\n .take(self.size)\r\n .collect()\r\n }\r\n }\r\n #[derive(Debug, Copy, Clone)]\r\n pub struct SizedCollect::Output>>\r\n where\r\n T: IterScan,\r\n B: FromIterator<::Output>,\r\n {\r\n _marker: PhantomData (T, B)>,\r\n }\r\n impl IterScan for SizedCollect\r\n where\r\n T: IterScan,\r\n B: FromIterator<::Output>,\r\n {\r\n type Output = B;\r\n #[inline]\r\n fn scan<'a, I: Iterator>(iter: &mut I) -> Option {\r\n let size = usize::scan(iter)?;\r\n repeat_with(|| ::scan(iter))\r\n .take(size)\r\n .collect()\r\n }\r\n }\r\n}\r\n#[macro_export]\r\nmacro_rules ! scan_value { ($ scanner : expr , ($ ($ t : tt) ,*)) => { ($ ($ crate :: scan_value ! ($ scanner , $ t)) ,*) } ; ($ scanner : expr , [$ t : tt ; $ len : expr]) => { (0 ..$ len) . map (| _ | $ crate :: scan_value ! ($ scanner , $ t)) . collect ::< Vec < _ >> () } ; ($ scanner : expr , [$ t : ty ; $ len : expr]) => { $ scanner . scan_vec ::<$ t > ($ len) } ; ($ scanner : expr , [$ t : ty]) => { $ scanner . iter ::<$ t > () } ; ($ scanner : expr , { $ e : expr }) => { $ scanner . mscan ($ e) } ; ($ scanner : expr , $ t : ty) => { $ scanner . scan ::<$ t > () } ; }\r\n#[macro_export]\r\nmacro_rules ! scan { ($ scanner : expr) => { } ; ($ scanner : expr ,) => { } ; ($ scanner : expr , mut $ var : tt : $ t : tt) => { let mut $ var = $ crate :: scan_value ! ($ scanner , $ t) ; } ; ($ scanner : expr , $ var : tt : $ t : tt) => { let $ var = $ crate :: scan_value ! ($ scanner , $ t) ; } ; ($ scanner : expr , mut $ var : tt : $ t : tt , $ ($ rest : tt) *) => { let mut $ var = $ crate :: scan_value ! ($ scanner , $ t) ; scan ! ($ scanner , $ ($ rest) *) } ; ($ scanner : expr , $ var : tt : $ t : tt , $ ($ rest : tt) *) => { let $ var = $ crate :: scan_value ! ($ scanner , $ t) ; scan ! ($ scanner , $ ($ rest) *) } ; ($ scanner : expr , mut $ var : tt) => { let mut $ var = $ crate :: scan_value ! ($ scanner , usize) ; } ; ($ scanner : expr , $ var : tt) => { let $ var = $ crate :: scan_value ! ($ scanner , usize) ; } ; ($ scanner : expr , mut $ var : tt , $ ($ rest : tt) *) => { let mut $ var = $ crate :: scan_value ! ($ scanner , usize) ; scan ! ($ scanner , $ ($ rest) *) } ; ($ scanner : expr , $ var : tt , $ ($ rest : tt) *) => { let $ var = $ crate :: scan_value ! ($ scanner , usize) ; scan ! ($ scanner , $ ($ rest) *) } ; }\r\npub mod mint_basic {\r\n use super::*;\r\n #[macro_export]\r\n macro_rules ! define_basic_mintbase { ($ name : ident , $ m : expr , $ basety : ty , $ signedty : ty , $ upperty : ty , [$ ($ unsigned : ty) ,*] , [$ ($ signed : ty) ,*]) => { pub struct $ name ; impl MIntBase for $ name { type Inner = $ basety ; # [inline] fn get_mod () -> Self :: Inner { $ m } # [inline] fn mod_zero () -> Self :: Inner { 0 } # [inline] fn mod_one () -> Self :: Inner { 1 } # [inline] fn mod_add (x : Self :: Inner , y : Self :: Inner) -> Self :: Inner { let z = x + y ; let m = Self :: get_mod () ; if z >= m { z - m } else { z } } # [inline] fn mod_sub (x : Self :: Inner , y : Self :: Inner) -> Self :: Inner { if x < y { x + Self :: get_mod () - y } else { x - y } } # [inline] fn mod_mul (x : Self :: Inner , y : Self :: Inner) -> Self :: Inner { (x as $ upperty * y as $ upperty % Self :: get_mod () as $ upperty) as $ basety } # [inline] fn mod_div (x : Self :: Inner , y : Self :: Inner) -> Self :: Inner { Self :: mod_mul (x , Self :: mod_inv (y)) } # [inline] fn mod_neg (x : Self :: Inner) -> Self :: Inner { if x == 0 { 0 } else { Self :: get_mod () - x } } fn mod_inv (x : Self :: Inner) -> Self :: Inner { let p = Self :: get_mod () as $ signedty ; let (mut a , mut b) = (x as $ signedty , p) ; let (mut u , mut x) = (1 , 0) ; while a != 0 { let k = b / a ; x -= k * u ; b -= k * a ; std :: mem :: swap (& mut x , & mut u) ; std :: mem :: swap (& mut b , & mut a) ; } (if x < 0 { x + p } else { x }) as _ } } $ (impl MIntConvert <$ unsigned > for $ name { # [inline] fn from (x : $ unsigned) -> Self :: Inner { (x % < Self as MIntBase >:: get_mod () as $ unsigned) as $ basety } # [inline] fn into (x : Self :: Inner) -> $ unsigned { x as $ unsigned } # [inline] fn mod_into () -> $ unsigned { < Self as MIntBase >:: get_mod () as $ unsigned } }) * $ (impl MIntConvert <$ signed > for $ name { # [inline] fn from (x : $ signed) -> Self :: Inner { let x = x % < Self as MIntBase >:: get_mod () as $ signed ; if x < 0 { (x + < Self as MIntBase >:: get_mod () as $ signed) as $ basety } else { x as $ basety } } # [inline] fn into (x : Self :: Inner) -> $ signed { x as $ signed } # [inline] fn mod_into () -> $ signed { < Self as MIntBase >:: get_mod () as $ signed } }) * } ; }\r\n #[macro_export]\r\n macro_rules ! define_basic_mint32 { ($ ([$ name : ident , $ m : expr , $ mint_name : ident]) ,*) => { $ (crate :: define_basic_mintbase ! ($ name , $ m , u32 , i32 , u64 , [u32 , u64 , u128 , usize] , [i32 , i64 , i128 , isize]) ; pub type $ mint_name = MInt <$ name >;) * } ; }\r\n define_basic_mint32!(\r\n [Modulo998244353, 998_244_353, MInt998244353],\r\n [Modulo1000000007, 1_000_000_007, MInt1000000007],\r\n [Modulo1000000009, 1_000_000_009, MInt1000000009],\r\n [\r\n DynModuloU32,\r\n DYN_MODULUS_U32.with(|cell| unsafe { *cell.get() }),\r\n DynMIntU32\r\n ]\r\n );\r\n thread_local ! (static DYN_MODULUS_U32 : std :: cell :: UnsafeCell < u32 > = std :: cell :: UnsafeCell :: new (1_000_000_007));\r\n impl DynModuloU32 {\r\n pub fn set_mod(m: u32) {\r\n DYN_MODULUS_U32.with(|cell| unsafe { *cell.get() = m })\r\n }\r\n }\r\n thread_local ! (static DYN_MODULUS_U64 : std :: cell :: UnsafeCell < u64 > = std :: cell :: UnsafeCell :: new (1_000_000_007));\r\n define_basic_mintbase!(\r\n DynModuloU64,\r\n DYN_MODULUS_U64.with(|cell| unsafe { *cell.get() }),\r\n u64,\r\n i64,\r\n u128,\r\n [u64, u128, usize],\r\n [i64, i128, isize]\r\n );\r\n impl DynModuloU64 {\r\n pub fn set_mod(m: u64) {\r\n DYN_MODULUS_U64.with(|cell| unsafe { *cell.get() = m })\r\n }\r\n }\r\n pub type DynMIntU64 = MInt;\r\n pub struct Modulo2;\r\n impl MIntBase for Modulo2 {\r\n type Inner = u32;\r\n #[inline]\r\n fn get_mod() -> Self::Inner {\r\n 2\r\n }\r\n #[inline]\r\n fn mod_zero() -> Self::Inner {\r\n 0\r\n }\r\n #[inline]\r\n fn mod_one() -> Self::Inner {\r\n 1\r\n }\r\n #[inline]\r\n fn mod_add(x: Self::Inner, y: Self::Inner) -> Self::Inner {\r\n x ^ y\r\n }\r\n #[inline]\r\n fn mod_sub(x: Self::Inner, y: Self::Inner) -> Self::Inner {\r\n x ^ y\r\n }\r\n #[inline]\r\n fn mod_mul(x: Self::Inner, y: Self::Inner) -> Self::Inner {\r\n x | y\r\n }\r\n #[inline]\r\n fn mod_div(x: Self::Inner, y: Self::Inner) -> Self::Inner {\r\n assert_ne!(y, 0);\r\n x\r\n }\r\n #[inline]\r\n fn mod_neg(x: Self::Inner) -> Self::Inner {\r\n x\r\n }\r\n #[inline]\r\n fn mod_inv(x: Self::Inner) -> Self::Inner {\r\n assert_ne!(x, 0);\r\n x\r\n }\r\n #[inline]\r\n fn mod_pow(x: Self::Inner, y: usize) -> Self::Inner {\r\n if y == 0 {\r\n 1\r\n } else {\r\n x\r\n }\r\n }\r\n }\r\n macro_rules ! impl_to_mint_base_for_modulo2 { ($ name : ident , $ basety : ty , [$ ($ t : ty) ,*]) => { $ (impl MIntConvert <$ t > for $ name { # [inline] fn from (x : $ t) -> Self :: Inner { (x & 1) as $ basety } # [inline] fn into (x : Self :: Inner) -> $ t { x as $ t } # [inline] fn mod_into () -> $ t { 1 } }) * } ; }\r\n impl_to_mint_base_for_modulo2!(\r\n Modulo2,\r\n u32,\r\n [u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize]\r\n );\r\n pub type MInt2 = MInt;\r\n}\r\n#[repr(transparent)]\r\npub struct MInt\r\nwhere\r\n M: MIntBase,\r\n{\r\n x: M::Inner,\r\n _marker: std::marker::PhantomData M>,\r\n}\r\npub trait MIntBase {\r\n type Inner: Sized + Copy + Eq + std::fmt::Debug + std::hash::Hash;\r\n fn get_mod() -> Self::Inner;\r\n fn mod_zero() -> Self::Inner;\r\n fn mod_one() -> Self::Inner;\r\n fn mod_add(x: Self::Inner, y: Self::Inner) -> Self::Inner;\r\n fn mod_sub(x: Self::Inner, y: Self::Inner) -> Self::Inner;\r\n fn mod_mul(x: Self::Inner, y: Self::Inner) -> Self::Inner;\r\n fn mod_div(x: Self::Inner, y: Self::Inner) -> Self::Inner;\r\n fn mod_neg(x: Self::Inner) -> Self::Inner;\r\n fn mod_inv(x: Self::Inner) -> Self::Inner;\r\n fn mod_pow(x: Self::Inner, y: usize) -> Self::Inner {\r\n let (mut x, mut y, mut z) = (x, y, Self::mod_one());\r\n while y > 0 {\r\n if y & 1 == 1 {\r\n z = Self::mod_mul(z, x);\r\n }\r\n x = Self::mod_mul(x, x);\r\n y >>= 1;\r\n }\r\n z\r\n }\r\n}\r\npub trait MIntConvert::Inner>: MIntBase {\r\n fn from(x: T) -> ::Inner;\r\n fn into(x: ::Inner) -> T;\r\n fn mod_into() -> T;\r\n}\r\nmod mint_base {\r\n use super::*;\r\n use std::{\r\n fmt::{self, Debug, Display},\r\n hash::{Hash, Hasher},\r\n iter::{Product, Sum},\r\n marker::PhantomData,\r\n ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign},\r\n str::FromStr,\r\n };\r\n impl MInt\r\n where\r\n M: MIntConvert,\r\n {\r\n #[inline]\r\n pub fn new(x: M::Inner) -> Self {\r\n Self::new_unchecked(>::from(x))\r\n }\r\n #[inline]\r\n pub fn inner(self) -> M::Inner {\r\n >::into(self.x)\r\n }\r\n }\r\n impl MInt\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n pub fn new_unchecked(x: M::Inner) -> Self {\r\n Self {\r\n x,\r\n _marker: PhantomData,\r\n }\r\n }\r\n #[inline]\r\n pub fn get_mod() -> M::Inner {\r\n M::get_mod()\r\n }\r\n #[inline]\r\n pub fn pow(self, y: usize) -> Self {\r\n Self::new_unchecked(M::mod_pow(self.x, y))\r\n }\r\n #[inline]\r\n pub fn inv(self) -> Self {\r\n Self::new_unchecked(M::mod_inv(self.x))\r\n }\r\n }\r\n impl Clone for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn clone(&self) -> Self {\r\n Self {\r\n x: Clone::clone(&self.x),\r\n _marker: PhantomData,\r\n }\r\n }\r\n }\r\n impl Copy for MInt where M: MIntBase {}\r\n impl Debug for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {\r\n Debug::fmt(&self.x, f)\r\n }\r\n }\r\n impl Default for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn default() -> Self {\r\n ::zero()\r\n }\r\n }\r\n impl PartialEq for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn eq(&self, other: &Self) -> bool {\r\n PartialEq::eq(&self.x, &other.x)\r\n }\r\n }\r\n impl Eq for MInt where M: MIntBase {}\r\n impl Hash for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn hash(&self, state: &mut H) {\r\n Hash::hash(&self.x, state)\r\n }\r\n }\r\n macro_rules ! impl_mint_from { ($ ($ t : ty) ,*) => { $ (impl < M > From <$ t > for MInt < M > where M : MIntConvert <$ t >, { # [inline] fn from (x : $ t) -> Self { Self :: new_unchecked (< M as MIntConvert <$ t >>:: from (x)) } } impl < M > From < MInt < M >> for $ t where M : MIntConvert <$ t >, { # [inline] fn from (x : MInt < M >) -> $ t { < M as MIntConvert <$ t >>:: into (x . x) } }) * } ; }\r\n impl_mint_from!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);\r\n impl Zero for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn zero() -> Self {\r\n Self::new_unchecked(M::mod_zero())\r\n }\r\n }\r\n impl One for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn one() -> Self {\r\n Self::new_unchecked(M::mod_one())\r\n }\r\n }\r\n impl Add for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n type Output = Self;\r\n #[inline]\r\n fn add(self, rhs: Self) -> Self::Output {\r\n Self::new_unchecked(M::mod_add(self.x, rhs.x))\r\n }\r\n }\r\n impl Sub for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n type Output = Self;\r\n #[inline]\r\n fn sub(self, rhs: Self) -> Self::Output {\r\n Self::new_unchecked(M::mod_sub(self.x, rhs.x))\r\n }\r\n }\r\n impl Mul for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n type Output = Self;\r\n #[inline]\r\n fn mul(self, rhs: Self) -> Self::Output {\r\n Self::new_unchecked(M::mod_mul(self.x, rhs.x))\r\n }\r\n }\r\n impl Div for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n type Output = Self;\r\n #[inline]\r\n fn div(self, rhs: Self) -> Self::Output {\r\n Self::new_unchecked(M::mod_div(self.x, rhs.x))\r\n }\r\n }\r\n impl Neg for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n type Output = Self;\r\n #[inline]\r\n fn neg(self) -> Self::Output {\r\n Self::new_unchecked(M::mod_neg(self.x))\r\n }\r\n }\r\n impl Sum for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn sum>(iter: I) -> Self {\r\n iter.fold(::zero(), Add::add)\r\n }\r\n }\r\n impl Product for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn product>(iter: I) -> Self {\r\n iter.fold(::one(), Mul::mul)\r\n }\r\n }\r\n impl<'a, M: 'a> Sum<&'a MInt> for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn sum>(iter: I) -> Self {\r\n iter.fold(::zero(), Add::add)\r\n }\r\n }\r\n impl<'a, M: 'a> Product<&'a MInt> for MInt\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn product>(iter: I) -> Self {\r\n iter.fold(::one(), Mul::mul)\r\n }\r\n }\r\n impl Display for MInt\r\n where\r\n M: MIntConvert,\r\n M::Inner: Display,\r\n {\r\n fn fmt<'a>(&self, f: &mut fmt::Formatter<'a>) -> Result<(), fmt::Error> {\r\n write!(f, \"{}\", self.inner())\r\n }\r\n }\r\n impl FromStr for MInt\r\n where\r\n M: MIntConvert,\r\n M::Inner: FromStr,\r\n {\r\n type Err = ::Err;\r\n #[inline]\r\n fn from_str(s: &str) -> Result {\r\n s.parse::().map(Self::new)\r\n }\r\n }\r\n impl IterScan for MInt\r\n where\r\n M: MIntConvert,\r\n M::Inner: FromStr,\r\n {\r\n type Output = Self;\r\n #[inline]\r\n fn scan<'a, I: Iterator>(iter: &mut I) -> Option {\r\n iter.next()?.parse::>().ok()\r\n }\r\n }\r\n macro_rules! impl_mint_ref_binop {\r\n ($ imp : ident , $ method : ident , $ t : ty) => {\r\n impl $imp<$t> for &$t\r\n where\r\n M: MIntBase,\r\n {\r\n type Output = <$t as $imp<$t>>::Output;\r\n #[inline]\r\n fn $method(self, other: $t) -> <$t as $imp<$t>>::Output {\r\n $imp::$method(*self, other)\r\n }\r\n }\r\n impl $imp<&$t> for $t\r\n where\r\n M: MIntBase,\r\n {\r\n type Output = <$t as $imp<$t>>::Output;\r\n #[inline]\r\n fn $method(self, other: &$t) -> <$t as $imp<$t>>::Output {\r\n $imp::$method(self, *other)\r\n }\r\n }\r\n impl $imp<&$t> for &$t\r\n where\r\n M: MIntBase,\r\n {\r\n type Output = <$t as $imp<$t>>::Output;\r\n #[inline]\r\n fn $method(self, other: &$t) -> <$t as $imp<$t>>::Output {\r\n $imp::$method(*self, *other)\r\n }\r\n }\r\n };\r\n }\r\n impl_mint_ref_binop!(Add, add, MInt);\r\n impl_mint_ref_binop!(Sub, sub, MInt);\r\n impl_mint_ref_binop!(Mul, mul, MInt);\r\n impl_mint_ref_binop!(Div, div, MInt);\r\n macro_rules! impl_mint_ref_unop {\r\n ($ imp : ident , $ method : ident , $ t : ty) => {\r\n impl $imp for &$t\r\n where\r\n M: MIntBase,\r\n {\r\n type Output = <$t as $imp>::Output;\r\n #[inline]\r\n fn $method(self) -> <$t as $imp>::Output {\r\n $imp::$method(*self)\r\n }\r\n }\r\n };\r\n }\r\n impl_mint_ref_unop!(Neg, neg, MInt);\r\n macro_rules! impl_mint_ref_op_assign {\r\n ($ imp : ident , $ method : ident , $ t : ty , $ fromimp : ident , $ frommethod : ident) => {\r\n impl $imp<$t> for $t\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn $method(&mut self, rhs: $t) {\r\n *self = $fromimp::$frommethod(*self, rhs);\r\n }\r\n }\r\n impl $imp<&$t> for $t\r\n where\r\n M: MIntBase,\r\n {\r\n #[inline]\r\n fn $method(&mut self, other: &$t) {\r\n $imp::$method(self, *other);\r\n }\r\n }\r\n };\r\n }\r\n impl_mint_ref_op_assign!(AddAssign, add_assign, MInt, Add, add);\r\n impl_mint_ref_op_assign!(SubAssign, sub_assign, MInt, Sub, sub);\r\n impl_mint_ref_op_assign!(MulAssign, mul_assign, MInt, Mul, mul);\r\n impl_mint_ref_op_assign!(DivAssign, div_assign, MInt, Div, div);\r\n}\r\npub trait Zero: Sized {\r\n fn zero() -> Self;\r\n #[inline]\r\n fn is_zero(&self) -> bool\r\n where\r\n Self: PartialEq,\r\n {\r\n self == &Self::zero()\r\n }\r\n #[inline]\r\n fn set_zero(&mut self) {\r\n *self = Self::zero();\r\n }\r\n}\r\npub trait One: Sized {\r\n fn one() -> Self;\r\n #[inline]\r\n fn is_one(&self) -> bool\r\n where\r\n Self: PartialEq,\r\n {\r\n self == &Self::one()\r\n }\r\n #[inline]\r\n fn set_one(&mut self) {\r\n *self = Self::one();\r\n }\r\n}\r\nmacro_rules ! zero_one_impls { ($ ({ $ Trait : ident $ method : ident $ ($ t : ty) *, $ e : expr }) *) => { $ ($ (impl $ Trait for $ t { fn $ method () -> Self { $ e } }) *) * } ; }\r\nzero_one_impls ! ({ Zero zero u8 u16 u32 u64 usize i8 i16 i32 i64 isize u128 i128 , 0 } { Zero zero f32 f64 , 0. } { One one u8 u16 u32 u64 usize i8 i16 i32 i64 isize u128 i128 , 1 } { One one f32 f64 , 1. });\r\n#[derive(Clone, Debug)]\r\npub struct PrimeTable {\r\n table: Vec,\r\n}\r\nimpl PrimeTable {\r\n pub fn new(max_n: u32) -> Self {\r\n let mut table = vec![1; (max_n as usize + 1) / 2];\r\n table[0] = 0;\r\n for i in (3..).step_by(2) {\r\n let i2 = i * i;\r\n if i2 > max_n {\r\n break;\r\n }\r\n if table[i as usize >> 1] == 1 {\r\n for j in (i2..=max_n).step_by(i as usize * 2) {\r\n if table[j as usize >> 1] == 1 {\r\n table[j as usize >> 1] = i;\r\n }\r\n }\r\n }\r\n }\r\n PrimeTable { table }\r\n }\r\n pub fn is_prime(&self, n: u32) -> bool {\r\n n == 2 || n % 2 == 1 && self.table[n as usize >> 1] == 1\r\n }\r\n pub fn for_each(&self, mut n: u32, mut f: F)\r\n where\r\n F: FnMut(u32, u32),\r\n {\r\n let k = n.trailing_zeros();\r\n if k > 0 {\r\n f(2, k);\r\n }\r\n n >>= k;\r\n while self.table[n as usize >> 1] > 1 {\r\n let p = self.table[n as usize >> 1];\r\n let mut cnt = 1;\r\n n /= p;\r\n while self.table[n as usize >> 1] == p {\r\n n /= p;\r\n cnt += 1;\r\n }\r\n if n == p {\r\n cnt += 1;\r\n n /= p;\r\n }\r\n f(p, cnt);\r\n }\r\n if n > 1 {\r\n f(n, 1);\r\n }\r\n }\r\n pub fn prime_factors(&self, n: u32) -> Vec<(u32, u32)> {\r\n let mut factors = vec![];\r\n self.for_each(n, |p, c| factors.push((p, c)));\r\n factors\r\n }\r\n pub fn count_divisors(&self, n: u32) -> u32 {\r\n let mut divisor_cnt = 1;\r\n self.for_each(n, |_, cnt| divisor_cnt *= cnt + 1);\r\n divisor_cnt\r\n }\r\n}\r\n", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics"], "code_uid": "c46a5bdfd631893db56227845780ceb6", "src_uid": "09be46206a151c237dc9912df7e0f057", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "mod cp {\n use std::io::prelude::*;\n pub fn stdin_to_string() -> String {\n let mut content = String::new();\n let stdin = std::io::stdin();\n let mut rd = stdin.lock();\n rd.read_to_string(&mut content).unwrap();\n return content;\n }\n\n pub struct Parser<'a> {\n tokens: std::str::SplitWhitespace<'a>,\n }\n\n impl<'a> Parser<'a> {\n pub fn new(text: &'a str) -> Self {\n Self {\n tokens: text.split_whitespace(),\n }\n }\n\n pub fn read_or_eof(&mut self) -> Option {\n self.next().map(|s| match s.parse() {\n Ok(x) => x,\n Err(_) => panic!(\"cannot parse {:?}\", s),\n })\n }\n\n pub fn read(&mut self) -> T {\n self.read_or_eof::().expect(\"unexpected end-of-file\")\n }\n }\n\n impl<'a> Iterator for Parser<'a> {\n type Item = &'a str;\n fn next(&mut self) -> Option<&'a str> {\n self.tokens.next()\n }\n }\n\n #[macro_export]\n macro_rules! take {\n ($p: expr, $n: expr) => {\n $p.by_ref().take($n).map(|x| x.parse().unwrap())\n };\n ($p: expr, $n: expr, $t: ty) => {\n $p.by_ref().take($n).map(|x| x.parse::<$t>().unwrap())\n };\n }\n\n #[macro_export]\n macro_rules! take_all {\n ($p: expr) => {\n $p.by_ref().map(|x| x.parse().unwrap())\n };\n ($p: expr, $t: ty) => {\n $p.by_ref().map(|x| x.parse::<$t>().unwrap())\n };\n }\n}\n\nuse cp::*;\n\nfn main() {\n let content = stdin_to_string();\n let mut inp = Parser::new(&content);\n\n let mut nd = vec![0i32; 1000001];\n for i in 1..=1000000 {\n for j in (i..=1000000).step_by(i) {\n nd[j] += 1;\n }\n }\n\n let mut f = vec![0i32; 2000001];\n let mut sum = 0i64;\n for i in (2..=2000000).step_by(2) {\n let t = nd[i / 2] as i64 + sum;\n f[i] = (t % 998244353) as i32;\n sum += f[i] as i64;\n }\n let n: usize = inp.read();\n println!(\"{}\", f[n * 2]);\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics"], "code_uid": "6353f24b1047003b162ab40617f399fd", "src_uid": "09be46206a151c237dc9912df7e0f057", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "\nuse std::io;\nuse std::io::BufRead;\n\nconst MAX_SCORE: usize = 600;\n\nfn main() {\n let stdin = io::stdin();\n let mut lines = stdin.lock().lines();\n\n lines.next().unwrap().expect(\"input reading failed\");\n let input_string = lines.next().unwrap().ok().unwrap();\n\n let mut awarded = [false; MAX_SCORE + 1];\n let mut count = 0;\n input_string.split(\" \").map(|x| x.parse::().unwrap()).filter(|x| *x > 0).for_each(|x| {\n let index = x as usize;\n if !awarded[index] {\n awarded[index] = true;\n count += 1;\n }\n });\n\n println!(\"{}\", count);\n}\n", "lang_cluster": "Rust", "tags": ["sortings", "implementation"], "code_uid": "8d5de97b00d037118594c07d8a977580", "src_uid": "3b520c15ea9a11b16129da30dcfb5161", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn read_line() -> String {\n let mut input_line = String::new();\n io::stdin().read_line(&mut input_line).unwrap();\n return String::from(input_line.trim());\n}\n\nfn read_line_vec() -> Vec {\n return read_line().split(' ')\n .map(|s| s.parse().unwrap())\n .collect();\n}\n\n\nfn main() {\n let n: i32 = read_line().parse().unwrap();\n let mut vs = read_line_vec();\n\n vs.sort();\n vs.dedup();\n\n for i in 2..vs.len() {\n let pprev = vs[i-2];\n let prev = vs[i-1];\n let me = vs[i];\n\n if me == prev + 1 && pprev + 1 == prev {\n println!(\"YES\");\n return;\n }\n }\n\n println!(\"NO\");\n \n}", "lang_cluster": "Rust", "tags": ["brute force", "sortings", "implementation"], "code_uid": "0870cbc0be10d469dda7b834596eb800", "src_uid": "d6c876a84c7b92141710be5d76536eab", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 \u3088\u308a\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, bytes) => {\n read_value!($iter, String).bytes().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n\n//\n\nfn run() {\n input! {\n n: usize,\n a: [usize; n],\n }\n let mut a = a;\n a.sort();\n a.dedup();\n let n = a.len();\n let mut ans = \"NO\";\n for i in 2..n {\n let s = a[i - 2];\n if a[(i - 2)..=i] == [s, s + 1, s + 2] {\n ans = \"YES\";\n }\n }\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "sortings", "implementation"], "code_uid": "848d437ea3c905da4e84e03aa6e9ed67", "src_uid": "d6c876a84c7b92141710be5d76536eab", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut buffer = String::new();\n io::stdin().read_line(&mut buffer).expect(\"err\");\n let mut n:i64 = buffer.trim().parse().unwrap();\n let mut d = 0;\n for i in 2..=(n as f64).sqrt() as i64 + 1{\n if n % i == 0 {\n d = i; n -= d;\n break;\n }\n }\n println!(\"{}\", \n if d != 0 {\n n/2+1\n } else {\n 1\n }\n );\n}", "lang_cluster": "Rust", "tags": ["math", "implementation", "number theory"], "code_uid": "fa9da5ab09ad479d7aa5c3d143b39437", "src_uid": "a1e80ddd97026835a84f91bac8eb21e6", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str;\n\npub struct Scanner {\n reader: R,\n buffer: Vec,\n}\n\nimpl Scanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buffer: vec![],\n }\n }\n\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn solve(scan: &mut Scanner, out: &mut W) {\n let n: i64 = scan.token();\n let m: i64 = scan.token();\n let mut ans: i64 = 0;\n for x in 1..=n {\n // How many multiples of 5 minus x are there in [1, m]?\n ans += (m + x) / 5 - (x + 5) / 5 + 1;\n }\n writeln!(out, \"{}\", ans).ok();\n}\n\nfn main() {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout.lock());\n solve(&mut scan, &mut out);\n}\n", "lang_cluster": "Rust", "tags": ["math", "constructive algorithms", "number theory"], "code_uid": "ef83824194c7313bc6b831bd831573dd", "src_uid": "df0879635b59e141c839d9599abd77d2", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// Try Codeforces\n// author: Leonardone @ NEETSDKASU\n\nfn main() {\n let mut stdin = String::new();\n std::io::Read::read_to_string(\n &mut std::io::stdin(),\n &mut stdin).unwrap();\n let mut stdin = stdin.split_whitespace();\n let mut get = || stdin.next().unwrap();\n macro_rules! get {\n ($t:ty) => (get().parse::<$t>().unwrap());\n () => (get!(i64));\n }\n \n let n = get!();\n let k = get!();\n let mut ans = 0;\n if n >= k {\n ans = (k - 1) / 2;\n } else if k <= n + (n - 1) {\n let x = k - n;\n ans = (n - x + 1) / 2;\n }\n \n println!(\"{}\", ans);\n}", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "f0b5619c5c015675636922ced9f7adfa", "src_uid": "98624ab2fcd2a50a75788a29e04999ad", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rusT\nuse std::io::*;\nuse std::str::{self,*};\nuse std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::{self,*};\n#[allow(unused_imports)] use std::ops::{self,*};\n#[allow(unused_imports)] use std::iter::{self,*};\n#[allow(unused_imports)] use std::collections::*;\n#[allow(unused_macros)]\nmacro_rules! m {\n ($c:tt, $x:expr, $y:expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\n#[allow(unused_macros)]\nmacro_rules! l {\n ($($v:ident),* = $i:ident.$f:ident $a:tt) => {\n $( let $v = $i.$f$a; )*\n };\n ($($v:ident),*:$t:ty = $i:ident.$f:ident $a:tt) => {\n $( let $v:$t = $i.$f$a; )*\n };\n}\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a> }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).ok();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn f(&mut self) -> f64 { self.p() }\n fn u(&mut self) -> usize { self.p() }\n fn sk(&mut self, n: usize) { self.it.nth(n - 1); }\n fn ii(&mut self, n: usize) -> impl Iterator {\n self.ip(n).into_iter()\n }\n fn vi(&mut self, n: usize) -> Vec {\n self.vp::(n)\n }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn ip(&mut self, n: usize) -> impl Iterator where T::Err: Debug {\n self.vp(n).into_iter()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n//------------------- End rusT\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n let a = input.bs().to_vec();\n let b = input.bs().to_vec();\n let mut i = 0;\n for c in b {\n if c == a[i] {\n i += 1;\n }\n }\n println!(\"{}\", i + 1);\n}\n\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "b9e8a4f850acd2ba746e1d912a0f700a", "src_uid": "f5a907d6d35390b1fb11c8ce247d0252", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\nuse std::io::{StdinLock, stdin, BufRead};\nuse std::collections::*;\nuse std::cmp::*;\n\nfn scan_helper(lock : &mut StdinLock) -> String {\n let mut buffer = String::new();\n lock.read_line(&mut buffer).ok();\n buffer\n}\n\nmacro_rules! scan {\n ($lock:ident, $t:ty) => ({\n scan_helper(&mut $lock).split_whitespace()\n .next().unwrap()\n .parse::<$t>().unwrap()\n });\n ($lock:ident, $($t:ty),+) => ({\n let buffer = scan_helper(&mut $lock);\n let mut iter = buffer.split_whitespace();\n ($(\n {\n iter.next().unwrap()\n .parse::<$t>().unwrap()\n },\n )+)\n })\n}\n\nmacro_rules! scan_iter {\n ($lock:ident, $t:ty) => ({\n scan_helper(&mut $lock).split_whitespace()\n .map(|x| x.parse::<$t>().unwrap())\n .collect()\n })\n}\n\ntrait Ext {\n fn idx(&self) -> usize;\n fn num(&self) -> i64;\n}\n\nmacro_rules! ext {\n ($t:ty) => (\n impl Ext for $t {\n #[inline]\n fn idx(&self) -> usize {\n *self as usize\n }\n\n #[inline]\n fn num(&self) -> i64 {\n *self as i64\n }\n }\n )\n}\next!(i64);\next!(usize);\n\nmacro_rules! derive_regular {\n ($t:ty) => (\n impl Ord for $t {\n fn cmp(&self, other : &$t) -> Ordering {\n self.partial_cmp(other).unwrap()\n }\n }\n impl PartialEq for $t {\n fn eq(&self, other : &$t) -> bool {\n self.cmp(other) == Ordering::Equal\n }\n }\n impl Eq for $t {}\n )\n}\n\nfn main() {\n let stdin = stdin();\n let mut s = stdin.lock();\n let n = scan!(s, usize);\n let max_n = 1000000;\n let mut squares = vec![2*max_n; 2001];\n squares[0] = 0;\n\n let mut i = 1;\n while i*i <= max_n {\n squares[i] = i*i;\n i += 1;\n }\n\n while squares[i] > n {\n i -= 1;\n }\n\n let mut result = 4*i;\n let diff = n - squares[i];\n if diff > 0 {\n if diff > i {\n result += 4;\n } else {\n result += 2; \n }\n }\n \n\n println!(\"{}\", result);\n}", "lang_cluster": "Rust", "tags": ["brute force", "math", "geometry"], "code_uid": "4426c9351c1c967db27034b6ae7f8074", "src_uid": "414cc57550e31d98c1a6a56be6722a12", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn read_string() -> String {\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).expect(\"Failed\");\n input\n}\n\nfn main(){\n let now_time = read_string().replace(\"\\n\", \"\").replace(\"\\r\", \"\");\n let sleep_time = read_string().replace(\"\\n\", \"\").replace(\"\\r\", \"\");\n let now_vec: Vec<&str> = now_time.split(\":\").collect();\n let sleep_vec: Vec<&str> = sleep_time.split(\":\").collect();\n let fix = if now_vec[1].parse::().unwrap() < sleep_vec[1].parse::().unwrap() {1} else {0};\n let mut hours = now_vec[0].parse::().unwrap() - (sleep_vec[0].parse::().unwrap()+fix);\n let mut minutes = now_vec[1].parse::().unwrap() - sleep_vec[1].parse::().unwrap();\n if hours < 0{\n hours = 24+hours;\n }\n if minutes < 0{\n minutes = 60+minutes;\n }\n println!(\"{}{}:{}{}\", if hours<10 {\"0\"} else {\"\"}, hours, if minutes<10 {\"0\"} else {\"\"},minutes);\n }", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "7e93c786438bacb45e49587c93036385", "src_uid": "595c4a628c261104c8eedad767e85775", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str;\n\npub struct Scanner {\n reader: R,\n buffer: Vec,\n}\n\nimpl Scanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buffer: vec![],\n }\n }\n\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn get_divisors(n: u64) -> Vec {\n let mut ans = vec![1];\n if n > 1 {\n ans.push(n);\n }\n let mut d = 2;\n while d * d <= n {\n if n % d == 0 {\n ans.push(d);\n if d * d < n {\n ans.push(n / d);\n }\n }\n d += 1;\n }\n ans.sort();\n ans\n}\n\nfn upper_bound(arr: &[u64], target: u64) -> usize {\n let mut lo = 0;\n let mut hi = arr.len();\n while lo < hi {\n let mid = lo + (hi - lo) / 2;\n if arr[mid] > target {\n hi = mid;\n } else {\n lo = mid + 1;\n }\n }\n lo\n}\n\nfn solve(scan: &mut Scanner, out: &mut W) {\n let a: u64 = scan.token();\n let b: u64 = scan.token();\n if a == 0 {\n if b == 0 {\n writeln!(out, \"infinity\").ok();\n } else {\n writeln!(out, \"0\").ok();\n }\n } else {\n if a < b {\n writeln!(out, \"0\").ok();\n } else if a == b {\n writeln!(out, \"infinity\").ok();\n } else {\n // Solve the modular equation a \u2261 b (mod x).\n // a = x * k + b, where k is some integer.\n // (a - b) = x * k -> x is a divisor of (a - b)\n // Count divisors of (a - b) such that x > b.\n let divisors = get_divisors(a - b);\n let ub = upper_bound(&divisors, b);\n let ans = divisors.len() - ub;\n writeln!(out, \"{}\", ans).ok();\n }\n }\n}\n\nfn main() {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout.lock());\n solve(&mut scan, &mut out);\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "b0ed9ad773990d3fd730f4dfce32294a", "src_uid": "6e0715f9239787e085b294139abb2475", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse io::BufRead;\n\nfn main() {\n let stdin = io::stdin();\n let mut input = stdin.lock().lines().flat_map(\n |x| x.unwrap().split_whitespace().map(|x| x.to_string()).collect::>()\n );\n let x1: i64 = input.next().unwrap().parse().unwrap();\n let y1: i64 = input.next().unwrap().parse().unwrap();\n let x2: i64 = input.next().unwrap().parse().unwrap();\n let y2: i64 = input.next().unwrap().parse().unwrap();\n let x: i64 = input.next().unwrap().parse().unwrap();\n let y: i64 = input.next().unwrap().parse().unwrap();\n\n if ((x2 - x1) % x != 0) || ((y2 - y1) % y != 0) {\n println!(\"NO\");\n return;\n }\n\n let dx = (x2 - x1) / x;\n let dy = (y2 - y1) / y;\n\n if (dx + dy) % 2 == 0 {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation", "number theory"], "code_uid": "cff36b28765ffe32b5a8114c2786655e", "src_uid": "1c80040104e06c9f24abfcfe654a851f", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\r\nuse std::collections::{HashSet, HashMap};\r\nuse std::cmp::{min,max};\r\nuse std::convert::TryInto;\r\nuse std::io;\r\nuse std::str;\r\n\r\nstruct Scanner {\r\n reader: R,\r\n buf_str: Vec,\r\n buf_iter: str::SplitWhitespace<'static>, //':\r\n}\r\nimpl Scanner {\r\n fn new(reader: R) -> Self {\r\n Self { reader, buf_str: vec![], buf_iter: \"\".split_whitespace() }\r\n }\r\n fn token(&mut self) -> T {\r\n loop {\r\n if let Some(token) = self.buf_iter.next() {\r\n return token.parse().ok().expect(\"Failed parse\");\r\n }\r\n self.buf_str.clear();\r\n self.reader.read_until(b'\\n', &mut self.buf_str).expect(\"Failed read\");\r\n self.buf_iter = unsafe {\r\n let slice = str::from_utf8_unchecked(&self.buf_str);\r\n std::mem::transmute(slice.split_whitespace())\r\n }\r\n }\r\n }\r\n}\r\n\r\nfn root(mut n: u32) -> u32 {\r\n let mut k = 0;\r\n while n>0 {\r\n k += n%10;\r\n n = n/10;\r\n }\r\n k\r\n}\r\n\r\nfn solve(scan: &mut Scanner, out: &mut W) {\r\n let n = scan.token();\r\n let mut ans = root(n);\r\n while ans/10 != 0 { ans = root(ans)}\r\n writeln!(out, \"{}\", ans).ok();\r\n }\r\n\r\nfn main() {\r\n let (stdin, stdout) = (io::stdin(), io::stdout());\r\n let mut scan = Scanner::new(stdin.lock());\r\n let mut out = io::BufWriter::new(stdout.lock());\r\n solve(&mut scan, &mut out);\r\n}\r\n", "lang_cluster": "Rust", "tags": ["implementation", "number theory"], "code_uid": "8df4b842538720774c2db6567ad4f2d7", "src_uid": "477a67877367dc68b3bf5143120ff45d", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn read_line() -> String {\n let mut line = String::new();\n io::stdin().read_line(&mut line).unwrap();\n line\n}\n\nfn solve(tag: String, pat: String) -> bool {\n\n let mut tag_stm = tag.chars();\n\n for pat_chr in pat.chars() {\n loop {\n match tag_stm.next() {\n Some(tag_chr) => {\n if tag_chr == pat_chr {\n break;\n }\n }\n None => return false\n }\n }\n }\n true\n}\n\nfn main() {\n if solve(read_line().trim().to_string(), \"hello\".to_string()) {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n", "lang_cluster": "Rust", "tags": ["greedy", "strings"], "code_uid": "ea664408f154e954bd286fa8d114585e", "src_uid": "c5d19dc8f2478ee8d9cba8cc2e4cd838", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut s = String::new();\n io::stdin().read_line(&mut s).unwrap();\n let (mut f1, mut f2, mut f3, mut f4, mut f5) = (false, false, false, false, false);\n for c in s.chars() {\n if c == 'h' && !f1 {\n f1 = true;\n } else if c == 'e' && f1 && !f2 {\n f2 = true;\n } else if c == 'l' && f2 && !f3 {\n f3 = true;\n } else if c == 'l' && f3 && !f4 {\n f4 = true;\n } else if c == 'o' && f4 && !f5 {\n f5 = true;\n }\n }\n if f5 {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}", "lang_cluster": "Rust", "tags": ["greedy", "strings"], "code_uid": "57742ce36f6f704231f63c408939fd6d", "src_uid": "c5d19dc8f2478ee8d9cba8cc2e4cd838", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let input: Vec = scan.next::().chars().collect();\n let mut changes = 0;\n for i in 0..(input.len() / 2) {\n if input[i] != input[input.len() - i - 1] {\n changes += 1;\n if changes > 1 {\n println!(\"NO\");\n return;\n }\n }\n }\n println!(\n \"{}\",\n if changes == 1 || changes == 0 && input.len() % 2 == 1 {\n \"YES\"\n } else {\n \"NO\"\n }\n );\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "strings", "constructive algorithms"], "code_uid": "22dd02e844cf88a029ea7af12505366d", "src_uid": "fe74313abcf381f6c5b7b2057adaaa52", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "macro_rules! parse_line {\n ($t: ty) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let a_str = a_str.trim();\n a_str.parse::<$t>().expect(\"parse error\")\n });\n ($($t: ty),+) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let mut a_iter = a_str.split_whitespace();\n (\n $(\n a_iter.next().unwrap().parse::<$t>().expect(\"parse error\"),\n )+\n )\n })\n}\n\n#[allow(unused_macros)]\nmacro_rules! parse_line_to_vec {\n ($t: ty) => {{\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n (a_str\n .split_whitespace()\n .map(|x| x.parse::<$t>().unwrap())\n .collect::>())\n }};\n}\n\nuse std::io::Write;\n\nfn solve(writer: &mut std::io::BufWriter) {\n let n = parse_line!(usize);\n let s: Vec = parse_line!(String).bytes().collect();\n let mut counts = std::collections::HashMap::new();\n let mut best = 0;\n let mut result = Vec::new();\n for i in 1..n {\n let cnt = counts.entry(s[i - 1..=i].iter().copied().collect::>()).or_insert(0);\n *cnt += 1;\n if *cnt > best {\n best = *cnt;\n result = s[i - 1..=i].iter().copied().collect::>();\n }\n }\n writeln!(writer, \"{}\", String::from_utf8(result).unwrap()).unwrap();\n}\n\nfn main() {\n let mut writer = std::io::BufWriter::new(std::io::stdout());\n let tests = 1; // parse_line!(usize);\n for _ in 0..tests {\n solve(&mut writer);\n }\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "7bfd5f18d34599d9f24772ad4d2ed024", "src_uid": "e78005d4be93dbaa518f3b40cca84ab1", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nfn read_line() -> String {\n let mut buffer = String::new();\n io::stdin().read_line(&mut buffer).unwrap();\n String::from(buffer.trim())\n}\nfn read_number() -> i64 {\n read_line().parse::().unwrap()\n}\nfn read_nums() -> Vec {\n read_line().split(' ').map(|x| x.parse::().unwrap()).collect()\n}\n\nfn main() {\n let mut nums = read_nums();\n nums.sort();\n let least = nums[0];\n let top = nums[1];\n println!(\"{}\", if least >= 3 { least * top - least * top % 2 } else {\n if least == 1 {\n top - [0, 1, 2, 3, 2, 1][(top % 6) as usize]\n } else {\n if top <= 2 {\n 0\n } else if top == 3 || top == 7 {\n least * top - 2\n } else {\n least * top\n }\n }\n });\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "constructive algorithms", "flows", "graph matchings"], "code_uid": "7f17d36a3987674fc3f38a878a3ba94a", "src_uid": "02ce135a4b276d1e9ba6a4ce37f2fe70", "difficulty": 2200.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(dead_code, unused_macros, unused_imports)]\nuse std::{cell::{Cell, RefCell, UnsafeCell}, cmp::{Ordering, Reverse, max, min}, collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque, hash_map::{DefaultHasher, RandomState}}, error::Error, fmt::{Display, Write as FmtWrite}, hash::{BuildHasher, Hash, Hasher}, io::{BufWriter, Read, Stdin, Stdout, Write}, iter::{FromIterator, Peekable}, mem::swap, ops::*, process::exit, rc::Rc, str::{FromStr, from_utf8_unchecked}, time::{Duration, Instant}, convert::TryInto, marker::PhantomData};\n\nconst IO_BUF_SIZE: usize = 1 << 16;\ntype Input = Scanner;\ntype Output = BufWriter;\nfn _init_input() -> Input { Scanner::new(std::io::stdin()) }\nfn _init_output() -> Output { BufWriter::with_capacity(IO_BUF_SIZE, std::io::stdout()) }\n\n#[repr(transparent)] struct Unsync(T);\nunsafe impl Sync for Unsync {}\n \ntype BadLazy = Unsync>>;\nimpl BadLazy {\n const fn new() -> Self { Self(UnsafeCell::new(None)) }\n}\n \nstatic INPUT: BadLazy = BadLazy::new();\nstatic OUTPUT: BadLazy = BadLazy::new();\n \nfn inp R, R>(f: F) -> R {\n unsafe { f((&mut *INPUT.0.get()).get_or_insert_with(_init_input)) }\n}\nfn out R, R>(f: F) -> R {\n unsafe { f((&mut *OUTPUT.0.get()).get_or_insert_with(_init_output)) }\n}\n\nmacro_rules! read {\n () => { read() };\n ($t: ty) => { read::<$t>() };\n ($t: ty, $($tt: ty),*) => { (read::<$t>(), $(read::<$tt>(),)*) };\n [$t: ty; $n: expr] => { read_vec::<$t>($n) };\n}\nmacro_rules! println { \n () => { out(|x| { let _ = writeln!(x); }) };\n ($exp: expr) => { out(|x| { let _ = writeln!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = writeln!(x, $fmt, $($arg)*); }) }\n}\nmacro_rules! print { \n ($exp: expr) => { out(|x| { let _ = write!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = write!(x, $fmt, $($arg)*); }) }\n}\n\nfn out_flush() { out(|x| { let _ = x.flush(); }); }\n\nfn input_is_eof() -> bool { inp(|x| x.eof()) }\nfn read_byte() -> u8 { inp(|x| x.byte()) }\nfn read_bytes_no_skip(n: usize) -> Vec { inp(|x| x.bytes_no_skip(n)) }\nfn read_bytes(n: usize) -> Vec { inp(|x| x.bytes(n)) }\nfn read_bytes2(n: usize, m: usize) -> Vec> { inp(|x| x.bytes2(n, m)) }\nfn read_token() -> Vec { inp(|x| x.token_bytes()) }\nfn read_token_str() -> String { unsafe { String::from_utf8_unchecked(read_token()) } }\nfn read_line() -> Vec { inp(|x| x.line_bytes()) }\nfn read_line_str() -> String { unsafe { String::from_utf8_unchecked(read_line()) } }\nfn read() -> T { read_token_str().parse::().ok().expect(\"failed parse\") }\nfn read_vec(n: usize) -> Vec { (0..n).map(|_| read()).collect() }\nfn read_vec2(n: usize, m: usize) -> Vec> { (0..n).map(|_| read_vec(m)).collect() }\n\nstruct Scanner {\n src: R,\n _buf: Vec,\n _pt: usize, // pointer\n _rd: usize, // bytes read\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new(src: R) -> Scanner {\n Scanner { src, _buf: vec![0; IO_BUF_SIZE], _pt: 1, _rd: 1 }\n }\n \n fn _check_buf(&mut self) {\n if self._pt == self._rd {\n self._rd = self.src.read(&mut self._buf).unwrap_or(0);\n self._pt = (self._rd == 0) as usize;\n }\n }\n \n // returns true if end of file\n fn eof(&mut self) -> bool {\n self._check_buf();\n self._rd == 0\n }\n \n // filters \\r, returns \\0 if eof\n fn byte(&mut self) -> u8 {\n loop {\n self._check_buf();\n if self._rd == 0 { return 0; }\n let res = self._buf[self._pt];\n self._pt += 1;\n if res != b'\\r' { return res; }\n }\n }\n\n fn bytes_no_skip(&mut self, n: usize) -> Vec { (0..n).map(|_| self.byte()).collect() }\n fn bytes(&mut self, n: usize) -> Vec {\n let res = self.bytes_no_skip(n);\n self.byte();\n res\n }\n fn bytes2(&mut self, n: usize, m: usize) -> Vec> { (0..n).map(|_| self.bytes(m)).collect() }\n \n fn token_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c <= b' ' {\n if c == b'\\0' { return res; }\n c = self.byte();\n }\n loop {\n res.push(c);\n c = self.byte();\n if c <= b' ' { return res; }\n }\n }\n \n fn line_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c != b'\\n' && c != b'\\0' {\n res.push(c);\n c = self.byte();\n }\n res\n }\n}\n\ntrait JoinToStr { \n fn join_to_str(self, sep: &str) -> String;\n fn concat_to_str(self) -> String;\n}\nimpl> JoinToStr for I { \n fn join_to_str(mut self, sep: &str) -> String {\n match self.next() {\n Some(first) => {\n let mut res = first.to_string();\n while let Some(item) = self.next() {\n res.push_str(sep);\n res.push_str(&item.to_string());\n }\n res\n }\n None => { String::new() }\n }\n }\n \n fn concat_to_str(self) -> String {\n let mut res = String::new();\n for item in self { res.push_str(&item.to_string()); }\n res\n }\n}\ntrait AsStr { fn as_str(&self) -> &str; }\nimpl AsStr for [u8] { fn as_str(&self) -> &str {std::str::from_utf8(self).expect(\"attempt to convert non-UTF8 byte string.\")} }\n\nmacro_rules! veci {\n ($n:expr , $i:ident : $gen:expr) => {{\n let _veci_n = $n;\n let mut _veci_list = Vec::with_capacity(_veci_n);\n for $i in 0.._veci_n {\n _veci_list.push($gen);\n }\n _veci_list\n }};\n ($n:expr , $gen:expr) => { veci!($n, _veci_: $gen) }\n}\n\nfn abs_diff + PartialOrd>(x: T, y: T) -> T {\n if x < y { y - x } else { x - y }\n}\n\ntrait CommonNumExt {\n fn div_ceil(self, b: Self) -> Self;\n fn div_floor(self, b: Self) -> Self;\n fn gcd(self, b: Self) -> Self;\n fn highest_one(self) -> Self;\n fn lowest_one(self) -> Self;\n fn sig_bits(self) -> u32;\n}\n\nmacro_rules! impl_common_num_ext {\n ($($ix:tt = $ux:tt),*) => {\n $(\n impl CommonNumExt for $ux {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { self / b }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self;\n if a == 0 || b == 0 { return a | b; }\n let shift = (a | b).trailing_zeros();\n a >>= a.trailing_zeros();\n b >>= b.trailing_zeros();\n while a != b {\n if a > b { a -= b; a >>= a.trailing_zeros(); }\n else { b -= a; b >>= b.trailing_zeros(); }\n }\n a << shift\n }\n #[inline] fn highest_one(self) -> Self { \n if self == 0 { 0 } else { const ONE: $ux = 1; ONE << self.sig_bits() - 1 } \n }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ux>() as u32 * 8 - self.leading_zeros() }\n }\n\n impl CommonNumExt for $ix {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if self ^ b >= 0 && r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { \n let q = self / b; let r = self % b;\n if self ^ b < 0 && r != 0 { q - 1 } else { q }\n }\n fn gcd(self, b: Self) -> Self {\n fn w_abs(x: $ix) -> $ux { (if x.is_negative() { x.wrapping_neg() } else { x }) as _ }\n w_abs(self).gcd(w_abs(b)) as _\n }\n #[inline] fn highest_one(self) -> Self { (self as $ux).highest_one() as _ }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ix>() as u32 * 8 - self.leading_zeros() }\n }\n )*\n }\n}\nimpl_common_num_ext!(i8 = u8, i16 = u16, i32 = u32, i64 = u64, i128 = u128, isize = usize);\n\ntrait ChMaxMin {\n fn chmax(&mut self, v: T) -> bool;\n fn chmin(&mut self, v: T) -> bool;\n}\nimpl ChMaxMin for Option {\n fn chmax(&mut self, v: T) -> bool { if self.is_none() || v > *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if self.is_none() || v < *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n}\nimpl ChMaxMin for T {\n fn chmax(&mut self, v: T) -> bool { if v > *self { *self = v; true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if v < *self { *self = v; true } else { false } }\n}\n\n// * end commons * //\n\n#[derive(Clone, Debug)]\npub struct Arr2 {\n a: usize, b: usize, t: Vec\n}\nimpl Arr2 {\n pub fn new(a: usize, b: usize) -> Self {\n Self { a, b, t: vec![T::default(); a*b] }\n }\n}\nimpl Arr2 {\n pub fn filled(a: usize, b: usize, v: T) -> Self {\n Self { a, b, t: vec![v; a*b] }\n }\n}\nimpl Arr2 {\n pub fn idx(&self, i: usize, j: usize) -> usize {\n debug_assert!(i < self.a && j < self.b);\n i.mul(self.b).add(j)\n }\n\n pub fn shape(&self) -> [usize; 2] { [self.a, self.b] }\n}\n\nimpl Index<[usize; 2]> for Arr2 {\n type Output = T;\n\n fn index(&self, [i, j]: [usize; 2]) -> &Self::Output {\n &self.t[self.idx(i, j)]\n }\n}\n\nimpl IndexMut<[usize; 2]> for Arr2 {\n fn index_mut(&mut self, [i, j]: [usize; 2]) -> &mut Self::Output {\n let i = self.idx(i, j);\n &mut self.t[i]\n }\n}\n\nimpl Index for Arr2 {\n type Output = [T];\n\n fn index(&self, i: usize) -> &Self::Output {\n &self.t[i * self.b .. (i+1) * self.b]\n }\n}\n\nimpl IndexMut for Arr2 {\n fn index_mut(&mut self, i: usize) -> &mut Self::Output {\n &mut self.t[i * self.b .. (i+1) * self.b]\n }\n}\n \n#[allow(non_snake_case, non_upper_case_globals)]\nfn main() {\n let num_cases: usize = 1;//read();\n \n for _case_num in 1..=num_cases {\n let S = [1200,1400,1600,1900,2100,2300,2400,2600,3000];\n let r = read!(i32);\n\n let ans = *S.iter().find(|&&s| s > r).unwrap();\n println!(ans);\n }\n \n out_flush();\n}", "lang_cluster": "Rust", "tags": ["math", "divide and conquer", "implementation"], "code_uid": "60fb6499f83573c48716b40beba5bba8", "src_uid": "22725effa6dc68b9c2a499d148e613c2", "difficulty": -1.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin ModInt ----------\nconst MOD: u32 = 1_000_000_007;\n\n#[derive(Clone, Copy)]\nstruct ModInt(u32);\n\nimpl std::ops::Add for ModInt {\n type Output = ModInt;\n fn add(self, rhs: ModInt) -> Self::Output {\n let mut d = self.0 + rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n\nimpl std::ops::AddAssign for ModInt {\n fn add_assign(&mut self, rhs: ModInt) {\n *self = *self + rhs;\n }\n}\n\nimpl std::ops::Sub for ModInt {\n type Output = ModInt;\n fn sub(self, rhs: ModInt) -> Self::Output {\n let mut d = self.0 + MOD - rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n\nimpl std::ops::SubAssign for ModInt {\n fn sub_assign(&mut self, rhs: ModInt) {\n *self = *self - rhs;\n }\n}\n\nimpl std::ops::Mul for ModInt {\n type Output = ModInt;\n fn mul(self, rhs: ModInt) -> Self::Output {\n ModInt((self.0 as u64 * rhs.0 as u64 % MOD as u64) as u32)\n }\n}\n\nimpl std::ops::MulAssign for ModInt {\n fn mul_assign(&mut self, rhs: ModInt) {\n *self = *self * rhs;\n }\n}\n\nimpl std::ops::Neg for ModInt {\n type Output = ModInt;\n fn neg(self) -> Self::Output {\n ModInt(if self.0 == 0 {0} else {MOD - self.0})\n }\n}\n\nimpl std::fmt::Display for ModInt {\n fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n}\n\nimpl std::str::FromStr for ModInt {\n type Err = std::num::ParseIntError;\n fn from_str(s: &str) -> Result {\n let val = s.parse::()?;\n Ok(ModInt::new(val))\n }\n}\n\n#[allow(dead_code)]\nimpl ModInt {\n pub fn new(n: u32) -> ModInt {\n ModInt(n % MOD)\n }\n pub fn zero() -> ModInt {\n ModInt(0)\n }\n pub fn one() -> ModInt {\n ModInt(1)\n }\n pub fn pow(self, mut n: u32) -> ModInt {\n let mut t = ModInt::one();\n let mut s = self;\n while n > 0 {\n if n & 1 == 1 {\n t *= s;\n }\n s *= s;\n n >>= 1;\n }\n t\n }\n pub fn inv(self) -> ModInt {\n self.pow(MOD - 2)\n }\n}\n// ---------- end ModInt ----------\n// ---------- begin Precalc ----------\n#[allow(dead_code)]\nstruct Precalc {\n inv: Vec,\n fact: Vec,\n ifact: Vec,\n}\n\n#[allow(dead_code)]\nimpl Precalc {\n pub fn new(n: usize) -> Precalc {\n let mut inv = vec![ModInt::one(); n + 1];\n let mut fact = vec![ModInt::one(); n + 1];\n let mut ifact = vec![ModInt::one(); n + 1];\n for i in 2..(n + 1) {\n inv[i] = -inv[MOD as usize % i] * ModInt(MOD / i as u32);\n fact[i] = fact[i - 1] * ModInt(i as u32);\n ifact[i] = ifact[i - 1] * inv[i];\n }\n Precalc {\n inv: inv,\n fact: fact,\n ifact: ifact,\n }\n }\n pub fn inv(&self, n: usize) -> ModInt {\n self.inv[n]\n }\n pub fn fact(&self, n: usize) -> ModInt {\n self.fact[n]\n }\n pub fn ifact(&self, n: usize) -> ModInt {\n self.ifact[n]\n }\n pub fn comb(&self, n: usize, k: usize) -> ModInt {\n if k > n {\n return ModInt::zero();\n }\n self.fact[n] * self.ifact[k] * self.ifact[n - k]\n }\n}\n// ---------- end Precalc ----------\nuse std::io::Read;\n\nfn run() {\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n let mut it = s.trim().split_whitespace();\n let n: usize = it.next().unwrap().parse().unwrap();\n let w: usize = it.next().unwrap().parse().unwrap();\n let mut a = vec![vec![]; 3];\n for _ in 0..n {\n let t: usize = it.next().unwrap().parse().unwrap();\n let g: usize = it.next().unwrap().parse().unwrap();\n a[g - 1].push(t);\n }\n let mut way = vec![vec![vec![vec![ModInt::zero(); a[2].len() + 2]; a[1].len() + 2]; a[0].len() + 2]; 3];\n way[0][1][0][0] = ModInt::one();\n way[1][0][1][0] = ModInt::one();\n way[2][0][0][1] = ModInt::one();\n for i in 0..=a[0].len() {\n for j in 0..=a[1].len() {\n for k in 0..=a[2].len() {\n for l in 0..3 {\n let v = way[l][i][j][k];\n for (g, &(x, y, z)) in [(i + 1, j, k), (i, j + 1, k), (i, j, k + 1)].iter().enumerate() {\n if g != l {\n way[g][x][y][z] += v;\n }\n }\n }\n }\n }\n }\n let mut dp1 = vec![vec![vec![ModInt::zero(); w + 1]; a[1].len() + 1]; a[0].len() + 1];\n dp1[0][0][0] = ModInt::one();\n for &b in a[0].iter() {\n for i in (1..=a[0].len()).rev() {\n for t in (b..=w).rev() {\n let v = dp1[i - 1][0][t - b];\n dp1[i][0][t] += v;\n }\n }\n }\n for &b in a[1].iter() {\n for i in 0..=a[0].len() {\n for j in (1..=a[1].len()).rev() {\n for t in (b..=w).rev() {\n let v = dp1[i][j - 1][t - b];\n dp1[i][j][t] += v;\n }\n }\n }\n }\n let mut dp2 = vec![vec![ModInt::zero(); w + 1]; a[2].len() + 1];\n dp2[0][0] = ModInt::one();\n for &b in a[2].iter() {\n for i in (1..=a[2].len()).rev() {\n for t in (b..=w).rev() {\n let v = dp2[i - 1][t - b];\n dp2[i][t] += v;\n }\n }\n }\n let pc = Precalc::new(n);\n let mut ans = ModInt::zero();\n for i in 0..=a[0].len() {\n for j in 0..=a[1].len() {\n for k in 0..=a[2].len() {\n for t in 0..=w {\n let way = way[0][i][j][k] + way[1][i][j][k] + way[2][i][j][k];\n ans += dp1[i][j][t] * dp2[k][w - t] * way * pc.fact(i) * pc.fact(j) * pc.fact(k);\n }\n }\n }\n }\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["dp", "combinatorics", "bitmasks"], "code_uid": "d8410933498bd3b50de0ff0be9551cc9", "src_uid": "ac2a37ff4c7e89a345b189e4891bbf56", "difficulty": 2100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn read_line() -> String {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"EOF\");\n line.pop();\n return line;\n}\n\nmacro_rules! read_line {\n (Vec<$t: ty>) => {{\n read_line().split_whitespace().map(|token| {\n <$t as std::str::FromStr>::from_str(token).expect(\"Invalid token\")\n }).collect()\n }};\n ($($t: ty),*) => {{\n let line = read_line();\n let mut iter = line.split_whitespace();\n ($({\n let token = iter.next().expect(\"Too few tokens\");\n <$t as std::str::FromStr>::from_str(token).expect(\"Invalid token\")\n }), *)\n }};\n}\n\nuse std::cmp;\n\nfn main() {\n let (n, k) = read_line!(usize, i32);\n let a: Vec = read_line!(Vec);\n let mut cur = 0;\n let mut b = 0;\n let mut m = -1;\n for i in 0..n {\n cur += a[i];\n b += cmp::min(cur, 8);\n cur -= cmp::min(cur, 8);\n if b >= k {\n m = i as i32 + 1;\n break;\n }\n }\n println!(\"{}\", m);\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "f4e2512f82ffe94f4fe4731768456ca5", "src_uid": "24695b6a2aa573e90f0fe661b0c0bd3a", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\nuse std::io::*;\nuse std::str::*;\nuse std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::{self,*};\n#[allow(unused_imports)] use std::ops::*;\n#[allow(unused_imports)] use std::collections::*;\n\n#[allow(unused_macros)]\nmacro_rules! m {\n ($c:tt, $x:expr, $y:expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\n#[allow(unused_macros)]\nmacro_rules! l {\n ($i:ident . $e:tt : $t:ty, $($a:ident),*) => {\n $( let $a: $t = $i.$e(); )*\n };\n ($i:ident . $e:tt, $($a:ident),*) => {\n $( let $a = $i.$e(); )*\n };\n}\n\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a>, }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).ok();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn f(&mut self) -> f64 { self.p() }\n fn u(&mut self) -> usize { self.p() }\n fn sk(&mut self, n: usize) { self.it.nth(n - 1); }\n fn vi(&mut self, n: usize) -> Vec {\n self.vp::(n)\n }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn ip(&mut self, n: usize) -> impl Iterator where T::Err: Debug {\n self.vp(n).into_iter()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n let n = input.u();\n let k = input.i();\n let mut sum1 = 0;\n let mut sum2 = 0;\n for i in 0..n {\n sum1 += input.i();\n let d = sum1.min(8);\n sum1 -= d;\n sum2 += d;\n if sum2 >= k {\n println!(\"{}\", i + 1);\n return;\n }\n }\n println!(\"-1\");\n}\n\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "e1c90bf316f934a731a97649b246b274", "src_uid": "24695b6a2aa573e90f0fe661b0c0bd3a", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\nuse std::cmp::Ordering::*;\nuse std::collections::{BTreeMap, BTreeSet};\nuse std::io::{self, BufWriter, Write};\nuse std::str::{self, SplitAsciiWhitespace};\n\n// I have no idea what I'm doing\n\nmacro_rules! answer {\n ($out:ident, $ans:expr) => {\n writeln!($out, \"{}\", $ans)\n };\n}\n\nfn sqrt(x: i32) -> i32 {\n (0..=2000).find(|y| y * y >= x).unwrap()\n}\n\nfn main() -> Result<(), io::Error> {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = UnsafeScanner::new(stdin.lock());\n let mut out = BufWriter::new(stdout.lock());\n\n let mut rev = false;\n\n let (mut x, mut y) = scan.pair::();\n if x < 0 {\n rev = !rev;\n x = -x;\n }\n if y < 0 {\n rev = !rev;\n y = -y;\n }\n\n let dsq = x*x + y*y;\n\n let d = sqrt(dsq);\n\n if d * d == dsq {\n return answer!(out, \"black\");\n }\n\n answer!(out, match (d & 1 == 1) != rev {\n true => \"black\",\n false => \"white\",\n })?;\n\n Ok(())\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////////////\n\n/// Copied from https://github.com/EbTech/rust-algorithms/blob/master/src/scanner.rs\n/// Same API as Scanner but nearly twice as fast, using horribly unsafe dark arts\n/// **REQUIRES** Rust 1.34 or higher\npub struct UnsafeScanner {\n reader: R,\n buf_str: Vec,\n buf_iter: SplitAsciiWhitespace<'static>,\n}\n\nimpl UnsafeScanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buf_str: vec![],\n buf_iter: \"\".split_ascii_whitespace(),\n }\n }\n\n /// This function should be marked unsafe, but noone has time for that in a\n /// programming contest. Use at your own risk!\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buf_iter.next() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n self.buf_str.clear();\n self.reader\n .read_until(b'\\n', &mut self.buf_str)\n .expect(\"Failed read\");\n self.buf_iter = unsafe {\n let slice = str::from_utf8_unchecked(&self.buf_str);\n std::mem::transmute(slice.split_ascii_whitespace())\n }\n }\n }\n\n pub fn pair(&mut self) -> (T, T) {\n (self.token(), self.token())\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "geometry", "constructive algorithms", "implementation"], "code_uid": "84745f51f561bac425db35cc5bf84da0", "src_uid": "8c92aac1bef5822848a136a1328346c6", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, BufReader};\nuse std::io::prelude::*;\nuse std::collections::HashMap;\n\nfn insert_dist(dist: i32, c: char, dist_map: &mut HashMap, diff: i32) {\n if dist <= (13 + diff) {\n dist_map.insert(c, (dist - diff).abs());\n } else {\n dist_map.insert(c, 26 + diff - dist);\n }\n}\n\nfn solve(input: &mut dyn Read, output: &mut dyn Write) {\n let mut reader = BufReader::new(input);\n let mut input = String::new();\n let mut dist_a: HashMap = HashMap::new();\n let mut dist_c: HashMap = HashMap::new();\n let mut dist_t: HashMap = HashMap::new();\n let mut dist_g: HashMap = HashMap::new();\n\n for (i, c) in \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\".chars().enumerate() {\n let dist = i as i32;\n insert_dist(dist, c, &mut dist_a, 0);\n insert_dist(dist, c, &mut dist_c, 2);\n if dist <= 6 {\n dist_t.insert(c, 7 + dist);\n } else {\n dist_t.insert(c, (dist - 19).abs());\n }\n insert_dist(dist, c, &mut dist_g, 6);\n }\n // for c in \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\".chars() {\n // println!(\"{} {}\", c, dist_t[&c]);\n // }\n \n\n reader.read_line(&mut input).unwrap();\n let n: usize = input.trim().parse().unwrap();\n\n input.clear();\n reader.read_line(&mut input).unwrap();\n let s = input.trim();\n // println!(\"{:?}\", s);\n\n let char_vec: Vec = s.chars().collect();\n let mut min_sum = -1;\n for i in 0..n-3 {\n let sum = dist_a.get(&char_vec[i]).expect(\"has values\") + \n dist_c.get(&char_vec[i + 1]).expect(\"has values\") + \n dist_t.get(&char_vec[i + 2]).expect(\"has values\") + \n dist_g.get(&char_vec[i + 3]).expect(\"has values\");\n\n if min_sum == -1 || sum < min_sum {\n min_sum = sum;\n }\n }\n\n // for c in s.chars() {\n // println!(\"{:?}\", c);\n // }\n\n writeln!(output, \"{}\", min_sum).expect(\"correct output\");\n\n}\n\nfn main() {\n solve(&mut io::stdin(), &mut io::stdout());\n}", "lang_cluster": "Rust", "tags": ["brute force", "strings"], "code_uid": "4fb252210fbd7920bb3068e892144e29", "src_uid": "ee4f88abe4c9fa776abd15c5f3a94543", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n\n let mut input = buf\n .split_whitespace()\n .map(|s| s.parse::().unwrap());\n\n // length\n let n = input.next().unwrap();\n // route 1 (+)\n let a = input.next().unwrap();\n let x = input.next().unwrap();\n // route 2 (-)\n let b = input.next().unwrap();\n let y = input.next().unwrap();\n\n println!(\"{}\", match solve(n, a, x, b, y) {\n true => \"YES\",\n false => \"NO\",\n });\n}\n\nfn solve(n: i32, a: i32, x: i32, b: i32, y: i32) -> bool {\n let x = if x < a { x + n } else { x };\n let b = if y > b { b + n } else { b };\n (y .. b + 1).rev().zip(a .. x + 1).any(|(i, j)| i % n == j % n)\n}\n\n#[cfg(test)]\nmod test {\n\n use super::solve;\n #[test]\n fn test1() {\n assert_eq!(solve(5, 1, 4, 3, 2), true);\n }\n #[test]\n fn test2() {\n assert_eq!(solve(10, 2, 1, 9, 10), false);\n }\n #[test]\n fn test3() {\n assert_eq!(solve(82, 9, 11, 15, 79), false);\n }\n #[test]\n fn test4() {\n assert_eq!(solve(47, 15, 45, 28, 38), true);\n }\n}", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "b12a39d101cb7820194fa1f3f7392595", "src_uid": "5b889751f82c9f32f223cdee0c0095e4", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n\nuse std::cmp::*;\nuse std::collections::*;\nuse std::fmt::Debug;\nuse std::io::{empty, Read};\nuse std::str::FromStr;\n\nfn main() {\n let nn = read_vec::();\n let (n, k) = (nn[0], nn[1]);\n\n let first = min(k - 1, n - k);\n let result = first + 3 * n;\n println!(\"{}\", result);\n}\n\n#[allow(dead_code)]\nconst DIV: i64 = 1_000_000_007;\n#[allow(dead_code)]\nconst N: usize = 200000;\n#[allow(dead_code)]\nconst CHARS: usize = 'z' as usize - 'a' as usize + 1;\n\n#[allow(dead_code)]\nfn print_vec(a: &Vec) {\n for i in 0..a.len() {\n if i != 0 {\n print!(\" \");\n }\n print!(\"{:?}\", a[i]);\n }\n println!();\n}\n\n#[allow(dead_code)]\nfn read_line() -> String {\n let mut s = String::with_capacity(N);\n std::io::stdin().read_line(&mut s).unwrap();\n s\n}\n\n#[allow(dead_code)]\nfn read_vec() -> Vec\n where T::Err: Debug\n{\n return read_line()\n .split_whitespace()\n .map(|x| x.parse().unwrap())\n .collect();\n}\n", "lang_cluster": "Rust", "tags": ["math", "constructive algorithms"], "code_uid": "309def4bb4bd722d50a015821861fd24", "src_uid": "24b02afe8d86314ec5f75a00c72af514", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next_line(&self) -> String {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n line\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let line = self.next_line();\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n\n fn next_n(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.next()).collect()\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let mut c = [0u64; 3];\n for s in scan.next::().chars() {\n match s {\n 'B' => {\n c[0] += 1;\n }\n 'S' => {\n c[1] += 1;\n }\n 'C' => {\n c[2] += 1;\n }\n _ => {}\n }\n }\n let n: Vec = scan.next_n(3);\n let p: Vec = scan.next_n(3);\n let r: u64 = scan.next();\n let mut low = 0u64;\n let mut high = 1000000001000u64;\n while low <= high {\n let middle = (low + high) / 2;\n let mut f = 0u64;\n for i in 0..3 {\n if c[i] * middle > n[i] {\n f += (c[i] * middle - n[i]) * p[i];\n }\n }\n if f <= r {\n low = middle + 1;\n } else {\n high = middle - 1;\n }\n }\n println!(\"{}\", low - 1);\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "binary search"], "code_uid": "dff2d1bc87daf776e9d6fe50f6a24d1f", "src_uid": "8126a4232188ae7de8e5a7aedea1a97e", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).expect(\"input: read line failed\");\n let vec = input.trim().split_whitespace().map(|item| {\n item.parse::().expect(\"item: parse to i32 failed\")\n }).collect::>();\n\n let (mut width, mut height, mut rings) = (vec[0], vec[1], vec[2]);\n\n let mut amount = i32::default();\n\n while rings > 0 {\n amount += (width + height) * 2 - 4;\n width -= 4;\n height -= 4;\n rings -= 1;\n }\n\n println!(\"{}\", amount);\n}", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "d3234ea3d43efc5efa74949be5ed543e", "src_uid": "2c98d59917337cb321d76f72a1b3c057", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin Matrix ----------\nmod matrix {\n use std::ops::*;\n pub trait SemiRing: Add + Mul + Copy {\n fn zero() -> Self;\n fn one() -> Self;\n }\n #[derive(Clone)]\n pub struct SquareMatrix {\n size: usize,\n buf: Box<[R]>,\n }\n #[allow(dead_code)]\n impl SquareMatrix {\n pub fn zero(size: usize) -> Self {\n SquareMatrix {\n size: size,\n buf: vec![R::zero(); size * size].into_boxed_slice(),\n }\n }\n pub fn identity(size: usize) -> Self {\n let mut e = Self::zero(size);\n for i in 0..size {\n e.buf[i * size + i] = R::one();\n }\n e\n }\n pub fn get(&self, x: usize, y: usize) -> &R {\n assert!(x < self.size && y < self.size);\n &self.buf[x * self.size + y]\n }\n pub fn get_mut(&mut self, x: usize, y: usize) -> &mut R {\n assert!(x < self.size && y < self.size);\n &mut self.buf[x * self.size + y]\n }\n pub fn matadd(&self, rhs: &Self) -> Self {\n assert!(self.size == rhs.size);\n let buf: Vec = self\n .buf\n .iter()\n .zip(rhs.buf.iter())\n .map(|p| *p.0 + *p.1)\n .collect();\n SquareMatrix {\n size: self.size,\n buf: buf.into_boxed_slice(),\n }\n }\n pub fn matmul(&self, rhs: &Self) -> Self {\n let size = self.size;\n assert!(size == rhs.size);\n let mut res = Self::zero(size);\n for (x, a) in res.buf.chunks_mut(size).zip(self.buf.chunks(size)) {\n for (a, b) in a.iter().zip(rhs.buf.chunks(size)) {\n for (x, b) in x.iter_mut().zip(b.iter()) {\n *x = *x + *a * *b;\n }\n }\n }\n res\n }\n pub fn mat_pow(&self, mut n: usize) -> Self {\n let size = self.size;\n let mut t = Self::identity(size);\n let mut s = self.clone();\n while n > 0 {\n if n & 1 == 1 {\n t = t.matmul(&s);\n }\n s = s.matmul(&s);\n n >>= 1;\n }\n t\n }\n }\n #[allow(dead_code)]\n impl> SquareMatrix {\n pub fn matsub(&self, rhs: &Self) -> Self {\n assert!(self.size == rhs.size);\n let buf: Vec = self\n .buf\n .iter()\n .zip(rhs.buf.iter())\n .map(|p| *p.0 - *p.1)\n .collect();\n SquareMatrix {\n size: self.size,\n buf: buf.into_boxed_slice(),\n }\n }\n }\n}\n// ---------- end Matrix ----------\n// ---------- begin ModInt ----------\nmod modint {\n\n #[allow(dead_code)]\n pub struct Mod;\n impl ConstantModulo for Mod {\n const MOD: u32 = 1_000_000_007;\n }\n\n #[allow(dead_code)]\n pub struct StaticMod;\n static mut STATIC_MOD: u32 = 0;\n impl Modulo for StaticMod {\n fn modulo() -> u32 {\n unsafe { STATIC_MOD }\n }\n }\n\n #[allow(dead_code)]\n impl StaticMod {\n pub fn set_modulo(p: u32) {\n unsafe {\n STATIC_MOD = p;\n }\n }\n }\n\n use std::marker::*;\n use std::ops::*;\n\n pub trait Modulo {\n fn modulo() -> u32;\n }\n\n pub trait ConstantModulo {\n const MOD: u32;\n }\n\n impl Modulo for T\n where\n T: ConstantModulo,\n {\n fn modulo() -> u32 {\n T::MOD\n }\n }\n\n pub struct ModInt(pub u32, PhantomData);\n\n impl Clone for ModInt {\n fn clone(&self) -> Self {\n ModInt::new_unchecked(self.0)\n }\n }\n\n impl Copy for ModInt {}\n\n impl Add for ModInt {\n type Output = ModInt;\n fn add(self, rhs: Self) -> Self::Output {\n let mut d = self.0 + rhs.0;\n if d >= T::modulo() {\n d -= T::modulo();\n }\n ModInt::new_unchecked(d)\n }\n }\n\n impl AddAssign for ModInt {\n fn add_assign(&mut self, rhs: Self) {\n *self = *self + rhs;\n }\n }\n\n impl Sub for ModInt {\n type Output = ModInt;\n fn sub(self, rhs: Self) -> Self::Output {\n let mut d = T::modulo() + self.0 - rhs.0;\n if d >= T::modulo() {\n d -= T::modulo();\n }\n ModInt::new_unchecked(d)\n }\n }\n\n impl SubAssign for ModInt {\n fn sub_assign(&mut self, rhs: Self) {\n *self = *self - rhs;\n }\n }\n\n impl Mul for ModInt {\n type Output = ModInt;\n fn mul(self, rhs: Self) -> Self::Output {\n let v = self.0 as u64 * rhs.0 as u64 % T::modulo() as u64;\n ModInt::new_unchecked(v as u32)\n }\n }\n\n impl MulAssign for ModInt {\n fn mul_assign(&mut self, rhs: Self) {\n *self = *self * rhs;\n }\n }\n\n impl Neg for ModInt {\n type Output = ModInt;\n fn neg(self) -> Self::Output {\n if self.0 == 0 {\n Self::zero()\n } else {\n Self::new_unchecked(T::modulo() - self.0)\n }\n }\n }\n\n impl std::fmt::Display for ModInt {\n fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n }\n\n impl std::str::FromStr for ModInt {\n type Err = std::num::ParseIntError;\n fn from_str(s: &str) -> Result {\n let val = s.parse::()?;\n Ok(ModInt::new(val))\n }\n }\n\n impl From for ModInt {\n fn from(val: usize) -> ModInt {\n ModInt::new_unchecked((val % T::modulo() as usize) as u32)\n }\n }\n\n impl From for ModInt {\n fn from(val: u64) -> ModInt {\n ModInt::new_unchecked((val % T::modulo() as u64) as u32)\n }\n }\n\n impl From for ModInt {\n fn from(val: i64) -> ModInt {\n let m = T::modulo() as i64;\n ModInt::new((val % m + m) as u32)\n }\n }\n\n #[allow(dead_code)]\n impl ModInt {\n pub fn new_unchecked(d: u32) -> Self {\n ModInt(d, PhantomData)\n }\n pub fn zero() -> Self {\n ModInt::new_unchecked(0)\n }\n pub fn one() -> Self {\n ModInt::new_unchecked(1)\n }\n pub fn is_zero(&self) -> bool {\n self.0 == 0\n }\n }\n\n #[allow(dead_code)]\n impl ModInt {\n pub fn new(d: u32) -> Self {\n ModInt::new_unchecked(d % T::modulo())\n }\n pub fn pow(&self, mut n: u64) -> Self {\n let mut t = Self::one();\n let mut s = *self;\n while n > 0 {\n if n & 1 == 1 {\n t *= s;\n }\n s *= s;\n n >>= 1;\n }\n t\n }\n pub fn inv(&self) -> Self {\n assert!(self.0 != 0);\n self.pow(T::modulo() as u64 - 2)\n }\n }\n\n #[allow(dead_code)]\n pub fn mod_pow(r: u64, mut n: u64, m: u64) -> u64 {\n let mut t = 1 % m;\n let mut s = r % m;\n while n > 0 {\n if n & 1 == 1 {\n t = t * s % m;\n }\n s = s * s % m;\n n >>= 1;\n }\n t\n }\n}\n// ---------- end ModInt ----------\n// ---------- begin Precalc ----------\nmod precalc {\n use super::modint::*;\n #[allow(dead_code)]\n pub struct Precalc {\n inv: Vec>,\n fact: Vec>,\n ifact: Vec>,\n }\n #[allow(dead_code)]\n impl Precalc {\n pub fn new(n: usize) -> Precalc {\n let mut inv = vec![ModInt::one(); n + 1];\n let mut fact = vec![ModInt::one(); n + 1];\n let mut ifact = vec![ModInt::one(); n + 1];\n for i in 2..(n + 1) {\n fact[i] = fact[i - 1] * ModInt::new_unchecked(i as u32);\n }\n ifact[n] = fact[n].inv();\n if n > 0 {\n inv[n] = ifact[n] * fact[n - 1];\n }\n for i in (1..n).rev() {\n ifact[i] = ifact[i + 1] * ModInt::new_unchecked((i + 1) as u32);\n inv[i] = ifact[i] * fact[i - 1];\n }\n Precalc {\n inv: inv,\n fact: fact,\n ifact: ifact,\n }\n }\n pub fn inv(&self, n: usize) -> ModInt {\n assert!(n > 0);\n self.inv[n]\n }\n pub fn fact(&self, n: usize) -> ModInt {\n self.fact[n]\n }\n pub fn ifact(&self, n: usize) -> ModInt {\n self.ifact[n]\n }\n pub fn perm(&self, n: usize, k: usize) -> ModInt {\n if k > n {\n return ModInt::zero();\n }\n self.fact[n] * self.ifact[n - k]\n }\n pub fn comb(&self, n: usize, k: usize) -> ModInt {\n if k > n {\n return ModInt::zero();\n }\n self.fact[n] * self.ifact[k] * self.ifact[n - k]\n }\n }\n}\n// ---------- end Precalc ----------\n// ---------- begin input macro ----------\n// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut iter = $s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n ($($r:tt)*) => {\n let s = {\n use std::io::Read;\n let mut s = String::new();\n std::io::stdin().read_to_string(&mut s).unwrap();\n s\n };\n let mut iter = s.split_whitespace();\n input_inner!{iter, $($r)*}\n };\n}\n\nmacro_rules! input_inner {\n ($iter:expr) => {};\n ($iter:expr, ) => {};\n ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($iter, $t);\n input_inner!{$iter $($r)*}\n };\n}\n\nmacro_rules! read_value {\n ($iter:expr, ( $($t:tt),* )) => {\n ( $(read_value!($iter, $t)),* )\n };\n ($iter:expr, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($iter, $t)).collect::>()\n };\n ($iter:expr, chars) => {\n read_value!($iter, String).chars().collect::>()\n };\n ($iter:expr, bytes) => {\n read_value!($iter, String).bytes().collect::>()\n };\n ($iter:expr, usize1) => {\n read_value!($iter, usize) - 1\n };\n ($iter:expr, $t:ty) => {\n $iter.next().unwrap().parse::<$t>().expect(\"Parse error\")\n };\n}\n// ---------- end input macro ----------\n\nuse modint::*;\ntype M = ModInt;\n\nuse matrix::*;\ntype Mat = SquareMatrix;\n\nimpl SemiRing for M {\n fn zero() -> Self {\n M::zero()\n }\n fn one() -> Self {\n M::one()\n }\n}\n\nfn run() {\n input! {\n w: [usize; 7],\n }\n // 0: \u7f6e\u3044\u3066ok\n // 1: \u304a\u3044\u305f\u3089\u30c0\u30e1\n let mut mat = vec![];\n for i in 1..=7 {\n let mut m = Mat::zero(1 << i);\n for j in 0..(1 << i) {\n for k in 0..(1 << (2 * i - 1)) {\n if j & k > 0 {\n continue;\n }\n let mut next = 0;\n for x in 0..i {\n let left = x == 0 || (k >> (i + x - 1)) & 1 == 1;\n let down = k >> x & 1 == 1;\n let right = x == i - 1 || (k >> (i + x)) & 1 == 1;\n if left && down && right {\n next |= 1 << x;\n }\n }\n *m.get_mut(next, j) += M::one();\n }\n }\n mat.push(m);\n let mut m = Mat::zero(1 << i);\n for j in 0..(1 << i) {\n *m.get_mut(j, j) = M::one();\n }\n mat.push(m);\n }\n let mul = |m: &Mat, b: &[M]| -> Vec {\n let mut res = vec![M::zero(); b.len()];\n for i in 0..b.len() {\n for j in 0..b.len() {\n res[i] += *m.get(i, j) * b[j];\n }\n }\n res\n };\n let mut b = vec![M::zero(); 1 << 7];\n let mut ini = false;\n let mut w = w;\n for (i, (w, mat)) in w.iter_mut().zip(mat.chunks(2)).enumerate().rev() {\n if !ini && *w > 0 {\n *w -= 1;\n ini = true;\n let i = i + 1;\n for k in 0..(1 << (i - 1)) {\n let mut bit = 0;\n for x in 0..i {\n let left = x == 0 || k >> (x - 1) & 1 == 1;\n let down = true;\n let right = x == i - 1 || k >> x & 1 == 1;\n if left && right && down {\n bit |= 1 << x;\n }\n }\n b[bit] += M::one();\n }\n }\n b = mul(&mat[1], &b);\n b = mul(&mat[0].mat_pow(*w), &b);\n b.truncate(1 << i);\n }\n let ans = b[0];\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["matrices", "dp"], "code_uid": "2c3fae2bc3412787f064d9bd548b63d6", "src_uid": "a4bda63b95dc14185c47a08652fe41bd", "difficulty": 2700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//#[derive(Debug)]\nuse std::io::{BufWriter, stdin, stdout, Write};\n\n#[derive(Default)]\nstruct Scanner {\n buffer: Vec\n}\nimpl Scanner {\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n stdin().read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\nuse std::collections::HashSet;\n\nfn main() {\n let mut scan = Scanner::default();\n let out = &mut BufWriter::new(stdout());\n\n let mut set = HashSet::new();\n let mut n=scan.next::();\n \n set.insert(n);\n while n > 0 {\n n += 1;\n while n % 10 == 0 {\n n /= 10;\n }\n if set.contains(&n) {\n break;\n }\n set.insert(n);\n }\n writeln!(out,\"{}\",set.len()).ok();\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "8c199dcd6e1ec0e800b76598e041e49e", "src_uid": "055fbbde4b9ffd4473e6e716da6da899", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::Read;\n\nfn input(read_file: bool) -> String {\n if read_file {\n let mut file = std::fs::File::open(\"sample.txt\").unwrap();\n let mut buf = String::new();\n file.read_to_string(&mut buf).unwrap();\n buf\n } else {\n let mut buf = String::new();\n std::io::stdin().read_to_string(&mut buf).unwrap();\n buf.trim_end().to_owned()\n }\n}\n\nfn solve(ws: &mut std::str::SplitWhitespace) {\n let r: f64 = ws.next().unwrap().parse().unwrap();\n let x: f64 = ws.next().unwrap().parse().unwrap();\n let y: f64 = ws.next().unwrap().parse().unwrap();\n let xd: f64 = ws.next().unwrap().parse().unwrap();\n let yd: f64 = ws.next().unwrap().parse().unwrap();\n\n let dist = ((xd - x).powi(2) + (yd - y).powi(2)).sqrt();\n let r2 = 2.0 * r;\n\n println!(\"{}\", (dist / r2).ceil() as u32);\n}\n\nfn main() {\n const READ_FROM_FILE: bool = false;\n\n let s = input(READ_FROM_FILE);\n let mut ws = s.split_whitespace();\n\n solve(&mut ws);\n}\n", "lang_cluster": "Rust", "tags": ["math", "geometry"], "code_uid": "7d70cea3e90e93029d577bd880bda245", "src_uid": "698da80c7d24252b57cca4e4f0ca7031", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let r: i64 = scan.next();\n let x: i64 = scan.next();\n let y: i64 = scan.next();\n let xp: i64 = scan.next();\n let yp: i64 = scan.next();\n let d = (((x - xp) * (x - xp) + (y - yp) * (y - yp)) as f64).sqrt();\n let mut steps = d as i64 / (2 * r);\n if ((steps * 2 * r) as f64) < d {\n steps += 1;\n }\n println!(\"{}\", steps);\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["math", "geometry"], "code_uid": "3278ea7e526475c1a306169d77ced6ff", "src_uid": "698da80c7d24252b57cca4e4f0ca7031", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::io::Stdin;\nuse std::str::FromStr;\n\nfn read_line(stdin : &Stdin, line : &mut String) {\n match stdin.read_line(line) {\n Ok(_) => return,\n Err(msg) => panic!(\"Could not read line! Message: {}.\", msg),\n }\n}\n\nfn parse_t(s : &str) -> T {\n match s.trim().parse() {\n Ok(y) => y,\n Err(_) => panic!(\"Could not read from string!\"),\n }\n}\n\nfn read_ts(stdin : &Stdin, ts : &mut Vec) {\n let mut line = String::new();\n read_line(stdin, &mut line);\n let word_iter = line.split_whitespace();\n for word in word_iter {\n let x = parse_t(word);\n ts.push(x);\n }\n}\n\nfn max_minutes(a : isize, b : isize) -> usize {\n let mut num_minutes = 0;\n let mut m_a = a;\n let mut m_b = b;\n loop {\n if (m_a <= 0) || (m_b <= 0) {\n break;\n } else if (m_a == 1) && (m_b == 1) {\n break;\n } else {\n num_minutes = num_minutes + 1;\n if m_a <= m_b {\n m_a = m_a + 1;\n m_b = m_b - 2;\n } else {\n m_a = m_a - 2;\n m_b = m_b + 1;\n }\n }\n }\n num_minutes\n}\n\nfn main() {\n let stdin = io::stdin();\n let mut a_b = vec![];\n read_ts(&stdin, &mut a_b);\n let a = a_b[0];\n let b = a_b[1];\n let result = max_minutes(a, b);\n println!(\"{}\", result);\n}", "lang_cluster": "Rust", "tags": ["math", "greedy", "dp", "implementation"], "code_uid": "8e7d9538f32e9cc26ec4b9684e74d3e5", "src_uid": "ba0f9f5f0ad4786b9274c829be587961", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// fn count_ways(n: usize) -> u32 {\n// let mut dynamic = vec![vec![0u32; 4]; n + 1];\n// dynamic[1] = vec![1u32; 4];\n// *dynamic[1].last_mut().unwrap() = 0;\n \n// for step_count in 2..=n {\n// for vertex_id in 0..=3 {\n// for neighbor_id in (0..=3).filter(|&x| x != vertex_id) {\n// dynamic[step_count][vertex_id] += dynamic[step_count - 1][neighbor_id];\n// dynamic[step_count][vertex_id] %= 1000000007\n// }\n// }\n// }\n// *dynamic.last().unwrap().last().unwrap()\n// }\n\nfn count_ways(n: usize) -> u64 {\n if n == 1 {\n return 0;\n }\n\n let mut count_for_abc: u64 = 1;\n for step_count in 2..n {\n // dbg!(count_for_abc);\n count_for_abc *= 3;\n if step_count % 2 == 0 {\n count_for_abc -= 1;\n } else {\n count_for_abc += 1;\n }\n count_for_abc %= 1000000007;\n }\n // dbg!(count_for_abc);\n (3 * count_for_abc) % 1000000007\n}\n\n\nfn main() {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n let n = buf.trim().parse::().unwrap();\n println!(\"{}\", count_ways(n));\n}", "lang_cluster": "Rust", "tags": ["math", "matrices", "dp"], "code_uid": "88c9877ccff30ad867ff38ef01dcc808", "src_uid": "77627cc366a22e38da412c3231ac91a8", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self, BufRead, Read, Stdin};\nuse std::str::FromStr;\n\nstruct InputUtils {\n stream: Stdin,\n buffer: String,\n}\n\nimpl Default for InputUtils {\n fn default() -> Self {\n return Self {\n stream: io::stdin(),\n buffer: String::new(),\n };\n }\n}\n\nimpl Iterator for InputUtils {\n type Item = String;\n\n fn next(&mut self) -> Option {\n match self.stream.lock().lines().next() {\n Some(line) => Some(line.unwrap().trim().to_string()),\n None => None,\n }\n }\n}\n\nimpl InputUtils {\n fn read(&mut self) -> &str {\n self.buffer.clear();\n self.stream\n .lock()\n .read_to_string(&mut self.buffer)\n .expect(\"Failed to read till EOF\");\n return self.buffer.trim();\n }\n\n fn input(&mut self) -> T\n where\n T: FromStr,\n T::Err: std::fmt::Debug,\n {\n return self\n .into_iter()\n .next()\n .unwrap()\n .parse::()\n .expect(\"Failed to parse line to type\");\n }\n\n fn inputs(&mut self, delimiter: Option<&str>) -> Vec\n where\n T: FromStr,\n T::Err: std::fmt::Debug,\n {\n let line = self.into_iter().next().unwrap();\n let parts = match delimiter {\n Some(delim) => line\n .split(delim)\n .map(|part| part.parse::().expect(\"Failed to parse part\"))\n .collect(),\n None => line\n .split_whitespace()\n .map(|part| part.parse::().expect(\"Failed to parse part\"))\n .collect(),\n };\n return parts;\n }\n}\n\nmacro_rules! print_vec {\n ($x:expr, $y:expr) => {\n println!(\n \"{}\",\n $x.iter()\n .map(|x| x.to_string())\n .collect::>()\n .join($y)\n );\n };\n}\n\nfn main() {\n let mut iu = InputUtils::default();\n let modulo: i64 = 1000000007;\n let n: i32 = iu.input();\n let mut a: i64 = 1;\n let mut an: i64;\n let mut other: i64 = 0;\n let mut othern: i64;\n for _ in 0..n {\n an = other % modulo;\n othern = (((3i64 * a) % modulo) + ((2i64 * other) % modulo)) % modulo;\n a = an;\n other = othern;\n }\n println!(\"{}\", a);\n}\n", "lang_cluster": "Rust", "tags": ["math", "matrices", "dp"], "code_uid": "623e07b70c7eb0913ca61bec4da07a00", "src_uid": "77627cc366a22e38da412c3231ac91a8", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn solve(n :i32, x :i32, numbers :&Vec) -> i32 {\n let mut r = 0;\n for elem in numbers.iter() {\n if elem > &x {\n break;\n } else if elem < &x {\n r = r + 1;\n } else {\n r = r - 1;\n }\n }\n x - r\n}\n\nfn main() {\n let mut input = String::new();\n io::stdin().read_line(&mut input).expect(\"io error\");\n let arr: Vec = input.trim_right().split_whitespace().map(|x| {\n let r: i32 = x.parse().expect(\"not a number\");\n r\n }).collect();\n let n = arr[0];\n let x = arr[1];\n input.clear();\n io::stdin().read_line(&mut input).expect(\"io error\");\n let mut numbers: Vec = input.trim_right().split_whitespace().map(|x| {\n let r: i32 = x.parse().expect(\"not a number\");\n r\n }).collect();\n numbers.sort();\n println!(\"{}\", solve(n, x, numbers.as_ref()));\n}\n", "lang_cluster": "Rust", "tags": ["greedy", "implementation"], "code_uid": "14487c6b296494173a2e4687c184a036", "src_uid": "21f579ba807face432a7664091581cd8", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{Read,stdin};\n\nfn main() {\n let mut buf = String::new();\n stdin().read_to_string(&mut buf).unwrap();\n let mut tok = buf.split_whitespace();\n let mut get = || tok.next().unwrap();\n macro_rules! get {\n ($t:ty) => (get().parse::<$t>().unwrap());\n () => (get!(i64));\n }\n \n let n = get!(usize);\n let s = get().as_bytes();\n \n let mut i = 0;\n let mut c = 1;\n let mut ans = vec![];\n while i < n {\n ans.push(s[i]);\n i += c;\n c += 1;\n }\n println!(\"{}\", String::from_utf8(ans).unwrap());\n \n }\n ", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "aa6ee3aa5b147859885aef7d08f340bb", "src_uid": "08e8c0c37b223f6aae01d5609facdeaf", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{min,max};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap,BTreeSet};\n#[allow(unused_imports)]\nuse std::ops::*;\n#[allow(unused_imports)]\nuse std::collections::BinaryHeap;\n\n#[allow(unused_macros)]\nmacro_rules! ite {\n ($c:expr, $t:expr, $f:expr) => {{\n if $c { $t } else { $f }\n }};\n}\n\n// ref: tanakh \n// diff: using Parser\n#[macro_export]\nmacro_rules! input {\n (source = $s:expr, $($r:tt)*) => {\n let mut parser = Parser::from_str($s);\n input_inner!{parser, $($r)*}\n };\n (parser = $parser:ident, $($r:tt)*) => {\n input_inner!{$parser, $($r)*}\n };\n (new_stdin_parser = $parser:ident, $($r:tt)*) => {\n let stdin = std::io::stdin();\n let reader = std::io::BufReader::new(stdin.lock());\n let mut $parser = Parser::new(reader);\n input_inner!{$parser, $($r)*}\n };\n ($($r:tt)*) => {\n input!{new_stdin_parser = parser, $($r)*}\n };\n}\n\n#[macro_export]\nmacro_rules! input_inner {\n ($parser:ident) => {};\n ($parser:ident, ) => {};\n ($parser:ident, $var:ident : $t:tt $($r:tt)*) => {\n let $var = read_value!($parser, $t);\n input_inner!{$parser $($r)*}\n };\n}\n\n#[macro_export]\nmacro_rules! read_value {\n ($parser:ident, ( $($t:tt),* )) => {\n ( $(read_value!($parser, $t)),* )\n };\n ($parser:ident, [ $t:tt ; $len:expr ]) => {\n (0..$len).map(|_| read_value!($parser, $t)).collect::>()\n };\n ($parser:ident, chars) => {\n read_value!($parser, String).chars().collect::>()\n };\n ($parser:ident, usize1) => {\n read_value!($parser, usize) - 1\n };\n ($parser:ident, $t:ty) => {\n $parser.next::<$t>().expect(\"Parse error\")\n };\n}\n\nfn main() {\n input! {\n n: usize,\n s: chars,\n }\n let mut i = 0;\n let mut k = 1;\n let mut res = String::new();\n while i < n {\n res.push(s[i]);\n i += k;\n k += 1;\n }\n println!(\"{}\", res);\n}\n\nuse std::io::BufRead;\nuse std::io;\nuse std::str;\n\n// ref: tatsuya6502 \n// ref: wariuni \n// diff: using std::io::BufRead::fill_buf()\npub struct Parser {\n reader: R,\n buf: Vec,\n pos: usize,\n}\n\nimpl Parser {\n pub fn from_str(s: &str) -> Parser {\n Parser {\n reader: io::empty(),\n buf: s.as_bytes().to_vec(),\n pos: 0,\n }\n }\n}\n\nimpl Parser {\n pub fn new(reader: R) -> Parser {\n Parser {\n reader: reader,\n buf: vec![],\n pos: 0,\n }\n }\n pub fn update_buf(&mut self) {\n self.buf.clear();\n self.pos = 0;\n loop {\n let (len,complete) = {\n let buf2 = self.reader.fill_buf().unwrap();\n self.buf.extend_from_slice(buf2);\n let len = buf2.len();\n (len, buf2[len-1] <= 0x20)\n };\n self.reader.consume(len);\n if complete {\n break;\n }\n }\n }\n pub fn next(&mut self) -> Result {\n loop {\n let mut begin = self.pos;\n while begin < self.buf.len() && (self.buf[begin] <= 0x20) {\n begin += 1;\n }\n let mut end = begin;\n while end < self.buf.len() && (self.buf[end] > 0x20) {\n end += 1;\n }\n if begin != self.buf.len() {\n self.pos = end;\n return str::from_utf8(&self.buf[begin..end]).unwrap().parse::();\n }\n else {\n self.update_buf();\n }\n }\n }\n}\n\nuse std::fmt::Display;\n#[allow(dead_code)]\nfn write_vec(xs: &Vec) {\n if xs.len() == 0 {\n println!();\n return;\n }\n print!(\"{}\", xs[0]);\n for i in 1..xs.len() {\n print!(\" {}\", xs[i]);\n }\n println!();\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "a0aed31070db30de63df57b2032361d7", "src_uid": "08e8c0c37b223f6aae01d5609facdeaf", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nmacro_rules! readln {\n () => {{\n use std::io;\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim().to_string()\n }};\n ( $t:ty ) => {{\n let input = readln!();\n input.parse::<$t>().unwrap()\n }};\n ( $( $t:ty ),+ ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n (\n $(\n input.next().unwrap().parse::<$t>().unwrap(),\n )+\n )\n }}\n}\n\nfn main() {\n let (mut weight, mut height) = readln!(i32, i32);\n let (weight1, height1) = readln!(i32, i32);\n let (weight2, height2) = readln!(i32, i32);\n\n while height > 0 {\n weight += height;\n if height1 == height {\n weight = std::cmp::max(0, weight - weight1);\n } else if height2 == height {\n weight = std::cmp::max(0, weight - weight2);\n }\n height -= 1;\n }\n\n println!(\"{}\", weight);\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "7c00d63b0b309c1b408b605901ad73eb", "src_uid": "084a12eb3a708b43b880734f3ee51374", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max, min, Ordering};\n#[allow(unused_imports)]\nuse std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};\n#[allow(unused_imports)]\nuse std::io::{stdin, stdout, BufWriter, StdoutLock, Write};\n#[allow(unused_imports)]\nuse std::iter::FromIterator;\n#[allow(unused_macros)]\nmacro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }\n#[allow(unused_macros)]\nmacro_rules ! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }\n#[allow(unused_macros)]\nmacro_rules ! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , bytes ) => { read_value ! ( $ next , String ) . into_bytes ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\n#[allow(dead_code)]\npub fn with_bufwriter) -> ()>(f: F) {\n let out = stdout();\n let writer = BufWriter::new(out.lock());\n f(writer)\n}\n#[allow(unused_macros)]\nmacro_rules ! debug { ( $ ( $ a : expr ) ,* ) => { eprintln ! ( concat ! ( $ ( stringify ! ( $ a ) , \" = {:?}, \" ) ,* ) , $ ( $ a ) ,* ) } ; }\n#[allow(dead_code)]\nfn main() {\n input!{\n w: i64,\n h: i64,\n u1: i64,\n d1: i64,\n u2: i64,\n d2: i64,\n }\n let mut ans = w;\n let mut height = h;\n while height > 0 {\n ans += height;\n if d1 == height {\n ans -= u1;\n }\n if d2 == height {\n ans -= u2;\n }\n if ans < 0 {\n ans = 0;\n }\n height -= 1;\n }\n println!(\"{}\", ans);\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "09208886fa1885c2b20e28667f40dc11", "src_uid": "084a12eb3a708b43b880734f3ee51374", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut x = String::new();\n io::stdin().read_line(&mut x).expect(\"error\");\n let mut i = x.split_whitespace();\n let a:u64 = i.next().unwrap().parse().expect(\"error\");\n let b:usize = i.next().unwrap().parse().expect(\"error\");\n let mut v:Vec = Vec::new();\n for i in 1..(a as f64).sqrt() as u64+1 {\n if a % i == 0 {\n &v.push(i);\n }\n }\n let len = v.len();\n if b <= len {\n println!(\"{}\", v[b-1]);\n } else if v[len-1]*v[len-1] == a && b <= 2*len-1 {\n println!(\"{}\", a/v[2*len-1-b]);\n } else if v[len-1]*v[len-1] < a && b <= 2*len {\n println!(\"{}\", a/v[2*len-b]);\n } else {\n println!(\"-1\");\n }\n\n}\n", "lang_cluster": "Rust", "tags": ["math", "number theory"], "code_uid": "fb034ff6897d2b3e6edefd1b45226d0e", "src_uid": "6ba39b428a2d47b7d199879185797ffb", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::cmp;\nuse std::error::Error;\nuse std::io::{self, Read};\n\nfn main() -> Result<(), Box> {\n let mut stdin = io::stdin();\n let mut line = String::new();\n stdin.read_line(&mut line)?;\n let num_digits: usize = line.trim().parse()?;\n let mut digits = vec![0u8; num_digits];\n stdin.read_exact(&mut digits)?;\n let num_eights = digits.iter().filter(|c| **c == b'8').count();\n println!(\"{}\", cmp::min(num_digits / 11, num_eights));\n Ok(())\n}\n", "lang_cluster": "Rust", "tags": ["brute force"], "code_uid": "faf4c7f7197827f42b9e375e216e3e84", "src_uid": "259d01b81bef5536b969247ff2c2d776", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::stdin;\nuse std::isize;\nfn main() {\n let (x,y) = parse_input();\n let abs_x = x.abs();\n let abs_y = y.abs();\n let a = abs_x+abs_y;\n if abs_x == x && abs_y == y{\n print(0,a ,a,0)\n }else if abs_x != x && abs_y !=y{\n print(-a,0,0,-a)\n }else if abs_x !=x {\n print(-a,0,0,a)\n }else{\n print(0,-a,a,0)\n }\n}\nfn parse_input()->(isize,isize){\n let mut input = String::new();\n stdin().read_line(&mut input).unwrap();\n let v:Vec = input.trim().split_whitespace().map(|e| e.parse().unwrap()).collect();\n (v[0],v[1])\n}\nfn print(a:isize,b:isize,c:isize,d:isize){\n println!(\"{} {} {} {}\",a,b,c,d)\n}", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "bf98210e42cb660f98787dac2800466f", "src_uid": "e2f15a9d9593eec2e19be3140a847712", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n\n fn next_n(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.next::()).collect()\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let n: usize = scan.next();\n let mut arr: Vec = scan.next_n(n);\n arr.sort();\n let mut res: usize = 0;\n for i in (0..n).step_by(2) {\n res += arr[i + 1] - arr[i];\n }\n println!(\"{}\", res);\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["sortings"], "code_uid": "4c419378032e17b79c1f6c2d913dcd48", "src_uid": "55485fe203a114374f0aae93006278d3", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\n#[allow(unused_macros)]\nmacro_rules! a {\n ($c: tt, $x: expr, $y: expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\nstruct WordReader {\n it : std::vec::IntoIter,\n}\n#[allow(dead_code)]\nimpl WordReader {\n fn new(mut reader: T) -> WordReader {\n let mut s = String::new();\n reader.read_to_string(&mut s).unwrap();\n WordReader {\n it : s.split_ascii_whitespace().map(String::from)\n .collect::>().into_iter()\n }\n }\n fn from_stdin() -> WordReader {\n WordReader::new(std::io::stdin())\n }\n fn s(&mut self) -> String {\n self.it.next().unwrap()\n }\n fn ab(&mut self) -> Vec {\n self.it.next().unwrap().into_bytes()\n }\n fn i(&mut self) -> i32 {\n self.it.next().unwrap().parse().unwrap()\n }\n fn ai(&mut self, n: usize) -> Vec {\n let mut a = Vec::with_capacity(n);\n for _ in 0..n { a.push(self.i()); }\n a\n }\n}\n\nfn main() {\n let mut input = WordReader::from_stdin();\n let n = input.i();\n let mut sum = 0;\n let mut sol = 0;\n for i in 1.. {\n sum += i * (i+1) / 2;\n if sum <= n {\n sol = i;\n } else {\n break;\n }\n }\n println!(\"{}\", sol);\n}\n\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "a551e4618a66d029c2fdc1287d21b14e", "src_uid": "873a12edffc57a127fdfb1c65d43bdb0", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "macro_rules! readln {\n () => {{\n use std::io;\n \n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim().to_string()\n }};\n ( $t:ty ) => {{\n let input = readln!();\n input.parse::<$t>().unwrap()\n }};\n ( $( $t:ty ),+ ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n (\n $(\n input.next().unwrap().parse::<$t>().unwrap(),\n )+\n )\n }}\n}\n\nmacro_rules! readvec {\n ( $t:ty ) => {{\n let input = readln!();\n let mut input = input.split_whitespace();\n let mut result = Vec::new();\n for elem in input {\n result.push(elem.parse::<$t>().unwrap());\n }\n result\n }}\n}\n\nfn main() {\n let n = readln!(i32);\n let mut sum = 0;\n let mut cur = 0;\n for i in 1.. {\n cur += i;\n sum += cur;\n if sum > n {\n println!(\"{}\",i-1);\n return;\n }\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "9770ab7eca15ff0112c0f33751c0809b", "src_uid": "873a12edffc57a127fdfb1c65d43bdb0", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{stdin, Read};\nuse std::str::FromStr;\nuse std::num::ParseIntError;\nuse std::ops::*;\nuse std::fmt;\n\nstatic mut TBL: [[Mnum; 1001]; 1001] = [[Mnum(0); 1001]; 1001];\n\nfn main() {\n let mut ws = Words::new();\n macro_rules! pop {($t:ty) => { ws.next().unwrap().parse::<$t>().unwrap() }; ($($t:ty),+) => { ($(pop!($t),)*) } }\n macro_rules! popn { ($n:expr $(,$t:ty)+) => { (0..$n).map(|_| pop!($($t),* )).collect::>() } }\n let (k, pa, pb) = pop!(usize, Mnum, Mnum);\n\n let d = Mnum(inv(pa.0 + pb.0, MBASE));\n let (a, b) = (pa * d, pb * d);\n let c = pa * Mnum(inv(pb.0, MBASE));\n\n for i in (1..k + 1).rev() {\n for j in (0..k + 1).rev() {\n unsafe {\n TBL[i][j] = if i + j >= k { Mnum(i as i64 + j as i64) + c } else { a * TBL[i + 1][j] + b * TBL[i][j + i] };\n }\n }\n }\n print!(\"{}\", unsafe {TBL[1][0]});\n}\n\nfn inv(x: i64, b: i64) -> i64 {\n let mut s = (0, 1, b, x); // (t, t1, r, r1)\n while s.3 != 0 {\n let q = s.2 / s.3;\n s = (s.1, s.0 - q * s.1, s.3, s.2 - q * s.3)\n }\n\n assert!(s.2 <= 1);\n if s.0 < 0 { s.0 + b } else { s.0 }\n}\n\n\nconst MBASE: i64 = 1000000007;\n#[derive(Clone, Copy, Debug)] struct Mnum(i64);\nimpl Add for Mnum {\n type Output = Mnum;\n fn add(self, rhs: Mnum) -> Mnum { Mnum((self.0 + rhs.0) % MBASE) }\n}\n\nimpl Mul for Mnum {\n type Output = Mnum;\n fn mul(self, rhs: Mnum) -> Mnum { Mnum((self.0 * rhs.0) % MBASE) }\n}\n\nimpl FromStr for Mnum {\n type Err = ParseIntError;\n\n fn from_str(s: &str) -> Result {\n Ok(Mnum(i64::from_str(s)?))\n }\n}\n\nimpl fmt::Display for Mnum {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"{}\", self.0)\n }\n}\n\nfn s32(s: String) -> i32 { s.parse().unwrap() }\n\n\nconst SZ: usize = 4096;\nstruct Words {\n buf: [u8; SZ],\n b: usize,\n e: usize\n}\n\nfn is_ws(c: u8) -> bool {\n match c as char {\n '\\r' | '\\n' | ' ' => true,\n _ => false\n }\n}\n\nimpl Words {\n fn new() -> Words { Words { buf: [0; SZ], b: 0, e: 0 } }\n\n fn len(&self) -> usize { self.e - self.b }\n\n fn fill(&mut self) {\n if self.len() <= 0 {\n self.b = 0;\n self.e = stdin().read(&mut self.buf).unwrap_or(0);\n }\n }\n}\n\nimpl Iterator for Words {\n type Item = String;\n fn next(&mut self) -> Option {\n let mut s = String::new();\n let mut ext = false;\n\n loop {\n self.fill();\n if self.len() <= 0 { return if ext { Some(s) } else { None } }\n\n match (self.b..).zip(self.buf[self.b..self.e].iter()).take_while(|&(_, &c)| is_ws(c)).last() {\n None => {},\n Some((i, _)) => {\n self.b = i + 1;\n if ext { return Some(s) }\n }\n }\n\n match (self.b..).zip(self.buf[self.b..self.e].iter()).take_while(|&(_, &c)| !is_ws(c)).last() {\n None => {},\n Some((i, _)) => {\n s.push_str(match String::from_utf8_lossy(&self.buf[self.b..i + 1]) {\n std::borrow::Cow::Borrowed(s) => s,\n _ => panic!(\"\")\n });\n self.b = i + 1;\n if self.len() <= 0 {\n ext = true;\n } else {\n return Some(s);\n }\n }\n }\n }\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp", "probabilities"], "code_uid": "f87aceb000ccb0b9637d752031ad7b45", "src_uid": "0dc9f5d75143a2bc744480de859188b4", "difficulty": 2200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::*;\nuse std::str::FromStr;\n\nfn main() {\n let stdin = stdin();\n let mut sc = Scanner::new(stdin.lock());\n let mut a: [usize; 14] = [0; 14];\n for i in 0..14 {\n a[i] = sc.next::();\n }\n let mut max: u64 = 0;\n for i in 0..14 {\n if a[i] == 0 {\n continue;\n }\n let mut b: [usize; 14] = a.clone();\n b[i] = 0;\n for j in 0..14 {\n b[(i + j + 1) % 14] += a[i] / 14 + (if j < a[i] % 14 { 1 } else { 0 });\n }\n\n let mut sum: u64 = 0;\n for j in 0..14 {\n if b[j] % 2 == 0 {\n sum += b[j] as u64;\n }\n }\n max = std::cmp::max(max, sum);\n }\n println!(\"{}\", max);\n}\n\n// \u57fa\u672c\u7684\u306b 14 \u5272\u3063\u305f\u6570\u8db3\u3059\n\npub struct Scanner {\n reader: B,\n buffer: Vec,\n}\n\nimpl Scanner {\n pub fn new(reader: B) -> Self {\n Self {\n reader,\n buffer: Vec::new(),\n }\n }\n\n pub fn next(&mut self) -> T\n where\n T::Err: ::std::fmt::Debug,\n {\n if let Some(front) = self.buffer.pop() {\n front.parse::().expect(&front)\n } else {\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Line not read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n self.next()\n }\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "7df1dca8b0819ceb485064c0a4feb26e", "src_uid": "1ac11153e35509e755ea15f1d57d156b", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str::FromStr;\n\nuse std::io::prelude::*;\nuse std::io::BufReader;\nuse std::cmp::{max, min};\n\nfn get_line() -> String {\n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n input\n}\n\nfn get_vec() -> Vec\nwhere T: FromStr,\n ::Err: std::fmt::Debug,\n{\n get_line().split_whitespace().map(|k| k.parse().unwrap()).collect()\n}\n\nfn main() {\n let (a, b): (u64, u64) = {\n let input = get_line();\n let mut it = input.split_whitespace().map(|x| x.parse().unwrap());\n (\n it.next().unwrap(),\n it.next().unwrap(),\n )\n };\n\n let ans = if b - a < 10 {\n (a..b).fold(1, |acc, k| ((k + 1) * acc) % 10)\n } else {\n 0\n };\n\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "ecea4e27348ea098b6bddf231834b6b9", "src_uid": "2ed5a7a6176ed9b0bda1de21aad13d60", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn get_count(n: u32) -> u32 {\n let mut count = 0;\n\n for i in 1..n {\n if n % i == 0 {\n count += 1;\n }\n }\n\n count\n}\n\npub fn solution() -> io::Result<()> {\n let mut number = String::new();\n\n io::stdin().read_line(&mut number)?;\n let number = number.trim().parse::().unwrap();\n\n println!(\"{}\", get_count(number));\n Ok(())\n}\n\nfn main() {\n solution();\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "86f44f03cbda93e7dc8ee21ba28987c3", "src_uid": "89f6c1659e5addbf909eddedb785d894", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rusT {{{\nuse std::io::*; use std::str::{self,*}; use std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::{self,*};\n#[allow(unused_imports)] use std::ops::{self,*};\n#[allow(unused_imports)] use std::iter::{self,*};\n#[allow(unused_imports)] use std::collections::*;\n#[allow(unused_imports)] use std::cell::*;\n#[allow(unused_macros)] macro_rules! min {\n\t($x:expr,$y:expr) => {{ let b=$y; let a=&mut$x; if b < *a {*a=b; true} else {false} }};\n}\n#[allow(unused_macros)] macro_rules! max {\n\t($x:expr,$y:expr) => {{ let b=$y; let a=&mut$x; if b > *a {*a=b; true} else {false} }};\n}\n#[allow(unused_macros)] macro_rules! l {\n\t($($v:ident),+ =$e:expr) => {$(let$v=$e;)+};\n\t($($v:ident),+:$t:ty=$e:expr) => {$(let$v:$t=$e;)+};\n\t(mut $($v:ident),+ =$e:expr) => {$(let mut$v=$e;)+};\n\t(mut $($v:ident),+:$t:ty=$e:expr) => {$(let mut$v:$t=$e;)+};\n}\n#[allow(unused_macros)] macro_rules! v {\n\t([$d:expr]$($s:tt)+) => {vec![v!($($s)+);$d]};\n\t([]) => {Vec::new()}; ([$e:expr]) => {Vec::with_capacity($e)}; (=$e:expr) => {$e};\n}\n#[allow(unused_macros)] macro_rules! rep { {[$c:expr]$($s:tt)+} => {for _ in 0..$c {$($s)+}} }\n#[allow(dead_code)] fn reader() -> WordReaderC { WordReaderC::new() }\n#[allow(dead_code)] fn writer() -> BufWriter { BufWriter::new(stdout()) }\nstruct WordReaderC {buf: Vec, pos: usize, q: std::io::StdinLock<'static>}//'\n#[allow(dead_code)] impl WordReaderC {\n\tfn new() -> Self {\n\t\tlet r = unsafe {&*Box::into_raw(Box::new(stdin()))};\n\t\tSelf { q: r.lock(), buf: v!([]), pos: 0 }\n\t}\n\tfn next_line(&mut self) -> bool {\n\t\tself.buf.clear(); self.pos = 0;\n\t\tself.q.read_until(b'\\n', &mut self.buf).unwrap_or(0) > 0\n\t}\n\tfn is_ws(c: u8) -> bool {\n\t\tc == b' ' || c == b'\\r' || c == b'\\n' || c == b'\\t'\n\t}\n\tfn byte(&mut self) -> Option {\n\t\tif self.pos == self.buf.len() { if !self.next_line() { return None; } }\n\t\tself.pos += 1; Some(self.buf[self.pos - 1])\n\t}\n\tfn vb(&mut self) -> Vec {\n\t\tlet mut s = v!([8]);\n\t\tlet mut f = false;\n\t\tloop {\n\t\t\tif let Some(c) = self.byte() {\n\t\t\t\tif !Self::is_ws(c) {\n\t\t\t\t\ts.push(c);\n\t\t\t\t\tf = true;\n\t\t\t\t} else if f { break; }\n\t\t\t} else { break; }\n\t\t}\n\t\ts\n\t}\n\tfn vvb(&mut self, r: usize, c: Option) -> Vec> {\n\t\tlet mut res = v!([r]);\n\t\tlet c = c.unwrap_or(0);\n\t\trep!{[r]\n\t\t\tlet t = self.vb();\n\t\t\tassert!(c == 0 || t.len() == c);\n\t\t\tres.push(t);\n\t\t}\n\t\tres\n\t}\n\tfn s(&mut self) -> String { String::from_utf8(self.vb()).expect(\"invalid utf8\") }\n\tfn i(&mut self) -> i32 { self.p() }\n\tfn l(&mut self) -> i64 { self.p() }\n\tfn u(&mut self) -> usize { self.p() }\n\tfn f(&mut self) -> f64 { self.p() }\n\tfn vi(&mut self, n: usize) -> Vec { self.vp(n) }\n\tfn vl(&mut self, n: usize) -> Vec { self.vp(n) }\n\tfn vu(&mut self, n: usize) -> Vec { self.vp(n) }\n\tfn ii(&mut self, n: usize) -> impl Iterator { self.ip(n).into_iter() }\n\tfn iu(&mut self, n: usize) -> impl Iterator { self.ip(n).into_iter() }\n\tfn p(&mut self) -> T where T::Err: Debug {\n\t\tlet w = self.vb(); str::from_utf8(w.as_ref()).unwrap().parse::().unwrap()\n\t}\n\tfn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n\t\t(0..n).map(|_|self.p()).collect()\n\t}\n\tfn ip(&mut self, n: usize) -> impl Iterator where T::Err: Debug {\n\t\tself.vp(n).into_iter()\n\t}\n}\n//------------------- End rusT }}}\n\nfn main() {\n\tlet mut rin = reader();\n\tlet mut rout = writer();\n\n\trep!{[rin.u()]\n\t\tlet s = rin.vb();\n\t\tlet n = s.len();\n\t\tlet res = 10 * (s[0] - b'1') as usize + n * (n+1) / 2;\n\t\twriteln!(rout, \"{}\", res).ok();\n\t}\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "ceed3774eff00d7149876d40b8feefc9", "src_uid": "289a55128be89bb86a002d218d31b57f", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str::FromStr;\nuse std::num::ParseIntError;\nuse std::ops::Index;\n\nstruct RevBinary {\n data: Vec,\n}\n\nimpl FromStr for RevBinary {\n type Err = ParseIntError;\n\n fn from_str(s: &str) -> Result {\n let i = s.parse::()?;\n\n Ok(RevBinary::new(i))\n }\n}\n\nimpl Index for RevBinary {\n type Output = bool;\n\n fn index(&self, i: usize) -> &Self::Output {\n &self.data[self.data.len() - i - 1]\n }\n}\n\nimpl RevBinary {\n fn new(x : u32) -> RevBinary {\n let mut y = x;\n let mut bin : Vec = Vec::new();\n while y != 0 {\n bin.push(if y % 2 == 1 { true } else { false }); \n y /= 2;\n }\n RevBinary {\n data: bin,\n }\n }\n\n fn size(&self) -> usize {\n self.data.len()\n }\n}\n\nfn process_node(all: &Vec, ind: Vec, depth: usize, k: u32) -> u32 {\n let mut result : u32 = ind.iter().take(k as usize).map(|&x| all[x].size() - depth).sum::() as u32;\n\n let mut new_ind0 : Vec = Vec::new();\n let mut new_ind1 : Vec = Vec::new();\n for i in ind.iter().filter(|&&x| all[x].size() > depth) {\n if all[*i][depth] {\n new_ind1.push(*i);\n } else {\n new_ind0.push(*i);\n } \n }\n if new_ind0.len() >= k as usize {\n result = result.min(process_node(&all, new_ind0, depth + 1, k));\n }\n if new_ind1.len() >= k as usize {\n result = result.min(process_node(&all, new_ind1, depth + 1, k));\n }\n result\n}\n\nfn main() {\n let mut input = String::new();\n io::stdin().read_line(&mut input).expect(\"failed to read input\");\n let mut input_iter = input.split_whitespace();\n let n = input_iter.next().unwrap().parse::().unwrap();\n let k = input_iter.next().unwrap().parse::().unwrap();\n let mut buffer = String::new();\n io::stdin().read_line(&mut buffer).expect(\"failed to read input\");\n let mut a = buffer.split_whitespace().map(|x| x.parse::().unwrap()).collect::>();\n a.sort_by(|a, b| a.size().cmp(&b.size()));\n \n println!(\"{}\", process_node(&a, (0..n).collect::>(), 0, k));\n}", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "d9573d70427c8e16c64073a4bdbd0d73", "src_uid": "ed1a2ae733121af6486568e528fe2d84", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::Read;\n\nfn input(read_file: bool) -> String {\n if read_file {\n let mut file = std::fs::File::open(\"sample.txt\").unwrap();\n let mut buf = String::new();\n file.read_to_string(&mut buf).unwrap();\n buf\n } else {\n let mut buf = String::new();\n std::io::stdin().read_to_string(&mut buf).unwrap();\n buf.trim_end().to_owned()\n }\n}\n\nfn solve(ws: &mut std::str::SplitWhitespace) {\n let s1: Vec = ws.next().unwrap().chars().collect();\n let s2: Vec = ws.next().unwrap().chars().collect();\n\n let mut p1 = 0;\n for c in s1.iter() {\n if *c == '+' {\n p1 += 1;\n } else {\n p1 -= 1;\n }\n }\n\n let mut p2 = 0;\n let mut uc = 0;\n for c in s2.iter() {\n match c {\n '+' => p2 += 1,\n '-' => p2 -= 1,\n _ => uc += 1,\n }\n }\n\n let mut v: Vec = Vec::new();\n for bit in 0..1 << uc {\n let mut p = p2;\n for i in 0..uc {\n if bit >> i & 1 == 1 {\n p += 1;\n } else {\n p -= 1;\n }\n }\n v.push(p);\n }\n\n let mut cnt = 0;\n for x in v.iter() {\n if *x == p1 {\n cnt += 1;\n }\n }\n\n println!(\"{}\", cnt as f64 / v.len() as f64);\n}\n\nfn main() {\n const READ_FROM_FILE: bool = false;\n\n let s = input(READ_FROM_FILE);\n let mut ws = s.split_whitespace();\n\n solve(&mut ws);\n // let t = ws.next().unwrap().parse().unwrap();\n // for _ in 0..t {}\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "dp", "combinatorics", "bitmasks", "probabilities"], "code_uid": "2516f9950ef6a748c3811464e9bbe5f4", "src_uid": "f7f68a15cfd33f641132fac265bc5299", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let sent: String = scan.next();\n let received: String = scan.next();\n let mut pos: isize = 0;\n for mov in sent.chars() {\n if mov == '+' {\n pos += 1;\n } else if mov == '-' {\n pos -= 1;\n }\n }\n let mut new_pos: isize = 0;\n let mut unknown: isize = 0;\n for mov in received.chars() {\n if mov == '+' {\n new_pos += 1;\n } else if mov == '-' {\n new_pos -= 1;\n } else {\n unknown += 1;\n }\n }\n let needed = pos - new_pos;\n if needed > unknown {\n println!(\"{:.10}\", 0.0f64);\n } else {\n let total: usize = 2usize.pow(unknown as u32);\n let mut valid = 0isize;\n for i in 0..total {\n if (2 * i.count_ones() as isize - unknown as isize) == needed {\n valid += 1;\n }\n }\n let result = (valid as f64) / (total as f64);\n println!(\"{:.10}\", result);\n }\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "math", "dp", "combinatorics", "bitmasks", "probabilities"], "code_uid": "00038a62b08dadcce378d1de6d1a550b", "src_uid": "f7f68a15cfd33f641132fac265bc5299", "difficulty": 1300.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(dead_code)]\n#![allow(unused_imports)]\n#![allow(unused_macros)]\n\nuse std::char::*;\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io::*;\nuse std::str::FromStr;\n\nmacro_rules! debug {($($a:expr),*) => {println!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);}}\nmacro_rules! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }\nmacro_rules! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }\nmacro_rules! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\n\n#[derive(PartialEq, PartialOrd)]\npub struct Total(pub T);\nimpl Eq for Total {}\nimpl Ord for Total { fn cmp(&self, other: &Total) -> std::cmp::Ordering { self.0.partial_cmp(&other.0).unwrap() }}\n\nconst MAX:usize = 5;\nconst MOD:i64 = 1e9 as i64 + 7;\n\n\nfn read() -> T {\n let stdin = stdin();\n let stdin = stdin.lock();\n let token: String = stdin\n .bytes()\n .map(|c| c.expect(\"failed to read char\") as char)\n .skip_while(|c| c.is_whitespace())\n .take_while(|c| !c.is_whitespace())\n .collect();\n token.parse().ok().expect(\"failed to parse token\")\n}\n\nfn read_vec() -> Vec {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).ok();\n s.trim().split_whitespace()\n .map(|e| e.parse().ok().unwrap()).collect()\n}\n\n\nuse std::f64;\n\nfn min(a:T, b:T) -> T {\n if a < b { a }\n else { b }\n}\n\nuse std::hash::Hash;\nfn inc(map:&mut BTreeMap, key:T) {\n let count = map.entry(key).or_insert(0);\n *count += 1;\n}\n\nfn mod_pow(x:i64, n:i64, m:i64) -> i64 {\n let mut x = x;\n let mut n = n;\n let mut res = 1i64;\n while n > 0 {\n if n & 1 > 0 {\n res = res * x % m;\n }\n x = x * x % m;\n n >>= 1;\n }\n res\n}\n\n\nfn main() {\n input!{n:i64};\n let s = n.to_string();\n\n let mut que = VecDeque::new();\n que.push_back(vec!['4']);\n que.push_back(vec!['7']);\n let mut cnt = 0;\n while !que.is_empty() {\n let mut chs = que.pop_front().unwrap();\n cnt += 1;\n //debug!(chs,cnt);\n if s == chs.iter().cloned().collect::() {\n println!(\"{}\", cnt);\n return();\n }\n //debug!(chs);\n chs.push('4');\n que.push_back(chs.clone());\n chs.pop();\n chs.push('7');\n que.push_back(chs.clone());\n\n }\n}\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation", "combinatorics", "bitmasks"], "code_uid": "d94ad14b35c643c5938aafd35aeb7f4c", "src_uid": "6a10bfe8b3da9c11167e136b3c6fb2a3", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next_line(&self) -> String {\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n line\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let line = self.next_line();\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn _main() -> std::io::Result<()> {\n let mut scan = Scan::new();\n let n: usize = scan.next();\n let mut oddeven = false;\n let mut parx = 0usize;\n let mut pary = 0usize;\n for _ in 0..n {\n let x: usize = scan.next();\n let y: usize = scan.next();\n parx = (parx + x) & 1;\n pary = (pary + y) & 1;\n if (x & 1) ^ (y & 1) == 1 {\n oddeven = true;\n }\n }\n if parx == 0 && pary == 0 {\n println!(\"0\");\n } else if n > 1 && oddeven && (parx * pary) == 1 {\n println!(\"1\");\n } else {\n println!(\"-1\");\n }\n Ok(())\n}\n\nfn main() -> std::io::Result<()> {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap()?;\n Ok(())\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "fb64a2b55c9797e1fa11ea455be360c0", "src_uid": "f9bc04aed2b84c7dd288749ac264bb43", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::{self};\n\nfn is_paly(x: i32) -> bool {\n let h = (x / 60) % 24;\n let m = x % 60;\n h % 10 * 10 + h / 10 == m\n}\n\nfn find_paly(x: i32) -> i32 {\n for i in x..3000{\n if is_paly(i) {return i - x}\n }\n -1\n}\n\n\n// fn read_int() -> Result {\n// let mut str = String::new();\n// try!(io::stdin().read_line(&mut str).map_err(|e| e.to_string()));\n// str.trim().parse::().map_err(|e|e.to_string())\n// }\n\nfn read_time() -> Result {\n let mut str = String::new();\n try!(io::stdin().read_line(&mut str).map_err(|e| e.to_string()));\n let parts: Vec<&str> = str.split(':').collect();\n if parts.len() != 2 { return Err(String::from(\"wrong format, should have single : delimiter\")) };\n let x = try!(parts[0].trim().parse::().map_err(|e|e.to_string()));\n let y = try!(parts[1].trim().parse::().map_err(|e|e.to_string()));\n Ok(x * 60 + y)\n}\n\nfn main() {\n let tt = read_time().unwrap();\n print!(\"{}\", find_paly(tt));\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "85e2dec6d7be22276833f79d656b442b", "src_uid": "3ad3b8b700f6f34b3a53fdb63af351a5", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(dead_code, unused_macros, unused_imports)]\nuse std::{cell::{Cell, RefCell, UnsafeCell}, cmp::{Ordering, Reverse, max, min}, collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque, hash_map::{DefaultHasher, RandomState}}, error::Error, fmt::{Display, Write as FmtWrite}, hash::{BuildHasher, Hash, Hasher}, io::{BufWriter, Read, Stdin, Stdout, Write}, iter::{FromIterator, Peekable}, mem::swap, ops::*, process::exit, rc::Rc, str::{FromStr, from_utf8_unchecked}, time::{Duration, Instant}, convert::TryInto, marker::PhantomData};\n\nconst IO_BUF_SIZE: usize = 1 << 16;\ntype Input = Scanner;\ntype Output = BufWriter;\nfn _init_input() -> Input { Scanner::new(std::io::stdin()) }\nfn _init_output() -> Output { BufWriter::with_capacity(IO_BUF_SIZE, std::io::stdout()) }\n\n#[repr(transparent)] struct Unsync(T);\nunsafe impl Sync for Unsync {}\n \ntype BadLazy = Unsync>>;\nimpl BadLazy {\n const fn new() -> Self { Self(UnsafeCell::new(None)) }\n}\n \nstatic INPUT: BadLazy = BadLazy::new();\nstatic OUTPUT: BadLazy = BadLazy::new();\n \nfn inp R, R>(f: F) -> R {\n unsafe { f((&mut *INPUT.0.get()).get_or_insert_with(_init_input)) }\n}\nfn out R, R>(f: F) -> R {\n unsafe { f((&mut *OUTPUT.0.get()).get_or_insert_with(_init_output)) }\n}\n\nmacro_rules! read {\n () => { read() };\n ($t: ty) => { read::<$t>() };\n ($t: ty, $($tt: ty),*) => { (read::<$t>(), $(read::<$tt>(),)*) };\n [$t: ty; $n: expr] => { read_vec::<$t>($n) };\n}\nmacro_rules! println { \n () => { out(|x| { let _ = writeln!(x); }) };\n ($exp: expr) => { out(|x| { let _ = writeln!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = writeln!(x, $fmt, $($arg)*); }) }\n}\nmacro_rules! print { \n ($exp: expr) => { out(|x| { let _ = write!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = write!(x, $fmt, $($arg)*); }) }\n}\n\nfn out_flush() { out(|x| { let _ = x.flush(); }); }\n\nfn input_is_eof() -> bool { inp(|x| x.eof()) }\nfn read_byte() -> u8 { inp(|x| x.byte()) }\nfn read_bytes_no_skip(n: usize) -> Vec { inp(|x| x.bytes_no_skip(n)) }\nfn read_bytes(n: usize) -> Vec { inp(|x| x.bytes(n)) }\nfn read_bytes2(n: usize, m: usize) -> Vec> { inp(|x| x.bytes2(n, m)) }\nfn read_token() -> Vec { inp(|x| x.token_bytes()) }\nfn read_token_str() -> String { unsafe { String::from_utf8_unchecked(read_token()) } }\nfn read_line() -> Vec { inp(|x| x.line_bytes()) }\nfn read_line_str() -> String { unsafe { String::from_utf8_unchecked(read_line()) } }\nfn read() -> T { read_token_str().parse::().ok().expect(\"failed parse\") }\nfn read_vec(n: usize) -> Vec { (0..n).map(|_| read()).collect() }\nfn read_vec2(n: usize, m: usize) -> Vec> { (0..n).map(|_| read_vec(m)).collect() }\n\nstruct Scanner {\n src: R,\n _buf: Vec,\n _pt: usize, // pointer\n _rd: usize, // bytes read\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new(src: R) -> Scanner {\n Scanner { src, _buf: vec![0; IO_BUF_SIZE], _pt: 1, _rd: 1 }\n }\n \n fn _check_buf(&mut self) {\n if self._pt == self._rd {\n self._rd = self.src.read(&mut self._buf).unwrap_or(0);\n self._pt = (self._rd == 0) as usize;\n }\n }\n \n // returns true if end of file\n fn eof(&mut self) -> bool {\n self._check_buf();\n self._rd == 0\n }\n \n // filters \\r, returns \\0 if eof\n fn byte(&mut self) -> u8 {\n loop {\n self._check_buf();\n if self._rd == 0 { return 0; }\n let res = self._buf[self._pt];\n self._pt += 1;\n if res != b'\\r' { return res; }\n }\n }\n\n fn bytes_no_skip(&mut self, n: usize) -> Vec { (0..n).map(|_| self.byte()).collect() }\n fn bytes(&mut self, n: usize) -> Vec {\n let res = self.bytes_no_skip(n);\n self.byte();\n res\n }\n fn bytes2(&mut self, n: usize, m: usize) -> Vec> { (0..n).map(|_| self.bytes(m)).collect() }\n \n fn token_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c <= b' ' {\n if c == b'\\0' { return res; }\n c = self.byte();\n }\n loop {\n res.push(c);\n c = self.byte();\n if c <= b' ' { return res; }\n }\n }\n \n fn line_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c != b'\\n' && c != b'\\0' {\n res.push(c);\n c = self.byte();\n }\n res\n }\n}\n\ntrait JoinToStr { \n fn join_to_str(self, sep: &str) -> String;\n fn concat_to_str(self) -> String;\n}\nimpl> JoinToStr for I { \n fn join_to_str(mut self, sep: &str) -> String {\n match self.next() {\n Some(first) => {\n let mut res = first.to_string();\n while let Some(item) = self.next() {\n res.push_str(sep);\n res.push_str(&item.to_string());\n }\n res\n }\n None => { String::new() }\n }\n }\n \n fn concat_to_str(self) -> String {\n let mut res = String::new();\n for item in self { res.push_str(&item.to_string()); }\n res\n }\n}\ntrait AsStr { fn as_str(&self) -> &str; }\nimpl AsStr for [u8] { fn as_str(&self) -> &str {std::str::from_utf8(self).expect(\"attempt to convert non-UTF8 byte string.\")} }\n\nmacro_rules! veci {\n ($n:expr , $i:ident : $gen:expr) => {{\n let _veci_n = $n;\n let mut _veci_list = Vec::with_capacity(_veci_n);\n for $i in 0.._veci_n {\n _veci_list.push($gen);\n }\n _veci_list\n }};\n ($n:expr , $gen:expr) => { veci!($n, _veci_: $gen) }\n}\n\nfn abs_diff + PartialOrd>(x: T, y: T) -> T {\n if x < y { y - x } else { x - y }\n}\n\ntrait CommonNumExt {\n fn div_ceil(self, b: Self) -> Self;\n fn div_floor(self, b: Self) -> Self;\n fn gcd(self, b: Self) -> Self;\n fn highest_one(self) -> Self;\n fn lowest_one(self) -> Self;\n fn sig_bits(self) -> u32;\n}\n\nmacro_rules! impl_common_num_ext {\n ($($ix:tt = $ux:tt),*) => {\n $(\n impl CommonNumExt for $ux {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { self / b }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self; while a != 0 { swap(&mut a, &mut b); a %= b; }\n b\n }\n #[inline] fn highest_one(self) -> Self { \n if self == 0 { 0 } else { const ONE: $ux = 1; ONE << self.sig_bits() - 1 } \n }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ux>() as u32 * 8 - self.leading_zeros() }\n }\n\n impl CommonNumExt for $ix {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if self ^ b >= 0 && r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { \n let q = self / b; let r = self % b;\n if self ^ b < 0 && r != 0 { q - 1 } else { q }\n }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self; while a != 0 { swap(&mut a, &mut b); a %= b; }\n b.abs()\n }\n #[inline] fn highest_one(self) -> Self { (self as $ux).highest_one() as _ }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ix>() as u32 * 8 - self.leading_zeros() }\n }\n )*\n }\n}\nimpl_common_num_ext!(i8 = u8, i16 = u16, i32 = u32, i64 = u64, i128 = u128, isize = usize);\n\ntrait ChMaxMin {\n fn chmax(&mut self, v: T) -> bool;\n fn chmin(&mut self, v: T) -> bool;\n}\nimpl ChMaxMin for Option {\n fn chmax(&mut self, v: T) -> bool { if self.is_none() || v > *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if self.is_none() || v < *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n}\nimpl ChMaxMin for T {\n fn chmax(&mut self, v: T) -> bool { if v > *self { *self = v; true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if v < *self { *self = v; true } else { false } }\n}\n\n// * end commons * //\n\n#[macro_use]\n#[allow(dead_code)]\nmod modint {\n use std::{fmt::{Display, Formatter}, marker::PhantomData, mem::swap, ops::*, str::FromStr, cell::Cell};\n use crate::ModInt;\n \n pub trait RemEuclidU32: Copy {\n /// Calculates `self` _mod_ `modulus` losslessly.\n fn rem_euclid_u32(self, modulus: u32) -> u32;\n }\n \n macro_rules! impl_rem_euclid_u32_for_small_signed {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self as i64).rem_euclid(i64::from(modulus)) as _\n }\n }\n )*\n }\n }\n \n impl_rem_euclid_u32_for_small_signed!(i8, i16, i32, i64, isize);\n \n impl RemEuclidU32 for i128 {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self.rem_euclid(i128::from(modulus)) as _\n }\n }\n \n macro_rules! impl_rem_euclid_u32_for_small_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n self as u32 % modulus\n }\n }\n )*\n }\n }\n \n macro_rules! impl_rem_euclid_u32_for_large_unsigned {\n ($($ty:tt),*) => {\n $(\n impl RemEuclidU32 for $ty {\n #[inline]\n fn rem_euclid_u32(self, modulus: u32) -> u32 {\n (self % (modulus as $ty)) as _\n }\n }\n )*\n }\n }\n \n impl_rem_euclid_u32_for_small_unsigned!(u8, u16, u32);\n impl_rem_euclid_u32_for_large_unsigned!(u64, u128);\n \n #[cfg(target_pointer_width = \"32\")]\n impl_rem_euclid_u32_for_small_unsigned!(usize);\n \n #[cfg(target_pointer_width = \"64\")]\n impl_rem_euclid_u32_for_large_unsigned!(usize);\n #[inline]\n pub fn mul_mod_u32(a: u32, b: u32, m: u32) -> u32 {\n (a as u64 * b as u64 % m as u64) as u32\n }\n \n // for a, b < m, unspecified otherwise\n #[inline]\n fn add_mod_raw(a: u32, b: u32, m: u32) -> u32 {\n let (r, c) = a.wrapping_sub(m).overflowing_add(b);\n if c { r } else { a + b }\n }\n #[inline]\n fn sub_mod_raw(a: u32, b: u32, m: u32) -> u32 {\n let (r, c) = a.overflowing_sub(b);\n if c { r.wrapping_add(m) } else { r }\n }\n fn pow_mod_raw(a: u32, mut k: u64, m: u32) -> u32 {\n if m == 1 { return 0; }\n let mut a = a as u64;\n let m = m as u64;\n let mut r: u64 = 1;\n while k > 0 {\n if k & 1 == 1 {\n r = r * a % m;\n }\n k >>= 1;\n a = a * a % m;\n }\n r as u32\n }\n \n /// # Parameters\n /// * `b` `1 <= b`\n /// # Returns\n /// (x, g) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g\n fn inv_gcd(a: i64, b: i64) -> (i64, i64) {\n let a = a.rem_euclid(b);\n if a == 0 { return (0, b); }\n let mut s = b;\n let mut t = a;\n let mut m0 = 0;\n let mut m1 = 1;\n \n while t != 0 {\n let u = s / t;\n s -= t * u;\n m0 -= m1 * u;\n swap(&mut s, &mut t);\n swap(&mut m0, &mut m1);\n }\n \n if m0 < 0 { m0 += b / s; }\n (m0, s)\n }\n \n pub trait Modulus: Copy + Eq {\n fn get_modulus() -> u32;\n }\n \n #[derive(Clone, Copy, PartialEq, Eq, Hash)]\n #[repr(transparent)]\n pub struct ModIntBase { \n val: u32,\n _phantom: PhantomData\n }\n \n impl ModIntBase {\n #[inline(always)]\n pub fn modulus() -> u32 { M::get_modulus() }\n #[inline] pub fn new(val: I) -> Self { Self::raw(val.rem_euclid_u32(Self::modulus())) }\n #[inline] pub fn raw(val: u32) -> Self { Self { val, _phantom: PhantomData } }\n pub fn inv(self) -> Self { \n let (x, gcd) = inv_gcd(self.val.into(), Self::modulus().into());\n debug_assert!(gcd == 1, \"the multiplicative inverse {}^-1 mod {} does not exist\", self.val, Self::modulus());\n Self::raw(x as u32)\n }\n #[inline] pub fn val(self) -> u32 { self.val }\n #[inline] pub fn pow(self, k: u64) -> Self {\n Self::raw(pow_mod_raw(self.val, k, Self::modulus()))\n }\n pub fn powi(self, k: i64) -> Self { if k < 0 { self.inv().pow(-k as _) } else { self.pow(k as _) } }\n pub fn pow_vec(self, n: usize) -> Vec {\n let mut res = vec![Self::raw(0); n+1];\n res[0] += 1;\n for i in 1..=n {\n res[i] = res[i-1] * self;\n }\n res\n }\n\n pub fn invs(a: &[Self]) -> Vec {\n let n = a.len();\n if n == 0 { return vec![]; }\n let mut acc = Self::new(1);\n let mut res = Vec::with_capacity(n);\n for i in 0..n {\n if a[i].val() != 0 { acc *= a[i]; }\n res.push(acc);\n }\n acc = acc.inv();\n for i in (1..n).rev() {\n res[i] = acc * res[i-1];\n if a[i].val() != 0 { acc *= a[i]; }\n }\n res[0] = acc;\n res\n }\n }\n \n #[inline]\n pub fn mi(val: I) -> ModInt { ModIntBase::new(val) }\n #[inline] pub fn mir(v: u32) -> ModInt { ModIntBase::raw(v) }\n \n impl From for ModIntBase {\n #[inline]\n fn from(from: V) -> Self { Self::new(from) }\n }\n impl Default for ModIntBase {\n fn default() -> Self { Self::raw(0) }\n }\n impl FromStr for ModIntBase {\n type Err = std::convert::Infallible;\n #[inline]\n fn from_str(s: &str) -> Result {\n Ok(s.parse::()\n .map(Self::new)\n .unwrap_or_else(|_| todo!(\"parsing as an arbitrary precision integer?\")))\n }\n }\n impl Display for ModIntBase {\n #[inline]\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n self.val.fmt(f)\n }\n }\n impl std::fmt::Debug for ModIntBase {\n #[inline]\n fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {\n std::fmt::Debug::fmt(&self.val, f)\n }\n }\n impl Neg for ModIntBase {\n type Output = Self;\n \n #[inline]\n fn neg(self) -> Self::Output {\n Self::raw(0) - self\n }\n }\n \n impl>, M: Modulus> Add for ModIntBase {\n type Output = Self;\n #[inline]\n fn add(self, rhs: V) -> Self::Output {\n Self::raw(add_mod_raw(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Sub for ModIntBase {\n type Output = Self;\n #[inline]\n fn sub(self, rhs: V) -> Self::Output {\n Self::raw(sub_mod_raw(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Mul for ModIntBase {\n type Output = Self;\n #[inline]\n fn mul(self, rhs: V) -> Self::Output {\n Self::raw(mul_mod_u32(self.val, rhs.into().val, Self::modulus()))\n }\n }\n impl>, M: Modulus> Div for ModIntBase {\n type Output = Self;\n #[inline]\n fn div(self, rhs: V) -> Self::Output { self * rhs.into().inv() }\n }\n \n impl >, M: Modulus> AddAssign for ModIntBase {\n #[inline]\n fn add_assign(&mut self, rhs: V) { *self = *self + rhs; }\n }\n impl >, M: Modulus> SubAssign for ModIntBase {\n #[inline]\n fn sub_assign(&mut self, rhs: V) { *self = *self - rhs; }\n }\n impl >, M: Modulus> MulAssign for ModIntBase {\n #[inline]\n fn mul_assign(&mut self, rhs: V) { *self = *self * rhs; }\n }\n impl >, M: Modulus> DivAssign for ModIntBase {\n #[inline]\n fn div_assign(&mut self, rhs: V) { *self = *self / rhs; }\n }\n \n impl std::iter::Sum for ModIntBase {\n #[inline] fn sum>(iter: I) -> Self {\n iter.fold(Self::raw(0), Add::add)\n }\n }\n impl std::iter::Product for ModIntBase {\n #[inline] fn product>(iter: I) -> Self {\n iter.fold(1.into(), Mul::mul)\n }\n }\n impl<'a, M: Modulus> std::iter::Sum<&'a Self> for ModIntBase {\n #[inline] fn sum>(iter: I) -> ModIntBase {\n iter.fold(Self::raw(0), |a, &b| a + b)\n }\n }\n impl<'a, M: Modulus> std::iter::Product<&'a Self> for ModIntBase {\n #[inline] fn product>(iter: I) -> ModIntBase {\n iter.fold(1.into(), |a, &b| a * b)\n }\n }\n \n macro_rules! const_modulus {\n ($mint: ident, $name: ident, $modulus: expr) => {\n #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]\n pub enum $name {}\n impl Modulus for $name {\n #[inline(always)] fn get_modulus() -> u32 { $modulus }\n }\n pub type $mint = ModIntBase<$name>;\n }\n }\n \n macro_rules! dynamic_modulus {\n ($mint: ident, $name: ident, $modulus: ident) => {\n static $modulus: crate::Unsync> = crate::Unsync(Cell::new(0));\n #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]\n pub enum $name {}\n impl Modulus for $name {\n fn get_modulus() -> u32 { $modulus.0.get() }\n }\n impl $name {\n pub fn set_modulus(val: u32) { $modulus.0.set(val) }\n }\n pub type $mint = ModIntBase<$name>;\n }\n }\n \n const_modulus!(ModInt998_244_353, Mod998_244_353, 998_244_353);\n const_modulus!(ModInt1_000_000_007, Mod1_000_000_007, 1_000_000_007);\n dynamic_modulus!(DynamicModInt, DynamicModulus, DYNAMIC_MODULUS);\n}\n \nuse crate::modint::*;\ntype ModInt = ModInt998_244_353;\n// type ModInt = ModInt1_000_000_007;\n// const_modulus!(ModInt, DefaultModulus, 1_000_000_009);\n// type ModInt = DynamicModInt;\n\n\nfn mod_factorials(maxn: usize) -> Vec {\n let mut res = vec![ModInt::default(); maxn+1];\n res[0] = 1.into();\n for i in 1..=maxn {\n res[i] = res[i-1] * i\n }\n return res;\n}\n\nstruct ModCombinatorics {\n factorials: Vec,\n inv_factorials: Vec\n}\n#[allow(non_snake_case)]\nimpl ModCombinatorics {\n fn new(maxn: usize) -> Self {\n let factorials = mod_factorials(maxn);\n let mut inv = vec![ModInt::default(); maxn+1];\n inv[maxn] = factorials[maxn].inv();\n for i in (1..=maxn).rev() {\n inv[i-1] = inv[i] * i;\n }\n Self { factorials, inv_factorials: inv }\n }\n #[inline]\n fn factorial(&self, n: usize) -> ModInt { self.factorials[n] }\n #[inline]\n fn inv_factorial(&self, n: usize) -> ModInt { self.inv_factorials[n] }\n fn P(&self, n: usize, k: usize) -> ModInt {\n if k > n { ModInt::raw(0) } else { self.factorial(n) * self.inv_factorial(n-k) }\n }\n fn C(&self, n: usize, k: usize) -> ModInt {\n if k > n { ModInt::raw(0) } else { self.factorial(n) * self.inv_factorial(k) * self.inv_factorial(n-k) }\n }\n\n // multi-choose, be sure to adjust maxn accordingly\n fn M(&self, n: usize, k: usize) -> ModInt {\n if k == 0 { 1.into() } else { self.C(n + k - 1, k) }\n }\n}\n \n#[allow(non_snake_case, non_upper_case_globals)]\nfn main() {\n let num_cases: usize = 1;//read();\n for _case_num in 1..=num_cases {\n let n = read!(usize);\n let k = read!(usize);\n let mc = ModCombinatorics::new(n-1);\n\n fn c2(n: usize) -> usize {\n n * n.saturating_sub(1) / 2\n }\n let m = c2(n-1);\n\n let mut dp = vec![mi(0); n];\n dp[0] = mi(1);\n for x in 0..k {\n let R = mi(k - x).pow_vec(m);\n for j in (1..n).rev() {\n for i in 0..j {\n let d = dp[i] * R[c2(j) - c2(i)] * mc.C(n-1-i, j-i);\n dp[j] += d;\n }\n }\n //dbg!(&dp);\n }\n\n let ans = dp[n-1];\n println!(ans);\n }\n \n out_flush();\n}", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics", "graph matchings"], "code_uid": "8b9c8b0ab1b502241f1952c5daf58b23", "src_uid": "b2d7ac8e75cbdb828067aeafd803ac62", "difficulty": 2200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//! http://codeforces.com/contest/815/problem/E\n\n#[macro_export]\nmacro_rules! scanln {\n ($($var:ident : $ty:path),+) => {\n $(let $var: $ty;)+\n {\n use std::io;\n let mut __buf = String::new();\n io::stdin().read_line(&mut __buf).unwrap();\n let mut eles = __buf.split_whitespace();\n $($var = Scan::scan(&mut eles);)+\n }\n }\n}\n\npub trait Scan {\n fn scan<'a, I>(eles: &mut I) -> Self where I: Iterator;\n}\n\nmacro_rules! impl_scan_single {\n ($ty:ty) => {\n impl Scan for $ty {\n fn scan<'a, I>(eles: &mut I) -> Self where I: Iterator {\n let next = eles.next().unwrap();\n match next.parse() {\n Ok(res) => res,\n Err(_) => panic!()\n }\n }\n }\n }\n}\n\nimpl_scan_single!(u8);\nimpl_scan_single!(u16);\nimpl_scan_single!(u32);\nimpl_scan_single!(u64);\nimpl_scan_single!(usize);\nimpl_scan_single!(i8);\nimpl_scan_single!(i16);\nimpl_scan_single!(i32);\nimpl_scan_single!(i64);\nimpl_scan_single!(isize);\nimpl_scan_single!(f32);\nimpl_scan_single!(f64);\nimpl_scan_single!(String);\n\nconst __IMPL_SCAN_FOR_VEC: () = {\n use std::str::FromStr;\n impl Scan for Vec where T: FromStr {\n fn scan<'a, I>(eles: &mut I) -> Self where I: Iterator {\n eles.map(|str| match str.parse() {\n Ok(res) => res,\n Err(_) => panic!()\n }).collect()\n }\n }\n};\n\n// -----------------------------------------------------------------------------\n\n#[inline]\nfn house_dist(segment: i64) -> i64 {\n (segment + 1) / 2\n}\n\n/// Check whether the k'th placed house has a position <= limit.\nfn is_before(n: i64, k: i64, limit: i64) -> bool {\n use std::collections::BTreeMap;\n let mut l_segs = BTreeMap::new();\n let mut r_segs = BTreeMap::new();\n let mut cross = Some((2, n - 1));\n let mut rem = k;\n\n l_segs.insert(0i64, 0i64);\n r_segs.insert(0i64, 0i64);\n\n while rem > 0 {\n let (&l_max, &l_cnt) = l_segs.iter().rev()\n .next()\n .unwrap();\n let (&r_max, &r_cnt) = r_segs.iter().rev()\n .next()\n .unwrap();\n\n let mut max_seg = match cross {\n Some((lo, hi)) => hi - lo + 1,\n None => i64::min_value()\n };\n max_seg = std::cmp::max(max_seg, l_max);\n max_seg = std::cmp::max(max_seg, r_max);\n\n if house_dist(max_seg) == house_dist(l_max) {\n if l_cnt >= rem { return true; }\n rem -= l_cnt;\n l_segs.remove(&l_max);\n *l_segs.entry((l_max - 1) / 2).or_insert(0) += l_cnt;\n *l_segs.entry(l_max / 2).or_insert(0) += l_cnt;\n } else if match cross {\n None => false,\n Some((lo, hi)) => house_dist(max_seg) == house_dist(hi - lo + 1)\n }\n {\n let (lo, hi) = cross.unwrap();\n let mid = (lo + hi) / 2;\n if rem == 1 { return mid <= limit; }\n rem -= 1;\n\n let (lr, rl) = (mid - 1, mid + 1);\n\n if limit < lr {\n cross = Some((lo, lr));\n *r_segs.entry(hi - rl + 1).or_insert(0) += 1;\n } else if limit >= rl {\n cross = Some((rl, hi));\n *l_segs.entry(lr - lo + 1).or_insert(0) += 1;\n } else {\n cross = None;\n *r_segs.entry(hi - rl + 1).or_insert(0) += 1;\n *l_segs.entry(lr - lo + 1).or_insert(0) += 1;\n }\n } else if house_dist(max_seg) == house_dist(r_max) {\n if r_cnt >= rem { return false; }\n rem -= r_cnt;\n r_segs.remove(&r_max);\n *r_segs.entry((r_max - 1) / 2).or_insert(0) += r_cnt;\n *r_segs.entry(r_max / 2).or_insert(0) += r_cnt;\n }\n }\n\n unreachable!()\n}\n\nfn main() {\n use std::io::{self, Write, BufWriter};\n let __stdout = io::stdout();\n let mut __out = BufWriter::with_capacity(4096, __stdout.lock());\n\n macro_rules! put {\n ($fmt:expr) => { write!(__out, $fmt).unwrap(); };\n ($fmt:expr, $($arg:expr),+) => { write!(__out, $fmt, $($arg),+).unwrap(); }\n }\n macro_rules! putln {\n () => { writeln!(__out, \"\").unwrap(); };\n ($fmt:expr) => { writeln!(__out, $fmt).unwrap(); };\n ($fmt:expr, $($arg:expr),+) => { writeln!(__out, $fmt, $($arg),+).unwrap(); }\n }\n macro_rules! fflush {\n () => { __out.flush().unwrap(); }\n }\n\n scanln!(n: i64, k: i64);\n\n if k == 1 { putln!(\"1\"); }\n else if k == 2 { putln!(\"{}\", n); }\n else {\n let (mut lo, mut hi) = (2, n - 1);\n let mut ans = hi;\n while lo <= hi {\n let mid = (lo + hi) / 2;\n if is_before(n, k - 2, mid) {\n ans = mid;\n hi = mid - 1;\n } else {\n lo = mid + 1;\n }\n }\n putln!(\"{}\", ans);\n }\n}\n", "lang_cluster": "Rust", "tags": ["constructive algorithms", "binary search", "implementation"], "code_uid": "7763969c5560756fd10e035f54d019ab", "src_uid": "eb311bde6a0e3244d92fafbd4aa1e61f", "difficulty": 2900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nfn main() {\n let mut buffer = String::new();\n io::stdin().read_line(&mut buffer).unwrap();\n let n = buffer.trim().parse::().unwrap();\n let max_iter = factorial(n+1);\n buffer.clear();\n io::stdin().read_line(&mut buffer).unwrap();\n let mut s1: Vec = buffer.split_whitespace().map(|x| x.parse::().unwrap()).collect();\n let mut s1_cards = s1.split_off(1);\n buffer.clear();\n io::stdin().read_line(&mut buffer).unwrap();\n let mut s2: Vec = buffer.split_whitespace().map(|x| x.parse::().unwrap()).collect();\n let mut s2_cards = s2.split_off(1);\n\n let mut counter = 0;\n let mut infinite_game = false;\n while s1_cards.len() > 0 && s2_cards.len() > 0 {\n \n if counter > max_iter {\n infinite_game = true;\n break;\n }\n\n match (s1_cards.remove(0), s2_cards.remove(0)) {\n (x, y) if x > y => {\n s1_cards.push(y);\n s1_cards.push(x);\n },\n (x, y) if x < y => {\n s2_cards.push(x);\n s2_cards.push(y);\n },\n _ => unreachable!()\n }\n counter += 1;\n }\n\n if infinite_game {\n println!(\"{}\", -1);\n } else {\n let winner: u32;\n if s1_cards.len() == 0 {\n winner = 2;\n } else {\n winner = 1;\n }\n println!(\"{} {}\", counter, winner);\n }\n\n}\n\nfn factorial(x: u32) -> u32 {\n (2..x).fold(1, |a, b| {\n a * b\n })\n}\n", "lang_cluster": "Rust", "tags": ["dfs and similar", "brute force", "games"], "code_uid": "f17114fa58df84b2a913baa05998fc79", "src_uid": "f587b1867754e6958c3d7e0fe368ec6e", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn read_line() -> String {\n let stdin = std::io::stdin();\n let mut line = String::new();\n stdin.read_line(&mut line).unwrap();\n String::from(line.trim())\n}\n\n#[derive(Clone)]\nstruct DPCell {\n q: u64,\n qa: u64,\n qaq: u64,\n}\n\nfn main() {\n let s = read_line();\n let mut dp = vec![DPCell {q: 0, qa: 0, qaq: 0}; s.len()];\n for (i, c) in s.chars().enumerate() {\n match c {\n 'Q' => {\n if i > 0 {\n dp[i].q = dp[i - 1].q + 1;\n dp[i].qa = dp[i - 1].qa;\n dp[i].qaq = dp[i - 1].qaq + dp[i - 1].qa;\n } else {\n dp[i].q = 1;\n }\n },\n 'A' => {\n if i > 0 {\n dp[i].q = dp[i - 1].q;\n dp[i].qa = dp[i - 1].qa + dp[i - 1].q;\n dp[i].qaq = dp[i - 1].qaq;\n } },\n _ => {\n if i > 0 {\n dp[i] = dp[i - 1].clone();\n }\n }\n }\n }\n println!(\"{}\", dp.last().unwrap().qaq);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "dp"], "code_uid": "107c7a90b26dda2d14fc47d9866acb77", "src_uid": "8aef4947322438664bd8610632fe0947", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut a_str = String::new();\n io::stdin().read_line(&mut a_str).expect(\"\");\n let mut v_a = a_str.trim().chars()\n .map(|x| x.to_digit(10).unwrap() as i32)\n .collect::>();\n\n let mut b_str = String::new();\n io::stdin().read_line(&mut b_str).expect(\"\");\n let mut v_b = b_str.trim().chars()\n .map(|x| x.to_digit(10).unwrap() as i32)\n .collect::>();\n\n\n let x: String= v_b.iter().map(|y| y.to_string()).collect();\n let n_b: i64 = x.parse().unwrap();\n\n let mut res = String::new();\n v_a.sort();\n for i in 0..v_a.len() {\n for j in (i + 1)..v_a.len() {\n let mut t = v_a.clone();\n t.swap(i, j);\n let x: String= t.iter().map(|y| y.to_string()).collect();\n let n_t: i64 = x.parse().unwrap();\n let x: String= v_a.iter().map(|y| y.to_string()).collect();\n let n_a: i64 = x.parse().unwrap();\n if n_a < n_t && n_t <= n_b {\n v_a.swap(i, j);\n }\n }\n }\n res = v_a.iter().map(|x| x.to_string()).collect();\n println!(\"{}\", res);\n}\n", "lang_cluster": "Rust", "tags": ["greedy", "dp"], "code_uid": "a0dd1da83364e855cb81e10f4f4538e3", "src_uid": "bc31a1d4a02a0011eb9f5c754501cd44", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::error::Error;\nuse std::io;\n\nfn get_lines() -> io::Result {\n\tlet mut buffer = String::new();\n\tio::stdin().read_line(&mut buffer)?;\n\tOk(buffer)\n}\n\nfn main() -> Result<(), Box> {\n\tlet input = get_lines()?;\n\tlet s = input.trim();\n\tlet a_count = s.chars().filter(|c| *c == 'a').count();\n\tlet not_a_count = s.len() - a_count;\n\tprint!(\n\t\t\"{}\",\n\t\tif a_count > not_a_count {\n\t\t\ts.len()\n\t\t} else {\n\t\t\ta_count * 2 - 1\n\t\t}\n\t);\n\tOk(())\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "08c82e9c286ea0ca2034c03da3c0c2c2", "src_uid": "84cb9ad2ae3ba7e912920d7feb4f6219", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut si = String::new();\n io::stdin().read_line(&mut si).unwrap();\n let count_a = si.trim().matches(\"a\").collect::>().len(); \n let len = si.trim().len();\n if count_a > len / 2 {\n println!(\"{}\", len);\n } else {\n println!(\"{}\", count_a * 2 - 1);\n }\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "874e39a226acf50d3ece4f09e12c54c0", "src_uid": "84cb9ad2ae3ba7e912920d7feb4f6219", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports)]\n#![allow(unused_macros)]\n#![allow(dead_code)]\n\nuse std::char::*;\nuse std::cmp::*;\nuse std::collections::*;\nuse std::io::*;\nuse std::str::FromStr;\n\nmacro_rules! debug {($($a:expr),*) => {println!(concat!($(stringify!($a), \" = {:?}, \"),*), $($a),*);}}\nmacro_rules! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; let mut next = || { iter . next ( ) . unwrap ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let stdin = std :: io :: stdin ( ) ; let mut bytes = std :: io :: Read :: bytes ( std :: io :: BufReader :: new ( stdin . lock ( ) ) ) ; let mut next = move || -> String { bytes . by_ref ( ) . map ( | r | r . unwrap ( ) as char ) . skip_while ( | c | c . is_whitespace ( ) ) . take_while ( | c |! c . is_whitespace ( ) ) . collect ( ) } ; input_inner ! { next , $ ( $ r ) * } } ; }\nmacro_rules! input_inner { ( $ next : expr ) => { } ; ( $ next : expr , ) => { } ; ( $ next : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ next , $ t ) ; input_inner ! { $ next $ ( $ r ) * } } ; }\nmacro_rules! read_value { ( $ next : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ next , $ t ) ) ,* ) } ; ( $ next : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ next , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ next : expr , chars ) => { read_value ! ( $ next , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ next : expr , usize1 ) => { read_value ! ( $ next , usize ) - 1 } ; ( $ next : expr , $ t : ty ) => { $ next ( ) . parse ::<$ t > ( ) . expect ( \"Parse error\" ) } ; }\n\n\nfn read() -> T {\n let stdin = stdin();\n let stdin = stdin.lock();\n let token: String = stdin\n .bytes()\n .map(|c| c.expect(\"failed to read char\") as char)\n .skip_while(|c| c.is_whitespace())\n .take_while(|c| !c.is_whitespace())\n .collect();\n token.parse().ok().expect(\"failed to parse token\")\n}\n\nuse std::f64;\n\nfn min(a:T, b:T) -> T {\n if a < b { a }\n else { b }\n}\n\nfn max(a:T, b:T) -> T {\n if a < b { b }\n else { a }\n}\n\nuse std::hash::Hash;\nfn inc(map:&mut BTreeMap, key:T) {\n let count = map.entry(key).or_insert(0);\n *count += 1;\n}\n\nfn digit(ch: char) -> i64 {\n return (ch as u8 - b'0') as i64\n}\n\nconst MAX:usize = 30;\nconst INF:i64 = std::i64::MAX;\nconst MOD:i64 = 1e9 as i64 + 7;\n\nfn gcd(x:i64, y:i64) -> i64 {\n if y==0 { return x; }\n gcd(y, x%y)\n}\n\nfn main() {\n //let t:usize = read();\n\n //'outer: for _ in 0..t {\n let mut p:Vec<(i64,i64)> = (0..6).map(|_| (read(), read())).collect();\n //debug!(p);\n\n // \uff11\u3064\u76ee\u306e\u9ed2\u306b\u3064\u3044\u3066\n if p[2].0 <= p[0].0 && p[2].1 <= p[0].1 && p[3].0 >= p[1].0 && p[3].1 >= p[1].1 {\n println!(\"NO\");\n return;\n }\n // \u767d\u306e\u4e0a\u304b\u4e0b\u304c\u6d88\u3048\u308b\u304b\u3069\u3046\u304b\n if p[2].0 <= p[0].0 && p[3].0 >= p[1].0 {\n if p[2].1 <= p[0].1 && p[3].1 >= p[0].1 {\n p[0].1 = p[3].1;\n }\n if p[3].1 >= p[1].1 && p[2].1 <= p[1].1 {\n p[1].1 = p[2].1;\n }\n }\n // \u767d\u306e\u5de6\u304b\u53f3\u304c\u6d88\u3048\u308b\u304b\u3069\u3046\u304b\n if p[2].1 <= p[0].1 && p[3].1 >= p[1].1 {\n if p[2].0 <= p[0].0 && p[3].0 >= p[0].0 {\n p[0].0 = p[3].0;\n }\n if p[3].0 >= p[1].0 && p[2].0 <= p[1].0 {\n p[1].0 = p[2].0;\n }\n }\n //debug!(p[0],p[1]);\n if p[0].0 >= p[1].0 || p[0].1 >= p[1].1 {\n println!(\"NO\");\n return;\n }\n if p[4].0 <= p[0].0 && p[4].1 <= p[0].1 && p[5].0 >= p[1].0 && p[5].1 >= p[1].1 {\n println!(\"NO\");\n return;\n }\n\n println!(\"YES\");\n\n //}\n\n}\n\n/*\n\n\n*/\n", "lang_cluster": "Rust", "tags": ["math", "geometry"], "code_uid": "cb0f78f93e0085a27cd9689a342babc2", "src_uid": "05c90c1d75d76a522241af6bb6af7781", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).unwrap();\n let mut v = s.split_whitespace().map(|x| x.parse::().unwrap()).collect::>();\n v.sort_unstable();\n let (_legs,headbody) : (&[i32], [i32;2]) = {\n if v[0] == v[1] && v[1] == v[2] && v[2] == v[3] \n {(&v[0..4],[v[4],v[5]])}\n else if v[1] == v[2] && v[2] == v[3] && v[3] == v[4] \n {(&v[1..5], [v[0],v[5]])}\n else if v[2] == v[3] && v[3] == v[4] && v[4] == v[5] \n {(&v[2..6], [v[0],v[1]])}\n else \n {(&v[0..0],[-1,-1])}\n };\n println!(\n \"{}\",\n if headbody == [-1,-1] {\"Alien\"}\n else if headbody[0] String {\n let mut input = String::new();\n\n io::stdin().read_line(&mut input).expect(\"\");\n\n input.trim().to_string()\n}\n\nfn main() {\n let s = get_string();\n let mut m = HashMap::new();\n\n for i in 0..10 {\n let n = get_string();\n m.insert(n, i);\n }\n\n let v = Vec::from(s);\n for w in v.chunks(10) {\n let mut k = String::new();\n\n for &c in w {\n k.push(c as char);\n }\n\n print!(\"{}\", m.get(&k).unwrap());\n }\n println!();\n}\n", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "cce14eaca767e3aea918a75be7e270c0", "src_uid": "0f4f7ca388dd1b2192436c67f9ac74d9", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "type Res = u64;\n\nfn main() {\n let k = {\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).unwrap();\n input.trim().parse::().unwrap()\n };\n\n let result = solve(k);\n\n println!(\"{}\", result);\n\n}\n\nfn int_len(inp: Res) -> Res {\n if inp == 0 {\n return 1;\n }\n\n let mut res = 0;\n let mut temp = 1;\n while temp <= inp {\n res += 1;\n temp *= 10\n }\n res\n}\n\nfn solve(k: Res) -> char {\n // counter for digits\n let mut n: Res = 1;\n // Potential number of the digit we search\n let mut d: Res = 1;\n while n impl Iterator {\n (0..).flat_map(|i| i.to_string().chars().collect::>())\n}\n\nfn main() {\n let stdin = io::stdin();\n let line = stdin.lock().lines().next().expect(\"input\").expect(\"UTF-8\");\n let index: usize = line.parse().expect(\"Numeric value\");\n\n println!(\"{}\", it().skip(index).next().unwrap());\n}\n\n#[test]\nfn vectors() {\n let in_out = [(7, '7'), (21, '5')];\n\n for (i, o) in &in_out {\n assert_eq!(it().skip(*i).next().unwrap(), *o);\n }\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "df3ecd071dcf48c6cc104d3939a8e38b", "src_uid": "1503d761dd4e129fb7c423da390544ff", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#[allow(dead_code)]\nfn scan() -> T\n{\n static mut BUFFER: Vec = vec![];\n loop {\n if let Some(token) = unsafe { BUFFER.pop() } {\n return token.parse().ok().unwrap();\n }\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).ok();\n unsafe { BUFFER = input.split_whitespace().rev().map(String::from).collect(); }\n }\n}\n\nfn non_stop(p1: i64, t1: i128, p2: i64, t2: i128, rem: i64, s: i64) -> i128\n{\n let mut t = 0;\n let mut dam = 0;\n while dam < rem {\n if t1 - t%t1 <= t2 - t%t2 {\n t += t1 - t%t1;\n dam += p1 - s;\n } else if t1 - t%t1 >= t2 - t%t2 {\n t += t2 - t%t2;\n dam += p2 - s;\n } else {\n t += t1 - t%t1;\n dam += p1 + p2 - s;\n }\n }\n t\n}\n\nfn main()\n{\n let (p1, t1) = (scan::(), scan::());\n let (p2, t2) = (scan::(), scan::());\n let (h, s) = (scan::(), scan::());\n let mut dp = vec![0i128; (h+1) as usize];\n for rem in 1..=h as usize {\n dp[rem] = non_stop(p1, t1, p2, t2, rem as i64, s); \n for i in 0..=h {\n let mut t = t1 * (i + 1) as i128;\n let mut dam = (p1 - s) * i;\n // 2 is charged before 1\n if t >= t2 {\n let mut cdam = dam;\n cdam += (t / t2 - 1) as i64 * (p2 - s);\n cdam += p1 + p2 - s;\n dp[rem] = dp[rem].min(if cdam as usize > rem { t }\n else { t + dp[rem - cdam as usize] });\n }\n // 1 is charged before 2\n dam += (t / t2) as i64 * (p2 - s);\n t += t2 - t%t2;\n dam += p1 + p2 - s;\n dp[rem] = dp[rem].min(if dam as usize > rem { t }\n else { t + dp[rem - dam as usize] });\n }\n }\n println!(\"{}\", dp[h as usize]);\n}\n", "lang_cluster": "Rust", "tags": ["dp", "binary search"], "code_uid": "7239ef1eea035742fc4336921a3a06b5", "src_uid": "ca9d48e48e69b931236907a9ac262433", "difficulty": 2400.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(dead_code, unused_macros, unused_imports)]\nuse std::{cell::{Cell, RefCell, UnsafeCell}, cmp::{Ordering, Reverse, max, min}, collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque, hash_map::{DefaultHasher, RandomState}}, error::Error, fmt::{Display, Write as FmtWrite}, hash::{BuildHasher, Hash, Hasher}, io::{BufWriter, Read, Stdin, Stdout, Write}, iter::{FromIterator, Peekable}, mem::swap, ops::*, process::exit, rc::Rc, str::{FromStr, from_utf8_unchecked}, time::{Duration, Instant}, convert::{TryInto, TryFrom}, marker::PhantomData};\n\nconst IO_BUF_SIZE: usize = 1 << 16;\ntype Input = Scanner;\ntype Output = BufWriter;\nfn _init_input() -> Input { Scanner::new(std::io::stdin()) }\nfn _init_output() -> Output { BufWriter::with_capacity(IO_BUF_SIZE, std::io::stdout()) }\n\n#[repr(transparent)] struct Unsync(T);\nunsafe impl Sync for Unsync {}\n \ntype BadLazy = Unsync>>;\nimpl BadLazy {\n const fn new() -> Self { Self(UnsafeCell::new(None)) }\n}\n \nstatic INPUT: BadLazy = BadLazy::new();\nstatic OUTPUT: BadLazy = BadLazy::new();\n \nfn inp R, R>(f: F) -> R {\n unsafe { f((&mut *INPUT.0.get()).get_or_insert_with(_init_input)) }\n}\nfn out R, R>(f: F) -> R {\n unsafe { f((&mut *OUTPUT.0.get()).get_or_insert_with(_init_output)) }\n}\n\nmacro_rules! read {\n () => { read() };\n ($t: ty) => { read::<$t>() };\n ($t: ty, $($tt: ty),*) => { (read::<$t>(), $(read::<$tt>(),)*) };\n [$t: ty; $n: expr] => { read_vec::<$t>($n) };\n}\nmacro_rules! println { \n () => { out(|x| { let _ = writeln!(x); }) };\n ($exp: expr) => { out(|x| { let _ = writeln!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = writeln!(x, $fmt, $($arg)*); }) }\n}\nmacro_rules! print { \n ($exp: expr) => { out(|x| { let _ = write!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = write!(x, $fmt, $($arg)*); }) }\n}\n\nfn out_flush() { out(|x| { let _ = x.flush(); }); }\n\nfn input_is_eof() -> bool { inp(|x| x.eof()) }\nfn read_byte() -> u8 { inp(|x| x.byte()) }\nfn read_bytes_no_skip(n: usize) -> Vec { inp(|x| x.bytes_no_skip(n)) }\nfn read_bytes(n: usize) -> Vec { inp(|x| x.bytes(n)) }\nfn read_bytes2(n: usize, m: usize) -> Vec> { inp(|x| x.bytes2(n, m)) }\nfn read_token() -> Vec { inp(|x| x.token_bytes()) }\nfn read_token_str() -> String { unsafe { String::from_utf8_unchecked(read_token()) } }\nfn read_line() -> Vec { inp(|x| x.line_bytes()) }\nfn read_line_str() -> String { unsafe { String::from_utf8_unchecked(read_line()) } }\nfn read() -> T { read_token_str().parse::().ok().expect(\"failed parse\") }\nfn read_vec(n: usize) -> Vec { (0..n).map(|_| read()).collect() }\nfn read_vec2(n: usize, m: usize) -> Vec> { (0..n).map(|_| read_vec(m)).collect() }\n\nstruct Scanner {\n src: R,\n _buf: Vec,\n _pt: usize, // pointer\n _rd: usize, // bytes read\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new(src: R) -> Scanner {\n Scanner { src, _buf: vec![0; IO_BUF_SIZE], _pt: 1, _rd: 1 }\n }\n \n fn _check_buf(&mut self) {\n if self._pt == self._rd {\n self._rd = self.src.read(&mut self._buf).unwrap_or(0);\n self._pt = (self._rd == 0) as usize;\n }\n }\n \n // returns true if end of file\n fn eof(&mut self) -> bool {\n self._check_buf();\n self._rd == 0\n }\n \n // filters \\r, returns \\0 if eof\n fn byte(&mut self) -> u8 {\n loop {\n self._check_buf();\n if self._rd == 0 { return 0; }\n let res = self._buf[self._pt];\n self._pt += 1;\n if res != b'\\r' { return res; }\n }\n }\n\n fn bytes_no_skip(&mut self, n: usize) -> Vec { (0..n).map(|_| self.byte()).collect() }\n fn bytes(&mut self, n: usize) -> Vec {\n let res = self.bytes_no_skip(n);\n self.byte();\n res\n }\n fn bytes2(&mut self, n: usize, m: usize) -> Vec> { (0..n).map(|_| self.bytes(m)).collect() }\n \n fn token_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c <= b' ' {\n if c == b'\\0' { return res; }\n c = self.byte();\n }\n loop {\n res.push(c);\n c = self.byte();\n if c <= b' ' { return res; }\n }\n }\n \n fn line_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c != b'\\n' && c != b'\\0' {\n res.push(c);\n c = self.byte();\n }\n res\n }\n}\n\ntrait JoinToStr { \n fn join_to_str(self, sep: &str) -> String;\n fn concat_to_str(self) -> String;\n}\nimpl> JoinToStr for I { \n fn join_to_str(mut self, sep: &str) -> String {\n match self.next() {\n Some(first) => {\n let mut res = first.to_string();\n while let Some(item) = self.next() {\n res.push_str(sep);\n res.push_str(&item.to_string());\n }\n res\n }\n None => { String::new() }\n }\n }\n \n fn concat_to_str(self) -> String {\n let mut res = String::new();\n for item in self { res.push_str(&item.to_string()); }\n res\n }\n}\ntrait AsStr { fn as_str(&self) -> &str; }\nimpl AsStr for [u8] { fn as_str(&self) -> &str {std::str::from_utf8(self).expect(\"attempt to convert non-UTF8 byte string.\")} }\n\nmacro_rules! veci {\n ($n:expr , $i:ident : $gen:expr) => {{\n let _veci_n = $n;\n let mut _veci_list = Vec::with_capacity(_veci_n);\n for $i in 0.._veci_n {\n _veci_list.push($gen);\n }\n _veci_list\n }};\n ($n:expr , $gen:expr) => { veci!($n, _veci_: $gen) }\n}\n\nfn abs_diff + PartialOrd>(x: T, y: T) -> T {\n if x < y { y - x } else { x - y }\n}\n\ntrait CommonNumExt {\n fn div_ceil(self, b: Self) -> Self;\n fn div_floor(self, b: Self) -> Self;\n fn gcd(self, b: Self) -> Self;\n fn highest_one(self) -> Self;\n fn lowest_one(self) -> Self;\n fn sig_bits(self) -> u32;\n}\n\nmacro_rules! impl_common_num_ext {\n ($($ix:tt = $ux:tt),*) => {\n $(\n impl CommonNumExt for $ux {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { self / b }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self;\n if a == 0 || b == 0 { return a | b; }\n let shift = (a | b).trailing_zeros();\n a >>= a.trailing_zeros();\n b >>= b.trailing_zeros();\n while a != b {\n if a > b { a -= b; a >>= a.trailing_zeros(); }\n else { b -= a; b >>= b.trailing_zeros(); }\n }\n a << shift\n }\n #[inline] fn highest_one(self) -> Self { \n if self == 0 { 0 } else { const ONE: $ux = 1; ONE << self.sig_bits() - 1 } \n }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ux>() as u32 * 8 - self.leading_zeros() }\n }\n\n impl CommonNumExt for $ix {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if self ^ b >= 0 && r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { \n let q = self / b; let r = self % b;\n if self ^ b < 0 && r != 0 { q - 1 } else { q }\n }\n fn gcd(self, b: Self) -> Self {\n fn w_abs(x: $ix) -> $ux { (if x.is_negative() { x.wrapping_neg() } else { x }) as _ }\n w_abs(self).gcd(w_abs(b)) as _\n }\n #[inline] fn highest_one(self) -> Self { (self as $ux).highest_one() as _ }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ix>() as u32 * 8 - self.leading_zeros() }\n }\n )*\n }\n}\nimpl_common_num_ext!(i8 = u8, i16 = u16, i32 = u32, i64 = u64, i128 = u128, isize = usize);\n\ntrait ChMaxMin {\n fn chmax(&mut self, v: T) -> bool;\n fn chmin(&mut self, v: T) -> bool;\n}\nimpl ChMaxMin for Option {\n fn chmax(&mut self, v: T) -> bool { if self.is_none() || v > *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if self.is_none() || v < *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n}\nimpl ChMaxMin for T {\n fn chmax(&mut self, v: T) -> bool { if v > *self { *self = v; true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if v < *self { *self = v; true } else { false } }\n}\n\n// * end commons * //\n\t\n\n#[allow(non_snake_case, non_upper_case_globals)]\nfn main() {\n let num_cases: usize = 1;//read();\n\t\n for _case_num in 1..=num_cases {\n let p1 = read!(usize);\n\t\tlet t1 = read!(i64);\n\t\tlet p2 = read!(usize);\n\t\tlet t2 = read!(i64);\n\t\tlet h = read!(usize);\n\t\tlet s = read!(usize);\n\t\t\n\t\tlet x1 = p1 - s;\n\t\tlet x2 = p2 - s;\n\t\tlet x3 = p1 + p2 - s;\n\t\t\n\t\tlet inf = i64::MAX;\n\t\tlet mut ans = inf;\n\t\tlet mut dp = vec![inf; h+1];\n\t\tdp[0] = 0;\n\t\t\n\t\tfor i in 0..h { if dp[i] != inf {\n\t\t\tlet t = dp[i];\n\t\t\t\n\t\t\tlet mut k1 = 0;\n\t\t\tlet mut k2 = 0;\n\t\t\tlet mut dm = 0;\n\t\t\tloop {\n\t\t\t\tdp[min(h, i+dm+x3)].chmin(t + max((k1+1) * t1, (k2+1) * t2));\n\t\t\t\t\n\t\t\t\tif (k1 + 1) * t1 < (k2 + 1) * t2 {\n\t\t\t\t\tk1 += 1;\n\t\t\t\t\tdm += x1;\n\t\t\t\t} else {\n\t\t\t\t\tk2 += 1;\n\t\t\t\t\tdm += x2;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif i + dm >= h {\n\t\t\t\t\tans.chmin(t + max(k1 * t1, k2 * t2));\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}}\n\t\t\n\t\t//println!(\"{:?}\", &dp);\n\t\t\n\t\tans.chmin(dp[h]);\n\t\tprintln!(ans);\n }\n \n out_flush();\n}", "lang_cluster": "Rust", "tags": ["dp", "binary search"], "code_uid": "8fac997122c73e66466f1c7f36c2a0c4", "src_uid": "ca9d48e48e69b931236907a9ac262433", "difficulty": 2400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let n: usize = scan.next();\n // case 1: 1\n // 2: 1 + 1*4 = 5\n // 3: 5 + 2*4 = 13\n // 4: 13 + 3*4\n // ....\n let mut result = 1usize;\n for i in 1..n {\n result += 4 * i;\n }\n println!(\"{}\", result);\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp", "implementation"], "code_uid": "67748125cb50838d64cc7630cead28b3", "src_uid": "758d342c1badde6d0b4db81285be780c", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[derive(Debug)]\nstruct RhombusIterator{\n current: isize,\n count: isize,\n total: isize,\n}\n\nimpl RhombusIterator{\n pub fn new() ->Self{\n RhombusIterator{\n current: 1,\n count: 0,\n total: 1,\n }\n }\n}\n\nimpl Iterator for RhombusIterator{\n type Item = isize;\n\n fn next(&mut self) -> Option {\n match self.current{\n 1 => {},\n _ => {\n self.total += 2* self.current + (2* self.count);\n self.count += 1;\n },\n }\n self.current +=1;\n Some(self.total)\n }\n}\n\nfn main() -> Result<(), Box> {\n\n //parse\n let mut input = String::new();\n std::io::stdin().read_line(&mut input)?;\n let input: usize = input.trim().parse().expect(\"Invalid input parameter\");\n\n //solve\n let result = solve(input);\n\n //print\n println!(\"{}\", result);\n\n Ok(())\n}\n\n\nfn solve(input: usize) -> isize{\n let iter = RhombusIterator::new();\n iter.skip(input-1).next().expect(\"Could not calc rhombus\")\n}\n\n\n#[cfg(test)]\nmod test{\n use super::solve;\n\n\n #[test]\n fn test1() {\n\n assert_eq!(1, solve(1));\n assert_eq!(5, solve(2));\n assert_eq!(solve(3), 13);\n assert_eq!(25, solve(4));\n assert_eq!(41, solve(5));\n }\n}", "lang_cluster": "Rust", "tags": ["math", "dp", "implementation"], "code_uid": "8e0de16e72ea7606bbbb24e28d1a4aa2", "src_uid": "758d342c1badde6d0b4db81285be780c", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn main() {\n let mut a_str = String::new();\n io::stdin().read_line(&mut a_str).expect(\"\");\n let mut num = a_str.split_whitespace()\n .map(|x| x.parse::().expect(\"parse error\"))\n .collect::>();\n let mut b_str = String::new();\n io::stdin().read_line(&mut b_str).expect(\"\");\n let mut v = b_str.split_whitespace()\n .map(|x| x.parse::().expect(\"parse error\"))\n .collect::>();\n\n let n = num[0];\n let k = num[1];\n\n let mut res = 0;\n v.sort();\n v.reverse();\n for i in &v {\n if k % i == 0 {\n res = k / i;\n break;\n }\n }\n println!(\"{}\", res);\n\n\n}\n", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "44e740d62b9b130892d2b51ce25cea85", "src_uid": "80520be9916045aca3a7de7bc925af1f", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{max, min};\n#[allow(unused_imports)]\nuse std::collections::{HashMap, HashSet};\n\nmod util {\n use std::io::stdin;\n use std::str::FromStr;\n use std::fmt::Debug;\n\n #[allow(dead_code)]\n pub fn line() -> String {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n line.trim().to_string()\n }\n\n #[allow(dead_code)]\n pub fn get() -> T\n where\n ::Err: Debug,\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n line.trim().parse().unwrap()\n }\n\n #[allow(dead_code)]\n pub fn gets() -> Vec\n where\n ::Err: Debug,\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n line.split_whitespace()\n .map(|t| t.parse().unwrap())\n .collect()\n }\n\n #[allow(dead_code)]\n pub fn get2() -> (T, U)\n where\n ::Err: Debug,\n ::Err: Debug,\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n iter.next().unwrap().parse().unwrap(),\n iter.next().unwrap().parse().unwrap(),\n )\n }\n\n #[allow(dead_code)]\n pub fn get3() -> (S, T, U)\n where\n ::Err: Debug,\n ::Err: Debug,\n ::Err: Debug,\n {\n let mut line: String = String::new();\n stdin().read_line(&mut line).unwrap();\n let mut iter = line.split_whitespace();\n (\n iter.next().unwrap().parse().unwrap(),\n iter.next().unwrap().parse().unwrap(),\n iter.next().unwrap().parse().unwrap(),\n )\n }\n}\n\n\n#[allow(unused_macros)]\nmacro_rules! debug {\n ($x: expr) => {\n println!(\"{}: {:?}\", stringify!($x), $x)\n }\n}\n\nfn main() {\n let n: usize = util::get();\n let a: usize = util::get();\n let b: usize = util::get();\n let c: usize = util::get();\n\n let mut dp = vec![vec![100000; 3]; n];\n dp[0][0] = 0;\n\n for i in 1..n {\n dp[i][0] = min(dp[i][0], dp[i - 1][1] + a);\n dp[i][0] = min(dp[i][0], dp[i - 1][2] + b);\n\n dp[i][1] = min(dp[i][1], dp[i - 1][0] + a);\n dp[i][1] = min(dp[i][1], dp[i - 1][2] + c);\n\n dp[i][2] = min(dp[i][2], dp[i - 1][0] + b);\n dp[i][2] = min(dp[i][2], dp[i - 1][1] + c);\n }\n\n println!(\"{}\", dp[n - 1].iter().min().unwrap());\n\n}\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "aa5b2a875a0c1f2d04a4bdadd4b978f2", "src_uid": "6058529f0144c853e9e17ed7c661fc50", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn main() {\n let mut input = String::new();\n use std::io::{self, prelude::*};\n io::stdin().read_to_string(&mut input).unwrap();\n\n let n: u64 = input.trim().parse().unwrap();\n\n let check = |k| {\n let mut n = n;\n\n let mut v = 0;\n let mut p = 0;\n loop {\n if n < k {\n v += n;\n break;\n }\n n -= k;\n v += k;\n\n let q = n / 10;\n n -= q;\n p += q;\n }\n\n p <= v\n };\n\n let mut low = 0;\n let mut up = (n + 1) / 2;\n\n while low + 1 != up {\n let cur = (low + up) / 2;\n if check(cur) {\n up = cur;\n } else {\n low = cur;\n }\n }\n\n println!(\"{}\", up);\n}\n", "lang_cluster": "Rust", "tags": ["implementation", "binary search"], "code_uid": "e047df290e1e6d6ed2a626b8a1809560", "src_uid": "db1a50da538fa82038f8db6104d2ab93", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// 991C\nuse std::io;\nfn main() {\n let n: u64 = read_one(&io::stdin());\n let mut min = 0;\n let mut max = n;\n loop {\n let mid = (min + max) / 2;\n if mid == min {\n break;\n }\n if eats_half(n, mid) {\n max = mid;\n } else {\n min = mid;\n }\n }\n println!(\"{}\", max);\n}\n\nfn eats_half(mut n: u64, k: u64) -> bool {\n let original_n = n;\n let mut v = 0;\n while n >= k {\n n -= k;\n v += k;\n n -= n / 10;\n }\n v += n;\n return 2 * v >= original_n;\n}\n\nfn read_one(stdin: &io::Stdin) -> T\nwhere\n T: std::str::FromStr,\n ::Err: std::fmt::Debug,\n{\n let mut s = String::new();\n stdin.read_line(&mut s).unwrap();\n s.trim().split_whitespace().next().unwrap().parse().unwrap()\n}\n", "lang_cluster": "Rust", "tags": ["implementation", "binary search"], "code_uid": "468685580ed3d6e9ebdbbcc1b28528f9", "src_uid": "db1a50da538fa82038f8db6104d2ab93", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::cmp::min;\n\nfn get_max_days(a: u32, b: u32, c: u32) -> u32 {\n let full_week_num: u32 = min(a / 3, min(b / 2, c / 2));\n let a_rest: u32 = a - 3 * full_week_num;\n let b_rest: u32 = b - 2 * full_week_num;\n let c_rest: u32 = c - 2 * full_week_num;\n\n let mut extra_days_max: u32 = 0;\n for start_weekday in 0..7 {\n let mut weekday: u32 = start_weekday;\n let mut extra_days: u32 = 0;\n let mut a_rest1: u32 = a_rest;\n let mut b_rest1: u32 = b_rest;\n let mut c_rest1: u32 = c_rest;\n loop {\n if (weekday == 0) || (weekday == 3) || (weekday == 6) {\n if a_rest1 > 0 {\n a_rest1 -= 1;\n } else {\n break;\n }\n } else if (weekday == 1) || (weekday == 5) {\n if b_rest1 > 0 {\n b_rest1 -= 1;\n } else {\n break;\n }\n } else {\n if c_rest1 > 0 {\n c_rest1 -= 1;\n } else {\n break;\n }\n }\n\n extra_days += 1;\n weekday += 1;\n weekday %= 7;\n }\n\n if extra_days > extra_days_max {\n extra_days_max = extra_days;\n }\n }\n\n return 7 * full_week_num + extra_days_max;\n}\n\n#[cfg(test)]\nmod tests {\n use super::get_max_days;\n\n #[test]\n fn test1() {\n assert_eq!(get_max_days(2, 1, 1), 4);\n }\n #[test]\n fn test2() {\n assert_eq!(get_max_days(3, 2, 2), 7);\n }\n #[test]\n fn test3() {\n assert_eq!(get_max_days(1, 100, 1), 3);\n }\n #[test]\n fn test4() {\n assert_eq!(get_max_days(30, 20, 10), 39);\n }\n}\n\nfn read_data() -> (u32, u32, u32) {\n let mut data_str: String = String::new();\n std::io::stdin().read_line(&mut data_str).unwrap();\n\n let data_values: Vec = data_str\n .trim()\n .split(\" \")\n .map(|s| s.parse::().unwrap())\n .collect();\n\n return (data_values[0], data_values[1], data_values[2]);\n}\n\nfn main() {\n let (a, b, c): (u32, u32, u32) = read_data();\n\n let max_days: u32 = get_max_days(a, b, c);\n\n println!(\"{}\", max_days);\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "2b053cf58ec991411ed3c0ac7990ae8b", "src_uid": "e17df52cc0615585e4f8f2d31d2daafb", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn raw_input() -> String {\n let mut buf = String::new();\n io::stdin().read_line(&mut buf).unwrap();\n buf.trim().to_string()\n}\n\nfn input_split() -> Vec {\n raw_input()\n .split_whitespace()\n .map(|elem| elem.parse().unwrap())\n .collect()\n}\n\nfn input() -> u16 {\n raw_input().parse().unwrap()\n}\n\nfn main() {\n let mut n = input();\n let days = input_split();\n\n let week_total: u16 = days.iter().sum();\n while n > week_total {\n n -= week_total;\n }\n\n let mut current_day = 0;\n loop {\n if days[current_day] >= n {\n break;\n } else {\n n -= days[current_day];\n }\n current_day += 1;\n }\n\n print!(\"{}\", current_day + 1);\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "ea3542bf160747ab9a96be8f16eff050", "src_uid": "007a779d966e2e9219789d6d9da7002c", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_imports, unused_macros)]\n\nuse kyoproio::*;\nuse std::{\n collections::*,\n io::{self, prelude::*},\n iter,\n mem::{replace, swap},\n};\n\nfn main() -> io::Result<()> {\n std::thread::Builder::new()\n .stack_size(64 * 1024 * 1024)\n .spawn(solve)?\n .join()\n .unwrap();\n Ok(())\n}\n\nfn solve() {\n let stdin = io::stdin();\n let mut kin = KInput::new(stdin.lock());\n let stdout = io::stdout();\n let mut out = io::BufWriter::new(stdout.lock());\n macro_rules! output { ($($args:expr),+) => { write!(&mut out, $($args),+).unwrap(); }; }\n macro_rules! outputln {\n ($($args:expr),+) => { output!($($args),+); outputln!(); };\n () => { output!(\"\\n\"); if cfg!(debug_assertions) { out.flush().unwrap(); } }\n }\n\n const MOD: i64 = 998244353;\n let (n, k): (i64, i64) = kin.input();\n if k > n {\n outputln!(\"0\");\n return;\n }\n let c = Combination::new(n as usize + 1, MOD);\n let mut ans = 0;\n for i in 1..=n {\n ans += c.comb(n / i - 1, k - 1);\n }\n ans %= MOD;\n outputln!(\"{}\", ans);\n}\n\npub fn mod_pow(mut a: i64, mut b: i64, m: i64) -> i64 {\n let mut y = 1;\n while b > 0 {\n if b & 1 == 1 {\n y = y * a % m;\n }\n a = a * a % m;\n b >>= 1;\n }\n y\n}\npub fn mod_inv(x: i64, m: i64) -> i64 {\n mod_pow(x, m - 2, m)\n}\npub struct Combination {\n m: i64,\n fact: Vec,\n}\nimpl Combination {\n pub fn new(size: usize, m: i64) -> Self {\n let mut comb = Self {\n m,\n fact: Vec::new(),\n };\n comb.resize(size);\n comb\n }\n pub fn resize(&mut self, size: usize) {\n let old_len = self.fact.len();\n self.fact.resize(size + 1, 0);\n for i in old_len..=size {\n self.fact[i] = if i == 0 {\n 1\n } else {\n i as i64 * self.fact[i - 1] % self.m\n };\n }\n }\n pub fn fact(&self, x: i64) -> i64 {\n self.fact[x as usize]\n }\n pub fn perm(&self, a: i64, b: i64) -> i64 {\n if a >= b {\n self.fact(a) * self.inv(self.fact(a - b)) % self.m\n } else {\n 0\n }\n }\n pub fn comb(&self, a: i64, b: i64) -> i64 {\n if a >= b {\n self.fact(a) * self.inv(self.fact(b) * self.fact(a - b) % self.m) % self.m\n } else {\n 0\n }\n }\n pub fn pow(&self, a: i64, b: i64) -> i64 {\n mod_pow(a, b, self.m)\n }\n pub fn inv(&self, x: i64) -> i64 {\n self.pow(x, self.m - 2)\n }\n}\n\n\n// -----------------------------------------------------------------------------\npub mod kyoproio {\n use std::io::prelude::*;\n pub trait Input {\n fn str(&mut self) -> &str;\n fn input(&mut self) -> T {\n T::input(self)\n }\n fn iter(&mut self) -> Iter {\n Iter(self, std::marker::PhantomData)\n }\n fn seq>(&mut self, n: usize) -> B {\n self.iter().take(n).collect()\n }\n }\n pub struct KInput {\n src: R,\n buf: String,\n pos: usize,\n }\n impl KInput {\n pub fn new(src: R) -> Self {\n Self {\n src,\n buf: String::with_capacity(1024),\n pos: 0,\n }\n }\n pub fn src(&mut self) -> &mut R {\n &mut self.src\n }\n }\n impl Input for KInput {\n fn str(&mut self) -> &str {\n loop {\n if self.pos >= self.buf.len() {\n self.pos = 0;\n self.buf.clear();\n if self.src.read_line(&mut self.buf).expect(\"io error\") == 0 {\n return &self.buf;\n }\n }\n let range = self.pos\n ..self.buf[self.pos..]\n .find(|c: char| c.is_ascii_whitespace())\n .map(|i| i + self.pos)\n .unwrap_or_else(|| self.buf.len());\n self.pos = range.end + 1;\n if range.end > range.start {\n return &self.buf[range];\n }\n }\n }\n }\n pub struct Iter<'a, T, I: ?Sized>(&'a mut I, std::marker::PhantomData<*const T>);\n impl<'a, T: InputParse, I: Input + ?Sized> Iterator for Iter<'a, T, I> {\n type Item = T;\n fn next(&mut self) -> Option {\n Some(self.0.input())\n }\n }\n pub trait InputParse: Sized {\n fn input(src: &mut I) -> Self;\n }\n impl InputParse for Vec {\n fn input(src: &mut I) -> Self {\n src.str().as_bytes().to_owned()\n }\n }\n macro_rules! from_str_impl {\n { $($T:ty)* } => {\n $(impl InputParse for $T {\n fn input(src: &mut I) -> Self {\n src.str().parse::<$T>().expect(\"parse error\")\n }\n })*\n }\n }\n from_str_impl! {\n String char bool f32 f64 isize i8 i16 i32 i64 i128 usize u8 u16 u32 u64 u128\n }\n macro_rules! tuple_impl {\n ($H:ident $($T:ident)*) => {\n impl<$H: InputParse, $($T: InputParse),*> InputParse for ($H, $($T),*) {\n fn input(src: &mut I) -> Self {\n ($H::input(src), $($T::input(src)),*)\n }\n }\n tuple_impl!($($T)*);\n };\n () => {}\n }\n tuple_impl!(A B C D E F G);\n #[macro_export]\n macro_rules! kdbg {\n ($($v:expr),*) => {\n if cfg!(debug_assertions) { dbg!($($v),*) } else { ($($v),*) }\n }\n }\n}\n", "lang_cluster": "Rust", "tags": ["math", "combinatorics", "number theory"], "code_uid": "31706d53b7f649d5c2a0893fbee11bd5", "src_uid": "8e8eb64a047cb970a549ee870c3d280d", "difficulty": 2000.0, "exec_outcome": "PASSED"} {"lang": "Rust 2021", "source_code": "#![allow(dead_code, unused_macros, unused_imports)]\nuse std::{cell::{Cell, RefCell, UnsafeCell}, cmp::{Ordering, Reverse, max, min}, collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque, hash_map::{DefaultHasher, RandomState}}, error::Error, fmt::{Display, Write as FmtWrite}, hash::{BuildHasher, Hash, Hasher}, io::{BufWriter, Read, Stdin, Stdout, Write}, iter::{FromIterator, Peekable}, mem::swap, ops::*, process::exit, rc::Rc, str::{FromStr, from_utf8_unchecked}, time::{Duration, Instant}, convert::{TryInto, TryFrom}, marker::PhantomData};\n\nconst IO_BUF_SIZE: usize = 1 << 16;\ntype Input = Scanner;\ntype Output = BufWriter;\nfn _init_input() -> Input { Scanner::new(std::io::stdin()) }\nfn _init_output() -> Output { BufWriter::with_capacity(IO_BUF_SIZE, std::io::stdout()) }\n\n#[repr(transparent)] struct Unsync(T);\nunsafe impl Sync for Unsync {}\n \ntype BadLazy = Unsync>>;\nimpl BadLazy {\n const fn new() -> Self { Self(UnsafeCell::new(None)) }\n}\n \nstatic INPUT: BadLazy = BadLazy::new();\nstatic OUTPUT: BadLazy = BadLazy::new();\n \nfn inp R, R>(f: F) -> R {\n unsafe { f((&mut *INPUT.0.get()).get_or_insert_with(_init_input)) }\n}\nfn out R, R>(f: F) -> R {\n unsafe { f((&mut *OUTPUT.0.get()).get_or_insert_with(_init_output)) }\n}\n\nmacro_rules! read {\n () => { read() };\n ($t: ty) => { read::<$t>() };\n ($t: ty, $($tt: ty),*) => { (read::<$t>(), $(read::<$tt>(),)*) };\n [$t: ty; $n: expr] => { read_vec::<$t>($n) };\n}\nmacro_rules! println { \n () => { out(|x| { let _ = writeln!(x); }) };\n ($exp: expr) => { out(|x| { let _ = writeln!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = writeln!(x, $fmt, $($arg)*); }) }\n}\nmacro_rules! print { \n ($exp: expr) => { out(|x| { let _ = write!(x, \"{}\", $exp); }) }; \n ($fmt: expr, $($arg : tt )*) => { out(|x| { let _ = write!(x, $fmt, $($arg)*); }) }\n}\n\nfn out_flush() { out(|x| { let _ = x.flush(); }); }\n\nfn input_is_eof() -> bool { inp(|x| x.eof()) }\nfn read_byte() -> u8 { inp(|x| x.byte()) }\nfn read_bytes_no_skip(n: usize) -> Vec { inp(|x| x.bytes_no_skip(n)) }\nfn read_bytes(n: usize) -> Vec { inp(|x| x.bytes(n)) }\nfn read_bytes2(n: usize, m: usize) -> Vec> { inp(|x| x.bytes2(n, m)) }\nfn read_token() -> Vec { inp(|x| x.token_bytes()) }\nfn read_token_str() -> String { unsafe { String::from_utf8_unchecked(read_token()) } }\nfn read_line() -> Vec { inp(|x| x.line_bytes()) }\nfn read_line_str() -> String { unsafe { String::from_utf8_unchecked(read_line()) } }\nfn read() -> T { read_token_str().parse::().ok().expect(\"failed parse\") }\nfn read_vec(n: usize) -> Vec { (0..n).map(|_| read()).collect() }\nfn read_vec2(n: usize, m: usize) -> Vec> { (0..n).map(|_| read_vec(m)).collect() }\n\nstruct Scanner {\n src: R,\n _buf: Vec,\n _pt: usize, // pointer\n _rd: usize, // bytes read\n}\n\n#[allow(dead_code)]\nimpl Scanner {\n fn new(src: R) -> Scanner {\n Scanner { src, _buf: vec![0; IO_BUF_SIZE], _pt: 1, _rd: 1 }\n }\n \n fn _check_buf(&mut self) {\n if self._pt == self._rd {\n self._rd = self.src.read(&mut self._buf).unwrap_or(0);\n self._pt = (self._rd == 0) as usize;\n }\n }\n \n // returns true if end of file\n fn eof(&mut self) -> bool {\n self._check_buf();\n self._rd == 0\n }\n \n // filters \\r, returns \\0 if eof\n fn byte(&mut self) -> u8 {\n loop {\n self._check_buf();\n if self._rd == 0 { return 0; }\n let res = self._buf[self._pt];\n self._pt += 1;\n if res != b'\\r' { return res; }\n }\n }\n\n fn bytes_no_skip(&mut self, n: usize) -> Vec { (0..n).map(|_| self.byte()).collect() }\n fn bytes(&mut self, n: usize) -> Vec {\n let res = self.bytes_no_skip(n);\n self.byte();\n res\n }\n fn bytes2(&mut self, n: usize, m: usize) -> Vec> { (0..n).map(|_| self.bytes(m)).collect() }\n \n fn token_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c <= b' ' {\n if c == b'\\0' { return res; }\n c = self.byte();\n }\n loop {\n res.push(c);\n c = self.byte();\n if c <= b' ' { return res; }\n }\n }\n \n fn line_bytes(&mut self) -> Vec {\n let mut res = Vec::new();\n let mut c = self.byte();\n while c != b'\\n' && c != b'\\0' {\n res.push(c);\n c = self.byte();\n }\n res\n }\n}\n\ntrait JoinToStr { \n fn join_to_str(self, sep: &str) -> String;\n fn concat_to_str(self) -> String;\n}\nimpl> JoinToStr for I { \n fn join_to_str(mut self, sep: &str) -> String {\n match self.next() {\n Some(first) => {\n let mut res = first.to_string();\n while let Some(item) = self.next() {\n res.push_str(sep);\n res.push_str(&item.to_string());\n }\n res\n }\n None => { String::new() }\n }\n }\n \n fn concat_to_str(self) -> String {\n let mut res = String::new();\n for item in self { res.push_str(&item.to_string()); }\n res\n }\n}\ntrait AsStr { fn as_str(&self) -> &str; }\nimpl AsStr for [u8] { fn as_str(&self) -> &str {std::str::from_utf8(self).expect(\"attempt to convert non-UTF8 byte string.\")} }\n\nmacro_rules! veci {\n ($n:expr , $i:ident : $gen:expr) => {{\n let _veci_n = $n;\n let mut _veci_list = Vec::with_capacity(_veci_n);\n for $i in 0.._veci_n {\n _veci_list.push($gen);\n }\n _veci_list\n }};\n ($n:expr , $gen:expr) => { veci!($n, _veci_: $gen) }\n}\n\nfn abs_diff + PartialOrd>(x: T, y: T) -> T {\n if x < y { y - x } else { x - y }\n}\n\ntrait CommonNumExt {\n fn div_ceil(self, b: Self) -> Self;\n fn div_floor(self, b: Self) -> Self;\n fn gcd(self, b: Self) -> Self;\n fn highest_one(self) -> Self;\n fn lowest_one(self) -> Self;\n fn sig_bits(self) -> u32;\n}\n\nmacro_rules! impl_common_num_ext {\n ($($ix:tt = $ux:tt),*) => {\n $(\n impl CommonNumExt for $ux {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { self / b }\n fn gcd(self, mut b: Self) -> Self {\n let mut a = self;\n if a == 0 || b == 0 { return a | b; }\n let shift = (a | b).trailing_zeros();\n a >>= a.trailing_zeros();\n b >>= b.trailing_zeros();\n while a != b {\n if a > b { a -= b; a >>= a.trailing_zeros(); }\n else { b -= a; b >>= b.trailing_zeros(); }\n }\n a << shift\n }\n #[inline] fn highest_one(self) -> Self { \n if self == 0 { 0 } else { const ONE: $ux = 1; ONE << self.sig_bits() - 1 } \n }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ux>() as u32 * 8 - self.leading_zeros() }\n }\n\n impl CommonNumExt for $ix {\n fn div_ceil(self, b: Self) -> Self {\n let q = self / b; let r = self % b;\n if self ^ b >= 0 && r != 0 { q + 1 } else { q }\n }\n fn div_floor(self, b: Self) -> Self { \n let q = self / b; let r = self % b;\n if self ^ b < 0 && r != 0 { q - 1 } else { q }\n }\n fn gcd(self, b: Self) -> Self {\n fn w_abs(x: $ix) -> $ux { (if x.is_negative() { x.wrapping_neg() } else { x }) as _ }\n w_abs(self).gcd(w_abs(b)) as _\n }\n #[inline] fn highest_one(self) -> Self { (self as $ux).highest_one() as _ }\n #[inline] fn lowest_one(self) -> Self { self & self.wrapping_neg() }\n #[inline] fn sig_bits(self) -> u32 { std::mem::size_of::<$ix>() as u32 * 8 - self.leading_zeros() }\n }\n )*\n }\n}\nimpl_common_num_ext!(i8 = u8, i16 = u16, i32 = u32, i64 = u64, i128 = u128, isize = usize);\n\ntrait ChMaxMin {\n fn chmax(&mut self, v: T) -> bool;\n fn chmin(&mut self, v: T) -> bool;\n}\nimpl ChMaxMin for Option {\n fn chmax(&mut self, v: T) -> bool { if self.is_none() || v > *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if self.is_none() || v < *self.as_ref().unwrap() { *self = Some(v); true } else { false } }\n}\nimpl ChMaxMin for T {\n fn chmax(&mut self, v: T) -> bool { if v > *self { *self = v; true } else { false } }\n fn chmin(&mut self, v: T) -> bool { if v < *self { *self = v; true } else { false } }\n}\n\n// * end commons * //\n\npub trait BinarySearchExt {\n fn binary_search_by Ordering>(&self, f: F) -> Result;\n\n fn partition_point bool>(&self, mut f: F) -> T {\n self.binary_search_by(|x| if f(x) { Ordering::Less } else { Ordering::Greater }).err().unwrap()\n }\n}\nmacro_rules! impl_binary_search_ext_integer {\n ($($ty:tt),*) => {\n $(\n impl BinarySearchExt<$ty> for std::ops::Range<$ty> {\n fn binary_search_by Ordering>(&self, mut f: F) -> Result<$ty, $ty> {\n let mut low = self.start;\n let mut high = self.end;\n \n while low < high {\n let mid = (low & high) + ((low ^ high) >> 1);\n let cmp = f(mid);\n if cmp == Ordering::Less {\n low = mid + 1;\n } else if cmp == Ordering::Greater {\n high = mid;\n } else {\n return Ok(mid);\n }\n }\n Err(low)\n }\n }\n )*\n }\n}\nimpl_binary_search_ext_integer!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize);\n\n#[allow(non_snake_case, non_upper_case_globals)]\nfn main() {\n let num_cases: usize = 1;//read();\n\t\n for _case_num in 1..=num_cases {\n\t\tlet n = read!(i64);\n\t\t\n\t\tlet ans = if n < 3 {n*2+1} else {n*4/3 + 3};\n\t\tprintln!(ans);\n }\n \n out_flush();\n}", "lang_cluster": "Rust", "tags": ["math", "geometry", "binary search"], "code_uid": "14c256864368ae81965989e8fe26a3ab", "src_uid": "d0a8604b78ba19ab769fd1ec90a72e4e", "difficulty": 1500.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let a: usize = scan.next();\n let mut b: usize = scan.next();\n let mut c: usize = scan.next();\n b /= 2;\n c /= 4;\n let n = a.min(b).min(c);\n println!(\"{}\", n * 7);\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "3ca8e98bbece6426436ebb93a83e1416", "src_uid": "82a4a60eac90765fb62f2a77d2305c01", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "//spnauti-rust\nuse std::io::*;\nuse std::str::*;\nuse std::fmt::Debug;\n#[allow(unused_imports)] use std::cmp::Ordering::*;\n#[allow(unused_imports)] use std::collections::*;\n\n#[allow(unused_macros)]\nmacro_rules! a {\n ($c: tt, $x: expr, $y: expr) => {{\n let b = $y; let a = &mut $x;\n if b $c *a { *a = b; true } else { false }\n }};\n}\nstruct WordReader<'a> { it : SplitAsciiWhitespace<'a>, }\n#[allow(dead_code)]\nimpl<'a> WordReader<'a> {\n fn new(b: &mut String, mut r: T) -> WordReader {\n b.clear();\n r.read_to_string(b).ok();\n WordReader { it: b.split_ascii_whitespace() }\n }\n fn from_stdin(b: &mut String) -> WordReader {\n WordReader::new(b, stdin())\n }\n fn sl(&mut self) -> &str { self.it.next().unwrap() }\n fn bs(&mut self) -> &[u8] { self.sl().as_bytes() }\n fn s(&mut self) -> String { String::from(self.sl()) }\n fn i(&mut self) -> i32 { self.p() }\n fn u(&mut self) -> usize { self.p() }\n fn vi(&mut self, n: usize) -> Vec {\n self.vp::(n)\n }\n fn p(&mut self) -> T where T::Err: Debug {\n self.sl().parse::().unwrap()\n }\n fn vp(&mut self, n: usize) -> Vec where T::Err: Debug {\n (0..n).map(|_| self.p()).collect()\n }\n}\n\n#[allow(dead_code)]\nfn build_counting_hashmap(i: T) -> HashMap\n where T: Iterator {\n let mut m = HashMap::new();\n for k in i {\n let n = 1 + if let Some(&n) = m.get(&k) { n } else { 0 };\n m.insert(k, n);\n }\n m\n}\n\nfn main() {\n let mut bin = String::new();\n let mut input = WordReader::from_stdin(&mut bin);\n\n let mut a = input.vi(3);\n let d = input.i();\n a.sort();\n println!(\"{}\", 2 * d - (a[1] - a[0]).min(d) - (a[2] - a[1]).min(d));\n}\n\n", "lang_cluster": "Rust", "tags": ["math"], "code_uid": "b91c9ad4708c5391968dcd9692694b31", "src_uid": "47c07e46517dbc937e2e779ec0d74eb3", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "fn input() -> u64 {\n let mut buf = String::new();\n std::io::stdin().read_line(&mut buf).unwrap();\n buf.trim().parse().unwrap()\n}\n\nfn main() {\n let n = input();\n println!(\"{}\", (1..n).fold(0, |count, i| count + i * (n - i)) + n);\n}", "lang_cluster": "Rust", "tags": ["math", "implementation"], "code_uid": "e88eca4fa04d8fb4c8f3112e109ac1a0", "src_uid": "6df251ac8bf27427a24bc23d64cb9884", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nfn main() {\n let mut buffer = String::new();\n io::stdin().read_line(&mut buffer).unwrap();\n let n_a: Vec = buffer.split_whitespace().map(|x| x.parse::().unwrap()).collect();\n let (_, a) = (n_a[0], n_a[1] - 1);\n buffer.clear();\n io::stdin().read_line(&mut buffer).unwrap();\n let s: Vec = buffer.split_whitespace().map(|x| x.parse::().unwrap()).collect();\n let i: usize = a;\n let mut d: usize = 1;\n let mut ans: u32 = 0;\n if s[a] == 1 { ans += 1};\n loop {\n let left_idx = i.checked_sub(d);\n let right_idx = i + d;\n\n let left = match left_idx {\n Some(x) => Some(s[x]),\n None => None\n };\n\n let right = match right_idx {\n x if x < s.len() => Some(s[x]),\n _ => None\n };\n\n ans += match (left, right) {\n (Some(1), Some(1)) => 2,\n (None, Some(1)) => 1,\n (Some(1), None) => 1,\n _ => 0\n };\n\n if left.is_none() && right.is_none() {\n break;\n }\n\n d += 1\n }\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["constructive algorithms", "implementation"], "code_uid": "16f1ade5451965971d9b2e0312ae611c", "src_uid": "4840d571d4ce6e1096bb678b6c100ae5", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#![allow(unused_variables)]\n#![allow(unused_must_use)]\n#![allow(dead_code)]\nuse std::io::{self, prelude::*};\n\nfn solve(mut input: FastInput, mut w: W) {\n let n: usize = input.token();\n let mut a = vec![0usize; n];\n for x in a.iter_mut() {\n *x = input.token();\n }\n let min = a.iter().min().unwrap();\n let cnt = a.iter().filter(|&x| x == min).count();\n if cnt > n / 2 {\n write!(w, \"Bob\\n\");\n } else {\n write!(w, \"Alice\\n\");\n }\n}\n\nfn main() {\n let stdin = io::stdin();\n let stdout = io::stdout();\n let input = FastInput::from(stdin.lock());\n let writer = io::BufWriter::new(stdout.lock());\n solve(input, writer);\n}\n\ntrait TokenStream {\n fn token(&mut self) -> T;\n}\n\nstruct FastInput {\n stdin: R,\n pos: usize,\n}\n\nimpl From for FastInput {\n fn from(r: R) -> Self {\n FastInput { stdin: r, pos: 0 }\n }\n}\n\nimpl TokenStream for FastInput {\n fn token(&mut self) -> u8 {\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n while self.pos < buf.len() {\n self.pos += 1;\n if buf[self.pos - 1] > 32 {\n return buf[self.pos - 1];\n }\n }\n if self.pos == 0 {\n return 0;\n }\n } else {\n return 0;\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nimpl TokenStream> for FastInput {\n fn token(&mut self) -> Vec {\n let mut ans = Vec::new();\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans.push(buf[self.pos]);\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n}\n\nmacro_rules! impl_token_stream_u {\n ($($t:ident),+) => {$(\n impl TokenStream<$t> for FastInput {\n fn token(&mut self) -> $t {\n let mut ans = 0;\n let mut parse_token = false;\n loop {\n if let Ok(buf) = self.stdin.fill_buf() {\n if !parse_token {\n while self.pos < buf.len() && buf[self.pos] <= 32 {\n self.pos += 1;\n }\n }\n while self.pos < buf.len() && buf[self.pos] > 32 {\n parse_token = true;\n ans = ans * 10 + (buf[self.pos] - b'0') as $t;\n self.pos += 1;\n }\n if self.pos != buf.len() || self.pos == 0 {\n return ans;\n }\n }\n self.stdin.consume(self.pos);\n self.pos = 0;\n }\n }\n }\n )+}\n}\n\npub trait Identity {\n fn identity() -> Self;\n}\n\npub trait SelfIdentity {\n fn self_identity(&self) -> Self;\n}\n\nimpl SelfIdentity for T {\n fn self_identity(&self) -> Self {\n Self::identity()\n }\n}\n\npub trait Inverse {\n fn inverse(self) -> Self;\n}\n\nmacro_rules! define_modular_type {\n ($mod:ident, $value:expr) => {\n #[derive(Copy, Clone, Default, PartialEq)]\n struct $mod(u32);\n\n impl $mod {\n const MOD: u64 = $value;\n }\n\n impl std::fmt::Debug for $mod {\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n write!(f, \"{:?}\", self.0)\n }\n }\n\n impl std::fmt::Display for $mod {\n fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n }\n\n impl> From for $mod {\n fn from(a: T) -> Self {\n $mod((a.into() % Self::MOD) as u32)\n }\n }\n\n impl Into for $mod {\n fn into(self) -> u32 {\n self.0\n }\n }\n\n impl Identity for $mod {\n fn identity() -> Self {\n 1u32.into()\n }\n }\n\n impl Inverse for $mod {\n fn inverse(self) -> Self {\n let mut t = (Self::default(), Self::identity());\n let mut r = (Self::MOD, self.0 as u64);\n while r.1 != 0 {\n let q = r.0 / r.1;\n t = (t.1, t.0 - t.1 * q.into());\n r = (r.1, r.0 - r.1 * q);\n }\n t.0\n }\n }\n\n impl std::ops::Add for $mod {\n type Output = $mod;\n fn add(self, rhs: $mod) -> Self::Output {\n let mut ret = self.0 + rhs.0;\n if ret >= Self::MOD as u32 {\n ret -= Self::MOD as u32;\n }\n $mod(ret)\n }\n }\n\n impl std::ops::AddAssign for $mod {\n fn add_assign(&mut self, rhs: Self) {\n self.0 += rhs.0;\n if self.0 >= Self::MOD as u32 {\n self.0 -= Self::MOD as u32;\n }\n }\n }\n\n impl std::ops::Neg for $mod {\n type Output = Self;\n fn neg(self) -> Self::Output {\n $mod(Self::MOD as u32 - self.0)\n }\n }\n\n impl std::ops::Sub for $mod {\n type Output = $mod;\n fn sub(self, rhs: Self) -> Self::Output {\n if self.0 < rhs.0 {\n $mod(self.0 + (Self::MOD as u32) - rhs.0)\n } else {\n $mod(self.0 - rhs.0)\n }\n }\n }\n\n impl std::ops::SubAssign for $mod {\n fn sub_assign(&mut self, rhs: Self) {\n if self.0 < rhs.0 {\n self.0 += Self::MOD as u32;\n }\n self.0 -= rhs.0\n }\n }\n\n impl std::ops::Mul for $mod {\n type Output = $mod;\n fn mul(self, rhs: Self) -> Self::Output {\n let a = self.0 as u64;\n let b = rhs.0 as u64;\n let c = a * b % Self::MOD;\n $mod(c as u32)\n }\n }\n\n impl std::ops::MulAssign for $mod {\n fn mul_assign(&mut self, rhs: Self) {\n *self = *self * rhs;\n }\n }\n\n impl std::ops::Div for $mod {\n type Output = Self;\n fn div(self, rhs: Self) -> Self::Output {\n self * rhs.inverse()\n }\n }\n\n impl std::ops::DivAssign for $mod {\n fn div_assign(&mut self, rhs: Self) {\n *self = *self / rhs;\n }\n }\n };\n}\n\n#[derive(Clone)]\npub struct Matrix {\n data: Vec,\n cols: usize,\n rows: usize,\n}\n\nimpl Matrix\nwhere\n T: std::default::Default + Clone,\n{\n pub fn new(rows: usize, cols: usize) -> Matrix {\n let data = vec![T::default(); cols * rows];\n Matrix {\n data: data,\n cols: cols,\n rows: rows,\n }\n }\n}\n\nimpl Matrix {\n pub fn rows(&self) -> std::slice::Chunks {\n self.data.chunks(self.cols)\n }\n pub fn rows_mut(&mut self) -> std::slice::ChunksMut {\n self.data.chunks_mut(self.cols)\n }\n pub fn elem(&self, row: usize, col: usize) -> &T {\n &self.data[self.cols * row + col]\n }\n pub fn elem_mut(&mut self, row: usize, col: usize) -> &mut T {\n &mut self.data[self.cols * row + col]\n }\n}\n\nimpl std::fmt::Debug for Matrix\nwhere\n T: std::fmt::Debug,\n{\n fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {\n self.rows()\n .try_for_each(|row| fmt.write_fmt(format_args!(\"{:?}\\n\", row)))\n }\n}\n\nimpl SelfIdentity for Matrix\nwhere\n T: Identity + std::default::Default + Clone,\n{\n fn self_identity(&self) -> Self {\n assert_eq!(self.cols, self.rows);\n let mut ret = Matrix::new(self.rows, self.cols);\n for (i, row) in ret.rows_mut().enumerate() {\n row[i] = T::identity();\n }\n ret\n }\n}\n\nimpl std::ops::Add for Matrix\nwhere\n T: Clone + std::default::Default + std::ops::Add,\n{\n type Output = Matrix;\n fn add(self, rhs: Matrix) -> Matrix {\n assert_eq!(self.cols, rhs.cols);\n assert_eq!(self.rows, rhs.rows);\n Matrix {\n data: self\n .data\n .iter()\n .zip(rhs.data)\n .map(|(a, b)| a.clone() + b.clone())\n .collect(),\n rows: self.rows,\n cols: self.cols,\n }\n }\n}\nimpl std::ops::Sub for Matrix\nwhere\n T: Clone + std::default::Default + std::ops::Sub,\n{\n type Output = Matrix;\n fn sub(self, rhs: Matrix) -> Matrix {\n assert_eq!(self.cols, rhs.cols);\n assert_eq!(self.rows, rhs.rows);\n Matrix {\n data: self\n .data\n .iter()\n .zip(rhs.data)\n .map(|(a, b)| a.clone() - b.clone())\n .collect(),\n rows: self.rows,\n cols: self.cols,\n }\n }\n}\nimpl std::ops::Mul for Matrix\nwhere\n T: Clone + std::default::Default + std::ops::AddAssign + std::ops::Mul,\n{\n type Output = Matrix;\n fn mul(self, rhs: Matrix) -> Matrix {\n assert_eq!(self.cols, rhs.rows);\n let mut ret: Matrix = Matrix::new(self.rows, rhs.cols);\n for (ret_row, self_row) in ret.rows_mut().zip(self.rows()) {\n for (rhs_row, self_el) in rhs.rows().zip(self_row) {\n for (ret_el, rhs_el) in ret_row.iter_mut().zip(rhs_row) {\n *ret_el += self_el.clone() * rhs_el.clone();\n }\n }\n }\n ret\n }\n}\n\nfn binary_power(a: &T, mut exp: u64) -> T\nwhere\n T: Clone + std::ops::Mul + SelfIdentity,\n{\n let mut base = a.clone();\n let mut acc = a.self_identity();\n while exp > 1 {\n if (exp & 1) == 1 {\n acc = acc * base.clone();\n }\n exp /= 2;\n base = base.clone() * base.clone();\n }\n if exp == 1 {\n acc = acc * base;\n }\n acc\n}\n\nimpl_token_stream_u!(usize);\ndefine_modular_type!(MOD7, 1_000_000_007);\n", "lang_cluster": "Rust", "tags": ["games"], "code_uid": "6cba9594f446cbe12b7e23272c88accf", "src_uid": "4b9cf82967aa8441e9af3db3101161e9", "difficulty": 2000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::iter::*;\nuse std::str::SplitWhitespace;\nuse std::io::{stdin, BufReader, Stdin};\nuse std::io::prelude::*;\nuse std::collections::hash_map::HashMap;\nuse std::collections::hash_set::HashSet;\nuse std::string::*;\n\nfn main() {\n let mut buf = String::new();\n stdin().read_line(&mut buf);\n let s: usize = vec![\"Danil\", \"Olya\", \"Slava\", \"Ann\", \"Nikita\"]\n .iter()\n .map(|&s| buf.matches(s).count())\n .sum();\n println!(\"{}\", if s == 1 { \"YES\" } else { \"NO\" });\n}", "lang_cluster": "Rust", "tags": ["strings", "implementation"], "code_uid": "e6439a03c745dc10191eca4a2711b644", "src_uid": "db2dc7500ff4d84dcc1a37aebd2b3710", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::{io::stdin, iter};\n\nfn find_smallest(n: usize, l: usize) -> usize {\n let remaining = l - 1;\n let mut res: Vec = iter::repeat(1).take(n - remaining).collect();\n for i in n - remaining..n {\n res.push(res[i - 1] * 2);\n }\n res.iter().sum()\n}\n\nfn find_biggest(n: usize, r: usize) -> usize {\n let remaining = r - 1;\n let mut res: Vec = iter::repeat(2usize.pow(remaining as u32))\n .take(n - remaining)\n .collect();\n for i in n - remaining..n {\n res.push(res[i - 1] / 2);\n }\n res.iter().sum()\n}\n\nfn main() {\n let mut buf = String::new();\n stdin().read_line(&mut buf).unwrap();\n let mut buf = buf\n .trim()\n .split_whitespace()\n .map(|c| c.parse::().unwrap());\n let (n, l, r) = (\n buf.next().unwrap(),\n buf.next().unwrap(),\n buf.next().unwrap(),\n );\n\n println!(\"{} {}\", find_smallest(n, l), find_biggest(n, r));\n}", "lang_cluster": "Rust", "tags": ["math", "greedy"], "code_uid": "f8aef2d936f3d68cf0be05846e12dffa", "src_uid": "ce220726392fb0cacf0ec44a7490084a", "difficulty": 900.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str;\n\npub struct Scanner {\n reader: R,\n buffer: Vec,\n}\n\nimpl Scanner {\n pub fn new(reader: R) -> Self {\n Self {\n reader,\n buffer: vec![],\n }\n }\n\n pub fn token(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop() {\n return token.parse().ok().expect(\"Failed parse\");\n }\n let mut input = String::new();\n self.reader.read_line(&mut input).expect(\"Failed read\");\n self.buffer = input.split_whitespace().rev().map(String::from).collect();\n }\n }\n}\n\nfn factorize(n: i64) -> Vec {\n let mut n = n;\n let mut ans = Vec::new();\n let mut d = 2;\n while d * d <= n {\n while n % d == 0 {\n ans.push(d);\n n /= d;\n }\n d += 1;\n }\n if n > 1 {\n ans.push(n);\n }\n ans\n}\n\nfn solve(scan: &mut Scanner, out: &mut W) {\n let n: i64 = scan.token();\n let k: i64 = scan.token();\n\n let factors = factorize(n);\n let num_factors = factors.len() as i64;\n if num_factors < k {\n writeln!(out, \"-1\").ok();\n return;\n }\n // Choose (k - 1) factors individually.\n // Make the k-th factor the product of the rest of the factors.\n for i in 0..(k - 1) {\n write!(out, \"{} \", factors[i as usize]).ok();\n }\n let mut last_factor = 1;\n for i in (k - 1)..num_factors {\n last_factor *= factors[i as usize];\n }\n writeln!(out, \"{}\", last_factor).ok();\n}\n\nfn main() {\n let (stdin, stdout) = (io::stdin(), io::stdout());\n let mut scan = Scanner::new(stdin.lock());\n let mut out = io::BufWriter::new(stdout.lock());\n solve(&mut scan, &mut out);\n}\n", "lang_cluster": "Rust", "tags": ["math", "implementation", "number theory"], "code_uid": "75a85f24fe1e9e875fd987f0d757fef6", "src_uid": "bd0bc809d52e0a17da07ccfd450a4d79", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io::*;\n\nfn main() {\n let mut k = String::new();\n stdin().read_line(&mut k);\n let mut flag = false;\n let mut cnt = 0;\n for x in k.chars() {\n if !flag && x == '1' {\n flag = true;\n }\n if flag && x == '0' {\n cnt += 1;\n }\n }\n if flag && cnt >= 6 {\n println!(\"yes\");\n } else {\n println!(\"no\");\n }\n}", "lang_cluster": "Rust", "tags": ["implementation"], "code_uid": "a6872fc9860084b78ed346cae20294d0", "src_uid": "88364b8d71f2ce2b90bdfaa729eb92ca", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn solve() -> Vec {\n let mut input = \"\".split_ascii_whitespace();\n let mut read = || loop {\n if let Some(word) = input.next() {\n break word;\n }\n input = {\n let mut input = \"\".to_owned();\n io::stdin().read_line(&mut input).unwrap();\n if input.is_empty() {\n panic!(\"reached EOF\");\n }\n Box::leak(input.into_boxed_str()).split_ascii_whitespace()\n };\n };\n macro_rules! read(($ty:ty) => (read().parse::<$ty>().unwrap()));\n\n let mut rr = vec![\"\".to_string(); 0];\n\n let t = 1;\n for _ in 0..t {\n let n = read!(usize);\n let ca = read!(String).chars().collect::>();\n\n let mut a = vec![' '; n];\n let mut b = vec![' '; n];\n for i in 0..n {\n a[i] = ca[i];\n b[i] = ca[i + n];\n }\n\n a.sort();\n b.sort();\n let mut t = 0;\n for i in 0..n {\n if a[i] < b[i] {\n t |= 1;\n } else if a[i] > b[i] {\n t |= 2;\n } else {\n t |= 4;\n }\n }\n\n if t < 3 {\n rr.push(\"YES\".to_string());\n } else {\n rr.push(\"NO\".to_string());\n }\n }\n\n rr\n}\n\n#[allow(dead_code)]\nfn main() {\n let output = solve();\n println!(\"{}\", output.join(\"\\n\"));\n}\n", "lang_cluster": "Rust", "tags": ["sortings", "greedy"], "code_uid": "5ef1697860d69078f1d8b885415e6abf", "src_uid": "e4419bca9d605dbd63f7884377e28769", "difficulty": 1100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::cmp::*;\nuse std::collections::*;\nuse std::io::*;\nuse std::str::*;\n\n// scanner from https://codeforces.com/contest/1396/submission/91365784\nstruct Scanner {\n stdin: Stdin,\n buffer: VecDeque,\n}\n#[allow(dead_code)]\nimpl Scanner {\n fn new() -> Self {\n Scanner {\n stdin: stdin(),\n buffer: VecDeque::new(),\n }\n }\n fn cin(&mut self) -> T {\n while self.buffer.is_empty() {\n let mut line = String::new();\n let _ = self.stdin.read_line(&mut line);\n for w in line.split_whitespace() {\n self.buffer.push_back(String::from(w));\n }\n }\n self.buffer.pop_front().unwrap().parse::().ok().unwrap()\n }\n fn chars(&mut self) -> Vec {\n self.cin::().chars().collect()\n }\n fn vec(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.cin()).collect()\n }\n fn u(&mut self) -> usize {\n self.cin()\n }\n fn vecu(&mut self, n: usize) -> Vec {\n self.vec(n)\n }\n}\n\n#[derive(Clone, Debug, Default)]\nstruct Solver {}\n\nimpl Solver {\n fn solve(&mut self, scan: &mut Scanner, out: &mut BufWriter) {\n // 1426e\n let n = scan.u();\n let a = scan.vecu(3);\n let b = scan.vecu(3);\n\n let maxwin = min(a[0], b[1]) + min(a[1], b[2]) + min(a[2], b[0]);\n let tmp = max(max(a[0] + b[1], a[1] + b[2]), a[2] + b[0]);\n let minwin = tmp.saturating_sub(n);\n\n writeln!(out, \"{} {}\", minwin, maxwin).ok();\n }\n}\n\nfn solve() {\n let mut scan = Scanner::new();\n let out = &mut BufWriter::new(stdout());\n\n let testcase = 1;\n //let testcase: usize = scan.cin();\n for _ in 0..testcase {\n let mut s: Solver = Default::default();\n s.solve(&mut scan, out);\n }\n}\n\nfn main() {\n let th = std::thread::Builder::new().stack_size(64 * 1024 * 1024);\n th.spawn(|| solve()).unwrap().join().unwrap()\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "constructive algorithms", "flows", "math", "greedy"], "code_uid": "2d163382b3e7ff596c4f8168169d5767", "src_uid": "e6dc3bc64fc66b6127e2b32cacc06402", "difficulty": 1800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "// ---------- begin ModInt ----------\nconst MOD: u32 = 998_244_353;\n#[derive(Clone, Copy)]\nstruct ModInt(u32);\n\nimpl std::ops::Add for ModInt {\n type Output = ModInt;\n fn add(self, rhs: ModInt) -> ModInt {\n let mut d = self.0 + rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n\nimpl std::ops::Mul for ModInt {\n type Output = ModInt;\n fn mul(self, rhs: ModInt) -> ModInt {\n ModInt((self.0 as u64 * rhs.0 as u64 % MOD as u64) as u32)\n }\n}\n\nimpl std::ops::Sub for ModInt {\n type Output = ModInt;\n fn sub(self, rhs: ModInt) -> ModInt {\n let mut d = self.0 + MOD - rhs.0;\n if d >= MOD {\n d -= MOD;\n }\n ModInt(d)\n }\n}\n\nimpl std::ops::Neg for ModInt {\n type Output = ModInt;\n fn neg(self) -> ModInt {\n if self.0 == 0 {self} else {ModInt(MOD - self.0)}\n }\n}\n\nimpl std::ops::AddAssign for ModInt {\n fn add_assign(&mut self, rhs: ModInt) {\n *self = *self + rhs;\n }\n}\n\nimpl std::ops::MulAssign for ModInt {\n fn mul_assign(&mut self, rhs: ModInt) {\n *self = *self * rhs;\n }\n}\n\nimpl std::ops::SubAssign for ModInt {\n fn sub_assign(&mut self, rhs: ModInt) {\n *self = *self - rhs;\n }\n}\n\nimpl std::fmt::Display for ModInt {\n fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result {\n write!(f, \"{}\", self.0)\n }\n}\n\nimpl std::str::FromStr for ModInt {\n type Err = std::num::ParseIntError;\n fn from_str(s: &str) -> Result {\n let val = s.parse::()?;\n Ok(ModInt::new(val))\n }\n}\n\n#[allow(dead_code)]\nimpl ModInt {\n pub fn new(v: u32) -> ModInt {\n ModInt(v % MOD)\n }\n pub fn zero() -> ModInt {\n ModInt(0)\n }\n pub fn one() -> ModInt {\n ModInt(1)\n }\n pub fn pow(self, mut n: u32) -> ModInt {\n let mut t = ModInt::one();\n let mut s = self;\n while n > 0 {\n if n & 1 == 1 {\n t = t * s;\n }\n s = s * s;\n n >>= 1;\n }\n t\n }\n pub fn inv(self) -> ModInt {\n self.pow(MOD - 2)\n }\n}\n// ---------- end ModInt ----------\n// ---------- begin Precalc ----------\n#[allow(dead_code)]\nstruct Precalc {\n n: usize,\n inv: Vec,\n fact: Vec,\n ifact: Vec,\n}\n\n#[allow(dead_code)]\nimpl Precalc {\n pub fn new(n: usize) -> Precalc {\n let mut inv = vec![ModInt::one(); n + 1];\n let mut fact = vec![ModInt::one(); n + 1];\n let mut ifact = vec![ModInt::one(); n + 1];\n for i in 2..(n + 1) {\n inv[i] = -inv[MOD as usize % i] * ModInt(MOD / i as u32);\n fact[i] = fact[i - 1] * ModInt(i as u32);\n ifact[i] = ifact[i - 1] * inv[i];\n }\n Precalc {\n n: n,\n inv: inv,\n fact: fact,\n ifact: ifact,\n }\n }\n pub fn fact(&self, n: usize) -> ModInt {\n self.fact[n]\n }\n pub fn ifact(&self, n: usize) -> ModInt {\n self.ifact[n]\n }\n pub fn comb(&self, n: usize, k: usize) -> ModInt {\n self.fact[n] * self.ifact[k] * self.ifact[n - k]\n }\n pub fn inv(&self, n: usize) -> ModInt {\n self.inv[n]\n }\n}\n\n// ---------- end Precalc ----------\n// ---------- begin NTT ----------\nfn ntt(f: &mut [ModInt]) {\n let n = f.len();\n assert!(n.count_ones() == 1);\n let len = n.trailing_zeros() as usize;\n for i in 1..(n - 1){\n let mut x = i;\n let mut j = 0;\n for _ in 0..len {\n j = (j << 1) | (x & 1);\n x >>= 1;\n }\n if i < j {\n f.swap(i, j);\n }\n }\n for k in 0..(n.trailing_zeros() as usize) {\n let m = 1 << k;\n let z = ModInt(3).pow((MOD - 1) >> (k + 1) as u32);\n for f in f.chunks_mut(2 * m) {\n let mut q = ModInt::one();\n let (x, y) = f.split_at_mut(m);\n for (x, y) in x.iter_mut().zip(y.iter_mut()) {\n let a = *x;\n let b = q * *y;\n *x = a + b;\n *y = a - b;\n q *= z;\n }\n }\n }\n}\n\nfn intt(f: &mut [ModInt]) {\n ntt(f);\n f[1..].reverse();\n let ik = ModInt(f.len() as u32).inv();\n for f in f.iter_mut() {\n *f *= ik;\n }\n}\n\nfn multiply(a: &[ModInt], b: &[ModInt]) -> Vec {\n let n = a.len() + b.len() - 1;\n let mut k = 1;\n while k < n {\n k *= 2;\n }\n assert!(k <= (1 << 23));\n let mut f = Vec::with_capacity(k);\n let mut g = Vec::with_capacity(k);\n f.extend_from_slice(a);\n f.resize(k, ModInt::zero());\n ntt(&mut f);\n g.extend_from_slice(b);\n g.resize(k, ModInt::zero());\n ntt(&mut g);\n for (f, g) in f.iter_mut().zip(g.iter()) {\n *f *= *g;\n }\n intt(&mut f);\n f.truncate(n);\n f\n}\n\n// ---------- end NTT ----------\n\nfn run() {\n let mut s = String::new();\n std::io::stdin().read_line(&mut s).unwrap();\n let mut it = s.trim().split_whitespace();\n let mut n: usize = it.next().unwrap().parse().unwrap();\n let m: u32 = it.next().unwrap().parse().unwrap();\n let k: usize = it.next().unwrap().parse().unwrap();\n let p = ModInt(m).inv();\n let pc = Precalc::new(k);\n let mut t = vec![ModInt::zero(); k + 1];\n let mut s = vec![p; k + 1];\n t[0] = ModInt::one();\n s[0] = ModInt::one();\n for (i, s) in s.iter_mut().enumerate() {\n *s *= pc.ifact(i);\n }\n while n > 0 {\n if n & 1 == 1 {\n t = multiply(&t, &s);\n t.truncate(k + 1);\n }\n s = multiply(&s, &s);\n s.truncate(k + 1);\n n >>= 1;\n }\n let ans = t[k] * pc.fact(k);\n println!(\"{}\", ans);\n}\n\nfn main() {\n run();\n}\n", "lang_cluster": "Rust", "tags": ["math", "dp", "combinatorics", "probabilities", "number theory"], "code_uid": "d3f4df8f2b95414575b6549305183a96", "src_uid": "e6b3e559b5fd4e05adf9f1cd1b22126b", "difficulty": 2600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::str::FromStr;\n\nuse std::io::prelude::*;\nuse std::io::BufReader;\nuse std::cmp::{max, min};\n\nfn get_line() -> String {\n let mut input = String::new();\n io::stdin().read_line(&mut input).unwrap();\n input\n}\n\nfn get_vec() -> Vec\nwhere T: FromStr,\n ::Err: std::fmt::Debug,\n{\n get_line().split_whitespace().map(|k| k.parse().unwrap()).collect()\n}\n\nfn extended_euclid(a: i64, b: i64) -> (i64, i64, i64) {\n if b == 0 {\n (a, 1, 0)\n } else {\n let (d0, x0, y0) = extended_euclid(b, a % b);\n (d0, y0, x0 - a / b * y0)\n }\n}\n\nfn main() {\n let a: Vec = get_vec();\n\n let sum: u32 = a.iter().cloned().sum();\n\n if sum % 2 != 0 {\n println!(\"NO\");\n return;\n }\n\n for i in 0..6 {\n for j in i + 1..6 {\n for k in j + 1..6 {\n if a[i] + a[j] + a[k] == sum / 2 {\n println!(\"YES\");\n return;\n }\n }\n }\n }\n\n println!(\"NO\");\n}\n", "lang_cluster": "Rust", "tags": ["brute force"], "code_uid": "4d336f74b78fe3b7c4a8e43c194fb529", "src_uid": "2acf686862a34c337d1d2cbc0ac3fd11", "difficulty": 1000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn read_line() -> String {\n let mut line = String::new();\n match io::stdin().read_line(&mut line) {\n Ok(_) => line.trim().to_string(),\n _ => panic!(\"QQ\"),\n }\n}\n\nfn main() {\n let mut ans: u32 = 1;\n let n = read_line().parse::().unwrap();\n for i in 1..n {\n ans = ans * (i + n - 1) / i;\n }\n println!(\"{}\", ans);\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "18fe221556a2d65169d8b48c11d8e918", "src_uid": "2f650aae9dfeb02533149ced402b60dc", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)] use std::{*, io::*, };\n#[allow(unused)] macro_rules! input { ($($r:tt)*) => { let stdin = std::io::stdin(); let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock())); let mut next = move || -> String{ bytes.by_ref().map(|r|r.unwrap() as char).skip_while(|c|c.is_whitespace()).take_while(|c|!c.is_whitespace()).collect() }; input_inner!{next, $($r)*} }; }\n#[allow(unused)] macro_rules! input_inner { ($next:expr) => {}; ($next:expr, ) => {}; ($next:expr, $var:ident : $t:tt $($r:tt)*) => { let $var = read_value!($next, $t); input_inner!{$next $($r)*} }; }\n#[allow(unused)] macro_rules! read_value { ($next:expr, ( $($t:tt),* )) => { ( $(read_value!($next, $t)),* ) }; ($next:expr, [ $t:tt ; $len:expr ]) => { (0..$len).map(|_| read_value!($next, $t)).collect::>() }; ($next:expr, chars) => { read_value!($next, String).chars().collect::>() }; ($next:expr, usize1) => { read_value!($next, usize) - 1}; ($next:expr, [ $t:tt ]) => {{ let len = read_value!($next, usize);(0..len).map(|_| read_value!($next, $t)).collect::>()}};($next:expr, $t:ty) => {$next().parse::<$t>().expect(\"Parse error\")};}\n#[allow(unused)] macro_rules! debug { ($($format:tt)*) => (write!(std::io::stderr(), $($format)*).unwrap()); }\n#[allow(unused)] macro_rules! debugln { ($($format:tt)*) => (writeln!(std::io::stderr(), $($format)*).unwrap()); }\n\nfn solve() { \n let out = std::io::stdout(); \n let mut out = BufWriter::new(out.lock());\n #[allow(unused)] macro_rules! puts { ($($format:tt)*) => (let _ = write!(out,$($format)*);); }\n input!{\n a: (i64, i64),\n b: (i64, i64),\n c: (i64, i64),\n }\n puts!(\n \"{}\",\n if (a.0 - b.0).pow(2) + (a.1 - b.1).pow(2) == (b.0 - c.0).pow(2) + (b.1 - c.1).pow(2) \n && (b.0 - a.0) * (c.1 - b.1) != (b.1 - a.1) * (c.0 - b.0) \n {\"Yes\"} else {\"No\"}\n );\n}\n\nfn main() {\n // In order to avoid potential stack overflow, spawn a new thread.\n let stack_size = 104_857_600; // 100 MB\n let thd = std::thread::Builder::new().stack_size(stack_size);\n thd.spawn(|| solve()).unwrap().join().unwrap();\n}\n\n#[allow(dead_code)]\nfn get_word() -> String {\n let stdin = std::io::stdin();\n let mut stdin=stdin.lock();\n let mut u8b: [u8; 1] = [0];\n loop {\n let mut buf: Vec = Vec::with_capacity(16);\n loop {\n let res = stdin.read(&mut u8b);\n if res.unwrap_or(0) == 0 || u8b[0] <= b' ' {\n break;\n } else {\n buf.push(u8b[0]);\n }\n }\n if buf.len() >= 1 {\n let ret = String::from_utf8(buf).unwrap();\n return ret;\n }\n }\n}\n#[allow(dead_code)]\nfn get() -> T { get_word().parse().ok().unwrap() }\n\n// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8", "lang_cluster": "Rust", "tags": ["math", "geometry"], "code_uid": "873e3435d98fb860f9ea2c35f5b77553", "src_uid": "05ec6ec3e9ffcc0e856dc0d461e6eeab", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "#[allow(unused_imports)]\nuse std::cmp::{min,max};\n//const INF: i32 = 0x3f3f3f3f;\n\nstruct Scanner {\n buffer: std::collections::VecDeque\n}\n\nimpl Scanner {\n fn new() -> Scanner {\n Scanner {\n buffer: std::collections::VecDeque::new()\n }\n }\n\n fn next(&mut self) -> T {\n while self.buffer.is_empty() {\n let mut input = String::new();\n std::io::stdin().read_line(&mut input).ok();\n self.buffer = input.split_whitespace()\n .map(ToString::to_string).collect();\n }\n let front = self.buffer.pop_front().unwrap();\n front.parse::().ok().unwrap()\n }\n}\n\nfn gcd(a: i64, b: i64) -> i64 {\n if b == 0 {\n return a\n }\n else {\n return gcd(b, a % b);\n }\n}\n\nfn main1() {\n let mut scan = Scanner::new();\n let n = scan.next::();\n let k = scan.next::();\n let a = scan.next::();\n let b = scan.next::();\n let len = n * k;\n \n // all offsets are in [0, k]\n let mut offsets = vec![a+b, max(a,b)-min(a,b)];\n let neg1 = k - offsets[0];\n let neg2 = k - offsets[1];\n offsets.push(neg1);\n offsets.push(neg2);\n \n let mut lo = len;\n let mut hi = 0;\n for offset in offsets {\n for i in 0..n {\n let l = offset + k * i;\n let stops = len / gcd(l, len);\n lo = min(lo, stops);\n hi = max(hi, stops);\n }\n }\n println!(\"{} {}\", lo, hi);\n}\n\nfn main() {\n std::thread::Builder::new().stack_size(50 << 20)\n .spawn(main1).unwrap().join().unwrap();\n}", "lang_cluster": "Rust", "tags": ["brute force", "math"], "code_uid": "6b472f82eb1f1cd9d6315e7415bbfd83", "src_uid": "5bb4adff1b332f43144047955eefba0c", "difficulty": 1700.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\n\nfn to_square(line: &str) -> Vec<(i32, i32)> {\n\tlet mut iter = line.trim().split_whitespace();\n\tlet mut ret = Vec::new();\n\twhile let Some(x) = iter.next() {\n\t\tret.push((x.parse().unwrap(),\n\t\t iter.next().unwrap().parse().unwrap()));\n\t}\n\tret.sort();\n\treturn ret\n}\n\nfn solve_square1(s1: &Vec<(i32, i32)>, x: i32) -> Option<(i32, i32)> {\n\tif x < s1[0].0 || x > s1[3].0 { return None; }\n\treturn Some((s1[0].1, s1[3].1));\n}\n\nfn solve_square2(s2: &Vec<(i32, i32)>, x: i32) -> Option<(i32, i32)> {\n\tlet x1 = s2[0].0;\n\tlet x2 = s2[3].0;\n\tlet y0 = s2[0].1;\n\tif x < x1 || x > x2 { return None; }\n\tlet d = if x < s2[1].0 {\n\t\tx - x1\n\t} else {\n\t\ts2[3].0 - x\n\t};\n\treturn Some((y0 - d, y0 + d));\n}\n\nfn solve(s1: Vec<(i32, i32)>, s2: Vec<(i32, i32)>) -> bool {\n\tlet mut xs = Vec::new();\n\tfor (x, _) in &s1 { xs.push(x); }\n\tfor (x, _) in &s2 { xs.push(x); }\n\txs.sort();\n\txs.dedup();\n\tfor x in xs {\n\t\tif let Some((lo1, hi1)) = solve_square1(&s1, *x) {\n\t\t\tif let Some((lo2, hi2)) = solve_square2(&s2, *x) {\n\t\t\t\tlet lo = if lo1 < lo2 { lo2 } else { lo1 };\n\t\t\t\tlet hi = if hi1 < hi2 { hi1 } else { hi2 };\n\t\t\t\tif lo <= hi { return true; }\n\t\t\t}\n\t\t}\n\t}\n\treturn false;\n}\n\nfn main() -> io::Result<()> {\n\tlet f = io::stdin();\n\tlet mut line = String::new();\n\tf.read_line(&mut line)?;\n\tlet s1 = to_square(&line);\n\tline.clear();\n\tf.read_line(&mut line)?;\n\tlet s2 = to_square(&line);\n\tprintln!(\"{}\", if solve(s1, s2) { \"YES\" } else { \"NO\" });\n\n\tOk(())\n}\n", "lang_cluster": "Rust", "tags": ["geometry", "implementation"], "code_uid": "3faeef7dea89a41e56a7935705ec4ded", "src_uid": "f6a3dd8b3bab58ff66055c61ddfdf06a", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "macro_rules! parse_line {\n ($t: ty) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let a_str = a_str.trim();\n a_str.parse::<$t>().expect(\"parse error\")\n });\n ($($t: ty),+) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let mut a_iter = a_str.split_whitespace();\n (\n $(\n a_iter.next().unwrap().parse::<$t>().expect(\"parse error\"),\n )+\n )\n })\n}\n\nmacro_rules! parse_line_to_vec {\n ($t: ty) => {{\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n (a_str\n .split_whitespace()\n .map(|x| x.parse::<$t>().unwrap())\n .collect::>())\n }};\n}\n\nfn solve() {\n let field: Vec> = (0..10).map(|_| parse_line!(String).bytes().collect()).collect();\n let mut ok = false;\n for i in 0..10 {\n for j in 0..10 {\n if i + 5 <= 10 {\n let mut xs = 0;\n let mut os = 0;\n for d in 0..5 {\n if field[i + d][j] == b'X' {\n xs += 1;\n }else if field[i + d][j] == b'O' {\n os += 1;\n }\n }\n if os == 0 && xs >= 4 {\n ok = true;\n }\n }\n if j + 5 <= 10 {\n let mut xs = 0;\n let mut os = 0;\n for d in 0..5 {\n if field[i][j + d] == b'X' {\n xs += 1;\n }else if field[i][j + d] == b'O' {\n os += 1;\n }\n }\n if os == 0 && xs >= 4 {\n ok = true;\n }\n }\n if i + 5 <= 10 && j + 5 <= 10 {\n let mut xs = 0;\n let mut os = 0;\n for d in 0..5 {\n if field[i + d][j + d] == b'X' {\n xs += 1;\n }else if field[i + d][j + d] == b'O' {\n os += 1;\n }\n }\n if os == 0 && xs >= 4 {\n ok = true;\n }\n }\n if i + 5 <= 10 && j >= 4 {\n let mut xs = 0;\n let mut os = 0;\n for d in 0..5 {\n if field[i + d][j - d] == b'X' {\n xs += 1;\n }else if field[i + d][j - d] == b'O' {\n os += 1;\n }\n }\n if os == 0 && xs >= 4 {\n ok = true;\n }\n }\n }\n }\n println!(\"{}\", if ok {\"YES\"} else {\"NO\"});\n}\n\nfn main() {\n let tests = 1; // parse_line!(usize);\n for _ in 0..tests {\n solve();\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "483a44542893177c49a7c7c412a3b6d9", "src_uid": "d5541028a2753c758322c440bdbf9ec6", "difficulty": 1600.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "macro_rules! parse_line {\n ($t: ty) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let a_str = a_str.trim();\n a_str.parse::<$t>().expect(\"parse error\")\n });\n ($($t: ty),+) => ({\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n let mut a_iter = a_str.split_whitespace();\n (\n $(\n a_iter.next().unwrap().parse::<$t>().expect(\"parse error\"),\n )+\n )\n })\n}\n\nmacro_rules! parse_line_to_vec {\n ($t: ty) => {{\n let mut a_str = String::new();\n std::io::stdin().read_line(&mut a_str).expect(\"read error\");\n (a_str\n .split_whitespace()\n .map(|x| x.parse::<$t>().unwrap())\n .collect::>())\n }};\n}\n\nfn solve_one(pos: usize, col: usize, c: &Vec) -> usize {\n let mut s = Vec::new();\n let mut result = 0;\n for i in 0..=c.len() {\n let val = if i < pos {c[i]} else if i > pos {c[i - 1]} else {col};\n if s.is_empty() {\n s.push((val, 1));\n }else if s.last().unwrap().0 == val {\n s.last_mut().unwrap().1 += 1;\n }else{\n if s.last().unwrap().1 > 2 {\n result += s.pop().unwrap().1;\n }\n if s.is_empty() {\n s.push((val, 1));\n }else if s.last().unwrap().0 == val {\n s.last_mut().unwrap().1 += 1;\n }else{\n s.push((val, 1));\n }\n }\n }\n if let Some((_col, cnt)) = s.last() {\n if *cnt > 2 {\n result += cnt;\n }\n }\n return if result > 0 {\n result - 1\n }else{\n 0\n }\n}\n\nfn solve() {\n let (n, _k, x) = parse_line!(usize, usize, usize);\n let c = parse_line_to_vec!(usize);\n let mut result = 0;\n for i in 0..=n {\n result = std::cmp::max(result, solve_one(i, x, &c));\n }\n println!(\"{}\", result)\n}\n\nfn main() {\n let tests = 1; // parse_line!(usize);\n for _ in 0..tests {\n solve();\n }\n}\n", "lang_cluster": "Rust", "tags": ["two pointers", "brute force"], "code_uid": "833d78e31f40176f8f4cfb3bd93bc5a9", "src_uid": "d73d9610e3800817a3109314b1e6f88c", "difficulty": 1400.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "pub trait Scan {\n fn scan<'a, I>(eles: &mut I) -> Self where I: Iterator;\n}\n\nmacro_rules! impl_scan_single {\n ($ty:ty) => {\n impl Scan for $ty {\n fn scan<'a, I>(eles: &mut I) -> Self where I: Iterator {\n let next = eles.next().unwrap();\n match next.parse() {\n Ok(res) => res,\n Err(_) => panic!()\n }\n }\n }\n }\n}\n\nimpl_scan_single!(u8);\nimpl_scan_single!(u16);\nimpl_scan_single!(u32);\nimpl_scan_single!(u64);\nimpl_scan_single!(usize);\nimpl_scan_single!(i8);\nimpl_scan_single!(i16);\nimpl_scan_single!(i32);\nimpl_scan_single!(i64);\nimpl_scan_single!(isize);\nimpl_scan_single!(f32);\nimpl_scan_single!(f64);\nimpl_scan_single!(String);\n\nconst __IMPL_SCAN_FOR_VEC: () = {\n use std::str::FromStr;\n impl Scan for Vec where T: FromStr {\n fn scan<'a, I>(eles: &mut I) -> Self where I: Iterator {\n eles.map(|str| match str.parse() {\n Ok(res) => res,\n Err(_) => panic!()\n }).collect()\n }\n }\n};\n\n// -----------------------------------------------------------------------------\n\nfn main() {\n #[allow(unused_imports)]\n use std::io::{self, BufReader, BufRead, Write, BufWriter};\n let __stdin = io::stdin();\n let __stdout = io::stdout();\n let mut __in = BufReader::with_capacity(4096, __stdin.lock());\n let mut __buf = String::new();\n let mut __out = BufWriter::with_capacity(4096, __stdout.lock());\n\n macro_rules! scanln {\n ($($var:ident : $ty:path),+) => {\n $(let $var: $ty;)+\n {\n __buf.clear();\n __in.read_line(&mut __buf).unwrap();\n let mut eles = __buf.trim().split_whitespace();\n $($var = Scan::scan(&mut eles);)+\n }\n }\n }\n\n macro_rules! put {\n ($fmt:expr) => { write!(__out, $fmt).unwrap(); };\n ($fmt:expr, $($arg:expr),+) => { write!(__out, $fmt, $($arg),+).unwrap(); }\n }\n macro_rules! putln {\n () => { writeln!(__out, \"\").unwrap(); };\n ($fmt:expr) => { writeln!(__out, $fmt).unwrap(); };\n ($fmt:expr, $($arg:expr),+) => { writeln!(__out, $fmt, $($arg),+).unwrap(); }\n }\n macro_rules! fflush {\n () => { __out.flush().unwrap(); }\n }\n\n // -- PLACE SOLUTION BODY BELOW THIS LINE ------------------------------------\n\n scanln!(l: u32, r: u32, x: u32, y: u32, k: u32);\n\n let mut cost = 1;\n let mut exp = k;\n let mut found = false;\n\n while exp <= r && cost <= y {\n if exp >= l && cost >= x {\n found = true;\n break;\n }\n exp += k;\n cost += 1;\n }\n\n putln!(\"{}\", if found { \"YES\" } else { \"NO\" });\n}\n", "lang_cluster": "Rust", "tags": ["two pointers", "brute force"], "code_uid": "9742b8c2d363be47313bf936d8ce44ae", "src_uid": "1110d3671e9f77fd8d66dca6e74d2048", "difficulty": 1200.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nfn read_line() -> String {\n let mut buffer = String::new();\n io::stdin().read_line(&mut buffer).unwrap();\n String::from(buffer.trim())\n}\nfn read_number() -> i64 {\n read_line().parse::().unwrap()\n}\nfn read_nums() -> Vec {\n read_line().split(' ').map(|x| x.parse::().unwrap()).collect()\n}\n\nfn main() {\n let nsk = read_nums();\n let (n, s, k) = (nsk[0] as usize, nsk[1] - 1, nsk[2]);\n let candies = read_nums();\n let colors = read_line().chars().collect::>();\n let mut shortest: Vec>> = vec![vec![None; 50 * n + 1]; n];\n for i in 0..n {\n shortest[i][candies[i]] = Some((i as i64 - s as i64).abs());\n }\n for candy_num in 1..(50usize*n+1) {\n for ind in 0..n {\n if let Some(mut dist) = shortest[ind][candy_num] {\n for jnd in 0..n {\n if colors[ind] != colors[jnd] && candies[jnd] > candies[ind] {\n let total_candies = candy_num + candies[jnd];\n let path = dist + (jnd as i64 - ind as i64).abs();\n if let Some(old) = shortest[jnd][total_candies] {\n shortest[jnd][total_candies] = Some(std::cmp::min(old, path));\n } else {\n shortest[jnd][total_candies] = Some(path);\n }\n }\n }\n }\n }\n }\n let mut ans: Option = None;\n for candy_num in k..(50usize*n+1) {\n for ind in 0..n {\n if let Some(mut dist) = shortest[ind][candy_num] {\n ans = Some(\n match ans {\n Some(old_ans) => std::cmp::min(old_ans, dist),\n None => dist,\n }\n );\n }\n }\n }\n println!(\"{}\", ans.unwrap_or(-1));\n}\n", "lang_cluster": "Rust", "tags": ["dp"], "code_uid": "28ec55ff64b90a920ed3a7387b1aa37c", "src_uid": "a95e54a7e38cc0d61b39e4a01a6f8d3f", "difficulty": 2000.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan { buffer: std::collections::VecDeque::new() }\n }\n\n fn next(&mut self)-> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let n1: usize = scan.next();\n let n2: usize = scan.next();\n let _k1: usize = scan.next();\n let _k2: usize = scan.next();\n println!(\"{}\", if n2>=n1 {\"Second\"} else {\"First\"});\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1<<23).spawn(_main).unwrap().join().unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["math", "constructive algorithms"], "code_uid": "91b7ff7e681caefc627fa9c91163eeef", "src_uid": "aed24ebab3ed9fd1741eea8e4200f86b", "difficulty": 800.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "use std::io;\nuse std::io::Stdin;\nuse std::str::FromStr;\n\nfn read_line(stdin : &Stdin, line : &mut String) {\n match stdin.read_line(line) {\n Ok(_) => return,\n Err(msg) => panic!(\"Could not read line! Message: {}.\", msg),\n }\n}\n\nfn parse_t(s : &str) -> T {\n match s.trim().parse() {\n Ok(y) => y,\n Err(_) => panic!(\"Could not read from string!\"),\n }\n}\n\nfn read_t(stdin : &Stdin) -> T {\n let mut line = String::new();\n read_line(stdin, &mut line);\n parse_t(&line)\n}\n\nfn digit_indices(ds : &Vec, di : &mut Vec>) {\n di.clear();\n for _ in 0 .. 10 {\n let ev = vec![];\n di.push(ev);\n }\n for i in 0 .. ds.len() {\n di[ds[i] as usize].push(i);\n }\n}\n\nfn digits(n : u64, ds : &mut Vec) {\n ds.clear();\n if n == 0 {\n ds.push(0);\n } else {\n let mut x = n;\n loop {\n if x == 0 {\n break;\n } else {\n let x_mod_10 = x % 10;\n let x_div_10 = x / 10;\n ds.push(x_mod_10);\n x = x_div_10;\n }\n }\n }\n}\n\nfn move_digits(from : usize, to : usize, dgts : &mut Vec) -> u64 {\n let mut num_swaps = 0;\n let dgt_from = dgts[from];\n let mut idx = from - 1;\n loop {\n if idx == to {\n dgts[idx + 1] = dgts[idx];\n dgts[idx] = dgt_from;\n num_swaps = num_swaps + 1;\n break;\n } else {\n dgts[idx + 1] = dgts[idx];\n idx = idx - 1;\n num_swaps = num_swaps + 1;\n }\n }\n num_swaps\n}\n\nfn swap_zero_out(from : usize, to : usize, dgts : &mut Vec) -> Option {\n if from < 2 {\n None\n } else {\n let mut found = false;\n let mut idx = from - 2;\n if idx < to {\n None\n } else {\n loop {\n if idx == to {\n if dgts[idx] == 0 {\n // Do nothing ...\n } else {\n found = true;\n }\n break;\n } else {\n if dgts[idx] == 0 {\n idx = idx - 1;\n } else {\n found = true;\n break;\n }\n }\n }\n if found {\n let num_swaps = move_digits(from - 1, idx, dgts);\n Some(num_swaps)\n } else {\n None\n }\n }\n }\n}\n\nfn swap_to_index(from : usize, to : usize, dgts : &mut Vec) -> Option {\n if from < to {\n panic!(\"Check failed: from({}) >= to({}).\", from, to);\n } else if from == to {\n Some(0)\n } else {\n let num_dgts = dgts.len();\n if from == (num_dgts - 1) {\n // From is the highest digit, we have to check whether\n // the digit immediately to the right of it is a zero.\n if dgts[from - 1] == 0 {\n // We have to swap zero out of its location.\n match swap_zero_out(from, to, dgts) {\n None => None,\n Some(x) => { \n let y = move_digits(from, to, dgts);\n let num_swaps = x + y;\n Some(num_swaps)\n },\n }\n } else {\n // We don't have to worry about swapping a zero into\n // the highest digit.\n let num_swaps = move_digits(from, to, dgts);\n Some(num_swaps)\n }\n } else {\n // From is not the highest digit, so we need not\n // worry about swapping a zero into its place.\n let num_swaps = move_digits(from, to, dgts);\n Some(num_swaps)\n }\n }\n}\n\nfn num_swaps_for_digits(n : u64,\n d_1 : usize,\n m_1 : usize,\n d_2 : usize,\n m_2 : usize) -> Option {\n let mut dgts = vec![];\n digits(n, &mut dgts);\n let mut dgt_indxs = vec![];\n digit_indices(&dgts, &mut dgt_indxs);\n let mut could_swap = true;\n let mut num_swaps = u64::max_value();\n match swap_to_index(dgt_indxs[d_1][m_1], 0, &mut dgts) {\n None => {\n could_swap = false;\n },\n Some(x) => {\n num_swaps = x;\n },\n };\n if could_swap {\n let mut could_swap_2 = true;\n digit_indices(&dgts, &mut dgt_indxs);\n match swap_to_index(dgt_indxs[d_2][m_2], 1, &mut dgts) {\n None => {\n could_swap_2 = false;\n },\n Some(x) => {\n num_swaps = num_swaps + x;\n },\n };\n if could_swap_2 {\n Some(num_swaps)\n } else {\n None\n }\n } else {\n None\n }\n}\n\nfn num_swaps_to_divisible_by_25(n : u64) -> Option {\n let mut dgts = vec![];\n digits(n, &mut dgts);\n let mut dgt_indxs = vec![];\n digit_indices(&dgts, &mut dgt_indxs);\n let num_digits = dgts.len();\n // Check for at least two digits.\n if num_digits < 2 {\n None\n } else {\n let mut min_num_swaps = u64::max_value();\n // Check for two zeros.\n if dgt_indxs[0].len() >= 2 {\n // We have to swap the digits into place...\n match num_swaps_for_digits(n, 0, 0, 0, 1) {\n None => (),\n Some(x) => {\n if x < min_num_swaps {\n min_num_swaps = x;\n }\n }\n }\n } \n if (dgt_indxs[0].len() >= 1) && (dgt_indxs[5].len() >= 1) {\n match num_swaps_for_digits(n, 0, 0, 5, 0) {\n None => (),\n Some(x) => {\n if x < min_num_swaps {\n min_num_swaps = x;\n }\n }\n }\n } \n if (dgt_indxs[2].len() >= 1) && (dgt_indxs[5].len() >= 1) {\n match num_swaps_for_digits(n, 5, 0, 2, 0) {\n None => (),\n Some(x) => {\n if x < min_num_swaps {\n min_num_swaps = x;\n }\n }\n }\n } \n if (dgt_indxs[7].len() >= 1) && (dgt_indxs[5].len() >= 1) {\n match num_swaps_for_digits(n, 5, 0, 7, 0) {\n None => (),\n Some(x) => {\n if x < min_num_swaps {\n min_num_swaps = x;\n }\n }\n }\n } \n if min_num_swaps < u64::max_value() {\n Some(min_num_swaps)\n } else {\n None\n }\n }\n}\n\nfn main() {\n let stdin = io::stdin();\n let n = read_t(&stdin);\n match num_swaps_to_divisible_by_25(n) {\n None => println!(\"-1\"),\n Some(s) => println!(\"{}\", s),\n }\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "greedy"], "code_uid": "ad80f0fa8fcf505ec07ec7dd53157231", "src_uid": "ea1c737956f88be94107f2565ca8bbfd", "difficulty": 2100.0, "exec_outcome": "PASSED"} {"lang": "Rust", "source_code": "struct Scan {\n buffer: std::collections::VecDeque,\n}\n\nimpl Scan {\n fn new() -> Scan {\n Scan {\n buffer: std::collections::VecDeque::new(),\n }\n }\n\n fn next(&mut self) -> T {\n loop {\n if let Some(token) = self.buffer.pop_front() {\n break token.parse::().ok().unwrap();\n }\n let mut line = String::new();\n std::io::stdin().read_line(&mut line).expect(\"Fail to read\");\n self.buffer = line.split_whitespace().map(String::from).collect();\n }\n }\n\n fn next_n(&mut self, n: usize) -> Vec {\n (0..n).map(|_| self.next::()).collect()\n }\n}\n\nfn _main() {\n let mut scan = Scan::new();\n let mut arr: Vec = scan.next_n(4);\n arr.sort();\n if arr[0] + arr[3] == arr[1] + arr[2] || arr[0] + arr[1] + arr[2] == arr[3] {\n println!(\"YES\");\n } else {\n println!(\"NO\");\n }\n}\n\nfn main() {\n std::thread::Builder::new()\n .stack_size(1 << 23)\n .spawn(_main)\n .unwrap()\n .join()\n .unwrap();\n}\n", "lang_cluster": "Rust", "tags": ["brute force", "implementation"], "code_uid": "6dc69081fd130ba709b649844992ae40", "src_uid": "5a623c49cf7effacfb58bc82f8eaff37", "difficulty": 800.0, "exec_outcome": "PASSED"}