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):
n, k = map(int, input().split())
h = tuple(map(int, input().split()))

ans = 0
for hh in h:
    if hh >= k:
        ans += 1
print(ans)

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

Solution (Python):
def InputToInt():
    A = input().split()
    for i in range(len(A)):
        A[i] = int(A[i])
    return A
    
if __name__ == '__main__':
    N, K = InputToInt()
    h = InputToInt()

    c = 0
    for a in h:
        if a >= K:
            c += 1
    print(c)

Solution (Python):
n,k = input().split(' ')
n = int(n)
k = int(k)
count = 0
for i in input().split(' '):
    i = int(i)
    if i >= k:
        count += 1
print(count)

Solution (Python):
a,b = [int(i) for i in input().split()]
l = [int(i) for i in input().split()]

l2 = [i for i in l if i >= b]
print(len(l2))

Solution (Python):
N, K = map(int, input().split())
h = list(map(int, input().split()))
print(len([hi for hi in h if hi >= K]))

Solution (Python):
N,K,*H=map(int,open(0).read().split());print(sum(h>=K for h in H))

Solution (Python):
import numpy as np

n, k = [int(v) for v in input().split()]
hs = np.array([int(v) for v in input().split()])
print((hs >= k).sum())

Solution (Python):
N, K = map(int, input().split())
h = [int(x) for x in 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()))

a = 0
for h in H:
    a += h >= K
print(a)

Solution (Python):
n, k = map(int, input().split())
ans = 0
for i in map(int, input().split()): ans+=(i>=k)
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 h in H:
    if h >= K:
        ans += 1
print(ans)

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

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):
def calc(N, K, A):
    return len([a for a in A if a >= K])


(N, K) = tuple([int(s) for s in input().split()])
A = [int(s) for s in input().split()]
print(calc(N, K, A))

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

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

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

out = sum([1 for h in hs if h >= k])
print(out)

Solution (Python):
n, k = map(int, input().split())
h_list = list(map(int, input().split()))
ans = 0
for h in h_list:
    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 h:
    if(i >= k):
        ans += 1

print(ans)

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

Solution (Python):
def main():
    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)

if __name__ == '__main__':
    main()

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

def s(generator, splitter, mapper):
    return [ mapper(s) for s in generator().split(splitter) ]


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]

n,k = get_nums_l()
hhh = get_nums_l()

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

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):
import sys
input = sys.stdin.readline
N,K = map(int,input().split())
ans = 0
for h in map(int,input().split()):
  if h >= K: ans += 1
print(ans)

Solution (Python):

n,k = map(int, input().split())

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

ret = sum([1 if hi>=k else 0 for hi in h])


print(ret)

Solution (Python):
def main():
    n, k = map(int, input().split(' '))
    h_s = list(map(int, input().split(' ')))

    ans = 0
    for h in h_s:
        if h >= k:
            ans += 1
    print(ans) 

if __name__ == '__main__':
    main()

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

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

print(res)

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

cnt = 0

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

Solution (Python):

import sys
INF = float("inf")


def solve(N: int, K: int, h: "List[int]"):
    counter = 0
    for hh in h:
        if hh >= K:
            counter += 1
    print(counter)

    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 =[int(i)for i in 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()))

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

print(num)

Solution (Python):
def main():
    N, K = [int(a) for a in input().split()]
    h = [int(a) for a in input().split()]

    print(sum(1 for a in h if a >= K))


if __name__ == "__main__":
    main()

Solution (Python):
a,b=map(int,input().split())
c=list(map(int,input().split()))
ans=0
for i in c:
  if i >=b:
    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())
count=0
for i in list(map(int,input().split())):
    if i>=k:count +=1
print(count)

Solution (Python):
import sys
import os

N,K  = map(int,input().split())
H = list(map(int,input().split()))
cnt = 0
for h in H:
    if h>= K:
        cnt +=1
print(cnt)

Solution (Python):
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

n, k = nm()

h = nl()

cnt = 0

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

print(cnt)

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):
N,K = map(int,input().split())
H = [int(i) for i in input().split()]
cnt = 0
for i in H:
    if i>=K:
        cnt +=1
print(cnt)

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

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 main():

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

if __name__ == '__main__':
    print(main())

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

Solution (Python):
n,k=map(int,input().split())
h=[int(x) for x in input().split()]
count=0

for x in h:
    if x>=k:
        count+=1

print(count)

Solution (Python):
N, K = map(int, input().split())
hs = list(map(int, input().split()))
r = len([h for h in hs if h >= K])
print(r)

Solution (Python):

n, k = map(int, input().split())
h = list(map(int, input().split()))
ans = 0
for i in range(len(h)):
    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):
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()))
count = 0
for i in range(n):
    if h[i] >= k:
        count += 1
print(count)

Solution (Python):
n, K = map(int, input().split())
L = list(map(int, input().split()))

res = 0
for i in range(n):
    if L[i] >= K:
        res += 1

print(res)

Solution (Python):
N, K = list(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 main():
  _, k = map(int, input().split())
  hs = map(int, input().split())
  
  print(len([h for h in hs if h >= k]))


if __name__ == '__main__':
  main()

Solution (Python):


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

ans = sum([1 for h in H if h >= K])

print(ans)

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 i in h:
    if i >=k:
        ans += 1
print(ans)

Solution (Python):
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
N,K=map(int,input().split())
h=list(map(int,input().split()))

cnt=0

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

print(cnt)

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

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

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 a in h:
    if a>=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 h in H:
    if h >= K: ans += 1
print(ans)

Solution (Python):
def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]






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

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

Solution (Python):
import sys
from bisect import *
from collections import *
from copy import deepcopy
from heapq import *
from itertools import *
from math import *
from operator import *
from pprint import *

sys.setrecursionlimit(10**8)

input = sys.stdin.readline


def main():
    """ main """
    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)

if __name__ == '__main__':
    main()

Solution (Python):

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

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

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

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

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

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

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

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


    print(cnt)

main()

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  

n, k = na()
h = na()
print(len([_ for _ in h if _ >= k]))

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

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

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

print(count)

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

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]
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()))
a=0
for i in h:
    if i>=K:
        a+=1
print(a)

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

Solution (Python):
a,b=map(int,input().split())
s=list(map(int,input().split()))
c=0
for i in s:
    if i>=b:
        c+=1
print(c)

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
def input():
    return sys.stdin.readline()[:-1]
from bisect import *
from collections import *
from heapq import *
import itertools
INF = 10**9
MOD = 10**9+7

N, K = map(int, input().split())
h = [int(x) for x in input().split()]
print(len([x for x in h if x >= K]))

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

ans = len([h for h in hs if h >= K])
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 h:
  if i>=k:
    ans+=1
print(ans)

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

count=0

for hl in hlist:
    if hl>=k:
        count+=1

print(count)

Solution (Python):
def solve():
  N, K = map(int, input().split())
  H = [int(i) for i in input().split()]
  return len(list(filter(lambda h: h >= K, H)))

print(solve())

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

t = 0
for i in range(n):
    if dat[i] >= k:
        t += 1

print(t)

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

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

ans = 0
for v in h:
    if k <= v:
        ans += 1
print(ans)

Solution (Python):


n,k = map(int,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):
n,h=map(int,input().split())
l=list(map(int,input().split()))

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

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

cnt = 0
for e in h:
    if e >= k:
        cnt += 1

print(cnt)

Solution (Python):
from bisect import bisect_left
n, k = map(int, input().split())
l = sorted(map(int, input().split()))
print(n - bisect_left(l, k))

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

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

r = 0
for hi in list_h:
    if (hi >= k):
        r += 1

print(r)

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

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

Solution (Python):

N,K = map(int,input().split())
H = list(map(int,input().split()))
H.sort(reverse=True)
ans = 0
for h in H:
    if h >= K:
        ans+=1
    else:
        break
        
print(ans)

Solution (Python):
n, k = map(int, input().split())
h = [x for x in input().split() if int(x) >= k]

print(len(h))

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

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):

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
n, k = [int(i) for i in sys.stdin.readline().split()]
h_ls = [int(i) for i in sys.stdin.readline().split()]
print(len([h for h in h_ls if h >= k]))

Solution (Python):
n,k,*h=map(int,open(0).read().split());print(sum(h>=k for h in h))

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

Solution (Python):
def main():
    out=0
    N,K=map(int,input().split())
    H=map(int,input().split())
    for h in H:
        if h>=K:
            out+=1

    return out
    

print(main())

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

count = 0
for i in h:
    if i >= K:
        count += 1
print(count)

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

h = list(map(int,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())
ls = list(map(int, input().split()))
print(sum([1 for x in ls if x >= k]))

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

count = 0
for n in range(N):
    if H[n] >= K:
        count += 1
print(count)

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

total = 0
for h in heights:
    if h >= K: total+=1

print(total)

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

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()

n, k = na()
h = na()
ct = 0
for hi in h:
    if hi >= k:
        ct += 1
print(ct)

Solution (Python):
n,k=map(int,input().split())
print(len([int(i) for i in input().split() if int(i)>=k]))

Solution (Python):
n,k=map(int,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):
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())
A=[int(x) for x in input().split()]

cnt=0
for a in A:
	if a>=K:cnt+=1
print(cnt)

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

print(sum([1 for i in h if i>=k]))

Solution (Python):
N,K=map(int,input().split())
H=list(map(int,input().split()))
print(sum([h>=K for h in H]))

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 main():
    n, k = (int(z) for z in input().split())
    hs = [int(h) for h in input().split()]
    res = sum(h >= k for h in hs)
    print(res)


if __name__ == "__main__":
    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 math
import heapq
from bisect import bisect_right, bisect_left
from collections import defaultdict, Counter
import itertools
import sys
sys.setrecursionlimit(10**7)
MOD = 10**9 + 7
INF = float("inf")


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 = (int(i) for i in input().split())
x = [int(i) for i in input().split()]
ans = 0
for i in x:
    if i>=k: ans+=1
print(ans)

Solution (Python):
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)

from math import factorial
import heapq, bisect
import math
import itertools


import queue
from collections import deque



def main():
    num, k = map(int, input().split())
    data = list(map(int, input().split()))
    ans = 0

    for i in range(num):
        if data[i] >= k:
            ans += 1

    print(ans)






if __name__ == '__main__':
    main()

Solution (Python):
import sys


def main():
    n, k = [int(s) for s in sys.stdin.readline().strip().split()]
    h = [int(s) for s in sys.stdin.readline().strip().split()]

    ans = 0
    for hi in h:
        if hi >= k:
            ans += 1
    print(ans)



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 range(n):
    if h[i] >= k:
        ans += 1
print(ans)

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

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, K, H):
    return len(list(filter(lambda x: x >= K, H)))


def main():
    N, K = read_int_n()
    H = read_int_n()
    print(slv(N, K, H))


if __name__ == '__main__':
    main()

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

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):
N,K = map(int,input().split())
*H, = map(int,input().split())
print(sum(h>=K for h in H))

Solution (Python):
N, K = map(int,input().split())
H = list(map(int,input().split()))
ans = [h >= K for h in H]
ans = sum(ans)
print(ans)

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

Solution (Python):


import sys
import collections
sys.setrecursionlimit(4100000)

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):

(N,M) = (int(i) for i in input().split(" "))
print(sum([int(i)>=M for i in input().split()]))

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

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

print(sum([h >= K for h in H]))

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

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

count = 0
for hi in h:
    if hi >= k:
        count += 1
print(count)

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

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

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

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

print(cnt)

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

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):
N, K = map(int, input().split())
A = list(map(int, input().split()))

c = 0
for a in A:
    if a >= K:
        c += 1
print(c)

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

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

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

ANS=[1 for i in range(N) if H[i]>=K]
print(len(ANS))

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

Solution (Python):
N, K = map(int, input().split())
A = [int(a) for a in input().split()]
print(len([a for a in A if a >= K]))

Solution (Python):

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

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()))
cnt = 0
for i in h:
  if i >= K:
    cnt += 1
print(cnt)

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
    n,k=map(int,input().split())
    H=list(map(int,input().split()))
    ans=0
    for h in H:
        ans+=(h>=k)
    print(ans)
resolve()

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 math
n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = 0
for i in range(n):
    if(a[i]>=m):
        ans+=1
print(ans)

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

sys.setrecursionlimit(10 ** 7)

def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x) - 1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())


n, k = li()
h = list(li())

ans = 0
for hi in h:
    if hi >= k:
        ans += 1

print(ans)

Solution (Python):
N, K = list(map(int, input().split()))
h = list(map(int, input().split()))
print(sum([x >= K for x in h]))

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):
mod = 1000000007
MOD = 998244353
ii = lambda :  int(input())
si = lambda :  input()
dgl = lambda : list(map(int, input()))
f = lambda :   map(int, input().split())
il = lambda :  list(map(int, input().split()))
it = lambda :  tuple(map(int, input().split()))
ls = lambda :  list(input())
n,k=f()
l=il()
print(sum(i>=k for i in l))

Solution (Python):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7



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

print(count)

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

print sum(x>=K for x in h)

Solution (Python):
N,K = (int(x) for x in input().split())
h_arr = [int(x) for x in input().split()]

print(len([x for x in h_arr if x >= K]))

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

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

Solution (Python):
def main():
    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)


if __name__ == "__main__":
    main()

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

Solution (Python):
N,K=map(int,input().split())
L=list(map(int,input().split()))
count=0
for i in L:
	if i >= K:
		count+=1
else:
	 print(count)

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())
a = list(map(int, input().split()))
ans = 0
for i in range(n):
    if a[i] >= k:
        ans += 1
print(ans)

Solution (Python):
n, k = [ int(v) for v in input().split() ]
h_list = [ int(v) for v in input().split() ]
h_list = [ i >= k for i in h_list ]
print(h_list.count(True))