add unsolved

storage/zeta/cpp/10432.cpp

@@ -0,0 +1,57 @@
+#include <iostream>
+#include <vector>
+#define let auto
+#define fn auto
+
+using namespace std;
+
+fn fastio() {
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+}
+
+fn main() -> int {
+    fastio();
+    size_t p;
+    cin >> p;
+    for (let i = 0; i < p; i++) {
+        size_t t;
+        cin >> t;
+        let arr = vector<int>();
+        for (let j = 0; j < 12; j++) {
+            size_t tmp;
+            cin >> tmp;
+            arr.push_back(tmp);
+        }
+
+        let stack = vector<int>();
+        let res = 0;
+        for (let elem: arr) {
+            if (stack.empty()) {
+                stack.push_back(elem);
+            }
+            let last = stack[stack.size() - 1];
+            if (elem > last) {
+                stack.push_back(elem);
+            }
+            else if (elem == last ) {
+                continue;
+
+            } else {
+                while (stack[stack.size() - 1] <= elem ){
+                    stack.pop_back();
+                    res += 1;
+                }
+
+                let mus_last = stack[stack.size() - 1];
+                
+                
+                if (mus_last < elem) {
+                    stack.push_back(elem);
+                } else if (mus_last == elem) {
+                    
+                }
+            }
+        }
+    }
+}

storage/zeta/cpp/24518.cpp

@@ -0,0 +1,113 @@
+#include <cmath>
+#include <iostream>
+#include <vector>
+
+#define let auto
+#define fn auto
+#define usize size_t
+
+using namespace std;
+
+const usize MOD = 1'000'000'007;
+
+fn fastio() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+}
+
+fn well_known_sum_draft(usize n, usize m) -> usize {
+    let res = (usize) 0;
+    for (usize i = 1; i <= n; i++) {
+        res += (n / i) * (i % m);
+        res %= MOD;
+    }
+    return res;
+}
+
+fn well_known_subarr_sum(usize d, usize lo, usize hi /* exclusive */, usize m) -> usize {
+    // surely lo < hi
+    let res = (usize) 0;
+
+    let lo_margin = lo % m;
+    let hi_margin = hi % m;
+    if (lo / m == hi / m) {
+        res += ((hi_margin * (hi_margin - 1) / 2) - (lo_margin * (lo_margin - 1) / 2)) * d;
+        res %= MOD;
+        // printf("%lld %lld %lld %lld\n", lo, hi, d, res);
+        return res;
+    }
+
+    res += (hi_margin * (hi_margin - 1) / 2) * d;
+    res %= MOD;
+
+    res += (m * (m - 1) / 2 - lo_margin * (lo_margin - 1) / 2) * d;
+    res %= MOD;
+
+    let d_cycle = (d * (m * (m - 1) / 2) % MOD) % MOD;
+    let cycle_cnt = (hi - lo - (hi_margin + m - lo_margin)) / m;
+    // printf("%lld %lld %lld %lld\n", lo, hi, d, res);
+    res += cycle_cnt * d_cycle;
+    res %= MOD;
+    return res;
+}
+
+fn well_known_sum(usize n, usize m) -> usize {
+    let res = (usize) 0;
+    let steps = vector<usize>();
+    steps.push_back(n + 1);
+    for (usize i = 2; i <= (usize) pow(n, 0.5) + 1; i++) {
+        steps.push_back(n / i + 1);
+    }
+
+    let k = (usize) pow(n, 0.5);
+    if (k * k == n) {
+        for (usize i = 1; i <= k; i++) {
+            res += (n / i) * (i % m);
+            res %= MOD;
+        }
+    } else {
+        for (usize i = 1; i <= k; i++) {
+            res += (n / i) * (i % m);
+            res %= MOD;
+        }
+    }
+
+    let step_size = steps.size();
+    for (usize i = 0; i < step_size - 1; i++) {
+        let temp = well_known_subarr_sum(i + 1, steps[i + 1], steps[i], m);
+        res += temp;
+        res %= MOD;
+    }
+
+    return res;
+}
+
+fn main() -> int {
+    fastio();
+    usize n;
+    usize m;
+
+    cin >> n;
+    cin >> m;
+
+    if (n <= 10) {
+        cout << well_known_sum_draft(n, m) << endl;
+    } else if (m == 1) {
+        cout << 0 << endl;
+    } else {
+        let x = well_known_sum_draft(n, m);
+        let y = well_known_sum(n, m);
+        cout << x << endl;
+        cout << y << endl;
+        for (usize i = 12; i < 100; i++) {
+            for (usize j = 12; j < 100; j++) {
+                let x = well_known_sum_draft(i, j);
+                let y = well_known_sum(i, j);
+                if (x != y) {
+                    printf("%lld %lld\n", i, j);
+                }
+            }
+        }
+    }
+    return 0;
+}

storage/zeta/rs/10973.rs

@@ -0,0 +1,14 @@
+use std::io::stdin;
+
+fn main() {
+    let mut line = String::new();
+
+    stdin().read_line(&mut line).unwrap();
+    let n: usize = line.trim().parse::<usize>();
+    line.clear();
+    stdin().read_line(&mut line).unwrap();
+    let iter = line
+        .trim()
+        .split_whitespace()
+        .map(|x| x.parse::<u32>().unwrap());
+}

storage/zeta/rs/11694.rs

@@ -0,0 +1,19 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let p = (0..n).map(|_| iter.next().unwrap() - 1);
+
+    let flg = p.fold(0, |acc, x| acc ^ x);
+
+    if flg == 0 {
+        println!("cubelover");
+    } else {
+        println!("koosaga");
+    }
+}

storage/zeta/rs/20555.rs

@@ -0,0 +1,17 @@
+use std::io::stdin;
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+    let n = line.trim().parse::<usize>().unwrap();
+
+    let words = (0..n)
+        .map(|_| {
+            line.clear();
+            stdin().read_line(&mut line).unwrap();
+            line.trim().chars().collect()
+        })
+        .collect::<Vec<Vec<_>>>();
+
+    
+}

storage/zeta/rs/27438.rs

@@ -0,0 +1,62 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap() - 1;
+
+    let mut levels = vec![1, 19];
+
+    // 10666
+    // 11666
+    // 1
+    // 10 + 8
+    // 100 + 8 * 10 + 81 *
+    // 1000 + 8 * 100 + 81 * 10 + 810
+    // 10000 + 8 * 1000 + 81 * 100
+    // 
+    // 66600
+    // 106660
+    // 166600
+    // 266600
+    // 566600
+    // 1000666
+    // 200166
+    // 2666000
+    // 3666000
+    // 7666000
+    // 1066600
+    // 1166600
+    // 1266600
+    // 13
+    // 6066600
+    // 1000666
+    // 10
+    // 6660000
+    // 0 666
+    // 1 1666
+    // 2 2666
+    // 3 3666
+    // 4 4666
+    // 5 5666
+    // 6 6660
+    // 7 6661
+    // 
+    //15 6669
+    //16 7666
+    //17 8666
+    //18 9666
+    //1
+
+    let mut delta = 18;
+    let mut s = 81;
+    for _ in 0..5 {
+        delta = delta * 10 + s;
+        s = s * 10;
+        levels.push(levels.last().unwrap() + delta);
+    }
+    println!("{:?}", levels);
+}

storage/zeta/rs/31190.rs

@@ -0,0 +1,88 @@
+use std::{
+    collections::HashMap,
+    io::{read_to_string, stdin},
+};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let m = iter.next().unwrap();
+    let n = iter.next().unwrap();
+
+    let arr = (0..n).map(|_| iter.next().unwrap()).collect::<Vec<_>>();
+
+    let mut cnts: HashMap<usize, usize> = HashMap::new();
+    let mut changes = vec![vec![]; m];
+    for &e in arr.iter() {
+        let (q, s) = ((e / m), (e % m));
+
+        *cnts.entry(q).or_insert(0) += 1;
+        let next_d = s + 1;
+        if next_d < m {
+            changes[next_d].push(q);
+        }
+    }
+
+    let mut cnt = cnts.len();
+    let mut best_ds = vec![];
+    let mut best_cnt = cnt;
+
+    let mut curr_d = 1;
+    let mut curr_cnt = cnt;
+
+    let mut changes_sorted = vec![];
+
+    for d in 1..m {
+        for &q in &changes[d] {
+            changes_sorted.push((d, q));
+        }
+    }
+
+    changes_sorted.sort_by_key(|&(d, _)| d);
+
+    let mut idx = 0;
+    while idx < changes_sorted.len() {
+        let d = changes_sorted[idx].0;
+
+        if d > curr_d {
+            if curr_cnt > best_cnt {
+                best_cnt = curr_cnt;
+                best_ds.clear();
+                best_ds.push(curr_d);
+            } else if curr_cnt == best_cnt {
+                best_ds.push(curr_d);
+            }
+        }
+
+        while idx < changes_sorted.len() && changes_sorted[idx].0 == d {
+            let q = changes_sorted[idx].1;
+            let cnt_q = cnts.entry(q).or_insert(1);
+            *cnt_q -= 1;
+            if *cnt_q == 0 {
+                cnts.remove(&q);
+                curr_cnt -= 1;
+            }
+
+            let cnt_qm = cnts.entry(q - 1).or_insert(0);
+            if *cnt_qm == 0 {
+                curr_cnt += 1;
+            }
+            *cnt_qm += 1;
+            idx += 1;
+        }
+        curr_d = d;
+    }
+
+    if curr_d <= m - 1 {
+        if curr_cnt > best_cnt {
+            best_cnt = curr_cnt;
+            best_ds.clear();
+            best_ds.push(curr_d);
+        }
+    }
+
+    println!("{:?}", best_ds);
+}

storage/zeta/rs/31700.rs

@@ -0,0 +1,15 @@
+use std::io::{read_to_string, stdin};
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp.split_ascii_whitespace().map(|x| x.parse::<usize>().unwrap());
+
+    let h = iter.next().unwrap();
+    let w = iter.next().unwrap();
+
+    let n = iter.next().unwrap();
+
+    let ds = (0..n).map(|_| iter.next().unwrap()).collect::<Vec<_>>();
+
+    
+}