Easy one using bitsets

Author: hir12111

acpcteam.cpp

@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+using namespace std;
+typedef long long ll;
+typedef pair<int, int> ii;
+typedef tuple<int, int, int> iii;
+typedef vector<ii > vii;
+typedef vector<iii > viii;
+
+int main()
+{
+  ios::sync_with_stdio(false);
+  int n, m;
+  bitset<512> people[512];
+  cin >> n >> m;
+  string input;
+  for(int i=0; i < n; i++) {
+    cin >> input;
+    for(int j=0; j < m; j++) {
+      if (input[j] == '1')
+        people[i].set(j);
+    }
+  }
+  size_t maxtopics = 0;
+  size_t maxnum = 0;
+  for(int i=0; i < n; i++) {
+    for(int j=i+1; j < n; j++) {
+      bitset<512> current = people[i] | people[j];
+      if (current.count() == maxtopics)
+        maxnum++;
+      else if (current.count() > maxtopics) {
+        maxnum = 1;
+        maxtopics = current.count();
+      }
+    }
+  }
+  cout << maxtopics << endl << maxnum << endl;
+  return 0;
+}

drazilanddate.rs

@@ -0,0 +1,41 @@
+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 a: isize = scan.next();
+    let b: isize = scan.next();
+    let s: isize = scan.next();
+    let x = a.abs() + b.abs();
+    let result: bool = s >= x && (s - x) % 2 == 0;
+    println!("{}", if result { "Yes" } else { "No" });
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}

game23.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();
+        }
+    }
+}
+
+fn _main() {
+    let mut scan = Scan::new();
+    let n: usize = scan.next();
+    let m: usize = scan.next();
+    if n == m {
+        println!("0");
+    } else if m % n != 0 {
+        println!("-1");
+    } else {
+        let mut rem = m / n;
+        let mut steps = 0usize;
+        while rem % 2 == 0 {
+            steps += 1;
+            rem /= 2;
+        }
+        while rem % 3 == 0 {
+            steps += 1;
+            rem /= 3;
+        }
+        if rem == 1 {
+            println!("{}", steps);
+        } else {
+            println!("-1");
+        }
+    }
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}

grasshoperandthestring.rs

@@ -0,0 +1,28 @@
+fn is_vowel(c: char) -> bool {
+    return c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U' || c == 'Y';
+}
+fn _main() {
+    let mut line = String::new();
+    std::io::stdin().read_line(&mut line).expect("Fail to read");
+    let mut result = 0usize;
+    let mut index = 0usize;
+    for c in line.trim().chars() {
+        index += 1;
+        if is_vowel(c) {
+            result = result.max(index);
+            index = 0;
+        }
+    }
+    index += 1;
+    result = result.max(index);
+    println!("{}", result);
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}

presentfromlena.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 printseq(x: usize, n: usize) {
+    let spaces = "  ".repeat(n - x);
+    print!("{}", spaces);
+    for i in 0..x {
+        print!("{} ", i);
+    }
+    print!("{}", x);
+    for i in (0..x).rev() {
+        print!(" {}", i);
+    }
+    println!();
+}
+
+fn _main() {
+    let mut scan = Scan::new();
+    let n: usize = scan.next();
+    for i in 0..n {
+        printseq(i, n);
+    }
+    printseq(n, n);
+    for i in (0..n).rev() {
+        printseq(i, n);
+    }
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}

systemofequations.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 mut res = 0usize;
+    let n: usize = scan.next();
+    let m: usize = scan.next();
+    let limit: usize = n.max(m);
+    for i in 0..=limit {
+        for j in 0..=limit {
+            if i * i + j == n && i + j * j == m {
+                res += 1;
+            }
+        }
+    }
+    println!("{}", res);
+}
+
+fn main() {
+    std::thread::Builder::new()
+        .stack_size(1 << 23)
+        .spawn(_main)
+        .unwrap()
+        .join()
+        .unwrap();
+}