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
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque


from collections import Counter

from itertools import accumulate,combinations,permutations

from heapq import heapify,heappop,heappush


from functools import lru_cache

from decimal import Decimal

def input(): 
    x=sys.stdin.readline()
    return x[:-1] if x[-1]=="\n" else x
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
    mod = 1000000007
    

    
    N, K = map(int, input().split())
    A = tuple(map(int, input().split())) 
    
    
    count=0
    for a in A:
        if a>=K:
            count+=1

    print(count)



if __name__ == "__main__":
    main()

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

Solution (Python):
import random as rng
import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)


def dump_impl(*objects):
    print(*objects, file=sys.stderr)


def dump_dummy(*objects):
    pass


dump = dump_impl if "DEBUG" in sys.argv else dump_dummy

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()))
sum=0
for l in h:
    if l>=k:
        sum+=1

print(sum)

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 sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, K, *H = map(int, read().split())
    
    ans = sum(h >= K for h in H)
    print(ans)
    return


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
from bisect import bisect_left
N, K = map(int, input().split())
H = list(map(int, input().split()))
H.sort()
res = 0
idx = bisect_left(H, K)
if idx < N:
    if H[idx] < K:
        res = N - idx - 1
    else:
        res = N - idx
print(res)

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

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())
height = list(map(int,input().split()))
chibi = [1] * N
for i in range (N):
  if height[i] >= K:
    chibi[i] = 0
print(N-sum(chibi))

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

if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
A, B = map(int, input().split())
H = list(map(int, input().split()))
 
print(len([1 for h in H if h >= B]))

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

Solution (Python):
number, req = map(int, input().split())

friends = list(map(int, input().split()))
allowed = 0
for i in friends:
  if i >=  req: allowed += 1
    
print(allowed)

Solution (Python):


n, k = map(int, input().split())
h = list(map(int, input().split()))
num = 0

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

print(num)

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

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

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

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

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

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 h:
    if 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(K):
    ans+=H.count(i)

print(N-ans)

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

def main():
    cnt = 0
    n, k = map(int, input().split())
    h = list(map(int, input().split()))

    print(sum([cnt+1 for v in h if v >= k]))

if __name__ ==  "__main__":
    main()

Solution (Python):
import math
import sys
from collections import deque
import heapq
import copy
import itertools
from itertools import permutations
from itertools import combinations
import bisect
def mi() : return map(int,sys.stdin.readline().split())
def ii() : return int(sys.stdin.readline().rstrip())
def i() : return sys.stdin.readline().rstrip()
a,b=mi()
l=list(mi())
l=sorted(l)
ind=bisect.bisect_left(l,b)
print(a-ind)

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

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

if __name__ == '__main__':
    solve()

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

Solution (Python):
N, K = (int(x) for x in 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_s = list(map(int,input().split()))
print(len(list(filter(lambda x:x>=K, h_s))))

Solution (Python):
import numpy as np
n,k = map(int,input().split())
h = np.array(list(map(int,input().split())))

print(len(h[k<=h]))

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

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

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

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 = list(map(int, input().split()))
ans=0
for x in H:
    if x>=K:
        ans+=1
print(ans)

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

h = []
h = input().split()

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

print(count)

Solution (Python):
_, K, *H = map(int, open(0).read().split())
print(len(tuple(filter(lambda h: h >= K, 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
  else:
    pass
print(ans)

Solution (Python):
n,k,*h=map(int,open(0).read().split())
j=0
for i in range(n):
  if h[i]>=k:
    j+=1
print(j)

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

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

count = 0

for i in range(len(h)):
    if k <= h[i]:
        count += 1

print(count)

Solution (Python):
line = input().split()
line2 = input().split()

num = int(line[0])
lim = int(line[1])

x = 0
for i in range(num):
  if int(line2[i]) >= lim:
    x += 1
    
print(x)

Solution (Python):
n,k = map(int,input().split())
num = list(map(int,input().split()))
c = 0
for i in num:
    if i >= k:
        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 = (int(a) for a in 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()))
c = 0

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

print(c)

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

print(c)

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

Solution (Python):



import sys
from collections import defaultdict, deque
from heapq import heappush, heappop
import math
import bisect
input = sys.stdin.readline




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

h.sort()
a = bisect.bisect_left(h, k)
print(N-a)

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

h.sort()
count = 0
for i in range(N):
  if h[i] < K:
    count += 1
print(N-count)

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

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

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

cnt = 0

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

print(cnt)

Solution (Python):
import bisect

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

h_list = sorted(h_list)

print(N - bisect.bisect_left(h_list, K))

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

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

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

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

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


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 h[i] >= k:
        ans += 1

print(ans)

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

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 = [int(x) for x in 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()))
h.append(k)
print(len(h[sorted(h).index(k)+1:]))

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

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

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

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

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

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

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

print(count)

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):
n, h = map(int, input().split())
hn = map(int, input().split())
cnt = 0
for i in hn:
    if i >= h:
        cnt += 1
print(cnt)

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

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

counter=0
for h in hlist:
	if h >= k:
		counter += 1
print(counter)

Solution (Python):
def actual(n, k, h_list):
    return len([h for h in h_list if h >= k])

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

print(actual(n, k, h_list))

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

J = [j for j in H if j >= K]

print(len(J))

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

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

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())
arr = list(map(int, input().split()))
ans = 0
for e in arr:
  if e >= k:
    ans += 1
print(ans)

Solution (Python):
import sys

input = lambda: sys.stdin.readline().rstrip()


def solve():
    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__':
    solve()

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):
def inp():return map(int,input().split())
def linp():return list(map(int,input().split()))

s=0
n,k=inp()
l=linp()
for x in l:
    if x>=k:s+=1
print(s)

Solution (Python):
n, k = map(int,input().split())
H = sorted(list(map(int, input().split())), reverse=True)
cnt = 0
for i in range(n):
    if H[i] >= k:
        cnt += 1
    elif H[i] < k:
        break
print(cnt)

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 sys


def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
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 S(): return input()
def LS(): return input().split()


n, k = LI()
h = LI()
h.sort()
ans = len([hi for hi in h if hi >= k])
print(ans)

Solution (Python):
import os, sys, re, math

(N, K) = [int(n) for n in input().split()]
H = [int(n) for n in input().split()]

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

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

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

Solution (Python):

N, K = [int(s) for s in input().split()]
h = [int(s) for s in input().split()]

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

Solution (Python):
n, k = [int(i) for i in input().split()]
hs = [int(i) for i in input().split()]
print (sum([1 if i >= k else 0 for i in hs]))

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

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

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

Solution (Python):
import sys
import decimal 

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

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

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

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

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

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

print(ans)

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):
n,k=map(int,input().split())
lis=list(map(int,input().split()))
lis.sort()
ans=0
for i in lis:
    if i<k:
        ans+=1
    else:
        
        break
print(n-ans)

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

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

print(len(ans))

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

count = 0
for i in hs:
    if i >= k:
        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())
h = list(map(int, input().split()))

import numpy as np
h = np.array(h)

print(len(h[h>=K]))

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



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

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 = map(int, input().split())
print(sum(1 for i in map(int, input().split()) if i >= k))

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

import numpy as np

D = np.array(d)

print(len(D[D>=K]))

Solution (Python):
n , m = map(int, input().split())
lis = list(map(int, input().split()))

total = 0

for i in lis:
    if i >= m:
        total += 1

print(total)

Solution (Python):
from sys import stdin, setrecursionlimit


def main():
    input = stdin.buffer.readline
    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)


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

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

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

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

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

Solution (Python):
n,m = map(int, raw_input().split(' '))
print sum([1 for e in  map(int, raw_input().split(' ')) if e >= m] or [0])

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):
N, K = map(int, input().split())
h = list(map(int, input().split()))
count = 0
for x in h:
    if x >= 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()))
print(sum(i >= k for i in h))

Solution (Python):

N,K = map(int,input().split())
H = [int(h) for h in input().split()]
H = sorted(H)
import bisect
ans =len(H)-bisect.bisect_left(H,K)
print(ans)

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

h.sort(reverse=True)
ans = 0
for i in range(len(h)):
    if(h[i] < k):
        ans = i
        print(ans) 
        sys.exit()

print(len(h))

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

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines


def main():
    _, K = map(int, readline().split())
    hs = map(int, readline().split())

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


if __name__ == '__main__':
    main()

Solution (Python):
n,k,*h=map(int,open(0).read().split())
print(sum([1 if h[i]>=k else 0 for i in range(n)]))

Solution (Python):
import sys

sys.setrecursionlimit(10000000)
import os
import math
import bisect
import collections
import itertools
import heapq
import re
import queue



ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)


MOD = 10 ** 9 + 7
MAX = float('inf')


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

    N, K = il()
    H = il()

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


if __name__ == '__main__':
    main()

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

print(count)

Solution (Python):
n, k = map(int, input().split())
h = list(map(int, input().split()))
ok_list = list()
for data in h:
    if data >= k:
        ok_list.append(data)
print(len(ok_list))

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

print(ans)

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

ans = bisect.bisect_left(h, k)
print(n-ans)

Solution (Python):
import sys
sys.setrecursionlimit(10**6)

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

h.sort()

l = -1; r = n 

while l+1 < r:
    c = (l+r)//2
    if h[c] < k:
        l = c
    else:
        r = c

print(n-(l+1))

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

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

cnt=0
for x in h:
    if(x>=k):
        cnt+=1
print(cnt)

Solution (Python):
import bisect
def roller_coaster(n, k, hli):

    hli.sort()

    lenght = len(hli)

    ans = lenght - bisect.bisect_left(hli, k)

    return ans

def main():
    n, k = map(int, input().split())
    hli = list(map(int, input().split()))
    print(roller_coaster(n, k, hli))

if __name__ == '__main__':
    main()

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

Solution (Python):
n,k=map(int,input().split())
a=list(map(int,input().split()))
x=0

for i in a:
  if i>=k:
    x+=1
print(x)

Solution (Python):
n,k = map(int,input().split())
l = list(map(int,input().split()))
ans = 0
for i in l:
    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):
n, k = map(int, input().rstrip().split())
h = [int(v) for v in input().rstrip().split()]
h.sort()
r = 0
for i in range(len(h)):
	if k <= h[i]:
		r = len(h) - i
		break

print(r)

Solution (Python):
N,K=map(int,input().split())
H=[int(h) for h in input().split()]
H=sorted(H)
cnt=0
for i in range(1,len(H)+1):
    if H[-i]>=K:
        cnt+=1
    else:
        print(cnt)
        exit()
print(cnt)

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())
list = [int(x) for x in input().split()]
ans = 0

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

print(ans)

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

t=[x for x in d if x>=k]

print(len(t))

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=ans+1
print(ans)

Solution (Python):
n, k = [int(x) for x in input().split()]
h = [int(x) for x in input().split()]
cnt = 0
for i in range(len(h)):
    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 = [int(i) for i in 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()))
x=0
for i in h:
    if i>=K:
        x+=1
print(x)