Problem:
Score: 200 points

Problem Statement

The number 105 is quite special - it is odd but still it has eight divisors.
Now, your task is this: how many odd numbers with exactly eight positive divisors are there between 1 and N (inclusive)?

Constraints

N is an integer between 1 and 200 (inclusive).

Input

Input is given from Standard Input in the following format:

N

Output

Print the count.

Sample Input 1

105

Sample Output 1

1

Among the numbers between 1 and 105, the only number that is odd and has exactly eight divisors is 105.

Sample Input 2

7

Sample Output 2

0

1 has one divisor. 3, 5 and 7 are all prime and have two divisors. Thus, there is no number that satisfies the condition.

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::io::Read;

struct CustomIn<'a> {
    sin: ::std::io::StdinLock<'a>,
}
impl<'a> CustomIn<'a> {
    pub fn new(sin: ::std::io::StdinLock<'a>) -> Self {
        CustomIn::<'a> { sin: sin }
    }

    pub fn _u32(&mut self) -> u32 {
        self.sin
            .by_ref()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .fold(0u32, |a, x| a * 10 + (x as u8 - b'0') as u32)
    }

    pub fn _u64(&mut self) -> u64 {
        self.sin
            .by_ref()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .fold(0u64, |a, x| a * 10 + (x as u8 - b'0') as u64)
    }

    pub fn _usize(&mut self) -> usize {
        self.sin
            .by_ref()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .fold(0usize, |a, x| a * 10 + (x as u8 - b'0') as usize)
    }
}

fn d(n: usize) -> usize {
    let mut cnt = 0usize;
    for i in 1..n + 1 {
        if n % i == 0usize {
            cnt += 1;
        }
    }
    cnt
}

fn main() {
    let mut sin = ::std::io::stdin();
    let mut cin = CustomIn::new(sin.lock());
    let n = cin._usize();
    let mut cnt = 0usize;
    for i in 1..n + 1 {
        if i % 2 == 1usize && d(i) == 8usize {
            cnt += 1;
        }
    }
    println!("{}", cnt);
}