update many

storage/zeta/cpp/6750.cpp

@@ -0,0 +1,37 @@
+#include <iostream>
+#include <stdint.h>
+#include <string>
+
+#define let auto
+
+typedef size_t usize;
+typedef int32_t i32;
+
+using namespace std;
+
+let main() -> i32 {
+    let line = string();
+
+    cin >> line;
+    let flag = true;
+    for (let c: line) {
+        switch (c) {
+            case 'I':
+            case 'O':
+            case 'S':
+            case 'H':
+            case 'Z':
+            case 'X':
+            case 'N': {
+                break;
+            }
+            default:
+                flag = false;
+                break;
+        }
+    }
+
+    cout << (flag ? "YES" : "NO") << endl;
+
+    return 0;
+}

storage/zeta/rs/13193.rs

@@ -0,0 +1,12 @@
+use std::io::{stdin, Read};
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_to_string(&mut line).unwrap();
+
+    let mut iter = line.trim().split(' ').map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let m = iter.next().unwrap();
+    let p = iter.next().unwrap();
+}

storage/zeta/rs/1948.rs

@@ -0,0 +1,105 @@
+use std::{collections::BinaryHeap, io::stdin, usize};
+
+#[derive(Eq, PartialEq)]
+struct DistElem {
+    node: usize,
+    dist: usize,
+}
+
+impl Ord for DistElem {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.dist.cmp(&other.dist)
+    }
+}
+
+impl PartialOrd for DistElem {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+fn find_longest_by_reverse_dijkstra(
+    n: usize,
+    ways_by_city: &Vec<Vec<(usize, usize)>>,
+    start: usize,
+    end: usize,
+) -> (usize, usize) {
+    let mut max_dist = vec![0; n];
+    let mut prev = vec![usize::MAX; n];
+    let mut heap: BinaryHeap<DistElem> = BinaryHeap::new();
+
+    heap.push(DistElem {
+        node: start,
+        dist: 0,
+    });
+
+    while !heap.is_empty() {
+        let DistElem { node, dist } = heap.pop().unwrap();
+
+        if dist < max_dist[node] {
+            continue;
+        }
+
+        for (v, w) in &ways_by_city[node] {
+            let next_dist = dist + w;
+
+            if next_dist > max_dist[*v] {
+                max_dist[*v] = next_dist;
+                prev[*v] = node;
+                heap.push(DistElem {
+                    node: *v,
+                    dist: next_dist,
+                });
+            }
+        }
+    }
+
+    let mut path_length = 0;
+
+    let mut curr = end;
+    while curr != start {
+        path_length += 1;
+        curr = prev[curr];
+        println!("curr: {}", curr);
+    }
+    (max_dist[end], path_length)
+}
+
+fn main() {
+    let mut line = String::new();
+    stdin().read_line(&mut line).unwrap();
+    let n: usize = line.trim().parse().unwrap();
+    line.clear();
+    stdin().read_line(&mut line).unwrap();
+    let m: usize = line.trim().parse().unwrap();
+
+    let mut ways_by_city: Vec<Vec<(usize, usize)>> = vec![vec![]; n];
+
+    for _ in 0..m {
+        line.clear();
+        stdin().read_line(&mut line).unwrap();
+        let mut iter = line
+            .trim()
+            .split(' ')
+            .map(|x| x.trim().parse::<usize>().unwrap());
+        let (u, v, w) = (
+            iter.next().unwrap() - 1, // convert to index
+            iter.next().unwrap() - 1, // convert to index
+            iter.next().unwrap(),
+        );
+
+        ways_by_city[u].push((v, w));
+    }
+
+    line.clear();
+    stdin().read_line(&mut line).unwrap();
+    let mut iter = line
+        .trim()
+        .split(' ')
+        .map(|x| x.trim().parse::<usize>().unwrap());
+
+    let (start, end) = (iter.next().unwrap() - 1, iter.next().unwrap() - 1);
+
+    let res = find_longest_by_reverse_dijkstra(n, &ways_by_city, start, end);
+    println!("{}\n{}", res.0, res.1);
+}

storage/zeta/rs/20439.rs

@@ -0,0 +1,75 @@
+use std::io::{read_to_string, stdin};
+
+const DAY_START: usize = 0;
+const DAY_END: usize = 1440;
+
+fn virtual_allocation(spaces: &mut Vec<usize>, tasks: &Vec<usize>, task_idx: usize) -> bool {
+    if task_idx == tasks.len() {
+        return true;
+    }
+
+    let task_time = tasks[task_idx];
+
+    for i in 0..spaces.len() {
+        if spaces[i] >= task_time {
+            spaces[i] -= task_time;
+            if virtual_allocation(spaces, tasks, task_idx + 1) {
+                return true;
+            }
+            spaces[i] += task_time;
+        }
+    }
+
+    false
+}
+
+fn main() {
+    let mut temp = read_to_string(stdin()).unwrap();
+
+    let mut iter = temp.split_whitespace().map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let k = iter.next().unwrap();
+
+    let mut pre_tasks = (0..n)
+        .map(|_| (iter.next().unwrap(), iter.next().unwrap()))
+        .collect::<Vec<(usize, usize)>>();
+
+    pre_tasks.sort_by_key(|&(start, _)| start);
+
+    let mut times_task_to_add = (0..k).map(|_| iter.next().unwrap()).collect::<Vec<usize>>();
+
+    let mut occupied_time = [false; DAY_END - DAY_START];
+
+    for (start, end) in pre_tasks {
+        for time in start..end {
+            occupied_time[time] = true;
+        }
+    }
+
+    let mut empty_space = vec![];
+
+    let mut cumulative = 0;
+    for time in DAY_START..DAY_END {
+        if !occupied_time[time] {
+            cumulative += 1;
+        } else {
+            if cumulative > 0 {
+                empty_space.push(cumulative);
+            }
+            cumulative = 0;
+        }
+    }
+
+    if cumulative > 0 {
+        empty_space.push(cumulative);
+    }
+
+    //
+
+    if virtual_allocation(&mut empty_space, &times_task_to_add, 0) {
+        println!("GOOD");
+    } else {
+        println!("BAD");
+    }
+}

storage/zeta/rs/22335.rs

@@ -0,0 +1,67 @@
+use std::collections::HashMap;
+
+fn solve_xor(image: &Vec<Vec<u8>>) {
+    let rows = image.len();
+    let cols = if rows > 0 { image[0].len() } else { 0 };
+
+    // 1. 차분 행렬 계산 (경계를 위해 크기를 +1)
+    // D[y][x] = P[y][x] ^ P[y-1][x] ^ P[y][x-1] ^ P[y-1][x-1]
+    let mut diff = vec![vec![0u8; cols + 2]; rows + 2];
+    for y in 1..=rows + 1 {
+        for x in 1..=cols + 1 {
+            let p = |r: usize, c: usize| if r <= rows && c <= cols { image[r-1][c-1] } else { 0 };
+            
+            diff[y][x] = p(y, x) ^ p(y-1, x) ^ p(y, x-1) ^ p(y-1, x-1);
+        }
+    }
+
+    // 2. 스캔라인으로 짝 맞추기
+    let mut active_segments: HashMap<(usize, usize), usize> = HashMap::new();
+    let mut count = 0;
+
+    for y in 1..=rows + 1 {
+        let mut row_ones = Vec::new();
+        for x in 1..=cols + 1 {
+            if diff[y][x] == 1 {
+                row_ones.push(x);
+            }
+        }
+
+        // x좌표들을 두 개씩 짝지어 선분을 만듦
+        for chunk in row_ones.chunks_exact(2) {
+            let (x1, x2) = (chunk[0], chunk[1]);
+            let segment = (x1, x2);
+
+            if let Some(y_start) = active_segments.remove(&segment) {
+                // 이전에 시작된 같은 x범위의 선분이 있다면 사각형 완성!
+                count += 1;
+                println!("{}: XOR(L:{}, R:{}, T:{}, B:{})", count, x1, x2 - 1, y_start, y - 1);
+            } else {
+                // 새로운 선분 시작
+                active_segments.insert(segment, y);
+            }
+        }
+    }
+}
+
+fn main() {
+    // --- Figure-3 이미지 시뮬레이션 ---
+    // 문제의 예시대로 8x8 정도의 공간에 3개의 XOR을 수행해봅시다.
+    let mut img = vec![vec![0u8; 10]; 10];
+
+    fn apply_xor(img: &mut Vec<Vec<u8>>, l: usize, r: usize, t: usize, b: usize) {
+        for y in t..=b {
+            for x in l..=r {
+                img[y-1][x-1] ^= 1; // 1-based to 0-based
+            }
+        }
+    }
+
+    println!("--- Figure-3 시뮬레이션 시작 ---");
+    apply_xor(&mut img, 2, 4, 2, 6); // Fig-1 생성
+    apply_xor(&mut img, 3, 6, 4, 7); // Fig-2 생성
+    apply_xor(&mut img, 1, 3, 3, 5); // Fig-3 완성
+
+    // 이제 이 '이미지 결과물'만 보고 원래의 XOR 호출을 찾아내는지 확인
+    solve_xor(&img);
+}

storage/zeta/rs/23629.rs

@@ -0,0 +1,285 @@
+use std::io::stdin;
+
+#[derive(Debug, Clone, Copy)]
+enum Token {
+    NUM(usize),
+    PLUS,
+    TIMES,
+    MINUS,
+    DIV,
+    EQUAL,
+    Err,
+}
+
+impl ToString for Token {
+    fn to_string(&self) -> String {
+        match self {
+            Token::NUM(x) => x.to_string(),
+            Token::PLUS => "+".to_string(),
+            Token::MINUS => "-".to_string(),
+            Token::TIMES => "x".to_string(),
+            Token::DIV => "/".to_string(),
+            Token::EQUAL => "=".to_string(),
+            Token::Err => "Err".to_string(),
+        }
+    }
+}
+
+fn convert(num: i64) -> String {
+    let mut s = String::new();
+    for ch in num.to_string().chars() {
+        match ch {
+            '0' => s.push_str("ZERO"),
+            '1' => s.push_str("ONE"),
+            '2' => s.push_str("TWO"),
+            '3' => s.push_str("THREE"),
+            '4' => s.push_str("FOUR"),
+            '5' => s.push_str("FIVE"),
+            '6' => s.push_str("SIX"),
+            '7' => s.push_str("SEVEN"),
+            '8' => s.push_str("EIGHT"),
+            '9' => s.push_str("NINE"),
+            '-' => s.push('-'),
+            _ => panic!("Invalid Number"),
+        }
+    }
+    s
+}
+
+fn priority(tok: Token) -> usize {
+    match tok {
+        Token::NUM(_) => 0,
+        Token::PLUS | Token::MINUS => 1,
+        Token::TIMES | Token::DIV => 2,
+        Token::EQUAL => 3,
+        Token::Err => 100,
+    }
+}
+
+#[allow(unused_assignments)]
+fn lex(s: String) -> Option<Vec<Token>> {
+    let mut lexed = vec![];
+
+    let mut iter = s.chars();
+    let mut curr: char = '\n';
+    let mut next: char = '\n';
+    curr = iter.next().unwrap();
+    next = iter.next().unwrap();
+
+    let mut skip = 0;
+    loop {
+        if skip <= 0 {
+            let mut tok = Token::Err;
+            match (curr, next) {
+                ('\n', _) => {
+                    break;
+                }
+                ('O', 'N') => {
+                    skip = 3;
+                    tok = Token::NUM(1);
+                }
+                ('T', 'W') => {
+                    skip = 3;
+                    tok = Token::NUM(2);
+                }
+                ('T', 'H') => {
+                    skip = 5;
+                    tok = Token::NUM(3);
+                }
+                ('F', 'O') => {
+                    skip = 4;
+                    tok = Token::NUM(4);
+                }
+                ('F', 'I') => {
+                    skip = 4;
+                    tok = Token::NUM(5);
+                }
+                ('S', 'I') => {
+                    skip = 3;
+                    tok = Token::NUM(6);
+                }
+                ('S', 'E') => {
+                    skip = 5;
+                    tok = Token::NUM(7);
+                }
+                ('E', 'I') => {
+                    skip = 5;
+                    tok = Token::NUM(8);
+                }
+                ('N', 'I') => {
+                    skip = 4;
+                    tok = Token::NUM(9);
+                }
+                ('Z', 'E') => {
+                    skip = 4;
+                    tok = Token::NUM(0);
+                }
+                ('+', _) => {
+                    tok = Token::PLUS;
+                }
+                ('-', _) => {
+                    tok = Token::MINUS;
+                }
+                ('x', _) => {
+                    tok = Token::TIMES;
+                }
+                ('/', _) => {
+                    tok = Token::DIV;
+                }
+                ('=', _) => {
+                    tok = Token::EQUAL;
+                }
+
+                _ => {
+                    return None;
+                }
+            }
+
+            match tok {
+                Token::NUM(x) => {
+                    let last = lexed.last();
+                    match last {
+                        Some(&Token::NUM(y)) => {
+                            lexed.pop();
+                            lexed.push(Token::NUM(y * 10 + x));
+                        }
+                        _ => {
+                            lexed.push(tok);
+                        }
+                    }
+                }
+                _ => {
+                    lexed.push(tok);
+                }
+            }
+        }
+        // next
+        if skip > 0 {
+            skip -= 1;
+        }
+        match iter.next() {
+            Some(ch) => {
+                curr = next;
+                next = ch;
+            }
+            None => {
+                if next == '\n' || next == '\0' {
+                    next = '\0';
+                    curr = '\n';
+                } else {
+                    curr = next;
+                    next = '\n';
+                }
+            }
+        }
+    }
+
+    // ON
+    // TW
+    // TH
+    // FO
+    // FI
+    // SI
+    // SE
+    // EI
+    // NI
+    // ZE
+
+    Some(lexed)
+}
+
+fn eval(op: Token, num_stack: &mut Vec<i64>) -> bool {
+    let (a, b) = match (num_stack.pop(), num_stack.pop()) {
+        (Some(x), Some(y)) => (y, x),
+        _ => {
+            return false;
+        }
+    };
+
+    match op {
+        Token::PLUS => {
+            num_stack.push(a + b);
+        }
+        Token::MINUS => {
+            num_stack.push(a - b);
+        }
+        Token::TIMES => {
+            num_stack.push(a * b);
+        }
+        Token::DIV => {
+            num_stack.push(a / b);
+        }
+        _ => {
+            return false;
+        }
+    }
+    return true;
+}
+
+fn parse(lexed: &Vec<Token>) -> Option<i64> {
+    let mut op_stack: Vec<Token> = vec![];
+    let mut num_stack: Vec<i64> = vec![];
+    for &token in lexed {
+        match token {
+            Token::NUM(x) => {
+                num_stack.push(x as i64);
+            }
+            Token::PLUS | Token::MINUS | Token::TIMES | Token::DIV => {
+                let p = priority(token);
+                while let Some(&top) = op_stack.last() {
+                    if priority(top) > p {
+                        if !eval(op_stack.pop().unwrap(), &mut num_stack) {
+                            return None;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+                op_stack.push(token);
+            }
+            Token::EQUAL => {
+                while let Some(op) = op_stack.pop() {
+                    if !eval(op, &mut num_stack) {
+                        return None;
+                    }
+                }
+            }
+            Token::Err => {
+                panic!("Invalid Token");
+            }
+        }
+    }
+    if (num_stack.len() == 1) {
+        return num_stack.pop();
+    } else {
+        return None;
+    }
+}
+
+fn main() {
+    let mut s = String::new();
+
+    stdin().read_line(&mut s).unwrap();
+
+    let s = s.trim_ascii_end().to_string();
+
+    let lexed = lex(s);
+    if lexed.is_none() {
+        println!("Madness!");
+        return;
+    }
+    let lexed = lexed.unwrap();
+
+    let parsed = parse(&lexed);
+
+    
+    if parsed.is_none() {
+        println!("Madness!");
+    } else {
+        for tok in lexed {
+            print!("{}", tok.to_string());
+        }
+        print!("\n");
+        println!("{}", convert(parsed.unwrap()));
+    }
+}

storage/zeta/rs/32381.rs

@@ -0,0 +1,13 @@
+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::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let q = iter.next().unwrap();
+
+    let blacks = (0..q).map(|_| iter.next().unwrap()).collect::<Vec<usize>>();
+}

storage/zeta/rs/4664.rs

@@ -0,0 +1,100 @@
+use std::io::{read_to_string, stdin};
+
+const SIZE: usize = 16;
+const SIDE: usize = 4;
+fn tokenize(s: &Vec<char>) -> u32 {
+    let mut res: u32 = 0;
+    for i in 0..SIDE {
+        for j in 0..SIDE {
+            let idx = (SIDE * (3 - i) + j);
+            match s[i] {
+                '.' => {
+                    res |= 0b10 << (2 * idx); // 2 BLANK
+                }
+                'o' => {
+                    res |= 0b01 << (2 * idx); // 1 O
+                }
+                'x' => {
+                    res |= 0b00 << (2 * idx); // 0 X
+                }
+                _ => {
+                    res |= 0b11 << (2 * idx); // 3 Err
+                }
+            }
+        }
+    }
+    res
+}
+
+// x가 아무 수나 둘때 o가 어떤 수나 두더라도 x가 이길 수 있는 가능성이 무조건 있으면 forced_win
+// 자명한 forced_win의 예시 후보가 2개이상일때
+fn get_el(tk: &u32, idx: u32) -> u32 {
+    return (tk >> (2 * idx)) & 0b11;
+}
+
+fn add_el(tk: &u32, idx: u32, el: u32) -> u32 {
+    let key = el << (2 * idx);
+    return tk | key;
+}
+
+fn el_candiates(tk: &u32) -> Vec<u32> {
+    let mut res = Vec::new();
+    for idx in 0..SIZE as u32 {
+        if get_el(tk, idx) == 0b10 {
+            res.push(idx);
+        }
+    }
+    return res;
+}
+
+fn is_win(tk: &u32, turn: u32) -> bool {
+    let mut res = 0;
+    for idx in 0..SIZE as u32 {
+        if get_el(tk, idx) == turn {
+            res |= 1 << idx;
+        }
+    }
+    
+    // horz
+    for y in 0..4 {
+        if (res & (0b1111 << (4 * y))) == (0b1111 << (4 * y)) {
+            return true;
+        }
+    }
+
+    // vert
+    for x in 0..4 {
+        if (res & (0b0001000100010001 << x)) == (0b0001000100010001 << x) {
+            return true;
+        }
+    }
+
+    // diag
+    if (res & 0b1000010000100001) == 0b1000010000100001 {
+        return true;
+    }
+    if (res & 0b0001001001001000) == 0b0001001001001000 {
+        return true;
+    }
+
+    return false;
+}
+
+fn is_forced_win(history: &mut )
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut chars = temp.chars();
+    let mut next_char = || {
+        let mut c = chars.next().unwrap();
+        while c.is_whitespace() {
+            c = chars.next().unwrap();
+        }
+        c
+    };
+
+    while next_char() == '?' {
+        let s = (0..SIZE).map(|_| next_char()).collect::<Vec<_>>();
+        let tk = tokenize(&s);
+    }
+}

storage/zeta/rs/5018.rs

@@ -0,0 +1,118 @@
+use std::{
+    collections::HashSet,
+    io::{read_to_string, stdin},
+};
+
+const ROW_MAX: usize = 12;
+
+fn array_sum(a: &[usize; ROW_MAX + 1], b: &[usize; ROW_MAX + 1]) -> [usize; ROW_MAX + 1] {
+    let mut c = [0; ROW_MAX + 1];
+    for i in 0..ROW_MAX + 1 {
+        c[i] = a[i] + b[i];
+    }
+    c
+}
+
+fn consume_check(groups_remain: &[usize; ROW_MAX + 1], cx: &[usize; ROW_MAX + 1]) -> bool {
+    groups_remain.iter().zip(cx.iter()).all(|(g, c)| g >= c)
+}
+
+fn consume(groups_remain: &mut [usize; ROW_MAX + 1], cx: &[usize; ROW_MAX + 1]) {
+    for i in 0..ROW_MAX + 1 {
+        groups_remain[i] -= cx[i];
+    }
+}
+
+fn restore(groups_remain: &mut [usize; ROW_MAX + 1], cx: &[usize; ROW_MAX + 1]) {
+    for i in 0..ROW_MAX + 1 {
+        groups_remain[i] += cx[i];
+    }
+}
+
+fn check_empty(groups_remain: &[usize; ROW_MAX + 1]) -> bool {
+    groups_remain.iter().all(|&g| g == 0)
+}
+
+fn main() {
+    let temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+    let n = iter.next().unwrap();
+    let mut groups = [0; ROW_MAX + 1];
+    for i in 1..=n {
+        groups[i] = iter.next().unwrap();
+    }
+
+    let mut cands: Vec<HashSet<[usize; ROW_MAX + 1]>> = vec![HashSet::new(); ROW_MAX + 1];
+    cands[0].insert([0; ROW_MAX + 1]);
+    cands[1].insert([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+    cands[2].insert([0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+
+    for i in 3..=ROW_MAX {
+        let mut arr = [0; ROW_MAX + 1];
+        arr[i] = 1;
+        cands[i].insert(arr);
+
+        for j in i / 2..i - 1 {
+            let k = i - 1 - j;
+            let mut v = vec![];
+            for can1 in cands[j].iter() {
+                for can2 in cands[k].iter() {
+                    v.push(array_sum(can1, can2));
+                }
+            }
+            for a in v {
+                cands[i].insert(a);
+            }
+        }
+    }
+
+    let mut deq = vec![];
+    deq.push((0, 1, [0usize; ROW_MAX + 1]));
+
+    let mut res = 13;
+    while !deq.is_empty() {
+        let (type_id, level, delta) = deq.pop().unwrap();
+
+        if type_id == 0 {
+            consume(&mut groups, &delta);
+            if check_empty(&groups) {
+                res = res.min(level - 1);
+                continue;
+            }
+            if level >= 13 {
+                continue;
+            }
+            let mut flag = false;
+            for i in (1..=level).rev() {
+                let v = cands[i]
+                    .iter()
+                    .filter(|c| consume_check(&groups, c))
+                    .collect::<Vec<_>>();
+
+                if v.is_empty() {
+                    continue;
+                }
+                flag = true;
+                for &e in v {
+                    deq.push((1, level + 1, e));
+                    deq.push((0, level + 1, e));
+                }
+            }
+            if !flag {
+                for &e in cands[0].iter() {
+                    deq.push((1, level + 1, e));
+                    deq.push((0, level + 1, e));
+                }
+            }
+        } else {
+            restore(&mut groups, &delta);
+        }
+    }
+    if res >= 13 {
+        println!("{}", -1);
+    } else {
+        println!("{}", res);
+    }
+}

storage/zeta/rs/7393.rs

@@ -0,0 +1,46 @@
+use std::io::{read_to_string, stdin};
+
+fn get_legendre(n: usize, p: usize) {
+    let mut key = p;
+    let mut res = 0;
+    let mut curr = n / p;
+    while curr == 0 {
+        
+    }
+}
+
+fn main() {
+    let mut temp = read_to_string(stdin()).unwrap();
+    let mut iter = temp
+        .split_ascii_whitespace()
+        .map(|x| x.parse::<usize>().unwrap());
+
+    let n = iter.next().unwrap();
+    let m = iter.next().unwrap();
+
+    let mut combs = vec![0; n];
+
+    combs[0] = 1;
+    let mut new_combs = vec![0; n];
+    new_combs[0] = 1;
+
+    for i in 1..=n - 1 {
+        for j in 1..i {
+            new_combs[j] = (combs[j] + combs[j - 1]) % m;
+        }
+        new_combs[i] = 1;
+        let ct = combs;
+        combs = new_combs;
+        new_combs = ct;
+    }
+
+    let res = (0..n)
+        .filter(|&i| combs[i] == 0)
+        .map(|i| i + 1)
+        .collect::<Vec<_>>();
+
+    println!("{}", res.len());
+    for i in res {
+        println!("{}", i);
+    }
+}

storage/zeta/rs/8983.rs

@@ -0,0 +1,3 @@
+fn main() {
+    
+}