projecteuler.net/058/main.rs

use std::collections::HashSet;

const UP: usize = 100;

//  from../ 027/main.rs
fn er() -> HashSet<usize> {
    let mut nums = Vec::new();
    let size = UP;
    for _n in 0..size+1 { nums.push(true); }
    let mut p = 1;
    loop {
        let mut found = false;
        for i in p+1..size {
            if nums[i] {
                found = true;
                p = i;
                break;
            }
        }
        if !found { break; }
        for i in (2 * p .. size).step_by(p) {
            nums[i] = false;
        }
    }
    let mut res = HashSet::new();
    for i in 2..size {
        if nums[i] { res.insert(i); }
    }
    return res;
}


struct Steps {
    l: usize,
    k: usize,
    s: usize,
}

impl Steps {
    fn new() -> Steps {
        return Steps {
            l: 1,
            k: 1,
            s: 0
        };
    }

    fn next(&mut self, n: usize) -> Option<usize> {
        if self.k > self.l {
            self.k = 1;
            self.s += 1;
            if self.s == 4 {
                self.s = 0;
                self.l += 1;
            }
            if self.s == 2 {
                self.l += 1;
            }
        }
        self.k += 1;
        if self.s == 0 && (self.k - 1 == self.l || self.k == 2) {
            return Some(n);
        }
        if self.s == 2 && self.k == 2 {
            return Some(n);
        }
        if self.s == 3 && self.k == 2 {
            return Some(n);
        }
        return None;
    }

}

fn main() {
    let mut st = Steps::new();
    println!("er begin");
    let ps = er();
    println!("er end");
    //return;
    let mut sq = 1;
    let mut corner_count = 1;
    let mut p_count = 1;
    for n in 1..UP {
        if n >= sq * sq {
            sq += 1;
        }
        match st.next(n) {
            Some(k) => {
                let is_prime = ps.contains(&k);
                corner_count += 1;
                if is_prime {
                    p_count += 1;
                }
                println!("{} {} {} {}", n, sq,  corner_count, p_count);
                if ((p_count as f64) * 100f64 as f64) / (corner_count as f64) < 60f64 {
                    println!("!!{}", sq);
                    break;
                }
            },
            None => ()
        }
    }
}