complete 1929.cpp 17425.cpp 32870.cpp 11868.rs

storage/zeta/cpp/completed/17425.cpp

@@ -0,0 +1,95 @@
+#include <cmath>
+#include <iostream>
+#include <vector>
+
+#define let auto
+#define fn auto
+#define usize size_t
+using namespace std;
+
+fn fastio() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+}
+
+const let N_MAX = 1'000'000;
+
+let Primes = vector<usize>();
+
+fn generate_primes(usize n) {
+    Primes.clear();
+    Primes.push_back(2);
+    for (usize i = 3; i <= n; i += 2) {
+        for (let p: Primes) {
+            if (i % p == 0) {
+                break;
+            } else if (p * p > i) {
+                Primes.push_back(i);
+                break;
+            }
+        }
+    }
+}
+
+fn prime_factors(usize n) -> vector<pair<usize, usize>> {
+    let factors = vector<pair<usize, usize>>();
+    for (let p: Primes) {
+        if (n == 1) {
+            break;
+        }
+        if (p * p > n) {
+            factors.push_back(pair(n, 1));
+            break;
+        }
+        let cnt = 0;
+        while (n % p == 0) {
+            n /= p;
+            cnt += 1;
+        }
+        if (cnt > 0) {
+            factors.push_back(pair(p, cnt));
+        }
+    }
+    return factors;
+}
+
+fn divisor_sum(usize n) -> usize {
+    static usize div_sum[N_MAX + 1];
+    if (div_sum[n] != 0) {
+        return div_sum[n];
+    }
+    let s = 1;
+
+    let fs = prime_factors(n);
+    for (let f: fs) {
+        s *= ((usize) pow(f.first, f.second + 1) - 1) / (f.first - 1);
+    }
+
+    div_sum[n] = s;
+    return s;
+}
+
+fn cumulative_divisor_sum(usize n) -> usize {
+    static usize cum_div_sum[N_MAX + 1];
+
+    if (cum_div_sum[n] != 0) {
+        return cum_div_sum[n];
+    }
+
+    for (usize i = 1; i <= N_MAX; i++) {
+        cum_div_sum[i] = divisor_sum(i) + cum_div_sum[i - 1];
+    }
+    return cum_div_sum[n];
+}
+
+fn main() -> int {
+    fastio();
+    generate_primes(N_MAX);
+    usize t;
+    cin >> t;
+    for (usize i = 0; i < t; i++) {
+        usize n;
+        cin >> n;
+        cout << cumulative_divisor_sum(n) << "\n";
+    }
+}

storage/zeta/cpp/completed/1929.cpp

@@ -0,0 +1,40 @@
+#include <iostream>
+#include <vector>
+#define let auto
+#define fn auto
+#define usize size_t
+using namespace std;
+
+fn fastio() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+}
+
+fn get_primes(usize n) -> vector<usize> {
+    let primes = vector<usize>();
+    primes.push_back(2);
+    for (usize i = 3; i <= n; i += 2) {
+        for (let p: primes) {
+            if (i % p == 0) {
+                break;
+            } else if (p * p > i) {
+                primes.push_back(i);
+                break;
+            }
+        }
+    }
+    return primes;
+}
+
+fn main() -> int {
+    fastio();
+    usize m, n;
+    cin >> m >> n;
+
+    let primes = get_primes(n);
+    let s = lower_bound(primes.begin(), primes.end(), m);
+    while (s < primes.end() && *s <= n) {
+        cout << *s << "\n";
+        s += 1;
+    }
+}

storage/zeta/cpp/completed/32870.cpp

@@ -0,0 +1,83 @@
+#include <iostream>
+#include <utility>
+
+#define let auto
+#define fn auto
+#define usize size_t
+using namespace std;
+
+const usize MAX_N = 300'000;
+
+fn fastio() {
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+}
+
+fn main() -> int {
+    fastio();
+    let exists = new bool[MAX_N + 1]{false};
+    let accum_minima = new usize[MAX_N + 2];
+    let accum_maxima = new usize[MAX_N + 2];
+    fill_n(accum_minima, MAX_N + 2, __UINT64_MAX__);
+    usize n, q;
+    cin >> n >> q;
+    for (usize i = 0; i < n; i++) {
+        usize tmp;
+        cin >> tmp;
+        exists[tmp] = true;
+    }
+
+    for (usize i = 1; i < MAX_N + 2; i++) {// maximum elem that is less than i
+        accum_maxima[i] = (exists[i - 1] ? i - 1 : accum_maxima[i - 1]);
+    }
+
+    for (int64_t i = MAX_N; i >= 0; --i) {// minimum elem that is greater or equal than i
+        accum_minima[i] = (exists[i] ? i : accum_minima[i + 1]);
+    }
+
+    let vis = new bool[MAX_N + 1];
+    let lo_query = new usize[MAX_N + 1];
+    let hi_query = new usize[MAX_N + 1];
+
+    for (usize ic = 0; ic < q; ic++) {
+        usize m;
+        cin >> m;
+
+        if (m == 1) {
+            cout << "0 0\n";
+            continue;
+        } else if (vis[m]) {
+            cout << lo_query[m] << " " << hi_query[m] << "\n";
+            continue;
+        }
+        vis[m] = true;
+        usize minima = m - 1;
+        usize maxima = 0;
+        usize i;
+        for (i = 0; i <= MAX_N; i += m) {
+            let key = i;
+            let t_min = m - 1;
+            if (accum_minima[key] != __UINT64_MAX__) {
+                t_min = accum_minima[key] % m;
+            }
+            let t_max = accum_maxima[key] % m;
+            minima = min(minima, t_min);
+            maxima = max(maxima, t_max);
+        }
+        if (i > MAX_N) {
+            maxima = max(maxima, accum_maxima[MAX_N + 1] % m);
+        }
+        lo_query[m] = minima;
+        hi_query[m] = maxima;
+        cout << minima << " " << maxima << "\n";
+    }
+
+    // free
+    delete[] exists;
+    delete[] accum_minima;
+    delete[] accum_maxima;
+
+    delete[] vis;
+    delete[] lo_query;
+    delete[] hi_query;
+}

storage/zeta/rs/completed/11868.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());
+
+    let flg = p.fold(0, |acc, x| acc ^ x);
+
+    if flg == 0 {
+        println!("cubelover");
+    } else {
+        println!("koosaga");
+    }
+}