There are N + 1 squares arranged in a row, numbered 0, 1, ..., N from left to right.
Initially, you are in Square X.
You can freely travel between adjacent squares. Your goal is to reach Square 0 or Square N.
However, for each i = 1, 2, ..., M, there is a toll gate in Square A_i, and traveling to Square A_i incurs a cost of 1.
It is guaranteed that there is no toll gate in Square 0, Square X and Square N.
Find the minimum cost incurred before reaching the goal.

-----Constraints-----
 - 1 \leq N \leq 100
 - 1 \leq M \leq 100
 - 1 \leq X \leq N - 1
 - 1 \leq A_1 < A_2 < ... < A_M \leq N
 - A_i \neq X
 - All values in input are integers.

-----Input-----
Input is given from Standard Input in the following format:
N M X
A_1 A_2 ... A_M

-----Output-----
Print the minimum cost incurred before reaching the goal.

-----Sample Input-----
5 3 3
1 2 4

-----Sample Output-----
1

The optimal solution is as follows:
 - First, travel from Square 3 to Square 4. Here, there is a toll gate in Square 4, so the cost of 1 is incurred.
 - Then, travel from Square 4 to Square 5. This time, no cost is incurred.
 - Now, we are in Square 5 and we have reached the goal.
In this case, the total cost incurred is 1.

Difficulty: introductory

Starter code:

Solutions:
import bisect

N,M,X = map(int,input().split())
A = list(map(int,input().split()))

index = bisect.bisect_left(A,X)
ans = min(M-index,index)
print(ans)

n,m,x=map(int, input().split())
a=[int(i) for i in input().split()]

count_1=0
for i in range(x):
    if i in a:
        count_1+=1
        
count_2=0
for i in range(x,n):
    if i in a:
        count_2+=1
        
print(min(count_1, count_2))

# B - Toll Gates
# https://atcoder.jp/contests/abc094/tasks/abc094_b

n, m, x = list(map(int, input().split()))
a = list(map(int, input().split()))

cost1 = 0
cost2 = 0

for i in range(x, 0, -1):
    if i in a:
        cost1 += 1

for i in range(x, n):
    if i in a:
        cost2 += 1

cost = [cost1, cost2]
print((min(cost)))


# 094b

def atc_094b(NMX: str, Ai_input: str) -> int:
    N, M, X = list(map(int, NMX.split(" ")))
    Ai = [int(ai) for ai in Ai_input.split(" ")]

    up_cost = 0
    down_cost = 0

    for i in range(X + 1, N + 1):
        if i in Ai:
            up_cost += 1
    for i in range(X - 1, 0, -1):
        if i in Ai:
            down_cost += 1
    return min(up_cost, down_cost)


NMX_input_value = input()
Ai_input_value = input()
print((atc_094b(NMX_input_value, Ai_input_value)))


n,m,x=map(int,input().split())
am=sorted(map(int,input().split()))
print(min(len(list(filter(lambda a:a<x,am))),len(list(filter(lambda a:x<a,am)))))

lst = input().split()
N = int(lst[0])
M = int(lst[1])
X = int(lst[2])
L = input().split()

cost_0 = 0
for n in L:
   if 0 < int(n) < X:
      cost_0 += 1
   elif X < int(n):
      break

cost_N = 0
for n in L:
   if X < int(n) < N:
      cost_N += 1

print(min([cost_0, cost_N]))

n,m,x = map(int,input().split())
a = list(map(int,input().split()))
root0 = 0
rootn = 0
for i in range(1,x):
  if i in a:
    root0 += 1
for i in range(x+1,n+1):
  if i in a:
    rootn += 1
print(min(root0,rootn))

#-*-coding:utf-8-*-
import sys
input=sys.stdin.readline

def main():
    n,m,x = map(int,input().split())
    maps=[]
    maps=list(map(int,input().split()))
    dp=[0]*(n+1)
    left=0
    right=0

    for i in maps:
        dp[i]=1

    left = sum(dp[x:])
    right = sum(dp[:x])

    print(min(left,right))

def __starting_point():
    main()
__starting_point()

import sys
lines = [s.rstrip("\n") for s in sys.stdin.readlines()]
n, m, x = [int(num) for num in lines.pop(0).split(" ")]
a_list = [int(num) for num in lines.pop(0).split(" ")]

for i in range(m):
    if a_list[i] > x:
        break

ans = min(i, m - i)
print(ans)


total_square, total_toll_gate, current_square = map(int, input().split())
toll_gate_square = list(map(int, input().split()))
route1 = 0
route2 = 0
for i in range(total_toll_gate):
    if toll_gate_square[i] < current_square:
        route1 += 1
    else:
        route2 += 1
print(min(route1, route2))

# B - Toll Gates

# N M X
N, M, X = list(map(int, input().split()))
my_list = list(map(int, input().split(maxsplit=M)))
count_start = 0
count_goal = 0

# 0へ行くパターン
for i in range(1, X):
    if i in my_list:
        count_start += 1

for i in range(X, N):
    if i in my_list:
        count_goal += 1

if count_start >= count_goal:
    answer = count_goal
else:
    answer = count_start

print(answer)


n,m,x=map(int,input().split())
A=list(map(int,input().split()))
print(min(sum([a<x for a in A]),sum([a>x for a in A])))

n,m,x = map(int,input().split())
a=list(map(int,input().split()))
cnt1, cnt2 = 0, 0
for i in range(m):
  if 0 <= a[i] < x:
    cnt1 += 1
  if x < a[i] <= a[-1]:
    cnt2 += 1
print(min(cnt1, cnt2))

N, M, X = map(int, input().split())
A = list(map(int, input().split()))

X_high = 0
X_low = 0

for i in range(X, N + 1):
    if i in A:
        X_high += 1

for i in range(0, X + 1):
    if i in A:
        X_low += 1

print(min(X_high, X_low))

N,M,X=map(int,input().split())
Ai=list(map(int,input().split()))

goto_0=0
goto_N=0

for i in range(X,0,-1):
    if i in Ai:
        goto_0 += 1

for i in range(X,N):
    if i in Ai:
        goto_N += 1

print(min(goto_0,goto_N))

N, M, X = list(map(int, input().split()))
A = list(map(int, input().split()))
l1 = []
l2 = []

for i in A:
    if X > i:
        l1.append(i)
    else:
        l2.append(i)

print((min(len(l1), len(l2))))


def tool_gate(now: int, gate_list: list) -> int:
    back_count = sum(i < now for i in gate_list)
    forward_count = sum(i > now for i in gate_list)
    return min(back_count, forward_count)


def __starting_point():
    n, m, now = list(map(int, input().split()))
    gate_list = list(map(int, input().split()))
    print((tool_gate(now, gate_list)))

__starting_point()

n,m,x = map(int,input().split())
a =list(map(int,input().split()))
start = sum(i>x for i in a)
end = sum(i<x for i in a)
print(min(start,end))

import sys
input = sys.stdin.readline
 
N,M,X = map(int,input().split())
A = list(map(int,input().split()))
if A[int(M/2)] > X:
  b = [i for i in A if i < X]
else:
  for i in A[::-1]:
     b = [i for i in A if i > X]
  
print(min(len(b),M - len(b)))

# 数値の取得
last,fee,cur = map(int,input().split())
feesqu = list(map(int,input().split()))
total = len(feesqu)

# コストの最小値を出力
tcost = 0
gcost = 0
for cnt in range(0,total,1):
    if feesqu[cnt] < cur:
        tcost += 1
gcost = total - tcost
print(min(tcost,gcost))

N, M, X = list(map(int, input().split()))
a_point = list(map(int,input().split()))
lg = 0
sl = 0
for i in range(len(a_point)):
    if X < a_point[i]:
        lg  += 1
    else:
        sl += 1

if lg > sl:
    print(sl)
else:
    print(lg)


N, M, X = map(int,input().split())
fee = list(map(int,input().split()))
result_1 = []
result_2 = []

for i in fee:
    if i > X:
        result_1.append(i)
    else:
        result_2.append(i)

result = (min(len(result_1) ,len(result_2)))
print(result)

n,m,x=map(int,input().split())
a=list(map(int,input().split()))
ans=0
for i in a:
    if i<x:
        ans+=1
    else:
        break
print(min(ans,m-ans))

n, m, x = list(map(int, input().split()))
a_lst = list(map(int, input().split()))

cost1 = 0
cost2 = 0
for i in range(x, n+1):
  if i in a_lst:
    cost1 += 1
for i in range(x, -1, -1):
  if i in a_lst:
    cost2 += 1
print((min(cost1, cost2)))


import bisect


def answer(n: int, m: int, x: int, a: []) -> int:
    i = bisect.bisect_left(a, x)
    return min(i, len(a) - i)


def main():
    n, m, x = map(int, input().split())
    a = list(map(int, input().split()))
    print(answer(n, m, x, a))


def __starting_point():
    main()
__starting_point()

N, M, X = [int(i) for i in input().split()]
AS = [int(i) for i in input().split()]

cnt1 = 0
for i in range(0, X):
  if i in AS:
    cnt1 += 1

cnt2 = 0
for i in range(X+1, N+1):
  if i in AS:
    cnt2 += 1

print((cnt1 if cnt1 < cnt2 else cnt2))


# 入力
n, m, x = map(int, input().split())
a = list(map(int, input().split()))


goto_goal_0 = 0 # 0までのコスト
goto_goal_n = 0 # nまでのコスト

# x から 0 へ向かうコストを計算
for i in range(x - 1, 0, -1):   # x-1 番目から順番にデクリメントしながらforループ
    if i in a:
        goto_goal_0 += 1
        # print("0 is {}".format(goto_goal_0))

# x から n へ向かうコストを計算
for i in range(x, n + 1):   # x 番目から順番にインクリメントしながらforループ
    if i in a:
        goto_goal_n += 1
        # print("n is {}".format(goto_goal_n))

if goto_goal_0 < goto_goal_n:
    print(goto_goal_0)
else:
    print(goto_goal_n)

N, M, X = map(int,input().split())
A = map(int,input().split())

L = 0
R = 0

for ai in A:
    if ai < X:
        L = L + 1
    else:
        R = R + 1
print(min(L, R))

import sys
input = sys.stdin.readline
 
N,M,X = list(map(int,input().split()))
A = list(map(int,input().split()))
count = 0
if A[int(M/2)] > X:
  for i in A:
    if i < X:
      count += 1
    else:
      break
else:
  for i in A[::-1]:
    if i > X:
      count += 1
    else:
      break
  
print((min(count,M - count)))


N, M, X = map(int, input().split())
A = list(map(int, input().split()))

right = [int(i) for i in A if i > X]
left = [int(i) for i in A if i < X]

r = len(right)
l = len(left)

if r < l:
    print(r)

else:
    print(l)

a = [int(c) for c in input().split()]
N=a[0]
M=a[1]
X=a[2]
A = [int(c) for c in input().split()]
A2 = [0]*(N+1)
for i in range(M):
    A2[A[i]] = 1

cnt = X
cost1 = 0
while cnt < N+1:
    cost1+=A2[cnt]
    cnt+=1

cnt = X
cost2 = 0
while cnt > 0:
    cost2+=A2[cnt]
    cnt-=1

if cost1<cost2:
    print(cost1)
else:
    print(cost2)


a=input().split()
N=int(a[0])
M=int(a[1])
X=int(a[2])
ryokinjo=[]
b=input().split()
for i in range(len(b)):
  ryokinjo.append(int(b[i]))
count1=0
count2=0
for i in range(len(ryokinjo)):
  if ryokinjo[i]<X:
    count1+=1
  if ryokinjo[i]>X:
    count2+=1
print((min([count1,count2])))


a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
d=list(map(int,input().split()))
e=0
f=0
for i in range(b):
  if d[i]>c:
    e=e+1
  if d[i]<c:
    f=f+1
if e>f:
  print(f)
else:
  print(e)

N,M,X=map(int,input().split())
A=list(map(int,input().split()))
cnt=len([a for a,i in enumerate(A) if i>=X])
cnt=min(cnt,M-cnt)
print(cnt)

n, m, x = list(map(int, input().split()))
a = list(map(int, input().split()))
cnt1 = 0
cnt2 = 0
x1 = x
x2 = x

while x1 < n+1:
    x1 += 1
    if x1 in a:
        cnt1 += 1

while x2 > 0:
    x2 -= 1
    if x2 in a:
        cnt2 += 1



if cnt1 < cnt2:
    ans = cnt1
else:
    ans = cnt2

print(ans)


N,M,X=map(int,input().split())
Ai=list(map(int,input().split()))

goto_0=0
goto_N=0

for i in range(0,X):
    if i in Ai:
        goto_0 += 1

for i in range(X,N):
    if i in Ai:
        goto_N += 1

print(min(goto_0,goto_N))

n, m, x = map(int, input().split())
a = list(map(int, input().split()))

acc = [0] * (n + 1)
for i in a:
    acc[i] = 1
print(min(sum(acc[:x]), sum(acc[x:])))

num, count_station, my_position = list(map(int, input().split()))
a = list(map(int, input().split()))
station_list = list(a)
space = num + 1
first_me_cost = 0
last_me_cost = 0

distance_me_first = my_position
distance_me_last = num - my_position

for i in station_list:
    if 1 <= i <= my_position - 1:
        first_me_cost += 1

for i in station_list:
    if my_position + 1 <= i < num:
        last_me_cost += 1

if first_me_cost > last_me_cost:
    print(last_me_cost)
elif last_me_cost > first_me_cost:
    print(first_me_cost)
elif last_me_cost == first_me_cost:
    print(first_me_cost)


n,m,x=map(int,input().split())
a=list(map(int,input().split()))
c=x
ans=0
ans1=0
while c:
  ans+=c in a
  c-=1
while x<n:
  ans1+=x in a
  x+=1
print(min(ans,ans1))

N, M, X = list(map(int, input().split()))
A = list(map(int, input().split()))
B = sorted(A)
C = [0]*(N+1)
cnt_1 = 0
cnt_2 = 0

for i in range(M):
    C[B[i]] += 1

for j in range(1, N-X):
    cnt_1 += C[X+j]

for k in range(1, X+1):
    cnt_2 += C[X-k]

cnt = [cnt_1, cnt_2]

print((min(cnt)))


n,m,x = list(map(int,input().split()))
a = list(map(int,input().split()))
k = n-1
for i in range(m):
    if a[i] > x:
        k = i
        break
if k==0 or k==n-1:
    print('0')
    return
else:
    print((min(k,m-k)))


S_list = [input() for i in range(2)]
N, M, X= map(int,S_list[0].split())    
A_list = list(map(int,S_list[1].split()))

A_goal_N = [i for i in A_list if X < i and i < N]
A_goal_0 = [i for i in A_list if 0 < i and i < X]
result = min(len(A_goal_N),len(A_goal_0))
print(result)

N, M, X, *A = map(int, open(0).read().split())

l = [0] * N
for a in A:
    l[a-1] = 1

print(min(sum(l[:X]), sum(l[X:])))

n, m, x = list(map(int,input().split()))
a = list(map(int,input().split()))

goal_0 = 0
goal_1 = 0

for i in range(x,0,-1):
    if i in a:
        goal_0 += 1

for i in range(x,n+1,1):
    if i in a:
        goal_1 += 1

if goal_0 < goal_1:
    print(goal_0)
else:
    print(goal_1)


n,m,x=map(int,input().split())
a=list(map(int, input().split()))
p = 0
q = 0
for i in a:
    if i > x:
        p +=1
    elif i < x:
        q +=1
print(min(p,q))

#ABC094 B 3番目が通らない
n,m,x=map(int,input().split())
List=[int(i) for i in input().split()]
lcost=0
rcost=0
for a in List:
    if a<x:
        lcost+=1

for b in List:
    if b>x:
        rcost+=1
print(min(lcost,rcost))

n,m,x = list(map(int, input().split()))
a = list(map(int, input().split()))
c0 = 0
cN = 0
for A in a:
    if A > x:
        cN += 1
    elif A < x:
        c0 += 1
print(min(c0, cN))

# 094b

def atc_094b(NMX: str, Ai_input: str) -> int:
    N, M, X = list(map(int, NMX.split(" ")))
    Ai = [int(ai) for ai in Ai_input.split(" ")]

    up_cost = 0
    down_cost = 0

    for i in range(X + 1, N + 1):
        if i in Ai:
            up_cost += 1
    for i in range(X - 1, 0, -1):
        if i in Ai:
            down_cost += 1
    return min(up_cost, down_cost)


NMX_input_value = input()
Ai_input_value = input()
print((atc_094b(NMX_input_value, Ai_input_value)))


n, m, x = map(int, input().split())
a = list(map(int, input().split()))

def answer(n: int, m: int, x: int, a:list) -> int:
    left = 0
    right = 0
    for i in a:
        if i < x:
            left += 1
        else:
            right += 1
    return min(left, right)

print(answer(n, m, x, a))

N, M, X = map(int,input().split())
L = list(map(int,input().split()))
s = 0
b = 0
for i in L:
    if i > X:
        s += 1
    else:
        b += 1

if s >= b:
    print(b)
else:
    print(s)

N, M, X = list(map(int,input().split()))
S = list(map(int,input().split()))
Fees = list(S)
Goal1 = []
Goal2 = []
count1 = 0
count2 = 0
point0 = 0

for i in range(X):
    point0 += 1
    Goal1.append(point0)
# print(Goal1)

for j in range(N-X):
    X += 1
    Goal2.append(X)
# print(Goal2)

for fee in Fees:
    if fee in Goal1:
        count1 += 1
    if fee in Goal2:
        count2 += 1

if count1 >= count2:
    print(count2)
if count1 < count2:
    print(count1)
















# Fee = list(S)
# print(Fee)
# count1 = 0
# count2 = 0
# for i in range(N-X):
#     X += 1
#     if X in Fee:
#         count1 += 1
# print(X)
# for j in range(N):
#     X -= 1
#     if X in Fee:
#         count2 += 1
#
# if count1 <= count2:
#     print(count1)
# if count1 > count2:
#     print(count2)


n, m, x = map(int, input().split())

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

r = 0
l = 0

for i in a:
    if i > x:
        r += 1
    elif i < x:
        l += 1

print(min(l,r))

from bisect import bisect_left

def main():
    N, M, X = list(map(int, input().split()))
    A = list(map(int, input().split()))
    mid = bisect_left(A, X)
    l = len(A[:mid])
    r = len(A[mid:])
    print((min(l, r)))

def __starting_point():
    main()

__starting_point()

n, m, x = map(int, input().split())

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

r = 0
for i in range(x+1,n):
    for j in range(m):
        if i == a[j]:
            r += 1

l = 0
for i in range(x-1, -1, -1):
    for j in range(m):
        if i == a[j]:
            l += 1
        
print(min(l,r))


# 入力
n, m, x = list(map(int, input().split()))
a = list(map(int, input().split()))

goto_goal_0 = 0 # 0までのコスト
goto_goal_n = 0 # nまでのコスト

# x から 0 へ向かうコストを計算
for i in range(x - 1, 0, -1):   # x-1 番目から順番にデクリメントしながらforループ
    if i in a:
        goto_goal_0 += 1
        # print("0 is {}".format(goto_goal_0))

# x から n へ向かうコストを計算
for i in range(x, n + 1):   # x 番目から順番にインクリメントしながらforループ
    if i in a:
        goto_goal_n += 1
        # print("n is {}".format(goto_goal_n))

if goto_goal_0 < goto_goal_n:
    print(goto_goal_0)
else:
    print(goto_goal_n)


N, M, X = map(int, input().split())
A = sum(int(i) < X for i in input().split())
print(min(A, M - A))

import numpy as np

n, m, x = map(int, input().split())
a = list(map(int, input().split()))

a = np.array(a)

ans = min(len(a[a<x]), len(a[a>x]))
print(ans)

n,m,x = map(int,input().split())
a = list(map(int,input().split()))
i = 0
j = 0
for k in a:
    if k>x:
        i += 1
    elif k<x:
        j += 1
print(min(i,j))

n, m, x = map(int, input().split())
a = [int(s) for s in input().split()]

for i in range(m):
    if a[i] > x:
        less = len(a[:i])
        more = len(a[i:])
        print(min(less, more))
        break

N, M, X = map(int, input().split())
A = list(map(int, input().split()))

goal_N = 0
goal_0 = 0

for i in range(X, N + 1):
    if i in A:
        goal_N += 1

for i in range(0, X + 1):
    if i in A:
        goal_0 += 1

min_cost = min(goal_N,goal_0)

print(min_cost)

N, M, X = map(int, input().split())
A = [*map(int, input().split())]
l = [i < X for i in A]
r = [i > X for i in A]
print(l.count(False) if l.count(False) < r.count(False) else r.count(False))

n, m, x = list(map(int, input().split()))
am = list(map(int, input().split()))


class Solution:
    def __init__(self, n, m, x, am):
        self.n = n
        self.m = m
        self.x = x
        self.am = am

    def __make_list(self):
        list_n = [0] * n
        for i in self.am:
            list_n[i - 1] = 1
        return list_n

    def answer(self):
        list_n = self.__make_list()
        print((min(sum(list_n[:self.x - 1]), sum(list_n[x - 1:]))))


conditions = Solution(n, m, x, am)
conditions.answer()


n,m,x = map(int,input().split())
a = [int(s) for s in input().split()]
cost = []
count = 0

for i in range(x,n):
    if a.count(i) == 1:
        count += 1
cost.append(count)
count = 0
c = range(0,x)
for i in reversed(c):
    if a.count(i) == 1:
        count += 1
cost.append(count)
print(min(cost))

n,m,x=map(int, input().split())
a=list(map(int, input().split()))
mas=[0]*(n+1)
for i in a:
    mas[i]=1
print(min(sum(mas[0:x]),sum(mas[x:n+1])))

n, m, x = input().split()
list01 = input().split()
list02 = [int(a) for a in list01]
b = sum(c > int(x) for c in list02)
d = sum(e < int(x) for e in list02)
print(min(b, d))

N,M,X=list(map(int,input().split()))
A=list(map(int,input().split()))
sum1=0
sum2=0
for i in range(M):
    if A[i]<X:
        sum1+=1
    else:
        sum2+=1
print((min(sum1,sum2)))


import sys
n,m,x=map(int,input().split())
a=list(map(int,input().split()))

s=0
b=0
for i in a:
    if i<x:
        s+=1
    if i>x:
        b+=1
print(min(s,b))

from bisect import bisect_left
n, m, x, *a = list(map(int, open(0).read().split()))

b = bisect_left(a, x)
print((min(m - b, b)))


n,m,x = map(int,input().split())
lst = list(map(int, input().split()))

a_cost = 0
b_cost = 0
for i in lst:
    if i > x:
        a_cost += 1
    else:
        b_cost += 1
print(min(a_cost, b_cost))

N, M, X = map(int,input().split())
A = list(map(int,input().split()))

goal_N = 0
goal_0 = 0

for i in range(X, N + 1):
    if i in A:
        goal_N += 1

for i in range(0, X + 1):
    if i in A:
        goal_0 += 1

min_cost = min(goal_N,goal_0)

print(min_cost)

n, m, x = map(int, input().split())

back = 0
for a in map(int, input().split()):
    if a < x:
        back += 1
else:
    print(min(back, m - back))

N, M, X = map(int, input().split())
A = list(map(int, input().split()))

l_cost = 0
g_cost = 0

for i in A:
    if i > X:
      l_cost += 1
    else:
        g_cost += 1
        
print(min(l_cost, g_cost))

_, m, x = map(int, input().split())

back = 0
for a in map(int, input().split()):
    if a < x:
        back += 1
else:
    print(min(back, m - back))

N,M,X=list(map(int,input().split()))
A=list(map(int,list(input().split())))
countA=0
countB=0
for i in A:
    if i>X:
        countA+=1
    if i<X:
        countB+=1
if countA<countB:
    print(countA)
else:
    print(countB)


N, M, X = list(map(int, input().split()))
A = list(map(int, input().split()))
right = 0
left = 0

for a in A:
    if X > a:
        right += 1
    elif X < a:
        left += 1

print((min(right, left)))




n,m,x = map(int,input().split())
a = list(map(int,input().split()))

# 小さいほうの料金所の数
small_cost = 0
# 大きい方の料金所の数
big_cost = 0

# リストaの値とｘを比較して
for i in a:
    # ｘより小さいものをカウント
    if x > i:
        small_cost += 1
    # ｘより大きいものをカウント
    elif x < i:
        big_cost += 1
# 少ない方のカウントを出力
if small_cost <= big_cost:
    print(small_cost)
else:
    print(big_cost)

N, M, X = map(int, input().split())
cost_masses = map(int, input().split())

cost_ToZero = cost_ToEnd = 0

for cost_mass in cost_masses:
    if X < cost_mass:
        cost_ToEnd = cost_ToEnd + 1
    elif X > cost_mass:
        cost_ToZero = cost_ToZero + 1
else:
  print(min([cost_ToZero, cost_ToEnd]))

n, m, x = map(int,input().split())
l = 0
a = list(map(int,input().split()))
for j in a:
    l += 1 if j > x else 0
print(min(l,m-l))

# -*- coding:utf-8 -*-
N,M,X = list(map(int,input().split()))
A = list(map(int,input().split()))

A.append(X)
A.sort()

A_index = A.index(X)

len_bef = len(A[0:A_index])
len_aft = len(A[A_index+1:])
ans = len_bef

if len_bef > len_aft:
    ans = len_aft

print(ans)


N, M, X = map(int, input().split())
A = list(map(int, input().split()))
l1 = []
l2 = []

for i in A:
    if X > i:
        l1.append(i)
    else:
        l2.append(i)

print(min(len(l1), len(l2)))

def mapt(fn, *args):
    return tuple(map(fn, *args))


def Input():
    return mapt(int, input().split(" "))


def main():
    n, m, x = Input()
    a = [0] * n
    for i in Input():
        a[i-1] = 1

    print(min(sum(a[:x]), sum(a[x-1:])))


main()

n,m,x = map(int,input().split())
a = list(map(int,input().split()))
ans = 0

for i in range(m):
    if a[i] > x:
        if i < m-i: ans = i
        else      : ans = m-i
        break
print(ans)

#!/usr/bin/env python3

def main():
    n, m, x = list(map(int, input().split()))
    a = list(map(int, input().split()))
    for i in range(m):
        if a[i] > x:
            ans = min(i, len(a) - i)
            break
    else:
        ans = 0
    print(ans)


def __starting_point():
    main()

__starting_point()

N, M, X = list(map(int, input().split()))
A = list(map(int, input().split()))

for i , a in enumerate(A):
    if X < a:
        break

if i > len(A) / 2:
    ans = len(A[i:])
else:
    ans = len(A[:i])

print(ans)


n,m,x = map(int,input().split())
a = list(map(int,input().split()))
data = [0]*(n + 1)
cost_1 = 0
cost_2 = 0
for i in range(m):
    data[a[i]] = 1
for i in range(0,x):
    cost_1 += data[i]
for j in range(x,n):
    cost_2 += data[j]
print(min(cost_1,cost_2))

# 全体のマスを開始位置でスライス、料金所だけ抽出し、要素の個数で条件分岐
N, M, X = list(map(int, input().split()))
A = list(map(int, input().split()))

square = list(range(0, N + 1))

a = square[:X + 1]
b = square[X:]

a_costs = []
b_costs = []

for i in a:
    if i in A:
        a_costs.append(i)
for i in b:
    if i in A:
        b_costs.append(i)

a_cost = len(a_costs)
b_cost = len(b_costs)

if a_cost > b_cost:
    print(b_cost)
else:
    print(a_cost)


n,m,x = map(int,input().split())
a = list(map(int,input().split()))
a.append(x)
a = sorted(a)
print(len(a[:a.index(x)]) if len(a[:a.index(x)+1]) <= len(a[a.index(x)+1:]) else len(a[a.index(x)+1:]))

n,m,x = map(int,input().split())
li = list(map(int,input().split()))
cnt = 0
cou = 0
for i in range(x):
    if i in li:
        cnt += 1
for i in range(x,n):
    if i in li:
        cou += 1
print(min(cnt,cou))

n,m,s = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]

low = 0
high = 0
for i in range(m):
  if a[i] < s:
    low += 1
  else:
    high += 1
print(min(low,high))

N, M, X = list(map(int,input().split()))
A = list(map(int, input().split())) 

zero_goal = 0
N_goal = 0

for i in A:
    if i < X:
        zero_goal = zero_goal + 1
    else:
        N_goal = N_goal + 1
print((min(zero_goal, N_goal)))


n, m, x = list(map(int, input().split()))
am = list(map(int, input().split()))
list_n = [0] * n
for i in am:
    list_n[i - 1] = 1
print((min(sum(list_n[:x - 1]), sum(list_n[x - 1:]))))


n, m, x = list(map(int, input().split()))
a = list(map(int, input(). split()))

goto_goal_0 = 0
goto_goal_n = 0

for i in range(x, 0, -1):
    if i in a:
        goto_goal_0 += 1


for i in range(x, n + 1, 1):
    if i in a:
        goto_goal_n += 1

if goto_goal_0 < goto_goal_n:
    print(goto_goal_0)
else:
    print(goto_goal_n)



N, M, X = map(int, input().split())
A = list(map(int, input().split()))

cost_0 = 0
cost_last = 0

for n in A:
  if n > X:
    cost_last += 1
  elif n < X:
    cost_0 += 1


if cost_0 >= cost_last:
  print(cost_last)
elif cost_0 < cost_last:
  print(cost_0)

n,m,x = list(map(int,input().split()))
l = [0]*n
a = list(map(int,input().split()))
for i in a:
    l[i-1] = 1

left = sum(l[:x])
right = sum(l[x-1:len(l)])

print((left if left<=right else right))


n,m,x = list(map(int,input().split()))
a = list(map(int,input().split()))
ans = 0
ans = min(sum(1 for i in a if i > x),sum(1 for i in a if i < x))
print(ans)




N, M, X = map(int, input().split())
A = list(map(int, input().split()))

A.sort()

import bisect
idx = bisect.bisect(A, X)

ans_r = len(A[idx:])
ans_l = len(A[:idx])

ans = min(ans_l, ans_r)
print(ans)

n, m, x = list(map(int, input().split()))
squares = list(map(int, input().split()))

left_cost = 0
right_cost = 0
for square in squares:
    if square < x:
        left_cost = left_cost + 1
    else:
        right_cost = right_cost + 1

print((min(right_cost, left_cost)))


n, m, x = map(int, input().split())
a_l = list(map(int, input().split()))

for i, a in enumerate(a_l):
    if x < a:
        break
if i > len(a_l)/2:
    ans = len(a_l[i:])
else:
    ans = len(a_l[:i])
print(ans)

n, m, x = list(map(int, input().split()))
arr = list(map(int, input().split()))

mn = 0
l_cost = 0
r_cost = 0

# Calculate left cost
for i in range(x):
    if i in arr:
        l_cost += 1

# Calculate right cost
for i in range(x, n + 1):
    if i in arr:
        r_cost += 1

print((min(l_cost, r_cost)))


n,m,x=map(int,input().split())
a=list(map(int,input().split()))
k=[0]*(n+1)
for i in a:k[i]=1
print(min(sum(k[0:x+1]),sum(k[x:n+1])))