Problem:
Score : 200 points

Problem Statement

N friends of Takahashi has come to a theme park.

To ride the most popular roller coaster in the park, you must be at least K centimeters tall.

The i-th friend is h_i centimeters tall.

How many of the Takahashi's friends can ride the roller coaster?

Constraints

1 \le N \le 10^5

1 \le K \le 500

1 \le h_i \le 500

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K
h_1 h_2 \ldots h_N

Output

Print the number of people among the Takahashi's friends who can ride the roller coaster.

Sample Input 1

4 150
150 140 100 200

Sample Output 1

2

Two of them can ride the roller coaster: the first and fourth friends.

Sample Input 2

1 500
499

Sample Output 2

0

Sample Input 3

5 1
100 200 300 400 500

Sample Output 3

5

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

macro_rules! scan {                                                                                                                                                              
    // Scan item                                                                                                                                                                 
    ($t:ty) => {                                                                                                                                                                 
        {                                                                                                                                                                        
            let mut buffer: String = String::new();                                                                                                                              
            std::io::stdin().read_line(&mut buffer).unwrap();                                                                                                                    
            buffer.trim().parse::<$t>().unwrap()                                                                                                                                 
        }                                                                                                                                                                        
    };                                                                                                                                                                           
    // Scan tuple                                                                                                                                                                
    ($($t:ty),*) => {                                                                                                                                                            
        {                                                                                                                                                                        
            let mut buffer: String = String::new();                                                                                                                              
            std::io::stdin().read_line(&mut buffer).unwrap();                                                                                                                    
            let mut it = buffer.split_whitespace();                                                                                                                              
            (                                                                                                                                                                    
                $(it.next().unwrap().parse::<$t>().unwrap(),)*                                                                                                                   
            )                                                                                                                                                                    
        }                                                                                                                                                                        
    };                                                                                                                                                                           
    // Scan values separated by whitespace                                                                                                                                       
    ($t:ty;) => {                                                                                                                                                                
        {                                                                                                                                                                        
            let mut buffer: String = String::new();                                                                                                                              
            std::io::stdin().read_line(&mut buffer).unwrap();                                                                                                                    
            buffer.split_whitespace()                                                                                                                                            
                .map(|t| t.parse::<$t>().unwrap())                                                                                                                               
                .collect::<Vec<_>>()                                                                                                                                             
        }                                                                                                                                                                        
    };                                                                                                                                                                           
}                                                                                                                                                                                
                                                                                                                                                                                 
fn main() {                                                                                                                                                                      
    let (_, k) = scan!(usize, usize);                                                                                                                                            
    let hs = scan!(usize;);                                                                                                                                                      
                                                                                                                                                                                 
    println!("{}", hs.into_iter().filter(|&h| h >= k).count());                                                                                                                  
}