complete 22880.rs 26110.rs

storage/zeta/rs/completed/22880.rs

@@ -0,0 +1,35 @@
+use std::io;
+
+fn beacon_interval_count(n: i32, hs: Vec<i32>) -> i64 {
+    let mut before: i32 = 0;
+
+    let mut edge: Vec<i32> = Vec::new();
+
+    for (i, &h) in hs.iter().enumerate() {
+        if before < h {
+            before = h;
+            edge.push(i as i32);
+        }
+    }
+
+    let mut cnt: i64 = 1;
+    let mut before_edge: i32 = 0;
+    for &ev in edge.iter() {
+        cnt = (cnt * ((ev - before_edge + 1) as i64)) % 1_000_000_007;
+        before_edge = ev;
+    }
+
+    cnt
+}
+
+fn main() {
+    let mut line = String::new();
+    io::stdin().read_line(&mut line).unwrap();
+    let n: i32;
+    n = line.trim().parse().unwrap();
+    line.clear();
+    io::stdin().read_line(&mut line).unwrap();
+    let hs: Vec<i32> = line.trim().split(' ').map(|x| x.parse().unwrap()).collect();
+
+    println!("{}", beacon_interval_count(n, hs));
+}

storage/zeta/rs/completed/26110.rs

@@ -0,0 +1,37 @@
+use std::cmp::min;
+
+fn find_type_of_palindrome(s: &String) -> i32 {
+    let s_chars = s.chars().collect::<Vec<char>>();
+    let mut dex: Vec<(i32, usize, usize)> = Vec::new();
+
+    dex.push((0, 0, s_chars.len() - 1));
+
+    let mut last_rm = 4;
+
+    while !dex.is_empty() {
+        let (rm, start, end) = dex.pop().unwrap();
+        if rm >= 4 || start >= end {
+            last_rm = min(last_rm, rm);
+            continue;
+        }
+        if s_chars[start] == s_chars[end] {
+            dex.push((rm, start + 1, end - 1));
+        } else {
+            dex.push((rm + 1, start + 1, end));
+            dex.push((rm + 1, start, end - 1));
+        }
+    }
+
+    return if (last_rm <= 3) { last_rm } else { -1 };
+}
+
+fn main() {
+    let mut s = String::new();
+
+    match std::io::stdin().read_line(&mut s) {
+        Ok(_) => s = s.trim().to_string(),
+        Err(_) => return,
+    };
+
+    println!("{}", find_type_of_palindrome(&s));
+}