use scanner::Scanner; use std::io; fn main() { let mut scanner = Scanner::from(io::stdin().lock()); println!("? 100"); let y = scan!(u32, <~ scanner); if y == 99 { println!("! 99 100"); return; } // (100 + A) % B = y, // ((100 - y) + A) % B = 0, // ((100 - y - 1) + A) % B = B - 1 let x = 100 - y - 1; // >= 1 println!("? {}", x); let z = scan!(u32, <~ scanner); let b = z + 1; assert!(y < b); let a = (0..b).filter(|a| (100 + a) % b == y).collect::>(); assert_eq!(a.len(), 1); println!("! {} {}", a[0], b); } // ✂ --- scanner --- ✂ #[allow(unused)] mod scanner { use std::fmt; use std::io; use std::str; pub struct Scanner { r: R, l: String, i: usize, } impl Scanner where R: io::BufRead, { pub fn new(reader: R) -> Self { Self { r: reader, l: String::new(), i: 0, } } pub fn scan(&mut self) -> T where T: str::FromStr, T::Err: fmt::Debug, { self.skip_blanks(); assert!(self.i < self.l.len()); // remain some character assert_ne!(&self.l[self.i..=self.i], " "); let rest = &self.l[self.i..]; let len = rest .find(|ch| char::is_ascii_whitespace(&ch)) .unwrap_or_else(|| rest.len()); // parse self.l[self.i..(self.i + len)] let val = rest[..len] .parse() .unwrap_or_else(|e| panic!("{:?}, attempt to read `{}`", e, rest)); self.i += len; val } pub fn scan_vec(&mut self, n: usize) -> Vec where T: str::FromStr, T::Err: fmt::Debug, { (0..n).map(|_| self.scan()).collect::>() } fn skip_blanks(&mut self) { loop { match self.l[self.i..].find(|ch| !char::is_ascii_whitespace(&ch)) { Some(j) => { self.i += j; break; } None => { self.l.clear(); // clear buffer let num_bytes = self .r .read_line(&mut self.l) .unwrap_or_else(|_| panic!("invalid UTF-8")); assert!(num_bytes > 0, "reached EOF :("); self.i = 0; } } } } } impl<'a> From<&'a str> for Scanner<&'a [u8]> { fn from(s: &'a str) -> Self { Self::new(s.as_bytes()) } } impl<'a> From> for Scanner>> { fn from(stdin: io::StdinLock<'a>) -> Self { Self::new(io::BufReader::new(stdin)) } } #[macro_export] macro_rules! scan { (( $($t: ty),+ ), <~ $scanner: expr) => { ( $(scan!($t, <~ $scanner)),+ ) }; ([ $t: tt; $n: expr ], <~ $scanner: expr) => { (0..$n).map(|_| scan!($t, <~ $scanner)).collect::>() }; ($t: ty, <~ $scanner: expr) => { $scanner.scan::<$t>() }; } } // ✂ --- scanner --- ✂