Use proconio in most of the examples

Author: qryxip

examples/abc054-c.rs

@@ -2,24 +2,15 @@
 
 use itertools::Itertools as _;
 use petgraph::graph::UnGraph;
-
-use std::io::{self, Read};
+use proconio::input;
+use proconio::marker::Usize1;
 
 fn main() {
-    let mut input = read_to_static(io::stdin()).split_whitespace();
-    macro_rules! read {
-        ([$tt:tt]) => (read!([$tt; read!(usize)]));
-        ([$tt:tt; $n:expr]) => ((0..$n).map(|_| read!($tt)).collect::<Vec<_>>());
-        (($($tt:tt),+)) => (($(read!($tt)),*));
-        ($ty:ty) => (input.next().unwrap().parse::<$ty>().unwrap());
-        ({ Usize1 }) => {
-            read!(usize) - 1
-        };
+    input! {
+        n: usize,
+        abs: [(Usize1, Usize1)],
     }
 
-    let n = read!(usize);
-    let abs = read!([({ Usize1 }, { Usize1 })]);
-
     let graph = UnGraph::<(), (), usize>::from_edges(abs);
     let ans = graph
         .node_indices()
@@ -28,9 +19,3 @@ fn main() {
         .count();
     println!("{}", ans);
 }
-
-fn read_to_static(mut source: impl Read) -> &'static str {
-    let mut input = "".to_owned();
-    source.read_to_string(&mut input).unwrap();
-    Box::leak(input.into_boxed_str())
-}

examples/abc073-d.rs

@@ -1,27 +1,25 @@
 // https://atcoder.jp/contests/abc073/tasks/abc073_d
 
 use itertools::Itertools as _;
-use petgraph::graph::{NodeIndex, UnGraph};
+use num::traits::One;
+use petgraph::graph::{IndexType, NodeIndex, UnGraph};
+use proconio::input;
+use proconio::source::{Readable, Source};
 
 use std::collections::HashMap;
-use std::io::{self, Read};
+use std::io::BufRead;
+use std::marker::PhantomData;
+use std::ops::Sub;
 
 fn main() {
-    let mut input = read_to_static(io::stdin()).split_whitespace();
-    macro_rules! read {
-        ([$tt:tt]) => (read!([$tt; read!(usize)]));
-        ([$tt:tt; $n:expr]) => ((0..$n).map(|_| read!($tt)).collect::<Vec<_>>());
-        (($($tt:tt),+)) => (($(read!($tt)),*));
-        ($ty:ty) => (input.next().unwrap().parse::<$ty>().unwrap());
-        ({ NodeIndex1 }) => {
-            NodeIndex::from(read!(u32) - 1)
-        };
+    input! {
+        _n: usize,
+        m: usize,
+        r: usize,
+        rs: [NodeIndex1<u32>; r],
+        abcs: [(NodeIndex1<u32>, NodeIndex1<u32>, u32); m],
     }
 
-    let (_, m, r) = read!((usize, usize, usize));
-    let rs = read!([{ NodeIndex1 }; r]);
-    let abcs = read!([({ NodeIndex1 }, { NodeIndex1 }, u32); m]);
-
     let graph = UnGraph::<(), u32>::from_edges(abcs);
 
     let dijkstra = rs
@@ -41,8 +39,12 @@ fn main() {
     println!("{}", ans);
 }
 
-fn read_to_static(mut source: impl Read) -> &'static str {
-    let mut input = "".to_owned();
-    source.read_to_string(&mut input).unwrap();
-    Box::leak(input.into_boxed_str())
+struct NodeIndex1<Ix>(PhantomData<fn() -> Ix>);
+
+impl<Ix: IndexType + Readable<Output = Ix> + One + Sub<Output = Ix>> Readable for NodeIndex1<Ix> {
+    type Output = NodeIndex<Ix>;
+
+    fn read<R: BufRead, S: Source<R>>(source: &mut S) -> NodeIndex<Ix> {
+        NodeIndex::from(Ix::read(source) - Ix::one())
+    }
 }

examples/abc129-f.rs

@@ -3,19 +3,21 @@
 use ndarray::{array, Array2, LinalgScalar};
 use num::{PrimInt, Unsigned};
 use num_derive::{One, Zero};
+use proconio::input;
+use proconio::source::{Readable, Source};
 
 use std::cell::Cell;
-use std::io::{self, Read};
+use std::io::BufRead;
 use std::ops::{Add, Div, Mul, Sub};
 use std::{cmp, fmt};
 
 fn main() {
-    let mut input = read_to_static(io::stdin()).split_whitespace();
-    macro_rules! read(() => (input.next().unwrap().parse().unwrap()));
-
-    let (l, a, b, m): (u64, u64, u64, u64) = (read!(), read!(), read!(), read!());
-
-    MOD.with(|cell| cell.set(m));
+    input! {
+        l: u64,
+        a: u64,
+        b: u64,
+        _m: Mod,
+    }
 
     let count = |d| -> _ {
         let count =
@@ -58,6 +60,16 @@ thread_local! {
     static MOD: Cell<u64> = Cell::new(0);
 }
 
+enum Mod {}
+
+impl Readable for Mod {
+    type Output = ();
+
+    fn read<R: BufRead, S: Source<R>>(source: &mut S) {
+        MOD.with(|cell| cell.set(u64::read(source)));
+    }
+}
+
 #[derive(Zero, One, Debug, Clone, Copy)]
 struct Z(u64);
 
@@ -104,9 +116,3 @@ impl Div for Z {
         unreachable!("should not be performed")
     }
 }
-
-fn read_to_static(mut source: impl Read) -> &'static str {
-    let mut input = "".to_owned();
-    source.read_to_string(&mut input).unwrap();
-    Box::leak(input.into_boxed_str())
-}

examples/abc142-c.rs

@@ -1,29 +1,15 @@
 // https://atcoder.jp/contests/abc142/tasks/abc142_c
 
 use itertools::Itertools as _;
+use proconio::input;
+use proconio::marker::Isize1;
 use superslice::Ext2 as _;
 
-use std::io::{self, Read};
-
 fn main() {
-    let mut input = read_to_static(io::stdin()).split_whitespace();
-    macro_rules! read {
-        ([$tt:tt]) => (read!([$tt; read!(usize)]));
-        ([$tt:tt; $n:expr]) => ((0..$n).map(|_| read!($tt)).collect::<Vec<_>>());
-        (($($tt:tt),+)) => (($(read!($tt)),*));
-        ($ty:ty) => (input.next().unwrap().parse::<$ty>().unwrap());
-        ({ Isize1 }) => {
-            read!(isize) - 1
-        };
+    input! {
+        mut a: [Isize1],
     }
 
-    let mut a = read!([{ Isize1 }]);
     a.invert_permutation();
     println!("{}", a.iter().map(|a| a + 1).format(" "));
 }
-
-fn read_to_static(mut source: impl Read) -> &'static str {
-    let mut input = "".to_owned();
-    source.read_to_string(&mut input).unwrap();
-    Box::leak(input.into_boxed_str())
-}

examples/abc144-d.rs

@@ -1,13 +1,15 @@
 // https://atcoder.jp/contests/abc144/tasks/abc144_d
 
+use proconio::input;
+
 use std::f64::consts::PI;
-use std::io::{self, Read};
 
 fn main() {
-    let mut input = read_to_static(io::stdin()).split_whitespace();
-    macro_rules! read(() => (input.next().unwrap().parse().unwrap()));
-
-    let (a, b, x): (f64, f64, f64) = (read!(), read!(), read!());
+    input! {
+        a: f64,
+        b: f64,
+        x: f64,
+    }
 
     let ans = 180.0 / PI
         * if x >= (a.powi(2) * b) / 2.0 {
@@ -17,9 +19,3 @@ fn main() {
         };
     println!("{}", ans);
 }
-
-fn read_to_static(mut source: impl Read) -> &'static str {
-    let mut input = "".to_owned();
-    source.read_to_string(&mut input).unwrap();
-    Box::leak(input.into_boxed_str())
-}

examples/abc150-d.rs

@@ -1,21 +1,15 @@
 // https://atcoder.jp/contests/abc150/tasks/abc150_d
 
 use itertools::Itertools as _;
-
-use std::io::{self, Read};
+use proconio::input;
 
 fn main() {
-    let mut input = read_to_static(io::stdin()).split_whitespace();
-    macro_rules! read {
-        ([$tt:tt]) => (read!([$tt; read!(usize)]));
-        ([$tt:tt; $n:expr]) => ((0..$n).map(|_| read!($tt)).collect::<Vec<_>>());
-        (($($tt:tt),+)) => (($(read!($tt)),*));
-        ($ty:ty) => (input.next().unwrap().parse::<$ty>().unwrap());
+    input! {
+        n: usize,
+        m: usize,
+        a: [usize; n],
     }
 
-    let (n, m) = read!((usize, usize));
-    let a = read!([usize; n]);
-
     if !a.iter().copied().map(usize::trailing_zeros).all_equal() {
         println!("0");
         return;
@@ -25,9 +19,3 @@ fn main() {
     let ans = (m + x0) / (2 * x0);
     println!("{}", ans);
 }
-
-fn read_to_static(mut source: impl Read) -> &'static str {
-    let mut input = "".to_owned();
-    source.read_to_string(&mut input).unwrap();
-    Box::leak(input.into_boxed_str())
-}

examples/abc151-d.rs

@@ -1,35 +1,22 @@
 // https://atcoder.jp/contests/abc151/tasks/abc151_d
 
 use ndarray::Array;
+use proconio::input;
+use proconio::marker::Bytes;
 use smallvec::SmallVec;
 
-use std::io::{self, Read};
 use std::{iter, mem};
 
 fn main() {
-    let mut input = read_to_static(io::stdin()).split_whitespace();
-    macro_rules! read {
-        ([$tt:tt]) => (read!([$tt; read!(usize)]));
-        ([$tt:tt; $n:expr]) => ((0..$n).map(|_| read!($tt)).collect::<Vec<_>>());
-        (($($tt:tt),+)) => (($(read!($tt)),*));
-        ($ty:ty) => (input.next().unwrap().parse::<$ty>().unwrap());
-        ({ Maze<$c:literal, ($h:expr, $w:expr)> }) => {
-            Array::from_shape_vec(
-                ($h, $w),
-                itertools::concat((0..$h).map(|_| read!({ Row<$c> }))),
-            )
-            .unwrap()
-        };
-        ({ Row<$c:literal> }) => {
-            read!({ Bytes }).into_iter().map(|c| c == $c).collect::<Vec<_>>()
-        };
-        ({ Bytes }) => {
-            read!(String).into_bytes()
-        };
+    input! {
+        h: usize,
+        w: usize,
+        sss: [Bytes; h],
     }
 
-    let (h, w) = read!((usize, usize));
-    let maze = read!({ Maze<b'.', (h, w)> });
+    let maze = Array::from_shape_vec((h, w), itertools::concat(sss))
+        .unwrap()
+        .map(|&c| c == b'.');
 
     let neighbors = Array::from_shape_fn((h, w), |(i, j)| {
         let mut neighbors = SmallVec::<[_; 4]>::new();
@@ -69,9 +56,3 @@ fn main() {
         .unwrap();
     println!("{}", ans);
 }
-
-fn read_to_static(mut source: impl Read) -> &'static str {
-    let mut input = "".to_owned();
-    source.read_to_string(&mut input).unwrap();
-    Box::leak(input.into_boxed_str())
-}

examples/apg4b-ex25.rs

@@ -2,24 +2,17 @@
 
 use fixedbitset::FixedBitSet;
 use itertools::Itertools as _;
-
-use std::io::{self, Read};
+use proconio::input;
 
 #[allow(clippy::many_single_char_names)]
 fn main() {
-    let mut input = read_to_static(io::stdin()).split_whitespace();
-    macro_rules! read {
-        ([$tt:tt]) => (read!([$tt; read!(usize)]));
-        ([$tt:tt; $n:expr]) => ((0..$n).map(|_| read!($tt)).collect::<Vec<_>>());
-        (($($tt:tt),+)) => (($(read!($tt)),*));
-        ($ty:ty) => (input.next().unwrap().parse::<$ty>().unwrap());
+    input! {
+        a: [usize],
+        b: [usize],
+        arg0: String,
+        args: [usize; if arg0 == "subtract" { 1 } else { 0 }],
     }
 
-    let a = read!([usize]);
-    let b = read!([usize]);
-    let arg0 = read!(String);
-    let args = read!([usize; if arg0 == "subtract" { 1 } else { 0 }]);
-
     let (a, b) = (a.into_iter().collect(), b.into_iter().collect());
 
     print_set(&match (&*arg0, &*args) {
@@ -61,9 +54,3 @@ fn increment(a: &FixedBitSet) -> FixedBitSet {
 fn decrement(a: &FixedBitSet) -> FixedBitSet {
     a.ones().map(|x| (x + 49) % 50).collect()
 }
-
-fn read_to_static(mut source: impl Read) -> &'static str {
-    let mut input = "".to_owned();
-    source.read_to_string(&mut input).unwrap();
-    Box::leak(input.into_boxed_str())
-}

examples/arc065-c.rs

@@ -1,32 +1,17 @@
 // https://atcoder.jp/contests/arc065/tasks/arc065_a
 
 use lazy_static::lazy_static;
+use proconio::input;
+use proconio::marker::Bytes;
 use regex::bytes::Regex;
 
-use std::io::{self, Read};
-
 fn main() {
-    let mut input = read_to_static(io::stdin()).split_whitespace();
-    macro_rules! read {
-        ([$tt:tt]) => (read!([$tt; read!(usize)]));
-        ([$tt:tt; $n:expr]) => ((0..$n).map(|_| read!($tt)).collect::<Vec<_>>());
-        (($($tt:tt),+)) => (($(read!($tt)),*));
-        ($ty:ty) => (input.next().unwrap().parse::<$ty>().unwrap());
-        ({ Bytes }) => {
-            read!(String).into_bytes()
-        };
+    input! {
+        s: Bytes,
     }
 
-    let s = read!({ Bytes });
-
     lazy_static! {
         static ref R: Regex = Regex::new(r"\A(dream(er)?|eraser?)*\z").unwrap();
     };
     println!("{}", if R.is_match(&s) { "YES" } else { "NO" });
 }
-
-fn read_to_static(mut source: impl Read) -> &'static str {
-    let mut input = "".to_owned();
-    source.read_to_string(&mut input).unwrap();
-    Box::leak(input.into_boxed_str())
-}