Solve 038, 044 in typical90

Author: k-yomo

atcoder/rust/typical90/src/bin/018.rs

@@ -2,14 +2,16 @@
 
 use std::cmp::*;
 use std::collections::*;
+use std::f64::consts::PI;
 use std::io::Write;
 use std::ops::Bound::*;
 
-use itertools::*;
 use itertools::__std_iter::once;
+use itertools::*;
 use itertools_num::ItertoolsNum;
-use proconio::*;
+use libm::{atan2, cos, sin};
 use proconio::marker::*;
+use proconio::*;
 use superslice::*;
 
 #[macro_export]
@@ -21,8 +23,34 @@ macro_rules! min {($ a : expr $ (, ) * ) => {{$ a } } ; ($ a : expr , $ b : expr
 #[macro_export]
 macro_rules! max {($ a : expr $ (, ) * ) => {{$ a } } ; ($ a : expr , $ b : expr $ (, ) * ) => {{std :: cmp :: max ($ a , $ b ) } } ; ($ a : expr , $ ($ rest : expr ) ,+ $ (, ) * ) => {{std :: cmp :: max ($ a , max ! ($ ($ rest ) ,+ ) ) } } ; }
 
-fn main() { 
+fn main() {
     input! {
-        
+        t: f64,
+        l: f64, x: f64, y: f64,
+        q: usize,
+        e: [f64; q],
+    }
+
+    // t/4 == 0, -L/2, L/2)
+    // t/2 == 0, 0, L)
+    // 3t/4 == 0, L/2, L/2)
+    // t/2 = 半周
+    // t/4 = 4分の1週
+    // t / t = t分の1周
+
+    // (x-a)^2+(y-b)^2=r^2
+    // (y-b)^2=r^2-(x-a)^2
+    // y^2 - 2yb + b^2=r^2-(x-a)^2
+
+    let radius = l / 2.0;
+    for i in e {
+        let cur_i = i % t;
+        let cur_angle = 360.0 / t * cur_i;
+        let cur_y = radius * cos(cur_angle * (PI / 180.0));
+        let cur_z = radius * sin(cur_angle * (PI / 180.0));
+        println!(
+            "{}",
+            atan2(cur_z, (x.powf(2.0) + (cur_y - y).powf(2.0)).sqrt()) / PI * 180.0
+        )
     }
 }

atcoder/rust/typical90/src/bin/032.rs

@@ -11,9 +11,12 @@ use itertools_num::ItertoolsNum;
 use proconio::*;
 use proconio::marker::*;
 use superslice::*;
+use num_integer::lcm;
 
 fn main() {
     input! {
-
+        a: usize, b: usize,
     }
+
+    println!(lcm(a, b));
 }

atcoder/rust/typical90/src/bin/038.rs

@@ -11,9 +11,17 @@ use itertools_num::ItertoolsNum;
 use proconio::*;
 use proconio::marker::*;
 use superslice::*;
+use num_integer::lcm;
 
 fn main() {
     input! {
-
+        a: u128, b: u128,
     }
+
+    let ans = lcm(a, b);
+    if ans <= 10_u128.pow(18_u32) {
+        println!("{}", ans)
+    } else {
+        println!("{}", "Large")
+    };
 }

atcoder/rust/typical90/src/bin/044.rs

@@ -14,6 +14,30 @@ use superslice::*;
 
 fn main() {
     input! {
+        n: usize, q: usize,
+        mut a: [usize; n],
+        txy: [(usize, usize, usize); q],
+    }
 
+    let mut shift_count = 0;
+    for (t, x, y) in txy {
+        match t {
+            1 => {
+                let x_i = if x <= shift_count { n + x - shift_count } else { x - shift_count } - 1;
+                let y_i = if y <= shift_count { n + y - shift_count } else { y - shift_count } - 1;
+                let tmp = a[x_i];
+                a[x_i] = a[y_i];
+                a[y_i] = tmp;
+            }
+            2 => {
+                shift_count += 1;
+                shift_count %= n;
+            }
+            3 => {
+                let x_i = if x <= shift_count { n + x - shift_count } else { x - shift_count } - 1;
+                println!("{}", a[x_i])
+            }
+            _ => {}
+        }
     }
 }

atcoder/rust/typical90/src/bin/085.rs

@@ -5,15 +5,72 @@ use std::collections::*;
 use std::io::Write;
 use std::ops::Bound::*;
 
-use itertools::*;
 use itertools::__std_iter::once;
+use itertools::*;
 use itertools_num::ItertoolsNum;
-use proconio::*;
 use proconio::marker::*;
+use proconio::*;
 use superslice::*;
 
 fn main() {
     input! {
+        k: usize
+    }
+
+    let primes = prime_factors(k);
+    println!("{:?}", primes)
+}
+
+fn prime_factors(mut n: usize) -> HashMap<usize, usize> {
+    let mut primes = sieve_of_eratosthenes(f64::sqrt(n as f64) as usize);
+    let mut hm_primes = HashMap::new();
+
+    for prime in primes {
+        while n % prime == 0 {
+            n /= prime;
+            if hm_primes.contains_key(&prime) {
+                let mut x = hm_primes.get_mut(&prime).unwrap();
+                *x += 1;
+            } else {
+                hm_primes.insert(prime, 1);
+            }
+        }
+    }
+
+    if n > 1 {
+        if hm_primes.contains_key(&n) {
+            let mut x = hm_primes.get_mut(&n).unwrap();
+            *x += 1;
+        } else {
+            hm_primes.insert(n, 1);
+        }
+    }
+    hm_primes
+}
+
+fn sieve_of_eratosthenes(n: usize) -> Vec<usize> {
+    let mut spf = vec![None; n + 1];
+    let mut is_prime = vec![true; n + 1];
+    let mut primes = Vec::new();
+
+    is_prime[0] = false;
+    is_prime[1] = false;
+
+    for i in 2..n + 1 {
+        if is_prime[i] {
+            primes.push(i);
+            spf[i] = Some(i);
+        }
+
+        for prime in &primes {
+            if i * prime >= n + 1 || prime > &spf[i].unwrap() {
+                break;
+            }
+
+            is_prime[i * prime] = false;
 
+            spf[i * prime] = Some(*prime);
+        }
     }
+    primes
 }