complete 16458.rs 30804.rs

storage/zeta/rs/completed/16458.rs

@@ -0,0 +1,200 @@
+use std::cmp::{max, min};
+use std::collections::VecDeque;
+use std::io::{stdin, stdout, Write};
+
+const prefield: [[[char; 3]; 5]; 10] = [
+    [
+        ['*', '*', '*'],
+        ['*', ' ', '*'],
+        ['*', ' ', '*'],
+        ['*', ' ', '*'],
+        ['*', '*', '*'],
+    ],
+    [
+        ['*', '*', ' '],
+        [' ', '*', ' '],
+        [' ', '*', ' '],
+        [' ', '*', ' '],
+        ['*', '*', '*'],
+    ],
+    [
+        ['*', '*', ' '],
+        [' ', ' ', '*'],
+        [' ', '*', ' '],
+        ['*', ' ', ' '],
+        ['*', '*', '*'],
+    ],
+    [
+        ['*', '*', '*'],
+        [' ', ' ', '*'],
+        [' ', '*', '*'],
+        [' ', ' ', '*'],
+        ['*', '*', '*'],
+    ],
+    [
+        [' ', ' ', '*'],
+        [' ', '*', '*'],
+        ['*', ' ', '*'],
+        ['*', '*', '*'],
+        [' ', ' ', '*'],
+    ],
+    [
+        ['*', '*', '*'],
+        ['*', ' ', ' '],
+        ['*', '*', ' '],
+        [' ', ' ', '*'],
+        ['*', '*', '*'],
+    ],
+    [
+        ['*', ' ', ' '],
+        ['*', ' ', ' '],
+        ['*', '*', '*'],
+        ['*', ' ', '*'],
+        ['*', '*', '*'],
+    ],
+    [
+        ['*', '*', '*'],
+        [' ', ' ', '*'],
+        [' ', '*', ' '],
+        ['*', ' ', ' '],
+        ['*', ' ', ' '],
+    ],
+    [
+        ['*', '*', '*'],
+        ['*', ' ', '*'],
+        ['*', '*', '*'],
+        ['*', ' ', '*'],
+        ['*', '*', '*'],
+    ],
+    [
+        ['*', '*', '*'],
+        ['*', ' ', '*'],
+        ['*', '*', '*'],
+        [' ', ' ', '*'],
+        [' ', ' ', '*'],
+    ],
+];
+
+fn get_next_curr(n: usize, m: usize, curr: (usize, usize)) -> (usize, usize) {
+    if curr.1 + 1 >= m {
+        (curr.0 + 1, 0)
+    } else {
+        (curr.0, curr.1 + 1)
+    }
+}
+
+fn is_fin_curr(n: usize, m: usize, curr: (usize, usize)) -> bool {
+    return curr.0 >= n - 1 && curr.1 >= m - 1;
+}
+
+fn find_biggest_number(n: usize, m: usize, display: &Vec<Vec<char>>) -> usize {
+    let mut curr: (usize, usize) = (0, 0);
+    let mut display_boxed_region = vec![vec![false; m]; n];
+
+    let deltas: Vec<(isize, isize)> = vec![
+        (-1, -1),
+        (-1, 0),
+        (-1, 1),
+        (0, -1),
+        (0, 1),
+        (1, -1),
+        (1, 0),
+        (1, 1),
+    ];
+
+    let mut largest: (usize, usize, usize, usize) = (usize::MAX, 0, usize::MAX, 0);
+
+    let mut largest_size: usize = 0;
+
+    'main: while !is_fin_curr(n, m, curr) {
+        if !display_boxed_region[curr.0][curr.1] {
+            let x = display[curr.0][curr.1];
+
+            if x == '*' {
+                let mut stack: VecDeque<(usize, usize)> = VecDeque::from(vec![curr]);
+                let (mut leftmost, mut rightmost, mut upmost, mut downmost) =
+                    (usize::MAX, 0usize, usize::MAX, 0usize);
+                while !stack.is_empty() {
+                    let now = stack.pop_front().unwrap();
+                    if display_boxed_region[now.0][now.1] {
+                        continue;
+                    }
+                    display_boxed_region[now.0][now.1] = true;
+                    upmost = min(upmost, now.0);
+                    downmost = max(upmost, now.1);
+                    leftmost = min(leftmost, now.1);
+                    rightmost = max(rightmost, now.1);
+                    for &delta in deltas.iter() {
+                        let next_r = delta.0 + now.0 as isize;
+                        let next_c = delta.1 + now.1 as isize;
+
+                        if next_r < 0 || next_c < 0 || next_r >= n as isize || next_c >= m as isize
+                        {
+                            continue;
+                        }
+                        let next_r = next_r as usize;
+                        let next_c = next_c as usize;
+                        if display_boxed_region[next_r][next_c] || display[next_r][next_c] != '*' {
+                            continue;
+                        }
+
+                        stack.push_back((next_r, next_c));
+                    }
+                }
+                let size = (rightmost - leftmost + 1) / 3;
+                if size > largest_size {
+                    largest_size = size;
+                    largest = (upmost, downmost, leftmost, rightmost);
+                }
+            }
+        }
+
+        curr = get_next_curr(n, m, curr);
+    }
+    let largest_up_left = (largest.0, largest.2);
+    let mut sample: [[char; 3]; 5] = [[' '; 3]; 5];
+    for i in 0..5 {
+        for j in 0..3 {
+            sample[i][j] =
+                display[largest_up_left.0 + i * largest_size][largest_up_left.1 + j * largest_size];
+        }
+    }
+    let mut largest_num = 10;
+    for k in (0..=9) {
+        let mut flag = true;
+        for i in 0..5 {
+            for j in 0..3 {
+                if prefield[k][i][j] != sample[i][j] {
+                    flag = false;
+                }
+            }
+        }
+        if flag {
+            largest_num = k;
+        }
+    }
+
+    largest_num
+}
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+
+    let mut iter = line
+        .trim_ascii_end()
+        .split(' ')
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let (n, m) = (iter.next().unwrap(), iter.next().unwrap());
+
+    let display: Vec<Vec<char>> = (0..n)
+        .map(|_| {
+            line.clear();
+            stdin().read_line(&mut line).unwrap();
+            line.trim_end_matches('\n').chars().collect::<Vec<char>>()
+        })
+        .collect::<Vec<Vec<char>>>();
+    let res = find_biggest_number(n, m, &display);
+    println!("{}", res);
+}

storage/zeta/rs/completed/30804.rs

@@ -0,0 +1,60 @@
+use std::{cmp::max, io::stdin};
+
+#[allow(unused_assignments)]
+fn second_order_tanghuru(n: usize, fruits: &Vec<usize>) -> usize {
+    let mut left = 0;
+    let mut right = 0;
+
+    let mut max_second_order_tanghuru = 0;
+
+    'main: loop {
+        let left_fruit = fruits[left];
+        let mut right_fruit = fruits[right];
+        while right_fruit == left_fruit {
+            right += 1;
+            if right < n {
+                right_fruit = fruits[right];
+            } else {
+                break 'main;
+            }
+        }
+
+        let panel = right;
+        let panel_fruit = fruits[panel];
+        let mut last_changed = panel;
+        let mut before_fruit = panel_fruit;
+        while right_fruit == panel_fruit || right_fruit == left_fruit {
+            if right_fruit != before_fruit {
+                last_changed = right;
+            }
+            right += 1;
+            if right < n {
+                before_fruit = right_fruit;
+                right_fruit = fruits[right];
+            } else {
+                break 'main;
+            }
+        }
+        max_second_order_tanghuru = max(max_second_order_tanghuru, right - left);
+        left = last_changed;
+    }
+
+    max_second_order_tanghuru = max(max_second_order_tanghuru, right - left);
+
+    max_second_order_tanghuru
+}
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+    let n = line.trim().parse::<usize>().unwrap();
+    line.clear();
+    stdin().read_line(&mut line).unwrap();
+    let fruits = line
+        .trim_end()
+        .split(' ')
+        .map(|x| x.parse::<usize>().unwrap())
+        .collect::<Vec<usize>>();
+
+    println!("{}", second_order_tanghuru(n, &fruits));
+}