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 (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  n,k=LI()
  ans=0
  l=LI()

  for x in l:
    if x>=k:
      ans+=1
  return ans


print(main())

Solution (Python):
N, K = map(int, input().split())
hs=list(map(int, input().split()))
ans=0
for h in hs:
  if h>=K:
    ans+=1
print(ans)

Solution (Python):
N,K=map(int,input().split())
lh=list(map(int,input().split()))
ans=0
for i in range(N):
    if lh[i]>=K:
        ans+=1
print(ans)

Solution (Python):
import sys
MAX_INT = int(10e12)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

N,K = IL()
h = IL()

ans = 0
for i in h:
  if i >= K:
    ans += 1

print(ans)

Solution (Python):
import sys
from collections import defaultdict, deque
from heapq import *
sys.setrecursionlimit(200000)
input = sys.stdin.readline

H, K, = map(int, input().split())

L = [int(v) for v in input().split()]





ans = 0
for v in L:
    if v >= K:
        ans += 1

print(ans)

Solution (Python):
n,k = map(int, input().split())
ans = sum(i>=k for i in map(int, input().split()))
print(ans)

Solution (Python):
N, K = map(int, input().split())			
H =        list( map(int, input().split()) )	

ans=0
for h in H:
	if h>=K: ans+=1

print(ans)

Solution (Python):
n,k = map(int,input().split())
arr = list(map(int,input().split()))

ans = 0

for h in arr:
    if h >=k:
        ans += 1

print(ans)

Solution (Python):



N, K = map(int, input().split())
h = list(map(int, input().split()))


ans = 0
for i in range(N):
    if h[i] >= K:
        ans += 1


print(ans)

Solution (Python):
import sys
from heapq import heappop, heappush
from operator import itemgetter
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 10**9 + 7
INF = float('inf')

def sol():
    N, K = map(int, input().split())
    H = list(map(int, input().split()))

    ans = 0
    for h in H:
        if h >= K:
            ans += 1
    print(ans)


sol()

Solution (Python):
N, K = map(int, input().split())
H = map(int, input().split())

print(len(list(filter(lambda h: h >= K, H))))

Solution (Python):
import sys


input = sys.stdin.readline


def main():
    N, K = map(int, input().split())
    h = [int(i) for i in input().split()]

    ans = 0
    for n in h:
        if n >= K:
            ans += 1
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    N, K = map(int, input().split())
    h = list(map(int, input().split()))

    ans = 0
    for i in range(N):
        if h[i] >= K:
            ans += 1
    print(ans)

if __name__ == "__main__":
    main()

Solution (Python):
n,k= list(map(int, input().split()))
h= list(map(int, input().split()))
ans=0
for i in h:
    if i>=k:
        ans+=1
print(ans)

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    
    n, k = map(int, input().split())
    arr = list(map(int, input().split()))
    
    ans = 0
    for x in arr:
        if x >= k:
            ans += 1
    
    print(ans)
    
    return 0

main()

Solution (Python):
n, k = [int(i) for i in input().split()]
h = [int(i) for i in input().split()]
ans = 0
for i in h:
    if i >= k:
        ans += 1
print(ans)

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    N,K = MI()
    H = LI()
    ans = 0
    for h in H:
        if(h>=K):
            ans+=1
    print(ans)
if __name__ == '__main__':
    main()

Solution (Python):
N,K = map(int,input().split())
H = list(map(int,input().split()))
ans = 0
for i in range(N):
    if K <= H[i]:
        ans += 1
print(ans)

Solution (Python):
import bisect
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7



N, K = list(map(int, sys.stdin.readline().split()))
H = list(map(int, sys.stdin.readline().split()))

H = np.array(H, dtype=int)
a = np.count_nonzero(H >=K)
print(a)

Solution (Python):
n,k =map(int,input().split())
h = list(map(int,input().split()))
ans = 0
for i in range (n):
         if h[i] >= k:
                  ans += 1
print(ans)

Solution (Python):
N,K = map(int,input().split())
H = list(map(int,input().split()))

ans = 0
for h in H:
    if h >= K:
        ans += 1
print(ans)

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    n, k = list(map(int, input().rstrip('\n').split()))
    h = list(map(int, input().rstrip('\n').split()))
    cnt = 0
    for i in range(n):
        cnt += 1 if h[i] >= k else 0
    print(cnt)


if __name__ == '__main__':
    slove()

Solution (Python):
N, K = map(int, input().split())
h = list(map(int, input().split()))
ans = 0
for i in range(N):
    if h[i]>=K:
        ans+=1
print(ans)

Solution (Python):
n, k = map(int, input().split())
h = list(map(int, input().split()))

ans = 0
for i in range(n):
    if h[i] >= k:
        ans += 1
print(ans)

Solution (Python):

import sys
sys.setrecursionlimit(300000)


def solve(N: int, K: int, h: "List[int]"):
    ret = 0
    for i in range(N):
        if h[i] >= K:
            ret += 1
    print(ret)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    K = int(next(tokens))  
    h = [ int(next(tokens)) for _ in range(N) ]  
    solve(N, K, h)

if __name__ == '__main__':
    main()

Solution (Python):
N, K = map(int, input().split())
h = list(map(int, input().split()))

ans = 0
for v in h:
    if v >= K:
        ans += 1

print(ans)

Solution (Python):
n,k=map(int,input().split())
h=list(map(int,input().split()))
a=0
for i in h:
  if k<=i:a+=1
print(a)

Solution (Python):
n,k = map(int,input().split())
a = list(map(int,input().split()))
res = 0
for i in a:
    res += int(i >= k)
print(res)

Solution (Python):
N, K = map(int, input().split())
h_list = list(map(int, input().split()))
ans = 0

for i in range(N):
    if h_list[i] >= K:
        ans += 1

print(ans)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline

def main():
    n,k=map(int, input().split())
    h=list(map(int, input().split()))
    cnt=0
    for hk in h:
        if hk>=k:cnt+=1
    print(cnt)

main()

Solution (Python):
N, K = map(int, input().split())
h = list(map(int, input().split()))

ans = 0
for i in h:
    if i >= K:
        ans += 1

print (ans)

Solution (Python):



import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

n,k = LI()
h = LI()
ans = 0
for i in range(n):
    if h[i] >= k:
        ans += 1
print(ans)

Solution (Python):
[n,k] = [int(i) for i in input().split()]
h = [int(i) for i in input().split()]
cnt = 0
for i in range(n):
    if h[i] >= k:
        cnt += 1
print(cnt)

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

N, K = map(int, input().split())
Hs = list(map(int, input().split()))
ans = 0
for h in Hs:
    ans += h >= K
print(ans)

Solution (Python):
N, K = map(int, input().split())
h = [int(i) for i in input().split()]

ret = 0
for i in range(N) :
    if h[i] >= K :
        ret += 1
print(ret)

Solution (Python):
N, K = map(int, input().split())
H = [int(i) for i in input().split()]
count = 0
for i in range(N):
  if H[i]>=K:
    count += 1
print(count)

Solution (Python):
n, k = map(int, input().split())
h = list(map(int, input().split()))

print(len(list(filter(lambda x: x >= k, h))))

Solution (Python):
n, k = map(int, input().split())
h = list(map(int, input().split()))
ans = 0
for i in h:
    if i >= k:
        ans += 1

print(ans)

Solution (Python):
N,K = map(int,input().split())
H = list(map(int,input().split()))

ans = 0
for h in H :
    if h >= K :
        ans += 1
print(ans)

Solution (Python):
n, k = map(int, input().split())
h = list(map(int, input().split()))

ans = 0
for i in range(n):
    if h[i] >= k:
        ans += 1
print(ans)

Solution (Python):
n,k = map(int,input().split())
ans = 0
h = list(map(int,input().split()))
for i in h:
    if i >= k:
        ans += 1

print(ans)

Solution (Python):
n, k = map(int, input().split(" "))
hs = list(map(int, input().split(" ")))

print(len([x for x in hs if x >= k]))

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

n,k = m()

a = l()

ans = 0

for i in range(n):
    if a[i] >= k:
        ans += 1
print(ans)

Solution (Python):

n,k= map(int,input().split())
A = list(map(int,input().split()))
ans = 0
for i in range(n):
    if A[i] >= k:
        ans += 1
print(ans)

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007


def A():

    return


def B():
    n,k = LI()
    h = LI()
    ans = 0
    for i in h:
        if i >= k:
            ans += 1
    print(ans)
    return


def C():

    return


def D():

    return


def E():

    return


def F():

    return


if __name__ == "__main__":
    B()