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()))
x=[abs(t-i*0.006-a) for i in h]
print(x.index(min(x))+1)

Solution (Python):
def main():
    N = int(input())
    T, A = map(int, input().split())
    H = [int(h) for h in input().split()]
    min_d, min_i = float('inf'), None
    for i in range(N):
        aveT = T - 0.006 * H[i]
        if abs(aveT - A) < min_d:
            min_d = abs(aveT-A)
            min_i = i
    return min_i+1


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

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

Solution (Python):
N = int(input())
T, A = map(int, input().split())
l = list(map(int, input().split()))
a = [abs(A - (T - h * 0.006)) for h in l]
print(sorted(list(zip(a, range(len(a)))))[0][1] + 1)

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

min_value = 10 ** 9
location = -1

for i, h in enumerate(H):
    tmp = abs((T - h * 0.006) - A)
    if tmp < min_value:
        min_value = tmp
        location = i

print(location + 1)

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

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

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

if __name__ == "__main__":
    main()

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

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

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

import numpy as np
def temp(T1,H):
    return T1-H*0.006
   
Q=[]
for i in range(len(H)):
    Q.append(np.abs(temp(T,H[i])-A))

print(np.argmin(Q)+1)

Solution (Python):



def temp(T, x, A):
    return abs(A - (T - 0.006 * x))

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

min_diff = temp(T, H[0], A)
answer = 0
for i in range(1, N):
    diff = temp(T, H[i], A)
    if diff < min_diff:
        answer = i
        min_diff = diff
print(answer + 1)

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

tem = []
for i in range(n):
  tem.append((t - h[i] * 0.006, i + 1))

print(sorted(tem, key=lambda x: abs(x[0] - a))[0][1])

Solution (Python):
n=int(input())
t,a=map(int,input().split())
h=list(map(int,input().split()))
k=0
s=float('inf')
for i in range(n):
    if abs(t-h[i]*.006-a)<s:
        s=abs(t-h[i]*.006-a)
        k=i
print(k+1)

Solution (Python):
n=int(input())
t,a=map(int,input().split())
H=list(map(int,input().split()))
m=1000
r=0
for i in range(len(H)):
    s=abs(t-0.006*H[i]-a)
    if s<m:
        r=i+1
        m=s
print(r)

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

def temperature(x):
    return t - x * 0.006

ans = 0
for i in range(1, n):
    if abs(a - temperature(h[ans])) > abs(a - temperature(h[i])):
        ans = i
print(ans + 1)

Solution (Python):
n = int(input())
t,a = map(int,input().split())
h = list(map(int,input().split()))
ans = []
for i in range(n):
  mean = t - h[i]*0.006
  if a >= 0 and mean < 0:
    ans.append(a+abs(mean))
  elif a >= 0 and mean >= 0:
    ans.append(abs(a-mean))
  elif a < 0 and mean >= 0:
    ans.append(abs(a)+mean)
  elif a < 0 and mean < 0:
    ans.append(abs(a-mean))
print(ans.index(min(ans))+1)

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

i = 0

p = [t-j*0.006 for j in h]
q = [abs(a-j) for j in p]
ans_bef = q.index(min(q))
print(ans_bef + 1)

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

array = [int(i) for i in input().split()]
ans = list(map(lambda x: t-x*0.006,array))
ans = list(map(lambda x: abs(x-a),ans))

minans = min(ans)
minidx = ans.index(minans)

print(minidx+1)

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

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

ans = 0
min_diff = 2**32
for i, h in enumerate(H):
  d = abs((T-int(h)*0.006)-A)
  if min_diff > d:
    min_diff = d
    ans = i+1
print(ans)

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

hss = [t-i*0.006 for i in hs]

hsss = [abs(i-a) for i in hss]

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

Solution (Python):
n = int(input())
ta = input().split()
h = input().split()

t = int(ta[0])
a = int(ta[1])
for i in range(n):
	h[i] = int(h[i])

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

rem = []
for i in range(n):
	if tem[i] >= a:
		rem.append(tem[i] - a)
	else:
		rem.append(a - tem[i])

tmp = rem[0]
ans = 0
for i in range(1, n):
	if tmp > rem[i]:
		tmp = rem[i]
		ans = i

print(ans+1)

Solution (Python):
n=int(input())
t,a=map(int,input().split())
l=list(map(int,input().split()))
d=sorted(l+[(t-a)*500/3])
b=d.index((t-a)*500/3)
bn=(t-a)*500/3
if b==0:
  print(l.index(d[1])+1)
elif b==n:
  print(l.index(d[n-1])+1)
else:
  x,y=d[b-1],d[b+1]
  k=min([bn-x,y-bn])
  print(l.index(x)+1) if k==bn-x else print(l.index(y)+1)

Solution (Python):



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

Solution (Python):
n = int(input())
t, a = map(int,input().split())
array = list(map(lambda x: abs(a - (t - int(x) * 0.006)),input().split()))
cnt = 0
Min = 9999
for i in range(n):
    if Min > array[i]:
        Min = array[i]
        cnt = i + 1
print(cnt)

Solution (Python):
import numpy as np
N = input()
T, A = list(map(int, input().split()))
H = list(map(int, input().split()))
l = list()
for h in H:
    l.append(T - h * 0.006)

print(np.abs(np.asarray(l) - A).argmin() + 1)

Solution (Python):
N = int(input())
T, A = [int(x) for x in input().split()]
HN = [int(x) for x in input().split()]
dT = 10 ** 10
res = 0
for i, h in enumerate(HN):
  tdT = abs(A - (T - h * 0.006))
  if tdT < dT:
    res = i
    dT = tdT
    
print(res + 1)

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

T,A=map(int,input().split())

min=5000

H=[int(x) for x in input().split()]

for i in range(N):
    
    if abs(A-(T-H[i]*0.006)) <= min:
        min=abs(A-(T-H[i]*0.006))
        buf=i+1

print(buf)

Solution (Python):
import math
import sys
from itertools import accumulate
from functools import reduce
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

sys.setrecursionlimit(10000)

mod = 1000000007

"""

a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 



    = sys.stdin.readline().rstrip()
    = list(sys.stdin.readline().rstrip())


    = int(sys.stdin.readline())
    = map(int, sys.stdin.readline().split())
    = list(map(int, sys.stdin.readline().split()))
    = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  
"""

if __name__ == "__main__":
    N = int(sys.stdin.readline())
    T, A = map(int, sys.stdin.readline().split())
    H = list(map(int, sys.stdin.readline().split()))
    ans = H[0]
    ansi = 1
    for i, h in enumerate(H):
        temper = T - h * 0.006
        if abs(A - ans) > abs(A - temper):
            ans = temper
            ansi = i + 1
    print(ansi)

Solution (Python):
n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
minV = 10**8
ans = 0

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

print(ans)

Solution (Python):
n = int(input())
x, y = map(int, input().split())
h_list = list(map(int, input().split()))

min_diff = 9999999999
min_index = 0
for i, h in enumerate(h_list):
    diff = abs(y - (x - h * 0.006))
    if min_diff > 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()))

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

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

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

tmp , near = map(int, input().split())

height = [int(x) for x in input().split()]

num = 0

box=[]

for x in height:
    av =tmp - x*0.006
    result = abs(av-near)
    box.append(result)
    
    
    
print(box.index(min(box))+1)

Solution (Python):
n = int(input())
t,a = map(int,input().split())
b = list(map(int,input().split()))
ans = []

for x in range(n):
    d = abs(a - (t - b[x]*0.006))
    ans.append(d)

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

Solution (Python):
N = int(input())
T, A = map(int, input().split())
hList = list(map(int, input().split()))
closest = 99999999
cIndex = 0

for i, temp in enumerate(hList):
  t = T - 0.006 * temp
  if closest > abs(A - t):
    closest = abs(A - t)
    cIndex = i

print(cIndex + 1)

Solution (Python):
def solve():
    n = int(input())
    t, a = map(int, input().split())
    h = list(map(int, input().split()))
    ans = 0
    min_diff = 10 ** 9
    for idx, hi in enumerate(h):
        diff = abs(t - hi * 0.006 - a)
        if diff < min_diff:
            min_diff = diff
            ans = idx + 1
    return ans


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

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

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

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

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

Solution (Python):
n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
_abs = 10 ** 9
place = 0
for i in range(n):
    tem = t - h[i] * 0.006
    if _abs > abs(a - tem):
        _abs = abs(a - tem)
        place = i + 1
print(place)

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

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

list_judge = []

for i in list_h:
    aaa= T-(i*0.006)
    bbb = abs(A - aaa)
    list_judge.append(bbb)

min = list_judge.index(min(list_judge))+1
print(min)

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

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

answer = 1
answer_t = T - H[0] * 0.006

for i in range(1, N):
    t = T - H[i] * 0.006
    if abs(A - answer_t) > abs(A - t):
        answer = i + 1
        answer_t = t
print(answer)

Solution (Python):

n = int(input())
T, a = map(int, input().split())
Hs = list(map(int, input().split()))

ans = 10**6
result = 0
for i in range(n):
    t = T- Hs[i]*0.006
    if abs(a - t) < ans:
        ans = abs(a-t)
        result = i

print(result+1)

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

for i in range(N):
  li[i] = T - li[i] * 0.006
  li[i] = abs(A - li[i])

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

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

min_k = 999999999999999999999999
for i in range(n):
    if abs(a - (t - h[i]*0.006)) < min_k:
        min_k = abs(a - (t - h[i]*0.006))
        min_index = i

print(min_index+1)

Solution (Python):
n = int(input())
t,a = (int(x) for x in input().split())
b = list(map(int,input().split()))
c = []

for i in b:
  c.append(abs((t - i * 0.006)-a))
  
print(c.index(min(c))+1)

Solution (Python):
import math
import copy
import sys

inputa = input().split()
inputb = input().split()


a = int(inputa[0])



x = int(inputb[0])
y = int(inputb[1])

inputb = input().split()
inputbList = [int(n) for n in inputb]












min = sys.maxsize
idx = -1
for i in range(a):
    tmp = abs(y - (x - 0.006*inputbList[i]))
    if min > tmp:
        min = tmp
        idx = i+1

print(idx)

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

temp_diff = 10000
tidx = -1

for i in range(N):
    x = h_list[i]
    temp = T - x*0.006
    abs_temp_diff = abs(A-temp)

    if abs_temp_diff <= temp_diff:
        temp_diff = abs_temp_diff
        tidx = i+1
print(tidx)

Solution (Python):
n=int(input())
t,a=input().split()
t,a=int(t),int(a)
h1=input().split()
h2=[]
for i in h1:
    h2.append(int(i))

d=abs(t-h2[0]*0.006-a)
j=1
for i in range(n-1):
    
    if d>abs(t-h2[i+1]*0.006-a):
        d=abs(t-h2[i+1]*0.006-a)
        j=i+2

print(j)

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

z = [abs(T - 0.006 * x - A) for x in H]
print (z.index(min(z)) + 1)

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 abs(T - 0.006 * H[i] - A) < abs(T - 0.006 * H[ans] - A):
    ans = i
print (ans + 1)

Solution (Python):

n = int(input())
t, a = [int(x) for x in input().split()]
locations =[int(x) for x in input().split()]

diff = [abs(a - (t - x * 6e-3)) for x in locations]
print(diff.index(min(diff))+1)

Solution (Python):

n = int(input())
t, a = [int(x) for x in input().split()]
locations =[int(x) for x in input().split()]
print(min([(i+1,abs(a - (t - x * 6e-3))) for i, x in enumerate(locations)],key=(lambda j:j[1]))[0])

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

Solution (Python):
Num = int(input())
Num2, Num3 = map(int,input().split())
Num_Array = list(map(int,input().split()))
result = 1000000000

for i  in range(0,Num):
    Check = Num3 - ( Num2 - (Num_Array[i] *0.006))
    if result > abs ( Check ):
        result = abs(Check)
        kekka = i + 1
print(kekka)

Solution (Python):
N = int(input())
T,A =list(map(int,input().split(" "))) 
Hs = list(map(int,input().split(" ")))
ans = 0
mindiff = 10 ** 9
for i,h in enumerate(Hs):
  temp = T - h * 0.006
  if abs(temp - A ) < mindiff:
    ans = i + 1
    mindiff = abs(temp - A )
print(ans)

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

temp=[]
c=t-hl[0]*0.006
ans=abs(c-a)
temp.append(ans)
for i in range(1,n) :
  cal=abs((t-hl[i]*0.006)-a)
  temp.append(cal)
  if ans>cal :
    ans=cal
print(temp.index(ans)+1)

Solution (Python):
n=int(input())
t,a=map(int,input().split())
hlist=list(map(int,input().split()))
def temp(t,x):
  temp = t-0.006*x
  return temp

diff = []
min=1000000
index=0
diff = 0
for i,h in enumerate(hlist):
  diff = abs(temp(t,h) - a)
  if min > diff:
    min = diff
    index = i
print(index+1)

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

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

x = 10**5 + 60
ans = 0
for i in range(len(h)):
    tmp = t-h[i]*0.006
    if abs(tmp-a) < x:
        x = abs(tmp-a)
        ans = i
print(ans+1)

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

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

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

sa = 100000000000

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

print(ans)

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

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

Solution (Python):
N = int(input())
t,a = map(int,input().split())
h_s = list(map(int,input().split()))
h = 100000000
ans = 0
for i in range(N):
    if abs(a-(t - (h_s[i]*0.006))) < h:
        h = abs(a-(t - (h_s[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()))

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

ans = 0
diff = 10000000000000000000
for i in range(n):
    if diff > abs(a-h[i]):
        ans = i+1
        diff = abs(a-h[i])
print(ans)

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

Solution (Python):
n = int(input())
avg_temparature, kijun_temparature = map(int,input().split())
list_height = [int(i) for i in input().split()]

result_position = 0
for candidate in range(1,len(list_height)):
    a = avg_temparature - (list_height[result_position] * 0.006)
    b = avg_temparature - (list_height[candidate] * 0.006)
    if abs(kijun_temparature - a) > abs(kijun_temparature - b):
        result_position = candidate

print(result_position+1)

Solution (Python):
ConstNum = 0.006
castle_N = int(input())
T,avg_A = input().rstrip().split()

dict_rec = {}
place_Cnt = 1
for i in input().rstrip().split():
  dict_rec[place_Cnt] = abs((int(T) - int(i) * ConstNum) - int(avg_A))
  place_Cnt += 1

rec = [k for k, v in dict_rec.items() if v == min(dict_rec.values())][0]
print(rec)

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

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

for i in range(N):
    D.append(T - H[i]*0.006)

D = [abs(A - D[i]) for i in range(N)]
ans = min(D)

for i in range(N):
    if ans == D[i]:
        print(i + 1)

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

H_to_T = []
for i in range(N):
    H_to_T.append(abs(T[1] - (T[0]-H[i]*0.006)))


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

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

Solution (Python):
import numpy as np
n = int(input())
t,a = map(int,input().split())
l = list(map(int,input().split()))
l = [abs(t-i*0.006-a) for i in l]
print(np.argmin(l)+1)

Solution (Python):
n = int(input())
t, a = map(int, input().split())
ondo = float('inf')
h = [int(x) for x in input().split()]
for i in range(n):
    if ondo > abs(a - (t - h[i]*0.006)):
        ans = i + 1
    else:
        continue
    ondo = min(ondo, abs(a - (t - h[i]*0.006)))
print(ans)

Solution (Python):
import sys

n = int(input())
t, a = map(int, input().split())
h_list = list(map(int, input().split()))
h_temp = [abs((t - h * 0.006) - a) for h in h_list]

min_h = min(h_temp)

for i in range(n):
    if h_temp[i] == min_h:
        print(i + 1)
        sys.exit()

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

n2, n3 = [int(i) for i in input().split()]
n4 = [int(j) for j in input().split()]


t1 = 1000
r1 = 0
for i1 in range(n1):
    if abs((n2 - (n4[i1] * 0.006))  - n3) <= t1:
        t1 = abs((n2 - (n4[i1] * 0.006))  - n3)
        r1 = i1 + 1

print(r1)

Solution (Python):
from numpy import array, argmin

input()
temp_on_sea, oracle = map(int, input().rstrip("\n").split())
heights = list(map(int , input().rstrip("\n").split()))
temp_diff = [abs(temp_on_sea - height * 0.006 - oracle) for height in heights]

print(array(temp_diff).argmin() + 1)

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

elevation_list = list(map(int, input().split()))
ans_list = []
min_ans = 1000
min_index = 0

for i in range(len(elevation_list)):
    ans = abs(a - (t - elevation_list[i] * 0.006))

    if ans < min_ans:
        min_ans = ans
        min_index = i + 1

print(min_index)

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

Solution (Python):
import sys
n = int(input())
t,a = list(map(int, input().split()))
hhh = list(map(int, input().split()))
ttt = [abs((t - h*0.006)-a) for h in hhh]
min_t = min(ttt)
for i in range(n):
  if ttt[i] == min_t:
    print(i+1)
    sys.exit()

Solution (Python):


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

target = (T - A) / 0.006
sub = 10 ** 6
for i in range(N):
    if abs(H[i] - target) < sub:
        sub = abs(H[i] - target)
        ans_idx = i

print(ans_idx + 1)

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

Solution (Python):
N = int(input())
T, A = map(int, input().split())
H = [int(i) for i in input().split()]
ans = []
for i,h in enumerate(H):
    ans.append([i+1, abs(T-0.006*h - A)])
ans.sort(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()))
ma = 10 ** 9
ans = 0
for i in range(n):
    if abs(t - h[i] * 0.006 - a) < ma:
        ma = abs(t - h[i] * 0.006 - a)
        ans = i + 1
print(ans)

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

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

Solution (Python):
def main():
    N = int(input())
    T, A = map( int, input().split())
    H = list (map( int, input().split()))
    pos = -1
    best = 1 << 64
    for i in range(0, N):
        avg = T - H[i] * 0.006
        if best > abs(A - avg):
            best = abs(A - avg)
            pos = i + 1
    print(pos)

if __name__ == "__main__":
    main()

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

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

temp = [0]*N

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

temp2 = sorted(temp)
print(temp.index(temp2[0])+1)

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

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

Solution (Python):
N = int(input())
list = input().split()
T = list[0]
A = list[1]
list2 = input().split()
H = []
T_mean = []
minimum = []
for i in range(N):
    H.append(list2[i])
    T_mean.append(int(T)-int(H[i])*0.006)
    minimum.append(abs(T_mean[i] - int(A)))


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

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

new = []
x = (T-A)/0.006
for h in H:
  new.append(abs(h-x))

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

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

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

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

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

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

Solution (Python):
n = int(input())
t,a = map(int, input().split())
h = map(int, input().split())
import numpy as np
print(np.argmin([abs(a - (t - i*6e-3)) for i in h])+1)

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

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

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

tmpr_list = [T - h * 0.006 for h in H_list]
abs_min = abs(tmpr_list[0] - A)
abs_min_index = 1

for i in range(length):
    if abs_min >= abs(tmpr_list[i] - A):
        abs_min = abs(tmpr_list[i] - A)
        abs_min_index = i + 1

print(abs_min_index)

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

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

Solution (Python):
n = int(input())
t,a = map(int,input().split())
h = list(map(int,input().split()))
ans_temp = 10**5
ans = 0
for i in range(n):
    temp = t - h[i] * 0.006
    if abs(a - ans_temp) > abs(a - temp):
        ans_temp = temp
        ans = i
print(ans + 1)

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

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

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

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

print(c)

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

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

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

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

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

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

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

Solution (Python):
n=int(input())
t,a=map(int,input().split())
t*=1000;a*=1000
h=list(map(int,input().split()))
m=10**17
ans=1
for i in range(n):
  l=abs(t-h[i]*6-a)
  if m>l:
    m=l
    ans=i+1
print(ans)

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

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

Solution (Python):
n = int(input())
t, a = map(int, input().split())
h = list(map(int, input().split()))
INF = 1000000
d = [INF] * n
for hi, hv in enumerate(h):
    d[hi] = abs(a - (t - hv * 0.006))

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

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

def main():
	w = 0.006
	n = int(input().strip())
	t, a = map(int, input().strip().split())
	v = list(map(int, input().strip().split()))
	T = 10**9
	ans = 0
	for i in range(n):
		if abs(a - (t-v[i]*w)) < T:
			T = abs(a - (t-v[i]*w))
			ans = i
	print(ans+1)

if __name__ == '__main__':
	main()

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

Solution (Python):
n,t,a,*h=map(int,open(0).read().split());y=[abs(t-a-i*6e-3)for i in h];print(y.index(min(y))+1)

Solution (Python):
N = int(input())
TA = list(map(int, input().split(' ')))
T = TA[0]
A = TA[1]
heights = list(map(int, input().split(' ')))
diff_temps = []
for height in heights:
    diff_temps.append(abs(A - (T - height * 0.006)))
res = diff_temps.index(min(diff_temps)) + 1
print(res)

Solution (Python):


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


for i in range(N):
    if i==0:
        temp=abs(A-(T-H[i]*0.006))
        point=i+1
    else:
        if temp>abs(A-(T-H[i]*0.006)):
            temp=abs(A-(T-H[i]*0.006))
            point=i+1

print(point)