#1138818 (Rust) No.6 使いものにならないハッシュ

• 問題: No.6 使いものにならないハッシュ
• ユーザー: srtry
• 提出日時: 2025-12-05 20:50:08
• 言語: Rust (1.94.0 + proconio + num + itertools)
• 結果: CE
  (最新)
  AC
  (最初)
• 実行時間: -
• コード長: 1,944 bytes
• コンパイル時間: 235 ms
• コンパイル使用メモリ: 159,128 KB
• 最終ジャッジ日時: 2026-07-18 23:03:20
• 合計ジャッジ時間: 1,701 ms
• ジャッジサーバーID （参考情報）: judge2_0 / judge1_0

コンパイルメッセージ

warning: unused imports: `HashMap` and `HashSet`
 --> src/main.rs:8:24
  |
8 | use std::collections::{HashSet, HashMap};
  |                        ^^^^^^^  ^^^^^^^
  |
  = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default

warning: unused import: `std::iter`
 --> src/main.rs:9:5
  |
9 | use std::iter;
  |     ^^^^^^^^^

error: cannot explicitly dereference within an implicitly-borrowing pattern
  --> src/main.rs:30:23
   |
30 |         .filter(|(e_k,&e_v)| e_v)
   |                       ^ reference pattern not allowed when implicitly borrowing
   |
   = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
note: matching on a reference type with a non-reference pattern implicitly borrows the contents
  --> src/main.rs:30:18
   |
30 |         .filter(|(e_k,&e_v)| e_v)
   |                  ^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
help: match on the reference with a reference pattern and borrow explicitly using a variable binding mode
   |
30 |         .filter(|&(ref e_k,&e_v)| e_v)
   |                  + +++

warning: unused variable: `e_v`
  --> src/main.rs:31:20
   |
31 |         .map(|(e_k,e_v)| e_k)
   |                    ^^^ help: if this is intentional, prefix it with an underscore: `_e_v`
   |
   = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default

warning: unused variable: `e_k`
  --> src/main.rs:30:19
   |
30 |         .filter(|(e_k,&e_v)| e_v)
   |                   ^^^ help: if this is intentional, prefix it with an underscore: `_e_k`

warning: value assigned to `primes` is never read
  --> src/main.rs:15:33
   |
15 |     let mut primes:Vec<usize> = Vec::new();
   |                                 ^^^^^^^^^^ this value is reassigned later and never used
...
27 |     primes = is_prime
   |     ------ `primes` is overwritten here before the previous value is read
   |
   = note: `#[warn(unused_assignments)]` (part of `#[warn(unused)

ソースコード

/* 
 *     Author:  srtry
 *     Created: 2025-10-17T21:49:35+09:00
 *     Coding:  utf-8-unix
 */

use proconio::input;
use std::collections::{HashSet, HashMap};
use std::iter;
use std::io::{stdout,Write,BufWriter};

const big:usize = 200001;

fn primes_leq(&n:&usize) -> Vec<usize> {
    let mut primes:Vec<usize> = Vec::new();
    let mut is_prime:Vec<bool> = vec![true;n+1];
    is_prime[0] = false;
    is_prime[1] = false;
    let limit:usize = (n as f64).sqrt() as usize;
    for i in 2..=limit {
        if is_prime[i] {            
            for j in i..=n/i {
                is_prime[i*j] = false;
            }
        }
    }
    primes = is_prime
        .iter()
        .enumerate()
        .filter(|(e_k,&e_v)| e_v)
        .map(|(e_k,e_v)| e_k)
        .collect();
    return primes;
}

fn main() {
    input!{
        k:usize,
        n:usize
    }

    let out = stdout();
    let mut out = BufWriter::new(out.lock());
    
    let primes:Vec<(usize,usize)> = primes_leq(&n)
        .iter()
        .filter(|&e| e>=&k)
        .map(|&e| (e, {if e==0 {9} else {(e-1)%9+1}}))
        .collect();
    let mut ans = primes[0].0;

    if primes.len()==1 {
        write!(out, "{}", ans).unwrap();
        return;
    }

    let mut max_len = 1;
    let mut r = 0;
    let mut l= 0;
    let mut mem:usize = 1<<(primes[0].1);
    loop {
        if r-l+1 >= max_len {
            max_len = r-l+1;
            ans = primes[l].0;
        }
        if r==primes.len()-1 {
            break;
        }
        match (mem&(1<<primes[r+1].1)==0, l==r, primes[r].1==primes[r+1].1) {
            (false,false,_) => {
                mem ^= 1<<primes[l].1;
                l += 1;
            }
            (_,true,true) => {
                r += 1;
                l += 1;
            }
            _ => {
                r += 1;
                mem |= 1<<primes[r].1;
            }
        }
    }

    write!(out, "{}", ans).unwrap();
}