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 Haskell (GHC 7.10.3) (judge verdict: Accepted)

main :: IO ()                                                                                                              
main = do                                                                                                                  
  n <- readLn :: IO Int                                                                                                    
  let k = powerset [3,5,7,11,13,17]                                                                                        
      a  = filter (<=n) $ map product $ filter ((==3) . length) k                                                          
      b1 = filter (<=n) $ map (\[x,y] -> x^3*y) $ filter ((==2) . length) k                                                
      -- b2 = filter (<=n) $ map (\[x,y] -> y^3*x) $ filter ((==2) . length) k                                             
      -- c  = filter (<=n) $ map (\[x] -> x^7) $ filter ((==1) . length) k                                                 
  print $ length $ a ++ b1                                                                                                 
                                                                                                                           
powerset :: [a] -> [[a]]                                                                                                   
powerset [] = [[]]                                                                                                         
powerset (x:xs) = [x:ys | ys <- powerset xs] ++ powerset xs