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 sys
input = sys.stdin.readline

import numpy as np

def main():
    n,k = map(int, input().split())
    h_list = list(map(int, input().split()))

    c = 0
    for i in h_list:
        if i >= k:
            c += 1

    print(c)


if __name__ == '__main__':
    main()

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

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

ans = sum([ 1 for x in hn if x>=k])

print(ans)

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

count = 0

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

print(count)

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

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

print(number)

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(str(ans))

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

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

Solution (Python):
import sys
import heapq
import bisect
import itertools

mod = 10**9+7
dd = ((-1,0),(1,0),(0,-1),(0,1))

def I(): return(int(sys.stdin.readline()))
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 S(): return(sys.stdin.readline()[:-1])
def IR(n): return([I() for _ in range(n)])

def GCD(a,b):
    while b!=0:
        a,b = b,a%b
    return a

def LCM(a,b):
    return a * b // GCD(a,b)

def Eratosthenes(N):
    r = [True]*(N+1)
    r[0] = False
    r[1] = False
    i = 2
    while i*i<=N:
        if r[i]: 
            j = i
            while i*j<=N:
                prime[i*j]=False
                j+=1
        i+=1
    return(r)

def main():
    N,K = LI()
    H = LI()

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

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

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

count = 0

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

print(count)

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

print(sum([i >= K for i in h_n]))

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):
n,k = map(int, input().split())
h = list(map(int, input().split()))
print(sum([i >= k for i in h]))

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

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

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

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

print(count)

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

counter = 0
hList = [int(i) for i in input().split()]

for i, e in enumerate(hList):
    if e >= K:
        counter += 1

print(counter)

Solution (Python):
import sys
input = sys.stdin.readline
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())
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())
h=list(map(int,input().split()))

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

print(cnt)

Solution (Python):
import numpy as np

l = raw_input().split()
N = int(l[0])
K = int(l[1])

h = map(int, raw_input().split())

h = np.array(h)

print np.sum(h >= K)

Solution (Python):
N, K = map(int, input().split())
print([int(i) >= K for i in input().split()].count(True))

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

Solution (Python):
import math
import copy

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

count = int(0)
ans = int(0)

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

ans = count

print(ans)

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

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

Solution (Python):
import sys

n, k = map(int, sys.stdin.readline().split())
H = list(map(int, sys.stdin.readline().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 i in h:
    if i >= K:
        count += 1

print(count)

Solution (Python):



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

n,k = [int(i) for i in readline().split()]
h = [int(i) for i in readline().split()]


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

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):
def main():
  n, k = map(int, raw_input().split())
  heights = map(int, raw_input().split())
  cnt = 0
  for h in heights:
    if h >= k:
      cnt += 1
  print(cnt)
  

main()

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

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

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

Solution (Python):


N, K = [int(x) for x in input().split(" ")]
heights = [int(x) for x in input().split(" ")]
count = 0
for height in heights:
    if height >= K:
        count += 1
print(count)

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

print(len([i for i in h if i >= K]))

Solution (Python):


N, K = map(int, input().split())
A = list(map(int,input().split()))
ctr = 0

for i in A:
    if i >= K:
        ctr += 1
print(ctr)

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

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

Solution (Python):



def solve(N, K, h):
    return sum(h1 >= K for h1 in h)


if __name__ == '__main__':
    N, K = map(int, input().split())
    h = map(int, input().split())

    ans = solve(N, K, h)

    print(ans)

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

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

ct = 0
for h in hlist:
    if h>=K:
        ct+=1
print(ct)

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

Solution (Python):
import numpy as np

N, K = list(map(int, input().split()))
h = np.array([int(a) for a in input().split()])
print(np.count_nonzero(h >= K))

Solution (Python):
def main():
    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)
if __name__ == '__main__':
    main()

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

answer = 0

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

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

output = 0
for h in h_list:
    if h >= k:
        output += 1

print(output)

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

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

print(c)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
n,k=map(int,input().split())
hh=map(int,input().split())
print(sum(h >=k for h in hh))

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

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

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

res = 0 
for h in hl:
  if h >= K:
    res += 1
print(res)

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

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

print(count)

Solution (Python):
friends, height = map(int,input().split())
heights = list(map(int,input().split()))
count = 0
for h in heights:
	if h >= height:
		count += 1
print(count)

Solution (Python):
from collections import deque
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline

def isprime(n):
  for i in range(2,int(n**0.5)+1):
    if n%i == 0:
      return False
  return True


def solve():
  n,k = (int(i) for i in input().split())
  h =  list(int(i) for i in input().split())
  ct = 0
  for i in h:
    if i >= k:
      ct += 1
  print(ct)
solve()

Solution (Python):
if __name__ == '__main__':
    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()))

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

Solution (Python):

import sys
from collections import deque, defaultdict
import copy
import bisect
sys.setrecursionlimit(10 ** 9)
import math
import heapq
from itertools import product, permutations,combinations
import fractions

import sys
def input():
	return sys.stdin.readline().strip()

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

h.sort()

loc = bisect.bisect_left(h, K)

print(N - loc)

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

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

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    N,K = i2nn()
    h = i2nn()
    print(len([x for x in h if x >= K]))
    return

main()

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

Solution (Python):
N, K = [int(_) for _ in input().split()]
ans = 0
for h in [int(_) for _ in input().split()]:
    ans += h >= K
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()]
count=0
for i in range(N):
  if h[i]>=K:
    count += 1
print(count)

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

Solution (Python):
n, k = map(int, input().split())
print(sum(1 for x in map(int, input().split()) if x >= k))

Solution (Python):


N, K = list(map(int, input().split()))
h_list = list(map(int, input().split()))
ans = len([h for h in h_list if h >= K])

print(ans)

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

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

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

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

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

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

mycnt = 0

for i in mylist:
    if i >= K:
        mycnt += 1

print(mycnt)

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






def main():

    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)



if __name__ == "__main__":
    main()

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)


INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007



from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce


INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007


n, k = LI()
A = LI()
cnt = 0
for i in A:
    if i >= k:
        cnt += 1

print(cnt)

Solution (Python):

N,K = map(int,input().split())
lst = list(map(int,input().split()))
ans = 0
for i in lst:
    if (i >= K):
        ans += 1
print(ans)

Solution (Python):
from sys import stdin

def main():
    input = lambda: stdin.readline()[:-1]
    N, K = map(int, input().split())
    H = map(int, input().split())

    ans = 0
    for h in H:
        ans += K <= h
    print(ans)

main()

Solution (Python):
import sys

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

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

Solution (Python):
N,K = list(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 k <= h[i]:
        count += 1
print(count)

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

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

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

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

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

Solution (Python):
N,K = map(int,input().split())
H = list(map(int,input().split()))
H = sorted(H,reverse=True)
ind = 0
for i in range(N):
    if H[i]<K:
        print(i)
        ind = 1
        break
if ind==0:
    print(N)

Solution (Python):
n,k = [int(s) for s in input().split()]
nums = [int(s) for s in input().split()]

p = 0
for i in nums:
  if i >= k:
    p += 1
print(p)

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

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

count = 0
for i in l:
    if i >= k:
        count += 1

print(count)

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

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

Solution (Python):

import sys


def solve(N: int, K: int, h: "List[int]"):
    print( len(list(filter(lambda x:x>=K, h))) )
    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())
l = list(map(int, input().split()))
c = 0
for h in l:
    if K <= h:
        c += 1
print(c)

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

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

print(count)

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

ans = 0

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

print(ans)

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

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

if __name__ == '__main__': main()

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

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

Solution (Python):
import sys

lines = sys.stdin.readlines()
n, k = map(int, lines[0].split())
print(len(list(filter(lambda h : h >= k, map(int, lines[1].split())))))

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

h.sort()

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

print(ans)

Solution (Python):
n, k = [int(elem) for elem in input().split()]

cnt = 0
for elem in input().split():
    if int(elem) - k >= 0:
        cnt += 1
print(cnt)

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

Solution (Python):
import sys

input = sys.stdin.readline


class AtCoder:
    def main(self):
        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__':
    AtCoder().main()

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

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

ans = 0

for a in ls:
  if a >=k:
    ans +=1
print(ans)

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

ct = 0

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

print(ct)

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

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

print(ans)

Solution (Python):
import math
import queue
import bisect
import heapq

mod = 1e9+7

def swap(a,b):
    return (b,a)

def gcd(a,b):
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

def divisors(a):
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def main():
    n,k = map(int,input().split())
    ans = 0
    h = [x for x in map(int,input().split())]
    for i in h:
        if i>=k:
            ans += 1
    print(ans)
    return

if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin

n,k = [int(x) for x in stdin.readline().rstrip().split()]

li = list(map(int,stdin.readline().rstrip().split()))

point = 0

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
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 LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

debug = True
debug = False

def dprint(*objects):
    if debug == True:
        print(*objects)

def solve():
    N, K = LI()
    h_list = LI()

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

solve()

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()))
a=0
for i in range(N):
  if H[i]>=K:
    a+=1

print(a)

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

count = 0 
for hi in hh:
  if hi >= k:
    count += 1

print(count)

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_list = map(int, input().split())

can_ride_num = 0
for h in h_list:
    if h >= k:
        can_ride_num += 1

print(can_ride_num)

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

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

print(c)

Solution (Python):













N, K = [int(i) for i in input().split(" ")]
Hs = [int(i) for i in input().split(" ")]
print(len([h for h in Hs if K <= h]))

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

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

ridable = [x for x in h if x >= K]

print(len(ridable))

Solution (Python):

def main():
    import sys
    input = sys.stdin.readline
    N, K = map(int, input().rstrip().split())
    H = [int(x) for x in input().rstrip().split()]
    print(len([x for x in H if x >= K]))

main()

Solution (Python):
from sys import stdin
import numpy as np




def main():
    n, k = [int(x) for x in input().split()]
    hs = [int(x) for x in input().split()]
    cnt = 0
    for h in hs:
        if h >= k:
            cnt += 1
    print(cnt)
    return


if __name__ == "__main__":
    main()

Solution (Python):

import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = False
def main(given = sys.stdin.readline):
    input = lambda : given().rstrip()
    LMIIS = lambda : list(map(int,input().split()))
    II = lambda : int(input())
    XLMIIS = lambda x : [LMIIS() for _ in range(x)]

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

if __name__ == '__main__':
    main()

Solution (Python):
n, k = map(int, input().split())
c = 0

for x in [int(x) for x in input().split()]:
    if x >= k:
        c += 1

print(c)

Solution (Python):
import numpy as np
N,K=map(int, input().split())
H=np.array(list(map(int, input().split())))
print(np.count_nonzero(H>=K))

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

print(count)

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

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

Solution (Python):
def read():
    N, K = map(int, input().strip().split())
    H = map(int, input().strip().split())
    return N, K, H

def solve(N, K, H):
    return sum([1 if h >= K else 0 for h in H])

if __name__ == '__main__':
    inputs = read()
    print("%d" % solve(*inputs))

Solution (Python):
num ,k = map(int,input().split())

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

count = 0
for i in arr:
    if i >= k:
        count +=1
        
print(count)

Solution (Python):
str_list = input().split(' ')
int_list = [int(x) for x in str_list]

N, K = int_list[0], int_list[1]

str_list = input().split(' ')
h_list = [int(x) for x in str_list]

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

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

    ans = 0
    for h in h_l:
        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()))

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()))
count = 0

for i in range(len(h)):
    if h[i] >= 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):
import sys
from io import StringIO
import unittest

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """4 150
150 140 100 200"""
        output = """2"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """1 500
499"""
        output = """0"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """5 1
100 200 300 400 500"""
        output = """5"""
        self.assertIO(input, output)
def resolve():
    (N,K)=(int(i) for i in input().split())
    h=[int(i) for i in input().split()]
    count=0
    for i in h:
        if i>=K:
            count+=1
    print(count)
if __name__ == "__main__":
    resolve()

Solution (Python):
import sys,queue,copy
sys.setrecursionlimit(10**8)
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

N,K =inpl()
hlist = inpl()
ans =0
for h in hlist:
    if h >= K :
        ans += 1

print(ans)