From 9abd51b9b89457735e9afdbfb7e3612d8db67992 Mon Sep 17 00:00:00 2001 From: yenru0 Date: Mon, 27 Apr 2026 10:21:50 +0900 Subject: [PATCH] add unsolved --- storage/zeta/cpp/10432.cpp | 57 +++++++++++++++++++ storage/zeta/cpp/24518.cpp | 113 +++++++++++++++++++++++++++++++++++++ storage/zeta/kt/16236.kt | 0 storage/zeta/py/11404.py | 0 storage/zeta/rs/10973.rs | 14 +++++ storage/zeta/rs/11694.rs | 19 +++++++ storage/zeta/rs/20555.rs | 17 ++++++ storage/zeta/rs/27438.rs | 62 ++++++++++++++++++++ storage/zeta/rs/31190.rs | 88 +++++++++++++++++++++++++++++ storage/zeta/rs/31700.rs | 15 +++++ 10 files changed, 385 insertions(+) create mode 100644 storage/zeta/cpp/10432.cpp create mode 100644 storage/zeta/cpp/24518.cpp create mode 100644 storage/zeta/kt/16236.kt create mode 100644 storage/zeta/py/11404.py create mode 100644 storage/zeta/rs/10973.rs create mode 100644 storage/zeta/rs/11694.rs create mode 100644 storage/zeta/rs/20555.rs create mode 100644 storage/zeta/rs/27438.rs create mode 100644 storage/zeta/rs/31190.rs create mode 100644 storage/zeta/rs/31700.rs diff --git a/storage/zeta/cpp/10432.cpp b/storage/zeta/cpp/10432.cpp new file mode 100644 index 0000000..b5269d0 --- /dev/null +++ b/storage/zeta/cpp/10432.cpp @@ -0,0 +1,57 @@ +#include +#include +#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(); + for (let j = 0; j < 12; j++) { + size_t tmp; + cin >> tmp; + arr.push_back(tmp); + } + + let stack = vector(); + 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) { + + } + } + } + } +} \ No newline at end of file diff --git a/storage/zeta/cpp/24518.cpp b/storage/zeta/cpp/24518.cpp new file mode 100644 index 0000000..23bf566 --- /dev/null +++ b/storage/zeta/cpp/24518.cpp @@ -0,0 +1,113 @@ +#include +#include +#include + +#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(); + 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; +} \ No newline at end of file diff --git a/storage/zeta/kt/16236.kt b/storage/zeta/kt/16236.kt new file mode 100644 index 0000000..e69de29 diff --git a/storage/zeta/py/11404.py b/storage/zeta/py/11404.py new file mode 100644 index 0000000..e69de29 diff --git a/storage/zeta/rs/10973.rs b/storage/zeta/rs/10973.rs new file mode 100644 index 0000000..413a6fd --- /dev/null +++ b/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::(); + line.clear(); + stdin().read_line(&mut line).unwrap(); + let iter = line + .trim() + .split_whitespace() + .map(|x| x.parse::().unwrap()); +} diff --git a/storage/zeta/rs/11694.rs b/storage/zeta/rs/11694.rs new file mode 100644 index 0000000..3b5ff7d --- /dev/null +++ b/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::().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"); + } +} diff --git a/storage/zeta/rs/20555.rs b/storage/zeta/rs/20555.rs new file mode 100644 index 0000000..7c18e85 --- /dev/null +++ b/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::().unwrap(); + + let words = (0..n) + .map(|_| { + line.clear(); + stdin().read_line(&mut line).unwrap(); + line.trim().chars().collect() + }) + .collect::>>(); + + +} diff --git a/storage/zeta/rs/27438.rs b/storage/zeta/rs/27438.rs new file mode 100644 index 0000000..84c89d7 --- /dev/null +++ b/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::().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); +} diff --git a/storage/zeta/rs/31190.rs b/storage/zeta/rs/31190.rs new file mode 100644 index 0000000..3c6cf5a --- /dev/null +++ b/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::().unwrap()); + + let m = iter.next().unwrap(); + let n = iter.next().unwrap(); + + let arr = (0..n).map(|_| iter.next().unwrap()).collect::>(); + + let mut cnts: HashMap = 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); +} diff --git a/storage/zeta/rs/31700.rs b/storage/zeta/rs/31700.rs new file mode 100644 index 0000000..398ce5d --- /dev/null +++ b/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::().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::>(); + + +} \ No newline at end of file