complete 1644.rs 2887.rs 15552.rs 24767.rs 25710.rs 34031.rs

storage/zeta/rs/completed/15552.rs

@@ -0,0 +1,24 @@
+use std::io::{stdin, stdout, BufWriter};
+use std::io::{BufRead, Write};
+
+fn main() {
+    let stdout = stdout();
+    let mut out = BufWriter::new(stdout.lock());
+
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+    let n: usize = line.trim_end().parse().unwrap();
+    line.clear();
+    for _ in 0..n {
+        stdin().read_line(&mut line).unwrap();
+        let s = line
+            .trim_end()
+            .split_ascii_whitespace()
+            .map(|x| x.parse::<u16>().unwrap())
+            .sum::<u16>();
+        line.clear();
+
+        //println!("{}", s);
+        writeln!(out, "{}", s).unwrap();
+    }
+}

storage/zeta/rs/completed/1644.rs

@@ -0,0 +1,66 @@
+use std::io::stdin;
+
+fn get_primes_upto(n: u32) -> Vec<u32> {
+    let mut primes = vec![2];
+    for i in (3..=n).step_by(2) {
+        let mut flag = true;
+        for &p in primes.iter() {
+            if p > (i as f32).sqrt() as u32 {
+                break;
+            }
+            if i % p == 0 {
+                flag = false;
+                break;
+            }
+        }
+        if flag {
+            primes.push(i);
+        }
+    }
+
+    primes
+}
+
+fn get_ways_sum_primes(n: u32) -> usize {
+    let primes = get_primes_upto(n);
+
+    let cumulative_primes: Vec<u32> = std::iter::once(0)
+        .chain(primes.iter().scan(0, |acc, &p| {
+            *acc += p;
+            Some(*acc)
+        }))
+        .collect();
+
+    let mut lo: usize = 0;
+    let mut hi: usize = 1;
+
+    let mut ways: usize = 0;
+
+    let get_sum = |lo: usize, hi: usize| cumulative_primes[hi] - cumulative_primes[lo];
+
+    while lo <= hi && lo < cumulative_primes.len() && hi < cumulative_primes.len() {
+        let s = get_sum(lo, hi);
+        if n == s {
+            ways += 1;
+            lo += 1;
+        } else if n > s {
+            hi += 1;
+        } else {
+            lo += 1;
+        }
+    }
+
+    ways
+}
+
+fn main() {
+    let n = stdin()
+        .lines()
+        .next()
+        .unwrap()
+        .unwrap()
+        .parse::<u32>()
+        .unwrap();
+
+    println!("{}", get_ways_sum_primes(n));
+}

storage/zeta/rs/completed/24767.rs

@@ -0,0 +1,49 @@
+use std::io::stdin;
+
+fn get_sour_sweet(d: f64, poses: Vec<(f64, f64)>) -> (usize, usize) {
+    let mut is_fight = vec![false; poses.len()];
+    let d_pow = d * d;
+    for (i, p1) in poses.iter().enumerate() {
+        for (j, p2) in poses.iter().enumerate().skip(i + 1) {
+            if (p1.0 - p2.0).powf(2.0) + (p1.1 - p2.1).powf(2.0) <= d_pow {
+                is_fight[i] = true;
+                is_fight[j] = true;
+            }
+        }
+    }
+
+    let fight_cnt = is_fight.iter().filter(|&&x| x).count();
+
+    (fight_cnt, poses.len() - fight_cnt)
+}
+
+fn main() {
+    while true {
+        let mut line = String::new();
+        stdin().read_line(&mut line).unwrap();
+        let mut iter = line.split_ascii_whitespace();
+        let d = iter.next().unwrap().parse::<f64>().unwrap();
+        let n = iter.next().unwrap().parse::<usize>().unwrap();
+        line.clear();
+
+        if (n == 0) {
+            break;
+        }
+
+        let poses: Vec<(f64, f64)> = (0..n)
+            .map(|_| {
+                stdin().read_line(&mut line).unwrap();
+                let mut iter = line.split_ascii_whitespace();
+                let t = (
+                    iter.next().unwrap().parse::<f64>().unwrap(),
+                    iter.next().unwrap().parse::<f64>().unwrap(),
+                );
+                line.clear();
+                t
+            })
+            .collect();
+        let res = get_sour_sweet(d, poses);
+
+        println!("{} sour, {} sweet", res.0, res.1);
+    }
+}

storage/zeta/rs/completed/25710.rs

@@ -0,0 +1,57 @@
+use std::io::stdin;
+
+fn get_score(a: u32, b: u32) -> u32 {
+    let mut k = a * b;
+    vec![100000, 10000, 1000, 100, 10, 1]
+        .iter()
+        .map(|&x| {
+            let t = k / x;
+            k %= x;
+            t
+        })
+        .sum()
+}
+
+fn get_mult_score(a: &Vec<u32>) -> u32 {
+    let mut a_cnt = vec![0; 1000];
+    for item in a {
+        a_cnt[*item as usize] += 1;
+    }
+
+    a_cnt
+        .iter()
+        .enumerate()
+        .flat_map(|(ia, &ca)| {
+            a_cnt
+                .iter()
+                .enumerate()
+                .skip(ia)
+                .map(|(ib, &cb)| (ia, ca, ib, cb))
+                .collect::<Vec<_>>()
+        })
+        .map(|(ia, ca, ib, cb)| {
+            if ca == 0 || cb == 0 {
+                0 as u32
+            } else if ia == ib && ca <= 1 {
+                0 as u32
+            } else {
+                get_score(ia as u32, ib as u32)
+            }
+        })
+        .max()
+        .unwrap_or(0)
+}
+
+fn main() {
+    let mut lines = stdin().lines();
+    lines.next();
+    let a: Vec<u32> = lines
+        .next()
+        .unwrap()
+        .unwrap()
+        .split_whitespace()
+        .map(|x| x.parse::<u32>().unwrap())
+        .collect();
+
+    println!("{}", get_mult_score(&a));
+}

storage/zeta/rs/completed/2887.rs

@@ -0,0 +1,103 @@
+use std::io::{stdin, BufRead};
+
+fn planets_find(mut parents: &Vec<usize>, i: usize) -> usize {
+    let mut node = parents[i];
+    while node != parents[node] {
+        node = parents[node];
+    }
+    node
+}
+
+fn planets_union(parents: &mut Vec<usize>, i: usize, j: usize) -> bool {
+    let ir = planets_find(parents, i);
+    let jr = planets_find(parents, j);
+    if ir == jr {
+        return false;
+    }
+    if ir < jr {
+        parents[jr] = ir;
+    } else {
+        parents[ir] = jr;
+    }
+    true
+}
+
+fn get_minimum_cost_planet_tunnel(v: &Vec<(i32, i32, i32)>) -> usize {
+    let mut x_axis_find_base = v
+        .clone()
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (x.0, i))
+        .collect::<Vec<(i32, usize)>>();
+    let mut y_axis_find_base = v
+        .clone()
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (x.1, i))
+        .collect::<Vec<(i32, usize)>>();
+    let mut z_axis_find_base = v
+        .clone()
+        .into_iter()
+        .enumerate()
+        .map(|(i, x)| (x.2, i))
+        .collect::<Vec<(i32, usize)>>();
+
+    x_axis_find_base.sort();
+    y_axis_find_base.sort();
+    z_axis_find_base.sort();
+
+    let mut parents = (0..v.len()).map(|i| i).collect::<Vec<usize>>();
+
+    let mut candidate_edges: Vec<(usize, (usize, usize))> = Vec::new();
+    for i in 0..v.len() - 1 {
+        let ahead = x_axis_find_base[i + 1];
+        let now = x_axis_find_base[i];
+        candidate_edges.push(((ahead.0 - now.0) as usize, (now.1, ahead.1)));
+    }
+    for i in 0..v.len() - 1 {
+        let ahead = y_axis_find_base[i + 1];
+        let now = y_axis_find_base[i];
+        candidate_edges.push(((ahead.0 - now.0) as usize, (now.1, ahead.1)));
+    }
+    for i in 0..v.len() - 1 {
+        let ahead = z_axis_find_base[i + 1];
+        let now = z_axis_find_base[i];
+        candidate_edges.push(((ahead.0 - now.0) as usize, (now.1, ahead.1)));
+    }
+
+    candidate_edges.sort();
+    let mut total_cost = 0;
+    for (cost, (i, j)) in candidate_edges {
+        if planets_union(&mut parents, i, j) {
+            total_cost += cost;
+        }
+    }
+
+    total_cost
+}
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+    let n = line.trim_end().parse::<usize>().unwrap();
+    line.clear();
+
+    let v: Vec<(i32, i32, i32)> = (0..n)
+        .map(|_| {
+            stdin().read_line(&mut line).unwrap();
+            let mut iter = line.split_ascii_whitespace();
+
+            let t: (i32, i32, i32) = (
+                iter.next().unwrap().parse().unwrap(),
+                iter.next().unwrap().parse().unwrap(),
+                iter.next().unwrap().parse().unwrap(),
+            );
+
+            line.clear();
+
+            t
+        })
+        .collect();
+
+    println!("{}", get_minimum_cost_planet_tunnel(&v));
+}

storage/zeta/rs/completed/34031.rs

@@ -0,0 +1,85 @@
+use std::cmp::min;
+use std::io::stdin;
+
+fn left_binary_search(arr: &Vec<i32>, target: i32) -> usize {
+    let mut lo = 0;
+    let mut hi = arr.len();
+
+    while lo < hi {
+        let mid = lo + ((hi - lo) >> 1);
+
+        if arr[mid] >= target {
+            hi = mid;
+        } else {
+            lo = mid + 1;
+        }
+    }
+
+    lo
+}
+
+fn get_count_hightouch(s1: String, s2: String) -> i64 {
+    let mut cnt: i64 = 0;
+
+    let mut cumulative_s1: Vec<i32> = Vec::new();
+
+    let mut before = 0;
+
+    for c in s1.chars() {
+        if c == '(' {
+            before += 1;
+        } else {
+            before -= 1;
+        }
+        if before < 0 {
+            break;
+        }
+        // ())) 이래놓으면 할 수가 없음
+        cumulative_s1.push(before);
+    }
+
+    let mut cds: Vec<Vec<i32>> = vec![Vec::new(); 200001];
+
+    before = 0;
+    let mut cum_min = 0;
+
+    for c in s2.chars() {
+        if c == '(' {
+            before += 1;
+        } else {
+            before -= 1;
+        }
+
+        cum_min = min(before, cum_min);
+
+        if before > 0 {
+            continue;
+        } else {
+            cds[(-before) as usize].push(cum_min);
+        }
+    }
+
+    for v in cds.iter_mut() {
+        v.sort();
+    }
+
+    for a in cumulative_s1.iter() {
+        let mins = &cds[(*a) as usize];
+        let append = (mins.len() - left_binary_search(mins, -a)) as i64;
+        cnt += append;
+    }
+
+    cnt
+}
+
+fn main() {
+    let (mut s1, mut s2) = (String::new(), String::new());
+
+    stdin().read_line(&mut s1).unwrap();
+    stdin().read_line(&mut s2).unwrap();
+
+    s1 = s1.trim().to_string();
+    s2 = s2.trim().to_string();
+
+    println!("{}", get_count_hightouch(s1, s2));
+}