Sorting exams like a champ

Author: hir12111

Diff for: books.rs

@@ -0,0 +1,59 @@
+struct Scan {
+    buffer: std::collections::VecDeque<String>,
+}
+
+impl Scan {
+    fn new() -> Scan {
+        Scan {
+            buffer: std::collections::VecDeque::new(),
+        }
+    }
+
+    fn next<T: std::str::FromStr>(&mut self) -> T {
+        loop {
+            if let Some(token) = self.buffer.pop_front() {
+                break token.parse::<T>().ok().unwrap();
+            }
+            let mut line = String::new();
+            std::io::stdin().read_line(&mut line).expect("Fail to read");
+            self.buffer = line.split_whitespace().map(String::from).collect();
+        }
+    }
+
+    fn next_n<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
+        (0..n).map(|_| self.next::<T>()).collect()
+    }
+}
+
+fn _main() {
+    let mut scan = Scan::new();
+    let n: usize = scan.next();
+    let t: usize = scan.next();
+    let arr: Vec<usize> = scan.next_n(n);
+    let mut acc = 0usize;
+    let mut result = 0usize;
+    let mut left = 0usize;
+    let mut right = 0usize;
+    while right < n {
+        if acc > t {
+            acc -= arr[left];
+            left += 1;
+        } else {
+            acc += arr[right];
+            right += 1;
+        }
+        if acc <= t {
+            result = result.max(right - left);
+        }
+    }
+    println!("{}", result);
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}

Diff for: dieroll.rs

@@ -0,0 +1,56 @@
+struct Scan {
+    buffer: std::collections::VecDeque<String>,
+}
+
+impl Scan {
+    fn new() -> Scan {
+        Scan {
+            buffer: std::collections::VecDeque::new(),
+        }
+    }
+
+    fn next<T: std::str::FromStr>(&mut self) -> T {
+        loop {
+            if let Some(token) = self.buffer.pop_front() {
+                break token.parse::<T>().ok().unwrap();
+            }
+            let mut line = String::new();
+            std::io::stdin().read_line(&mut line).expect("Fail to read");
+            self.buffer = line.split_whitespace().map(String::from).collect();
+        }
+    }
+}
+
+fn gcd(mut a: usize, mut b: usize) -> usize {
+    if b > a {
+        std::mem::swap(&mut a, &mut b);
+    }
+    while b != 0 {
+        let new_b = a % b;
+        a = b;
+        b = new_b;
+    }
+    if a == 0 {
+        1
+    } else {
+        a
+    }
+}
+
+fn _main() {
+    let mut scan = Scan::new();
+    let a: usize = scan.next();
+    let b: usize = scan.next();
+    let x = 6 - a.max(b) + 1;
+    let common = gcd(x, 6);
+    println!("{}/{}", x / common, 6 / common);
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}

Diff for: exams.rs

@@ -0,0 +1,58 @@
+struct Scan {
+    buffer: std::collections::VecDeque<String>,
+}
+
+impl Scan {
+    fn new() -> Scan {
+        Scan {
+            buffer: std::collections::VecDeque::new(),
+        }
+    }
+
+    fn next<T: std::str::FromStr>(&mut self) -> T {
+        loop {
+            if let Some(token) = self.buffer.pop_front() {
+                break token.parse::<T>().ok().unwrap();
+            }
+            let mut line = String::new();
+            std::io::stdin().read_line(&mut line).expect("Fail to read");
+            self.buffer = line.split_whitespace().map(String::from).collect();
+        }
+    }
+}
+#[derive(Eq, Ord, PartialOrd, PartialEq)]
+struct Exam {
+    a: usize,
+    b: usize,
+}
+fn _main() {
+    let mut scan = Scan::new();
+    let n: usize = scan.next();
+    let mut arr: Vec<Exam> = vec![];
+    for _ in 0..n {
+        let a: usize = scan.next();
+        let b: usize = scan.next();
+        arr.push(Exam { a: a, b: b });
+    }
+    arr.sort();
+    let mut result = arr[0].a.min(arr[0].b);
+    for i in 1..n {
+        let min_date = arr[i].a.min(arr[i].b);
+        let max_date = arr[i].a.max(arr[i].b);
+        if min_date >= result {
+            result = min_date;
+        } else {
+            result = max_date;
+        }
+    }
+    println!("{}", result);
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}

Diff for: frogjumping.rs

@@ -0,0 +1,43 @@
+struct Scan {
+    buffer: std::collections::VecDeque<String>,
+}
+
+impl Scan {
+    fn new() -> Scan {
+        Scan {
+            buffer: std::collections::VecDeque::new(),
+        }
+    }
+
+    fn next<T: std::str::FromStr>(&mut self) -> T {
+        loop {
+            if let Some(token) = self.buffer.pop_front() {
+                break token.parse::<T>().ok().unwrap();
+            }
+            let mut line = String::new();
+            std::io::stdin().read_line(&mut line).expect("Fail to read");
+            self.buffer = line.split_whitespace().map(String::from).collect();
+        }
+    }
+}
+
+fn _main() {
+    let mut scan = Scan::new();
+    let t: isize = scan.next();
+    for _ in 0..t {
+        let a: i64 = scan.next();
+        let b: i64 = scan.next();
+        let k: i64 = scan.next();
+        let result = (a - b) * (k / 2) + a * (k % 2);
+        println!("{}", result);
+    }
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}

Diff for: maxinc.rs

@@ -0,0 +1,52 @@
+struct Scan {
+    buffer: std::collections::VecDeque<String>,
+}
+
+impl Scan {
+    fn new() -> Scan {
+        Scan {
+            buffer: std::collections::VecDeque::new(),
+        }
+    }
+
+    fn next<T: std::str::FromStr>(&mut self) -> T {
+        loop {
+            if let Some(token) = self.buffer.pop_front() {
+                break token.parse::<T>().ok().unwrap();
+            }
+            let mut line = String::new();
+            std::io::stdin().read_line(&mut line).expect("Fail to read");
+            self.buffer = line.split_whitespace().map(String::from).collect();
+        }
+    }
+
+    fn next_n<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
+        (0..n).map(|_| self.next::<T>()).collect()
+    }
+}
+
+fn _main() {
+    let mut scan = Scan::new();
+    let n: usize = scan.next();
+    let arr: Vec<usize> = scan.next_n(n);
+    let mut result = 0;
+    let mut acc = 0;
+    for i in 1..n {
+        if arr[i] > arr[i - 1] {
+            acc += 1;
+            result = result.max(acc);
+        } else {
+            acc = 0;
+        }
+    }
+    println!("{}", result + 1);
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}

Diff for: modexp.rs

@@ -0,0 +1,42 @@
+struct Scan {
+    buffer: std::collections::VecDeque<String>,
+}
+
+impl Scan {
+    fn new() -> Scan {
+        Scan {
+            buffer: std::collections::VecDeque::new(),
+        }
+    }
+
+    fn next<T: std::str::FromStr>(&mut self) -> T {
+        loop {
+            if let Some(token) = self.buffer.pop_front() {
+                break token.parse::<T>().ok().unwrap();
+            }
+            let mut line = String::new();
+            std::io::stdin().read_line(&mut line).expect("Fail to read");
+            self.buffer = line.split_whitespace().map(String::from).collect();
+        }
+    }
+}
+
+fn _main() {
+    let mut scan = Scan::new();
+    let n: usize = scan.next();
+    let m: usize = scan.next();
+    if n >= 27 {
+        println!("{}", m);
+    } else {
+        println!("{}", m % (1 << n));
+    }
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}

Diff for: repeatingcipher.rs

@@ -0,0 +1,47 @@
+struct Scan {
+    buffer: std::collections::VecDeque<String>,
+}
+
+impl Scan {
+    fn new() -> Scan {
+        Scan {
+            buffer: std::collections::VecDeque::new(),
+        }
+    }
+
+    fn next<T: std::str::FromStr>(&mut self) -> T {
+        loop {
+            if let Some(token) = self.buffer.pop_front() {
+                break token.parse::<T>().ok().unwrap();
+            }
+            let mut line = String::new();
+            std::io::stdin().read_line(&mut line).expect("Fail to read");
+            self.buffer = line.split_whitespace().map(String::from).collect();
+        }
+    }
+}
+
+fn _main() {
+    let mut scan = Scan::new();
+    let n: usize = scan.next();
+    let arr: Vec<char> = scan.next::<String>().chars().collect();
+    let mut res: Vec<char> = vec![];
+    let mut i = 0usize;
+    let mut cnt = 1usize;
+    while i < n {
+        res.push(arr[i]);
+        i += cnt;
+        cnt += 1;
+    }
+    let res: String = res.iter().collect();
+    println!("{}", res);
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}