Problem:
 Score: 200 points    Problem Statement A country decides to build a palace.  In this country, the average temperature of a point at an elevation of x meters is T-x \times 0.006 degrees Celsius.  There are N places proposed for the place. The elevation of Place i is H_i meters.  Among them, Princess Joisino orders you to select the place whose average temperature is the closest to A degrees Celsius, and build the palace there.  Print the index of the place where the palace should be built.  It is guaranteed that the solution is unique.      Constraints  1 \leq N \leq 1000  0 \leq T \leq 50  -60 \leq A \leq T  0 \leq H_i \leq 10^5  All values in input are integers.  The solution is unique.         Input Input is given from Standard Input in the following format:  N  T  A  H_1  H_2  ...  H_N       Output Print the index of the place where the palace should be built.        Sample Input 1 2
12 5
1000 2000      Sample Output 1 1   The average temperature of Place 1 is 12-1000 \times 0.006=6 degrees Celsius.  The average temperature of Place 2 is 12-2000 \times 0.006=0 degrees Celsius.   Thus, the palace should be built at Place 1 .       Sample Input 2 3
21 -11
81234 94124 52141      Sample Output 2 3

Solution (Python):
n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
diff = []
for i in range(n):
    diff.append(abs(t - h[i] * 0.006 - a))
print(diff.index(min(diff)) + 1)

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

kion = [abs(a-(t-i*0.006)) for i in h]

print(kion.index(min(kion))+1)

Solution (Python):
n=int(input())
u=.006
t,a=map(int,input().split())
h=list(map(int,input().split()))
lst=[]
for i,j in enumerate(h):
    lst.append(abs(t-u*j-a))
print(lst.index(min(lst))+1)

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

mi = 100000
idx = 1000

for i in range(N):
    temp = T - H[i]*0.006
    diff = abs(temp-A)
    if diff < mi :
        mi = diff
        idx = i+1
        
print(idx)

Solution (Python):

n = int(input())
t, a = map(int, input().split(' '))
H = [int(el) for el in input().split(' ')]

B = []
for i in range(n):
    B.append(abs((t - H[i]*0.006) - a))
print(B.index(min(B))+1)

Solution (Python):
def temp(x, t):
  return t - x * 0.006

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

dt = abs(a - temp(h[0], t))
di = 0
for i in range(n):
  ti = temp(h[i], t)
  dti = abs(a - ti)
  if dti < dt:
    dt = dti
    di = i
print(di+1)

Solution (Python):
n = int(input())
l = [int(i) for i in input().split(" ")]
t = l[0]
a = l[1]
diff_list = [abs(t-int(i)*0.006-a) for i in input().split(" ")]
print(diff_list.index(min(diff_list))+1)

Solution (Python):
import sys
from collections import deque

sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def solve(inputs):
    N = int(inputs[0])
    [T, A] = string_to_int(inputs[1])
    H = string_to_int(inputs[2])

    min_diff = -1
    min_diff_i = -1
    for i, h in enumerate(H):
        t = T - h * 0.006
        diff = abs(A-t)
        if min_diff == -1 or diff < min_diff:
            min_diff = diff
            min_diff_i = i
    return min_diff_i + 1


def string_to_int(string):
    return list(map(int, string.split()))


if __name__ == "__main__":
    ret = solve(inputs(3))
    print(ret)

Solution (Python):
N = int(input())
T, A = map(int, input().split())
lst = list(map(int, input().split()))
diff = 10 ** 5
ans = 0
for i, k in enumerate(lst):
    tmp = T - k* 0.006
    if (abs(tmp - A) < diff):
        diff = abs(tmp - A)
        ans = i + 1
print(ans)

Solution (Python):
N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))
ans = 0
for i in range(N):
    diff = abs(A - (T-H[i]*0.006))
    if i == 0:
        temp = diff
        ans = i+1
    else:
        if diff < temp:
            temp = diff
            ans = i+1

print(ans)

Solution (Python):
n = int(input())
t,a = list(map(int,input().split()))
h = list(map(int, input().split()))
ans = 1000000000
okok = 0

for i in range(0,n):
  if(ans > abs(a-(t-h[i]*0.006))):
    ans = abs(a-(t-h[i]*0.006))
    okok = i+1

print(okok)

Solution (Python):

n=int(input())
temp,a=map(int,input().split())
hs=map(int,input().split())

t=list(map(lambda h: temp-h*0.006, hs))
t=list(enumerate(t,1))

def solve(best,a,t):
    if not t:
        return best[0]
    if abs(best[1] - a) < abs(t[0][1] - a):
        return solve(best, a, t[1:])
    else:
        return solve(t[0],a,t[1:])

min_diff = 100000000
res = 0
for i in range(len(t)):
    if min_diff > abs(t[i][1] - a):
        min_diff = abs(t[i][1] - a)
        res = i + 1


print(res)

Solution (Python):
n=int(input())
t,a=map(int,input().split())
h=list(map(int,input().split()))
l=[]
q=[]
for i in range(n):
    l.append(t-h[i]*0.006)
    q.append(abs(l[i]-a))

ans=0
b=10**20
for i in range(n):
    if q[i]<=b:
        b=q[i]
        ans=i+1

print(ans)

Solution (Python):
N=int(input())
T,A=map(int,input().split())
ans,d=-1,10**9
H=list(map(int,input().split()))
for i in range(N):
    x=T-H[i]*0.006
    if abs(A-x)<=d:
        ans=i
        d=abs(A-x)
print(ans+1)

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

temp = [0] * N
temp_A = [0] * N
for i in range(N):
    temp[i] = T - H[i] *0.006
    temp_A[i] = A - temp[i]
    if temp_A[i] <= 0:
        temp_A[i] = - temp_A[i]

print(temp_A.index(min(temp_A)) + 1)

Solution (Python):
N = int(input())
T, A = list(map(int, input().split()))
V = [abs(T-int(h)*0.006-A) for h in input().split()]
m = min(V)
for i,v in enumerate(V):
    if v==m:
        print(i+1)
        break

Solution (Python):
    
def main():

    N = int(input())
    T,A = map(int,input().split())
    H = list(map(int,input().split()))
    ans = [abs(A-(T - H[i]*0.006)) for i in range(N)]
    print(ans.index(min(ans))+1)
    
    


if __name__== "__main__":
    main()

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

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

degrees=[]

for i in can:
    degrees.append(t-i*0.006)



ans=[]

for j in degrees:
    ans.append(abs(j-a))



print(ans.index(min(ans))+1)

Solution (Python):
import math
n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
place_list = []
ans = []

for num in h:
  place = t - num*0.006
  place_list.append(place)

for num in place_list:
  i = math.fabs(a - num)
  ans.append(i)
  
print(ans.index(min(ans)) + 1)

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

for i in range(N):
    H[i] = T - H[i] * 0.006

c = 10**9
for j in range(N):
    if abs(H[j]-A) <= c:
        ans = j+1
        c = abs(H[j]-A)
        
print(ans)

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

ans=-1
ansT=-1000000000

for i in range(N):
  if abs(ansT-A)>(abs(T-H[i]*0.006-A)):
    ans=i+1
    ansT=T-H[i]*0.006

print(ans)

Solution (Python):
N = int(input())
T,A = map(int , input().split())
H = [int(k) for k in input().split()]

l = []
for i in range(N):
  tem = abs(T - H[i] * 0.006 - A)
  l.append(tem)

ans = l.index(min(l)) + 1
print(ans)

Solution (Python):
n = int(input())
T, A = map(int,input().split())
H = list(map(int, input().split()))
tempara = []
sa = []
for i in range(n):
    tempara.append(T - H[i] * 0.006)
    sa.append(abs(A - tempara[i]))
print(sa.index(min(sa)) + 1)

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

temp_li = [abs(a - (t - i * 0.006)) for i in li]
print(temp_li.index(min(temp_li))+1)

Solution (Python):
n=int(input())
t,a=map(int,input().split())
h=list(map(int,input().split()))
min=10000 
ans=0

for i in range(n):
    temp=t-h[i]*0.006
    
    c=abs(temp-a)
    if c<min:
        ans=i+1
        min=c
        
print(ans)

Solution (Python):
N = int(input())
T, A = map(int, input().split())
Hs = list(map(int, input().split()))

index = -1
min_temp = 10**9
for i in range(N):
  now_temp = abs(T-Hs[i]*0.006-A)
  if min_temp > now_temp:
    min_temp = now_temp
    index = i+1
print(index)

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

ans = 0
diff = 100000
for i in range(n):
    if abs(t - h[i] * 0.006 - a) < diff:
        ans = i + 1
        diff = abs(t - h[i] * 0.006 - a)

print(ans)

Solution (Python):
n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
b = [(t - h[i] * 0.006) for i in range(n)]
m = min(b, key=lambda x: abs(x - a))
print(b.index(m) + 1)

Solution (Python):
import numpy as np

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

res=[0]*n
for i in range(n):
	res[i]=abs(h-0.006*x[i]-t)

print(int(np.argmin(res)+1))

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")


def A():
    x, y = LI()
    print(x+y//2)
    return


def B():
    II()
    t, a = LI()
    h = LI()
    ans = [0,inf]
    for num, i in enumerate(h):
        if ans[1] > abs(t - a - i * 0.006):
            ans = [num, abs(t - a - i * 0.006)]
    print(ans[0] + 1)
    return


def C():
    n, m = LI()
    py = LIR(m)
    pya = py[::1]
    py.sort(key=lambda x: x[1])
    city = [1 for i in range(n)]
    dicity = {}
    for p, y in py:
        dicity[(p,y)] = city[p-1]
        city[p-1] += 1    
    for p, y in pya:
        a = "00000" + str(p)
        a = a[-6:]
        b = "00000" + str(dicity[(p, y)])
        b = b[-6:]
        print(a+b)

    return


def D():
    return


if __name__ == '__main__':
    B()

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

min_temp = float('inf')
ans = None
for i in range(N):
    temp = abs(A - (T - H[i] * 0.006))
    if min_temp > temp:
        min_temp = temp
        ans = i
print(ans + 1)

Solution (Python):
N = int(input())
T,A  =[int(i) for i in input().split()]
H = [int(i) for i in input().split()]
diff = (abs(A-(T-H[0]*0.006)))
palace = 0
for i in range(len(H)):
    if(abs(A-(T-H[i]*0.006)) < diff):
        palace = i
        diff = abs(A-(T-H[i]*0.006))
print(palace+1)

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

min_diff = float('inf')
min_index = None
for i, h in enumerate(H):
    ave_temp = T - h * 0.006
    diff = abs(ave_temp - A)
    if diff < min_diff:
        min_diff = diff
        min_index = i
print(min_index + 1)

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

li = []
for i in range(n):
    li.append(abs(a-(t-(h[i]*0.006))))

print(li.index(min(li))+1)

Solution (Python):
N = int(input())
T, A = map(int, input().split())
hLst = list(map(int, input().split()))

ans = 0
tmp = 1000000000
for i in range(N):
    ansTmp = abs(A - (T - (hLst[i] * 0.006)))
    if tmp >= ansTmp:
        ans = i + 1
        tmp = ansTmp

print(ans)

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

ans = 0
min_diff = 10**5
for i in range(N):
  if abs((T - H[i]*0.006) - A) < min_diff:
    ans = i+1
    min_diff = abs((T - H[i]*0.006) - A)
print(ans)

Solution (Python):
N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))
tempwithindex = []
for i in range(0, N):
	tempwithindex.append([i+1, T-0.006*H[i]])
tempwithindex.sort(key = lambda v: abs(A-v[1]))
print(tempwithindex[0][0])

Solution (Python):
n = int(input())
t,a = map(int, input().split())
h = list(map(int,input().split()))
t_list=[]
for i in range(n):
  t_list.append(abs(t-h[i]*0.006-a))
print(t_list.index(min(t_list))+1)

Solution (Python):
n = int(input())
t, a = map(int, input().split(" "))
hs = list(map(int, input().split(" ")))
hs = [ abs(a - (t - h * 0.006)) for h in hs ]
print(hs.index(min(hs)) + 1)

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

res = float("inf")
ans = 0

for i in range(n):
    t = T - h[i]*0.006
    
    if abs(t-A) < abs(res-A):
        res = t
        ans = i+1

print(ans)

Solution (Python):
N = int(input())
T, A = map(int, input().split())
a = list(map(int, input().split()))

answers = []

for j in a:
  a_2 = T - j * 0.006
  answer = abs(A - a_2)
  answers.append(answer)

min_answer = min(answers)
index_number = answers.index(min_answer)
print(index_number +1)

Solution (Python):
n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
m = float("INF")
num = 0
for i in range(n):
    if abs(t - h[i] * 0.006 - a) < m:
        num = i
        m = abs(t - h[i] * 0.006 - a)

print(num + 1)

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

B=999999999999999
X=0
for i in range(N):
  if B>abs((T-H[i]*0.006)-A):
    X=i+1
    B=min(abs((T-H[i]*0.006)-A),B)

print(X)

Solution (Python):
n = int(input())
t,a = map(int, input().split())
ls = list(map(int, input().split()))
res = float('inf')

for i in range(n):
    tmp = t - ls[i] * 0.006
    if res > abs(a-tmp):
        res = abs(a-tmp)
        ans = i + 1
print(ans)

Solution (Python):
n=int(input())
t,a=[int(i) for i in input().split()]
h=[t-int(i)*0.006 for i in input().split()]
ans=0
for i in range(n):
  if abs(a-h[i])<abs(a-h[ans]):
    ans=i
print(ans+1)

Solution (Python):
import numpy as np
N=int(input())
T,A=map(int,input().split())
H=np.array(list(map(int,input().split())))
Tnp=abs(T-H*0.006-A)
print(np.argmin(Tnp)+1)

Solution (Python):
a = int(input())
b, c = map(int, input().split())
d = list(map(int, input().split()))
e = []
for i in range(a):
    e.append([abs((b - d[i] * 0.006) - c), i+1])
e.sort()
print(e[0][1])

Solution (Python):
n = int(input())
t, a = map(int, input().split())
h = [abs(t - int(x) * 0.006 - a) for x in input().split()]
print(h.index(min(h))+1 )

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

min_index,min_diff = -1,10**10
for i,h in enumerate(hlist):
  diff=abs(A-(T-h*0.006))
  if diff<min_diff:
    min_index,min_diff = i+1,diff
    
print(min_index)

Solution (Python):
'''
allinputs = iter(input().splitlines())
input = lambda : next(allinputs)

N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))
deviation_temperature = float('inf')
candidate_cite = -1

for i in range(N):
	tmp = T - H[i] * 0.006
	if abs(tmp - A) < deviation_temperature:
		deviation_temperature = abs(tmp - A)
		candidate_cite = i + 1
		
print(candidate_cite)

Solution (Python):
import numpy as np

N = int(input())
lis = [int(i) for i in input().split()]
height = np.array([int(i) for i in input().split()])

temperature = [abs(lis[1] - (lis[0] - 0.006*i)) for i in height]

print(temperature.index(min(temperature)) + 1)

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

ans=[]


for i in range(len(H)):
    relay=(abs(A-(T-H[i]*0.006)))
    ans.append([i+1,relay])
    ans=sorted(ans,key=lambda x:x[1])
    
print(ans[0][0])

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

D = -1
for i, h in enumerate(H):
    tem = abs(T - h * 0.006 - A)

    if tem < D or i == 0:
        D = tem
        ans = i + 1
print(ans)

Solution (Python):
def resolve():
    n=int(input())
    t,a=map(int,input().split())
    h=list(map(int,input().split()))
    temp=[abs(a-(t-i*0.006)) for i in h]
    m=min(temp)
    print(temp.index(m)+1)
resolve()

Solution (Python):
import sys
import numpy as np

N = int(input())
T, A = list(map(int, input().split()))
H = np.array(list(map(int, input().split())))

m = abs(A - (T - 0.006 * H[0]))
num = 1

for n in range(1, N):
    d = abs(A - (T - 0.006 * H[n]))
    if d < m:
        m = d
        num = n+1

print(num)

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

temp_abs_list = [abs((T - h * 0.006) -A) for h in H]

print(temp_abs_list.index(min(temp_abs_list)) +1)

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

m = [abs(t-x*0.006-a) for x in l]

print(m.index(min(m)) + 1)

Solution (Python):
n = int(input())
t, a = map(int, input().split())
h_list = list(map(int, input().split()))
min = 10 ** 10
nearest = 0

for i in range(1, n+1):
    temp = t - h_list[i - 1]*0.006
    if abs(a - temp) < min:
        min = abs(a - temp)
        nearest = i

print(nearest)

Solution (Python):
n = int(input())
t,a = map(int, input().split())
h = list(map(int, input().split()))
height = [abs(t - x*0.006 - a) for x in h]
print(height.index(min(height)) + 1)

Solution (Python):
n=int(input())
t,a=map(int,input().split())
h=[int(x) for x in input().split()]
new=[]
for i in range(n):
  temp=t-h[i]*0.006
  new.append(temp)
new2=[]
for j in range(n):
  sub=abs(a-new[j])
  new2.append(sub)
num=min(new2)
print(new2.index(num)+1)

Solution (Python):
import numpy as np
a = int(input())
b = list(map(int,input().split()))
c = np.array(input().split(),dtype=np.int)
d = np.abs(b[0]-0.006*c-b[1])
print(np.argmin(d)+1)

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

min = 1000000
min_index = -1
for i, h in enumerate(H):
    v = abs(A-(T-h*0.006))
    if v < min:
        min = v
        min_index = i
print(min_index+1)

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

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

i = 0
x = 65536

for t in [T - height * 6 / 1000 for height in h]:
  i += 1
  if abs(t-a) < x:
    x = abs(t-a)
    ans = i

print(ans)

Solution (Python):



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

mi = float('inf')
for i in range(n):
    if mi > abs(a-(t-h[i]*0.006)):
        mi = abs(a-(t-h[i]*0.006))
        ans = i
print(ans+1)

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

dif=1000000000000
ans=1
for i in range(n):
    ttt=t-0.006*h[i]
    if abs(ttt-a)<dif:
        dif=abs(ttt-a)
        ans=i+1
print(ans)

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

mn = 10**10
for i in range(n):
    if mn > abs(a - (t - h[i] * 0.006)):
        mn = min(mn, abs(a - (t - h[i] * 0.006)))
        ans = i+1
print(ans)

Solution (Python):
N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))
absss = 100000
ans = 0
for i,h in enumerate(H):
    if abs((T - h * 0.006) - A) < absss:
        ans = i + 1
        absss = abs((T - h * 0.006) - A)
print(ans)

Solution (Python):
n = input()
t, a = map(int, input().split())
H = map(int, input().split())

temp = [(i + 1, abs(a - (t - h * 0.006))) for i, h in enumerate(H)]
i = min(temp, key=lambda v: v[1])[0]
print(i)

Solution (Python):
n=int(input())
t,a=map(int,input().split())
h=list(map(int,input().split()))
cnt=0
ans_min=999
for i in h:
    cnt = cnt+1
    mean=t-i*0.006
    ans = abs(a-mean)
    
    if ans<=ans_min:
        ans_min=ans
        cnt_ans=cnt
print(cnt_ans)

Solution (Python):
from operator import itemgetter
n = int(input())
t, a = list(map(int, input().split()))
hl = list(map(int, input().split()))
dil = [[abs(t-hl[i]*0.006-a),i] for i in range(n)]
dil.sort(key=itemgetter(0))
print(dil[0][1]+1)

Solution (Python):
a = int(input())
b, c = map(int, input().split())
d = list(map(int, input().split()))
e = []
for i in range(a):
    f = b - d[i] * 0.006
    e.append([i+1, abs(f-c)])
e = sorted(e, key=lambda x: x[1])
print(e[0][0])

Solution (Python):
n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
mean_temp = [t-i*0.006  for i in h]
abs_temp = [abs(a-i) for i in mean_temp]
min_index = abs_temp.index(min(abs_temp))
print(min_index+1)

Solution (Python):
N = int(input())
T, A = map(int, input().split())
h = list(map(int, input().split()))
ans = [abs(A - (T - h[i] * 0.006)) for i in range(N)]
print(ans.index(min(ans)) + 1)

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



p = []
for i in ls:
  p.append(abs(a - (t - i * 0.006)))

print(p.index(min(p)) + 1)

Solution (Python):
n = int(input())
t, a = map(int, input().split())
t_mean_list = list(map(int, input().split()))
t_diff_list = list(map(lambda x: abs(t - x * 0.006 - a), t_mean_list))
 
print(t_diff_list.index(min(t_diff_list)) + 1)

Solution (Python):







N = int(input())
T, A = map(int, input().split())
H = input().split()
h = list(map(int, H))
tans = T - 0.006*h[0]
for i in range(N):
    tmp = T - 0.006*h[i]
    if abs(A - tmp) <= abs(A - tans):
        tans = tmp
        ans = i+1
print(ans)

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

check = float('inf')
ans = 0
for i in range(n):
    if check > abs(a - t + 0.006 * h[i]):
        ans = i + 1
        check = abs(a - t + 0.006 * h[i])
print(ans)

Solution (Python):
n = int(input())

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

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

def temp(t, h):
    return t - h * 0.006



dif = [abs(a - temp(t, i)) for i in h]

print(dif.index(min(dif))+1)

Solution (Python):
N = int(input())
T, A = map(int, input().split())
H = [int(x) for x in input().split()]
temperature = 0
ans = 0
diff = 10**6
for place in range(N):
    temperature = T-H[place]*0.006
    kari_diff = abs(A - temperature)
    if diff > kari_diff:
        diff = kari_diff
        ans = place + 1
print(ans)

Solution (Python):
n = int(input())
t,a = map(float,input().split(" "))
l=[]
l=input().split(" ")
indx=0
min=1000000.0
for i in range(0,n):
	val = t-int(l[i])*(0.006)
	if(val>a):
		val=val-a
	else:
		val=a-val
	if(val<min):
		min=val
		indx=i+1
print(indx)

Solution (Python):
N = int(input())
row = input().split()
T = int(row[0])
A = int(row[1])
H = input().split()
H = list(map(int, H))

for i in range(N):
    H[i] = abs(T - H[i] * 0.006 - A)
print(H.index(min(H))+1)

Solution (Python):
n=int(input())
t,a=map(int,input().split())
count=0
h=list(map(int,input().split()))
for i in range(n):
    T=t-h[i]*0.006
    h[i]=abs(T-a)
print(h.index(min(h))+1)

Solution (Python):


n = int(input())
t, a = map(int, input().split())
heights = list(map(int, input().split()))

tempertures = [t - 0.006 * height for height in heights]
temp_diff = [abs(temperture - a) for temperture in tempertures]

minimum_diff_point = 0

for i, diff in enumerate(temp_diff):
    if diff < temp_diff[minimum_diff_point]:
        minimum_diff_point = i

print(minimum_diff_point + 1)

Solution (Python):
n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
absolute = 9999
ans = 0
for i in range(n):
    tmp = abs(a - (t - h[i] * 0.006))
    if tmp < absolute:
        absolute = tmp
        ans = i + 1
print(ans)

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


ans = 0
for i in range(N):
    if i == 0:
        palce = T - H[i] * 0.006
        ans = i+1
    else:
        palce_2 = T - H[i] * 0.006
        if (palce-A)**2 > (palce_2-A)**2:
            palce = T - H[i] * 0.006
            ans = i+1

print(ans)

Solution (Python):
candidates = input()
T, A = map(int, input().split())
heights = input().split()
ans = []
for i in range(len(heights)):
    if T - int(heights[i])*0.006 >= A:
        ans.append((T - int(heights[i])*0.006) - A)
    else:
        ans.append(A - (T - int(heights[i])*0.006))
answer = ans.index(min(ans))
print(answer + 1)

Solution (Python):
N=int(input())
T,A=map(int,input().split())
H=list(map(int,input().split()))
HH=[abs(A-(T-h*0.006))for h in H]
print(int(HH.index(min(HH))+1))

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

H = [abs(A - T + h * 0.006) for h in H]

print(H.index(min(H)) + 1)

Solution (Python):
N=int(input())
T,A=map(int,input().split())
H=[int(i) for i in input().split()]
tlist=[]
for i in range(N):
    tlist.append(float(T-H[i]*0.006))
ans=1
for i in range(1,N):
    if abs(tlist[i]-A)<abs(tlist[ans-1]-A):
        ans=i+1
    if tlist[i]-A==0:
        break

print(ans)

Solution (Python):
import numpy; input(); t,a=map(int,input().split())
h=list(map(lambda x: abs(a-(t-int(x)*0.006)),input().split()))
print(numpy.argmin(h)+1)

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

ans = 0
for i in range(n):
    tmp = t - lst[i]*0.006
    dst = abs(a-tmp)
    if i == 0:
        val = dst
    elif dst < val:
        ans = i
        val = dst
print(ans+1)

Solution (Python):
n=int(input())
t,a=map(int,input().split())
h=map(int,input().split())
d_list = [t-0.006*i-a for i in h]
print(d_list.index(sorted(d_list,key=abs)[0])+1)

Solution (Python):
N=int(input())
T, A=map(int, input().split())
N=list(map(int,input().split()))
temp1=list(map(lambda x: (T-0.006*x),N))
temp=list(map(lambda x: abs(A-(T-0.006*x)),N))
print(temp.index(min(temp))+1)

Solution (Python):
n = int(input())
t,a = map(int, input().split())
h = list(map(int, input().split()))
tem=[]
for i in range(n):
    tem.append(abs((t-h[i]*0.006)-a))

print(tem.index(min(tem))+1)

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

x = [abs((t-i*0.006)-a) for i in h]
print(x.index(min(x))+1)

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


min = 10000
mini = 0

for i, x in enumerate(h):
  val = T - x*0.006
  gap = abs(A-val)
  if gap < min:
    min = gap
    mini = i

print(mini+1)

Solution (Python):
n = int(input())
t,a = map(int,input().split())
h = list(map(int,input().split()))
l = [abs(t-i*0.006-a) for i in h]
print(l.index(min(l))+1)

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

avg = [T-H[i]*0.006 for i in range(N)]

diff = 10**9
for i in range(N):
    temp = abs(avg[i]-A)
    if temp<diff:
        diff = temp
        idx = i+1
        
print(idx)

Solution (Python):
N = int(input())
T,A = map(int,input().split())
H = list(map(int,input().split()))
B = list(range(N))
def Temp(x):
  Temp = T-0.006*x
  return(Temp)
for i in range(N):
  B[i] = abs(Temp(H[i])-A)
ans = min(B)
print(B.index(ans)+1)

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

temp = [0 for i in range(N)]

for i in range(N):
    temp[i] = T - H[i] * 0.006

dist = 10000000
num = 0
for i in range(N):
    if dist > abs(temp[i] - A):
        dist = abs(temp[i] - A)
        num = i

print(num+1)

Solution (Python):
def main():
    N = int(input())
    T, A = map(int, input().split())
    H = list(map(int, input().split()))
    ans = 0
    min_diff = 1000
    for i in range(N):
        temp = T - H[i] * 0.006
        diff = abs(A - temp)
        if diff < min_diff:
            min_diff = diff
            ans = i + 1
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np
N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))

d = [A - (T - 0.006 * h) for h in H]
dd = np.abs(d)

print(np.argmin(dd) + 1)

Solution (Python):
N = int(input())
T,A = map(int, input().split())
H = list(input().split())
L = []

for i in range(N):
    point = T - int(H[i]) * 0.006
    focus_point = A - point
    L.append(abs(focus_point))

print(L.index(min(L))+1)

Solution (Python):
import numpy as np

n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
h = np.array(h)
h = t - (h * 0.006)
h_best_idx = np.argmin(abs(h - a))

print(h_best_idx + 1)

Solution (Python):
n = int(input())
t, a = list(map(int, input().split()))
h = list(map(int, input().split()))
cur = 1e9
idx = 0
for i in range(n):
  if abs(a-(t-h[i]*0.006))<cur:
    cur = abs(a-(t-h[i]*0.006))
    idx = i+1
print(idx)

Solution (Python):
INF = float("inf")
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

N = n()
T, A = nl()
Hs = nl()

min_i = -1
min_diff = INF
for i in range(N):
    diff = abs(A - (T - Hs[i] * 0.006))
    if diff < min_diff:
        min_diff = diff
        min_i = i
print(min_i+1)

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, d=DVSR): return pow(x, d - 2, d)
def DIV(x, y, d=DVSR): return (x * INV(y, d)) % d
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())


N=II()
T,A=LI()
INL=LI()

res = float(INTMAX)
name = 0
for i, h in enumerate(INL,1):
    if abs(A - (T - h*0.006)) < res:
        res = abs(A - (T - h*0.006))
        name = i

print(name)

Solution (Python):
N = int(input())
T,A = map(int,input().split())
H = list(map(int,input().split()))
num = 0
temp = abs(T-H[0]*0.006-A)
for i in range(N):
    if abs(T-H[i]*0.006-A) < temp:
        num = i
        temp = abs(T-H[i]*0.006-A)
print(num+1)

Solution (Python):
n = int(input())
t, a = tuple(map(int, input().split()))
h = list(map(int, input().split()))
min=599
b=0


def kion(hi):
    return abs(a-t+0.006*hi)

for i in range(0,n):
    ne=kion(h[i])
    if min>ne:
        min=ne
        b=i+1

print(b)

Solution (Python):
N = int(input())
T, A = map(int, input().split())
H = list(input().split())
a = []
b = 0
c = 0
for i in range(N):
        a.append(abs(A - (T - int(H[i]) * 0.006)))
b = min(a)
for i in range(N):
    if b == a[i]:
        c += i
print(c + 1)

Solution (Python):
n = int(input())
t, a = map(int, input().split())
h_list = [int(i) for i in input().split()]

ans=(abs(t - h_list[0] * 0.006-1),1)   
for index,height in enumerate( h_list):
    tempa = t - height * 0.006
    if ans[0] > abs(tempa - a):
        ans = (abs(tempa - a), index + 1)
print(ans[1])

Solution (Python):
N = int(input())
T,A = map(int,input().split())
H = list(map(int,input().split()))
t = [abs((T - i*0.006) - A) for i in H]

print(t.index(min(t))+1)

Solution (Python):
n = int(input())
t,a = map(int,input().split())
h = list(map(int,input().split()))
ans = 0
for i,l in enumerate(h):
    k = t-l*0.006
    if(i == 0):
        abs1 = abs(a-k)
        ans = i+1
    elif(abs1 > abs(a-k)):
        abs1 = abs(a-k)
        ans = i+1
print(ans)

Solution (Python):
n = int(input())
t,a = map(int,input().split())
li = list(map(int,input().split()))
tmp = 0
ans_no = 1
ans_val = abs(a - (t - (li[0] * 0.006)))
for i in range(1,len(li)):
    tmp = abs(a - (t - (li[i] * 0.006)))
    if ans_val > tmp:
        ans_val = tmp
        ans_no = i + 1
print(ans_no)