There is a fence in front of Polycarpus's home. The fence consists of n planks of the same width which go one after another from left to right. The height of the i-th plank is h_{i} meters, distinct planks can have distinct heights. [Image] Fence for n = 7 and h = [1, 2, 6, 1, 1, 7, 1] 

Polycarpus has bought a posh piano and is thinking about how to get it into the house. In order to carry out his plan, he needs to take exactly k consecutive planks from the fence. Higher planks are harder to tear off the fence, so Polycarpus wants to find such k consecutive planks that the sum of their heights is minimal possible.

Write the program that finds the indexes of k consecutive planks with minimal total height. Pay attention, the fence is not around Polycarpus's home, it is in front of home (in other words, the fence isn't cyclic).


-----Input-----

The first line of the input contains integers n and k (1 ≤ n ≤ 1.5·10^5, 1 ≤ k ≤ n) — the number of planks in the fence and the width of the hole for the piano. The second line contains the sequence of integers h_1, h_2, ..., h_{n} (1 ≤ h_{i} ≤ 100), where h_{i} is the height of the i-th plank of the fence.


-----Output-----

Print such integer j that the sum of the heights of planks j, j + 1, ..., j + k - 1 is the minimum possible. If there are multiple such j's, print any of them.


-----Examples-----
Input
7 3
1 2 6 1 1 7 1

Output
3



-----Note-----

In the sample, your task is to find three consecutive planks with the minimum sum of heights. In the given case three planks with indexes 3, 4 and 5 have the required attribute, their total height is 8.

Difficulty: EASY

Solutions:
(n, k) = map(int, input().split())
h = list(map(int, input().split()))
j = 0
m = 0
sum = 0
s = float('inf')
if n == k:
	print(1)
else:
	for i in range(n):
		sum += h[i]
		m += 1
		if m == k:
			a = s
			s = min(s, sum)
			sum -= h[j]
			j += 1
			m -= 1
			if a != s:
				index = j
		else:
			continue
	print(index)


[n, k] = list(map(int, input().split(' ')))
h = list(map(int, input().split(' ')))
s = 0
resultIndex = 0
resultValue = 10 ** 8
for i in range(0, n):
	s += h[i] - h[i - k]
	if i >= k - 1:
		if s < resultValue:
			resultValue = s
			resultIndex = i
print(resultIndex - k + 2)


nk = [int(k) for k in input().split()]
(n, k) = (nk[0], nk[1])
heights = [int(k) for k in input().split()]
currTot = sum(heights[:k])
minTot = currTot
minTotInd = 0
(start, end) = (0, k - 1)
while end < n - 1:
	currTot -= heights[start]
	currTot += heights[end + 1]
	start += 1
	end += 1
	if currTot < minTot:
		minTot = currTot
		minTotInd = start
print(minTotInd + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
s = sum(a[0:k])
dp = [0] * (n - k + 1)
dp[0] = s
(m, x) = (s, 0)
for i in range(1, n - k + 1):
	dp[i] = dp[i - 1] + a[i + k - 1] - a[i - 1]
	if dp[i] < m:
		m = dp[i]
		x = i
print(x + 1)


(n, k) = [int(i) for i in input().split()]
arr = [0] * (n - k + 1)
ls = [int(i) for i in input().split()]
for i in range(k):
	arr[0] += ls[i]
for i in range(k, n):
	arr[i - k + 1] = arr[i - k] - ls[i - k] + ls[i]
print(arr.index(min(arr)) + 1)


(n, k) = map(int, input().split())
ls = list(map(int, input().split()))
j = 0
s = sum(ls[:k])
mas = s
for i in range(k, n):
	s -= ls[i - k]
	s += ls[i]
	if s < mas:
		j = i - k + 1
		mas = s
print(j + 1)


(n, k) = map(int, input().split())
lst = list(map(int, input().split()))
s = sum(lst[:k])
result = [(s, 0)]
for i in range(k, n):
	s = s - lst[i - k] + lst[i]
	result.append((s, i - k + 1))
mi = min(result, key=lambda x: x[0])
print(mi[1] + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
pref = [0] * (n + 1)
for i in range(n):
	pref[i + 1] = pref[i] + arr[i]
ans = 10 ** 18
id = 0
for i in range(n - k + 1):
	now = pref[i + k] - pref[i]
	if now < ans:
		ans = now
		id = i
print(id + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
j = 0
x = 1
for q in range(k):
	j += l[q]
h = j
for q in range(k, n):
	h -= l[q - k]
	h += l[q]
	if h < j:
		j = h
		x = q - k + 2
print(x)


(n, k) = map(int, input().split())
heights = list(map(int, input().split()))
sums = [sum((heights[i] for i in range(k)))]
for i in range(1, n - (k - 1)):
	sums.append(sums[i - 1] - heights[i - 1] + heights[i + (k - 1)])
print(sums.index(min(sums)) + 1)


(n, m) = map(int, input().strip().split())
arr = list(map(int, input().strip().split()))
s = sum(arr[0:m])
minimum = s
index = 0
for i in range(m, n):
	s = s - arr[i - m] + arr[i]
	if s < minimum:
		minimum = s
		index = i - m + 1
print(index + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
minCost = min = pos = 0
for j in range(k):
	minCost += arr[0 + j]
cost = minCost
for i in range(k, n):
	minCost += arr[i] - arr[i - k]
	if cost > minCost:
		cost = minCost
		pos = i - k + 1
print(pos + 1)


string = input()
numbers = string.split(' ')
a = int(numbers[0])
b = int(numbers[1])
string = input()
numbers = string.split(' ')
for x in range(a):
	numbers[x] = int(numbers[x])
n = sum(numbers[:b])
heights = [n]
for x in range(a - b):
	n -= numbers[x]
	n += numbers[x + b]
	heights.append(n)
print(heights.index(min(heights)) + 1)


(n, k) = list(map(int, input().split()))
a = list(map(int, input().split()))
s = sum(a[:k])
min_s = s
idx = 1
for i in range(n - k):
	s -= a[i]
	s += a[i + k]
	if s < min_s:
		min_s = s
		idx = i + 2
print(idx)


(n, k) = map(int, input().split())
fence = [0] * n
fence = list(map(int, input().split()))
height = sum(fence[0:k])
h = height
index = 0
for i in range(1, n - k + 1):
	h = h - fence[i - 1] + fence[i + k - 1]
	if h < height:
		height = h
		index = i
print(index + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
p = []
p.append(a[0])
for i in range(1, n):
	p.append(p[i - 1] + a[i])
min = p[k - 1]
j = 0
for i in range(k, n):
	if min > p[i] - p[i - k]:
		min = p[i] - p[i - k]
		j = i - k + 1
print(j + 1)


from sys import maxsize, stdout, stdin, stderr
mod = int(1000000000.0 + 7)

def I():
	return int(stdin.readline())

def lint():
	return [int(x) for x in stdin.readline().split()]

def S():
	return input().strip()

def grid(r, c):
	return [lint() for i in range(r)]
from collections import defaultdict, Counter
import math
import heapq
from heapq import heappop, heappush
import bisect
from itertools import groupby

def gcd(a, b):
	while b:
		a %= b
		tmp = a
		a = b
		b = tmp
	return a

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

def check_prime(n):
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True

def Bs(a, x):
	i = 0
	j = 0
	left = 0
	right = len(a)
	flag = False
	while left < right:
		mi = (left + right) // 2
		if a[mi] <= x:
			left = mi + 1
			i += 1
		else:
			right = mi
			j += 1
	if left > 0 and a[left - 1] == x:
		return (i - 1, j)
	else:
		return (-1, -1)
(n, k) = lint()
s = lint()
l = [10 ** 9 + 7] * n
l[k - 1] = sum(s[:k])
las = 0
ans = 10 ** 9 + 7
for j in range(k, n):
	l[j] = l[j - 1] - s[las] + s[j]
	las += 1
idx = -1
for i in range(k - 1, n):
	if l[i] < ans:
		idx = i - k + 1
		ans = l[i]
print(idx + 1)


(n, k) = (int(x) for x in input().split())
arr = [int(x) for x in input().split()]
p_s = [0]
t_sum = 0
for x in arr:
	t_sum += x
	p_s.append(t_sum)
m = p_s[k] - p_s[0]
ans = 0
for x in range(n - k + 1):
	if p_s[k + x] - p_s[x] < m:
		ans = x
		m = p_s[k + x] - p_s[x]
print(ans + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
min_sum = sum(h[:k])
min_ind = 0
h_sum = min_sum
for i in range(1, n - k + 1):
	h_sum = h_sum - h[i - 1] + h[k + i - 1]
	if h_sum < min_sum:
		min_sum = h_sum
		min_ind = i
print(min_ind + 1)


(n, k) = [int(x) for x in input().strip().split(' ')]
h = [int(x) for x in input().strip().split(' ')]
min_sum = sum(h[:k])
min_idx = 1
s = min_sum
for i in range(k, n):
	s += h[i]
	s -= h[i - k]
	if s < min_sum:
		min_sum = s
		min_idx = i - k + 2
print(min_idx)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
sumi = sum(h[:k])
mn = sumi
q = 1
for i in range(n - k):
	sumi += h[k + i] - h[i]
	if sumi < mn:
		mn = sumi
		q = i + 2
print(q)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
cur = 0
index = 0
for i in range(0, k):
	cur += l[i]
mn = cur
for i in range(k, n):
	cur += l[i]
	cur -= l[i - k]
	if cur < mn:
		mn = cur
		index = i - k + 1
print(index + 1)


inputs = input().split()
num = int(inputs[0])
w = int(inputs[1])
planks = [int(x) for x in input().split()]
saved = [sum(planks[:w])]
for i in range(w, len(planks)):
	saved.append(saved[-1] + planks[i] - planks[i - w])
print(saved.index(min(saved)) + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
l1 = [0 for i in range(0, n + 1)]
count = 0
for i in range(0, n):
	count += a[i]
	l1[i + 1] = count
minm = 1000000000
mini = 1
for i in range(k, n + 1):
	if minm > l1[i] - l1[i - k]:
		minm = l1[i] - l1[i - k]
		mini = i - k + 1
print(mini)


temp = input().split(' ')
n = int(temp[0])
k = int(temp[1])
f = input().split(' ')
s = 0
ft = []
fs = []
minimum = 0
for i in range(n):
	s += int(f[i])
	ft.append(s)
	if i >= k - 1:
		tr = int(ft[i - k]) if i - k > -1 else 0
		temp = s - tr
		fs.append(temp)
print(fs.index(min(fs)) + 1)


(n, k) = map(int, input().split())
m = list(map(int, input().split()))
ps = []
cnt = 0
if k == 1:
	print(m.index(min(m)) + 1)
	exit()
for i in range(n):
	cnt += m[i]
	ps.append(cnt)
mins = float('inf')
index = 1
for i in range(n - k + 1):
	if i == 0:
		mins = min(mins, ps[k - 1])
		continue
	if mins > ps[i + k - 1] - ps[i - 1]:
		mins = ps[i + k - 1] - ps[i - 1]
		index = i + 1
print(index)


(n, k) = map(int, input().split())
Fences = [int(s) for s in input().split()]
net = 0
pos = 1
minimum = 0
for i in range(n - k):
	L = Fences[i]
	R = Fences[i + k]
	net = net + R - L
	if net < minimum:
		minimum = net
		pos = i + 2
print(pos)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
t = 0
result = 0
for i in range(0, k):
	t += a[i]
	result += a[i]
index = 0
for i in range(k, n):
	t += a[i]
	t -= a[i - k]
	if result > t:
		result = t
		index = i - k + 1
print(index + 1)


import math
(n, k) = map(int, input().split())
_list_ = list(map(int, input().split()))
(ans, s) = (math.inf, sum(_list_[:k]))
index = 0
for i in range(0, n - k + 1):
	if ans > s:
		index = i
		ans = s
	try:
		s = s - _list_[i] + _list_[i + k]
	except IndexError:
		break
print(index + 1)


import os
import sys
debug = True
if debug and os.path.exists('input.in'):
	input = open('input.in', 'r').readline
else:
	debug = False
	input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
test_count = 1
if debug:
	test_count = inp()
for _ in range(test_count):
	(n, k) = invr()
	a = inlt()
	one_sum = [0] * (n + 1)
	for i in range(1, n + 1):
		one_sum[i] = one_sum[i - 1] + a[i - 1]
	ans = -1
	min_sum = -1
	for i in range(1, n - k + 2):
		s = one_sum[i + k - 1] - one_sum[i - 1]
		if min_sum == -1 or s < min_sum:
			min_sum = s
			ans = i
	print(ans)


import sys
s = sys.stdin.read()
S = s.split()
S = [int(i) for i in S]
N = S[0]
K = S[1]
S = S[2:]
ind = 0
for j in range(N - K + 1):
	if j == 0:
		a = total = sum((S[i] for i in range(K)))
	else:
		total = total - S[j - 1] + S[j + K - 1]
	if total < a:
		a = total
		ind = j
print(ind + 1)


import sys
import os

def get_int():
	return map(int, input().split())

def get_array():
	return list(map(int, input().split()))

def str_replacer(old_str, new_str, index):
	if index in range(len(old_str)):
		return old_str[:index] + new_str + old_str[index + 1:]
	else:
		return old_str
if os.environ.get('DEBUGSTER_PYTHON'):
	sys.stdin = open('in.txt', 'r')
	sys.stdout = open('out.txt', 'w')
(n, k) = get_int()
h = get_array()
mn = 1000000000
sum = 0
x = 0
for i in range(n):
	sum += h[i]
	if i >= k:
		sum -= h[i - k]
	if i >= k - 1 and sum < mn:
		mn = sum
		x = i + 1
print(x - k + 1)


def fence(n, k, ar):
	dp = [0] * (n - k + 1)
	for q in range(k):
		dp[0] += ar[q]
	for i in range(1, n - k + 1):
		dp[i] = dp[i - 1] - ar[i - 1] + ar[i + k - 1]
	ans = dp.index(min(dp))
	print(ans + 1)
(n, k) = map(int, input().split())
ar = list(map(int, input().split()))
fence(n, k, ar)


import sys

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

def iinput():
	return int(input())

def rinput():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
(n, k) = rinput()
a = list(map(int, input().split()))
ans = 0
for i in range(k):
	ans += a[i]
l = [ans]
for i in range(1, n - k + 1):
	ans = ans - a[i - 1] + a[i + k - 1]
	l.append(ans)
i = l.index(min(l))
print(i + 1)


from sys import stdin, stdout
cin = stdin.readline
cout = stdout.write
(n, k) = map(int, cin().split())
a = list(map(int, cin().split()))
(sumk, t) = ([], 0)
for i in range(n):
	t += a[i]
	sumk.append(t)
r = id = 10000000000.0
for i in range(n - k + 1):
	if sumk[i + k - 1] - sumk[i] + a[i] < r:
		r = sumk[i + k - 1] - sumk[i] + a[i]
		id = i
print(id + 1)


I = lambda : list(map(int, input().split()))
(n, k) = I()
h = I()
m = t = sum(h[:k])
a = 1
for i in range(k, n):
	t += h[i] - h[i - k]
	if t < m:
		a = i - k + 2
		m = t
print(a)


from math import inf
yoar = list(map(int, input().split()))
n = yoar[0]
k = yoar[1]
arr = list(map(int, input().split()))
presum = [0 for i in range(n)]
presum[0] = arr[0]
for i in range(1, n):
	presum[i] = presum[i - 1] + arr[i]
mini = inf
minind = -1
for i in range(n):
	try:
		curr = presum[i + k - 1] - presum[i] + arr[i]
		if curr < mini:
			mini = curr
			minind = i + 1
	except:
		break
print(minind)


def solution(n, k, h):
	sums = [0] * n
	sums[0] = h[0]
	for i in range(1, n):
		sums[i] = sums[i - 1] + h[i]
	tSum = tuple(sums)
	ans = 0
	minSum = tSum[k - 1]
	for i in range(1, n - k + 1):
		nSum = tSum[i + k - 1] - tSum[i - 1]
		if nSum < minSum:
			ans = i
			minSum = nSum
	return ans + 1
(n, k) = [int(x) for x in input().split(' ')]
h = [int(x) for x in input().split(' ')]
print(solution(n, k, h))


(n, k) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
p = [0] * (n + 10)
p[1] = a[0]
for i in range(2, n + 1):
	p[i] = p[i - 1] + a[i - 1]
min_ind = -1
ans = 10 ** 9
for i in range(1, n + 2 - k):
	cur = p[i + k - 1] - p[i - 1]
	if cur < ans:
		min_ind = i
		ans = cur
print(min_ind)


(length, consecutive) = list(map(int, input().split()))
fence = list(map(int, input().split()))
heights = []
heights.append(sum(fence[0:consecutive]))
for i in range(1, length - consecutive + 1):
	heights.append(heights[i - 1] - fence[i - 1] + fence[i + consecutive - 1])
print(heights.index(min(heights)) + 1)


(n, k) = map(int, input().split())
l = [int(i) for i in input().split()]
s = sum(l[:k])
crawl = 0
ans = 0
minim = s
for i in range(k, n):
	s += l[i]
	s -= l[crawl]
	crawl += 1
	if s < minim:
		minim = s
		ans = crawl
print(ans + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
s = sum(arr[:k])
minSum = s
index = 0
for i in range(1, len(arr) - k + 1):
	s = s - arr[i - 1] + arr[i + k - 1]
	if s < minSum:
		minSum = s
		index = i
print(index + 1)


import sys
input = sys.stdin.readline

def io():
	(n, k) = map(int, input().split())
	ls = list(map(int, input().split()))
	return (n, k, ls)

def solve():
	(n, k, ls) = io()
	first_window = sum(ls[:k])
	min_window = first_window
	first = 0
	last = k - 1
	idx = 1
	for i in range(1, n - k + 1):
		tmp_sum = 0
		tmp_sum += first_window - ls[first]
		tmp_sum += ls[last + i]
		if tmp_sum < min_window:
			idx = i + 1
			min_window = tmp_sum
		first_window = tmp_sum
		first += 1
	print(idx)
solve()


def main():
	(m, n) = [int(v) for v in input().split()]
	vals = [int(v) for v in input().split()]
	sum = 0
	sums = [0]
	for (i, v) in enumerate(vals):
		sum += v
		sums.append(sum)
	min_v = sums[n]
	res = 0
	for i in range(m + 1):
		if i + n - 1 >= m:
			continue
		if sums[i + n] - sums[i] < min_v:
			min_v = sums[i + n] - sums[i]
			res = i
	print(res + 1)
main()


(n, h) = map(int, input().split())
kk = list(map(int, input().split()))
l = [0] * (n - h + 1)
l[0] = sum(kk[0:h])
for i in range(1, n - h + 1):
	l[i] = l[i - 1] + kk[i + h - 1] - kk[i - 1]
k = l[0]
j = 0
for i in range(1, n - h + 1):
	if k > l[i]:
		k = l[i]
		j = i
print(j + 1)


t = input()
temp = t.split()
n = int(temp[0])
k = int(temp[1])
s = input()
temp = s.split()
heights = [int(i) for i in temp]
sum = 0
index = 0
flag = True
for i in range(k):
	sum += heights[i]
kSum = sum
for i in range(k, n):
	kSum = kSum + heights[i] - heights[i - k]
	if kSum < sum:
		sum = kSum
		index = i
		flag = False
if flag == True:
	print(index + 1)
else:
	print(index - k + 2)


(x, y) = map(int, input().split())
li = list(map(int, input().split()))
cnt = 0
count = sum(li[:y])
ans = count
for i in range(y, x):
	count -= li[i - y]
	count += li[i]
	if count < ans:
		cnt = i - y + 1
		ans = count
print(cnt + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
cur = sum(a[0:k])
m = 1
z = cur
for i in range(k, n):
	cur += a[i] - a[i - k]
	if z > cur:
		z = cur
		m = i - k + 2
print(m)


from collections import deque
(n, k) = map(int, input().split())
queue = deque()
data = map(int, input().split())
for i in range(k):
	queue.append(next(data))
min_value = 0
min_index = 1
curr_index = 1
curr_value = 0
while True:
	curr_index += 1
	try:
		v = next(data)
	except StopIteration:
		break
	delta = v - queue.popleft()
	queue.append(v)
	curr_value += delta
	if curr_value < min_value:
		(min_value, min_index) = (curr_value, curr_index)
print(min_index)


(n, k) = map(int, input().split())
heights = list(map(int, input().split()))
dp = [h for h in heights]
for i in range(1, n):
	dp[i] += dp[i - 1]
minSoFar = dp[k - 1]
res = 1
for i in range(k, n):
	sumSoFar = dp[i] - dp[i - k]
	if minSoFar > sumSoFar:
		minSoFar = sumSoFar
		res = i - k + 1 + 1
print(res)


def getmin(x, y):
	if x == -1:
		return y
	elif y == -1:
		return x
	return min(x, y)
p = [int(x) for x in input().split(' ')]
fence = [int(x) for x in input().split(' ')]

def safeaccess(l, i):
	if i < 0:
		return 0
	return l[i]
a = []
s = 0
for i in range(len(fence)):
	s += fence[i]
	a.append(s)
end = p[1] - 1
start = 0
answer = -1
submit = start
while end < len(fence):
	newanswer = getmin(answer, safeaccess(a, end) - safeaccess(a, start - 1))
	if newanswer < answer:
		submit = start
	answer = newanswer
	start += 1
	end += 1
print(submit + 1)


(n, k) = map(int, input().split())
li = list(map(int, input().split()))
min = sum(li[:k])
cur = min
res = 0
for i in range(1, n - k + 1):
	cur = cur - li[i - 1] + li[i + k - 1]
	if cur < min:
		res = i
		min = cur
if cur < min:
	res = i
print(res + 1)


(n, m) = map(int, input().split())
c = list(map(int, input().split()))
c.reverse()
c.append(0)
c.reverse()
for i in range(1, n + 1):
	c[i] += c[i - 1]
x = 1
l = 10 ** 9
for i in range(m, n + 1):
	if c[i] - c[i - m] < l:
		l = c[i] - c[i - m]
		x = i - m + 1
print(x)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
min_s = sum(h[:k])
temp_s = min_s
min_i = 1
for i in range(n - k):
	temp_s += h[i + k] - h[i]
	if temp_s < min_s:
		min_s = temp_s
		min_i = i + 2
print(min_i)


(n, k) = map(int, input().split())
f = [int(i) for i in input().split()]
a = sum(f[:k])
s = []
for i in range(n - k):
	s.append(a)
	a = a + f[i + k] - f[i]
s.append(a)
print(s.index(min(s)) + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
mn = 10 ** 10
indx = -1
prev_sm = 0
for i in range(n):
	if i + k - 1 < n and i == 0:
		prev_sm = sum(l[i:i + k])
		if prev_sm < mn:
			mn = prev_sm
			indx = i
	elif i + k - 1 < n:
		prev_sm -= l[i - 1]
		prev_sm += l[i + k - 1]
		if prev_sm < mn:
			mn = prev_sm
			indx = i
print(indx + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
h = min_h = sum(arr[:k])
idx = 1
for i in range(n - k):
	h = h - arr[i] + arr[i + k]
	if h < min_h:
		min_h = h
		idx = i + 2
print(idx)


alpha = list(map(int, input().split()))
beta = list(map(int, input().split()))
delta = data = sum(beta[:alpha[1]])
i = 0
for j in range(alpha[0] - alpha[1]):
	data = data - beta[j] + beta[j + alpha[1]]
	if data < delta:
		delta = data
		i = j + 1
print(i + 1)


(n, k) = map(int, input().split())
b = []
a = list(map(int, input().split()))
s = sum(a[0:k])
b.append(s)
for i in range(1, n - k + 1):
	s = s - a[i - 1] + a[i + k - 1]
	b.append(s)
print(b.index(min(b)) + 1)


(n, k) = map(int, input().split())
g = list(map(int, input().split()))
s = 0
l = 1
r = [float('inf'), 0]
for i in range(len(g)):
	if i <= k - 1:
		s += g[i]
	else:
		if s < r[0]:
			r = [s, l - k]
		s = s - g[i - k] + g[i]
	l += 1
if s < r[0]:
	r = [s, l - k]
print(r[1])


def main():
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	init_sum = 0
	index = 0
	for i in range(k):
		init_sum += a[i]
	i = k
	curr_sum = init_sum
	while i < n:
		curr_sum += a[i] - a[i - k]
		if curr_sum < init_sum:
			init_sum = curr_sum
			index = i - k + 1
		i += 1
	print(index + 1)
main()


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
min = sum(l[:k])
start = 0
su = 0
for i in range(len(l)):
	su += l[i]
	if i > k - 1:
		su -= l[i - k]
		if su < min:
			min = su
			start = i - k + 1
print(start + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
s = sum(h)
ind = 0
ans = s
for i in range(1, n - k + 1):
	ans = ans + h[i + k - 1] - h[i - 1]
	if ans < s:
		s = ans
		ind = i
print(ind + 1)


(n, l) = map(int, input().strip().split())
L = list(map(int, input().strip().split()))
s = sum(L[:l])
m = s
k = l
o = 0
for i in range(l, n):
	s -= L[i - l] - L[i]
	if s < m:
		k = i + 1
		m = s
	o = i
print(k + 1 - l)


(a, b) = map(int, input().split())
l = list(map(int, input().split()))
f = sum(l[0:b])
l2 = [f]
for i in range(b, a):
	l2.append(f + l[i] - l[i - b])
	f = f + l[i] - l[i - b]
print(l2.index(min(l2)) + 1)


def list_input(data):
	return list(map(data, input().strip().split()))

def single_input(data):
	return map(data, input().strip().split())
(n, k) = single_input(int)
l1 = list_input(int) + [0]
res = 99999999999
inde = 0
sum_q = sum(l1[0:k])
for i in range(0, n - k + 1):
	if sum_q < res:
		res = sum_q
		inde = i
	sum_q -= l1[i]
	sum_q = sum_q + l1[i + k]
print(inde + 1)


from collections import deque
(n, k) = map(int, input().split())
a = [int(i) for i in input().split()]
segment = deque([a[i] for i in range(k)])
cost = sum(segment)
min_cost = cost
such_i = 0
for i in range(1, n - k + 1):
	cost = cost - segment.popleft() + a[i + k - 1]
	segment.append(a[i + k - 1])
	if min_cost > cost:
		min_cost = cost
		such_i = i
print(such_i + 1)


(n, k) = map(int, input().split())
l = [int(j) for j in input().split()]
s = 0
m = 10 ** 8
t = 0
for i in range(n):
	s += l[i]
	if i + 1 > k:
		s -= l[i - k]
	if i + 1 >= k:
		if s < m:
			m = s
			t = i - k + 1
print(t + 1)


(n, k) = map(int, input().strip().split())
A = list(map(int, input().strip().split()))
sm = sum(A[:k])
idx = 0
index = 0
mn = sm
for i in range(k, len(A)):
	sm += A[i] - A[i - k]
	if mn > sm:
		mn = sm
		idx = i - k + 1
print(idx + 1)


import sys
inf = float('inf')
mod = 1000000007

def get_array():
	return list(map(int, sys.stdin.readline().split()))

def get_ints():
	return map(int, sys.stdin.readline().split())

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

def main():
	(n, k) = get_ints()
	arr = get_array()
	prefix_sum = [0] * n
	prefix_sum[0] = arr[0]
	for i in range(1, n):
		prefix_sum[i] = arr[i] + prefix_sum[i - 1]
	mx = prefix_sum[k - 1]
	index = 0
	for i in range(1, n - k + 1):
		if prefix_sum[i + k - 1] - prefix_sum[i - 1] < mx:
			mx = prefix_sum[i + k - 1] - prefix_sum[i - 1]
			index = i
	print(index + 1, sep=' ', end='\n', file=sys.stdout, flush=False)
main()


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
arr = []
ans = 0
for i in range(k):
	ans += l[i]
arr.append([ans, 1, 2, 3])
j = 0
for i in range(1, n - k + 1):
	ans -= l[j]
	j += 1
	ans += l[i + k - 1]
	arr.append([ans, i + 1, i + 2, i + 3])
arr.sort(key=lambda x: x[0])
print(arr[0][1])


import sys

def solve():
	hauteursCum = [hauteurs[0]]
	for i in range(1, len(hauteurs)):
		hauteursCum += [hauteursCum[i - 1] + hauteurs[i]]
	hauteursCumK = [hauteursCum[k - 1]]
	for i in range(k, len(hauteurs)):
		hauteursCumK += [hauteursCum[i] - hauteursCum[i - k]]
	valMin = hauteursCumK[0]
	iMin = 0
	for i in range(1, len(hauteursCumK)):
		if hauteursCumK[i] < valMin:
			valMin = hauteursCumK[i]
			iMin = i
	print(iMin + 1)

def main():
	global k
	global hauteurs
	f = sys.stdin
	(n, k) = map(int, f.readline().split())
	hauteurs = list(map(int, f.readline().split()))
	solve()
main()


from sys import stdin
(n, k) = map(int, stdin.readline().rstrip().split(' '))
nums = list(map(int, stdin.readline().rstrip().split(' ')))
if k == 1:
	print(nums.index(min(nums)) + 1)
else:
	cur_sum = 0
	for i in range(k):
		cur_sum += nums[i]
	l = 0
	r = k - 1
	idx = 0
	mi = cur_sum
	while r < len(nums) - 1:
		cur_sum += nums[r + 1] - nums[l]
		if cur_sum < mi:
			mi = cur_sum
			idx = l + 1
		l += 1
		r += 1
	print(idx + 1)


(n, k) = map(int, input().split())
l = [0] + list(map(int, input().split())) + [0]
(p, t, s) = (1, k, 1)
q = sum(l[1:k + 1])
r = q
while t <= n:
	if q < r:
		(r, s) = (q, p)
	q -= l[p]
	q += l[t + 1]
	p += 1
	t += 1
print(s)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
s = 0
mini = 0
I = 0
for i in range(n - k):
	s += arr[i + k] - arr[i]
	if s < mini:
		s = mini
		I = i + 1
print(I + 1)


s = input().split(' ')
n = int(s[0])
k = int(s[1])
s = input().split(' ')
a = [int(i) for i in s]
mini = sum(a[0:k])
x = [mini]
for i in range(1, n - k + 1):
	x.append(mini - a[i - 1] + a[i + k - 1])
	mini = x[i]
mini = min(x)
print(x.index(mini) + 1)


num_input = input()
num_input = num_input.split(' ')
n = int(num_input[0])
k = int(num_input[1])
arr = input()
arr = arr.split(' ')
for i in range(0, len(arr)):
	arr[i] = int(arr[i])
sum = 0
for i in range(0, k):
	sum = sum + arr[i]
min = sum
min_index = 0
for i in range(1, len(arr) - (k - 1)):
	sum = sum + arr[i + (k - 1)]
	sum = sum - arr[i - 1]
	if sum < min:
		min = sum
		min_index = i
print(min_index + 1)


from collections import Counter
line1 = list(map(int, input().split()))
line2 = list(map(int, input().split()))
if len(Counter(line2)) == 1:
	print(1)
else:
	k = line1[1]
	(new_sum, cum_sum) = (0, [])
	for val in line2:
		new_sum += val
		cum_sum.append(new_sum)
	min_height = sum(line2[0:k])
	best_index = 0
	for i in range(1, line1[0] - k + 1):
		prev_min = min_height
		new_height = cum_sum[i - 1 + k] - cum_sum[i - 1]
		min_height = min(min_height, new_height)
		if prev_min != min_height:
			best_index = i
	print(best_index + 1)


import sys
k = int(sys.stdin.readline().split()[1])
t = list(map(lambda s: int(s), sys.stdin.readline().split()))
cur = 0
for i in range(k):
	cur += t[i]
j = 1
min = cur
for i in range(len(t) - k):
	cur -= t[i]
	cur += t[i + k]
	if cur < min:
		min = cur
		j = i + 2
print(j)


(n, k) = map(int, input().split(' '))
inputArr = list(map(int, input().split()))
output = 0
startIndex = 0
for i in range(0, k):
	output = output + inputArr[i]
currentSum = output
for i in range(k, n):
	currentSum = currentSum + inputArr[i] - inputArr[i - k]
	if currentSum < output:
		output = currentSum
		startIndex = i - k + 1
print(startIndex + 1)


f = lambda : map(int, input().split())
(n, k) = f()
h = list(f())
sum_first = sum(h[:k])
(min_h_sum, mini) = (sum_first, 0)
for i in range(1, n - k + 1):
	sum_first -= h[i - 1]
	sum_first += h[i + k - 1]
	if sum_first < min_h_sum:
		min_h_sum = sum_first
		mini = i
print(max(mini + 1, 1))


import sys
(n, k) = map(int, sys.stdin.readline().split())
list1 = list(map(int, sys.stdin.readline().split()))
sum1 = sum(list1[:k])
s = sum(list1[:k])
p = 0
for i in range(1, len(list1) - k + 1):
	s += -list1[i - 1] + list1[i + k - 1]
	if s < sum1:
		sum1 = s + 0
		p = i + 0
print(p + 1)


(n, k) = [int(t) for t in input().split()]
x = [int(t) for t in input().split()]
l = [0] * (n + 1)
for j in range(0, n):
	l[j + 1] = l[j] + x[j]
val = 5000000000000
pt = -1
for j in range(k, n + 1):
	if l[j] - l[j - k] < val:
		val = l[j] - l[j - k]
		pt = j - k + 1
print(pt)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
res = 0
for i in range(k):
	res += arr[i]
curr_res = res
index = 1
for i in range(k, n):
	curr_res += arr[i] - arr[i - k]
	if curr_res < res:
		index = i - k + 2
		res = curr_res
print(index)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(1, n):
	a[i] += a[i - 1]
high = a[k - 1]
ans = 1
for i in range(1, n - k + 1):
	s = a[i + k - 1] - a[i - 1]
	if s < high:
		ans = i + 1
		high = s
print(ans)


from collections import deque
(n, k) = map(int, input().split())
h = input().split()
for i in range(n):
	h[i] = int(h[i])
a = deque()
b = []
count = 0
for i in range(n):
	if i <= k - 1:
		a.append(h[i])
		count += h[i]
	else:
		b.append(count)
		count -= a[0]
		a.popleft()
		a.append(h[i])
		count += h[i]
b.append(count)
print(b.index(min(b)) + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
pref = [0] * (n + 1)
for i in range(1, n + 1):
	pref[i] = pref[i - 1] + arr[i - 1]
ans = -1
mm = 1000000000000000000
for i in range(0, n - k + 1):
	xx = pref[i + k] - pref[i]
	if xx < mm:
		ans = i + 1
		mm = xx
if k == 1:
	print(arr.index(min(arr)) + 1)
	exit()
if ans == -1:
	ans = 1
print(ans)


(n, k) = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
s = sum(l[0:k])
t = s
rank = 1
for i in range(k, n):
	t -= l[i - k]
	t += l[i]
	if t < s:
		s = t
		rank = i - k + 2
print(rank)


I = lambda : list(map(int, input().split()))
(n, m) = I()
l = I()
for i in range(1, n):
	l[i] += l[i - 1]
ans = l[m - 1]
ind = 0
for i in range(1, n - m + 1):
	temp = l[i + m - 1] - l[i - 1]
	if temp < ans:
		ans = temp
		ind = i
print(ind + 1)


(n, k) = list(map(int, input().split()))
a = list(map(int, input().split()))
m = sum(a[:k])
c = m
mi = k - 1
for ci in range(k, n):
	c = c - a[ci - k] + a[ci]
	if c < m:
		m = c
		mi = ci
print(mi - k + 2)


def gint():
	return int(input())

def gint_arr():
	return list(map(int, input().split()))

def gfloat():
	return float(input())

def gfloat_arr():
	return list(map(float, input().split()))

def pair_int():
	return map(int, input().split())
INF = 1 << 31
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
(n, k) = gint_arr()
a = gint_arr()
res = 0
sum = sum(a[:k])
min_sum = sum
i = k
while i < n:
	sum -= a[i - k]
	sum += a[i]
	if sum < min_sum:
		min_sum = sum
		res = i - k + 1
	i += 1
print(res + 1)


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math

def bin1(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = k ** mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin1(mid + 1, r, k, t, b, val, ans)
		else:
			return bin1(l, mid - 1, k, t, b, val, ans)

def bin2(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = t * k ** mid + b * mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin2(l, mid - 1, k, t, b, val, ans)
		else:
			return bin2(mid + 1, r, k, t, b, val, ans)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def bin(l, r, ll, val):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		if val >= ll[mid][0] and val <= ll[mid][1]:
			return mid
		elif val < ll[mid][0]:
			return bin(l, mid - 1, ll, val)
		else:
			return bin(mid + 1, r, ll, val)

def deci(n):
	s = ''
	while n != 0:
		if n % 2 == 0:
			n = n // 2
			s = '0' + s
		else:
			n = n // 2
			s = '1' + s
	return s

def diff(s1, s2):
	if len(s1) < len(s2):
		v = len(s1)
		while v != len(s2):
			s1 = '0' + s1
			v = v + 1
	else:
		v = len(s2)
		while v != len(s1):
			s2 = '0' + s2
			v = v + 1
	c = 0
	for i in range(len(s1)):
		if s1[i:i + 1] != s2[i:i + 1]:
			c = c + 1
	return c
from sys import stdin, stdout

def fac(a, b):
	v = a
	while a != b:
		v *= a - 1
		a = a - 1
	return v

def bino(l, r, n):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		val1 = math.log(n / mid + 1, 2)
		val2 = int(val1)
		if val1 == val2:
			return val1
		elif val1 < 1.0:
			return bino(l, mid - 1, n)
		else:
			return bino(mid + 1, r, n)
(n, k) = map(int, stdin.readline().split(' '))
l = list(map(int, stdin.readline().split(' ')))
c = 0
total = 0
l1 = []
mini = 1000000000
for i in range(k):
	total += l[i]
l1.append(total)
for i in range(n - k):
	total = total - l[i] + l[i + k]
	l1.append(total)
mini = 1000000000
ind = -1
for i in range(len(l1)):
	if mini > l1[i]:
		ind = i + 1
		mini = l1[i]
print(ind)


import sys
(planks, piano_width, i, heights) = (0, 0, 0, [])
for line in sys.stdin:
	numbers = [int(x) for x in line.strip().split()]
	if i == 0:
		(planks, piano_width, i) = (numbers[0], numbers[1], 1)
		heights = [0] * planks
		continue
	heights = numbers
s = sum(heights[0:piano_width])
smallest = sum(heights[0:piano_width])
index = 0
for i in range(1, len(heights) - piano_width + 1):
	s = s - heights[i - 1] + heights[i + piano_width - 1]
	if s < smallest:
		smallest = s
		index = i
print(index + 1)


(m, n) = map(int, input().split())
arr = list(map(int, input().split()))
prefix = [0] + arr
for i in range(1, len(prefix)):
	prefix[i] += prefix[i - 1]
index = 0
minimum = sum(arr) + 1
for i in range(n, len(prefix)):
	sum = prefix[i] - prefix[i - n]
	if sum < minimum:
		index = i - n + 1
	minimum = min(minimum, sum)
print(index)


(n, k) = map(int, input().split())
t = list(map(int, input().split()))
for i in range(n - 1):
	t[i + 1] += t[i]
t = [0] + t
print(min(((t[i + k] - t[i], i) for i in range(n - k + 1)))[1] + 1)


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


(n, k) = list(map(int, input().split()))
ls = list(map(int, input().split()))
ans = s = sum(ls[:k])
ind = 1
for i in range(k, n):
	s -= ls[i - k] - ls[i]
	if s < ans:
		ans = s
		ind = i - k + 2
print(ind)


def Fence(n, k, arr):
	m = 0
	index = 1
	pointer1 = 0
	tempSum = 0
	for i in range(0, k):
		m += arr[i]
	tempSum = m
	for i in range(k, n):
		tempSum += arr[i]
		tempSum -= arr[i - k]
		if tempSum < m:
			m = tempSum
			index = i - k + 2
	print(index)
(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
Fence(n, k, arr)


(l, m) = ([0], 1000000001)
(n, k) = map(int, input().split())
l.extend(list(map(int, input().split())))
for i in range(1, n + 1):
	l[i] += l[i - 1]
i = k
ans = 2
while i < n + 1:
	p = l[i] - l[i - k]
	if p < m:
		m = p
		ans = i - k + 1
	i += 1
print(ans)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
mn = 0
ind = 0
for i in range(k):
	mn += a[i]
sn = mn
for i in range(n - k):
	sn = sn - a[i] + a[i + k]
	if sn < mn:
		mn = sn
		ind = i + 1
print(ind + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
s = k + 1
j = 1
min = sum(a[0:k])
c = min
x = 0
for i in range(k, len(a)):
	min = min - a[x]
	min = min + a[i]
	if min < c:
		c = min
		j = x + 2
	x = x + 1
print(j)


data = input().split(' ')
n = int(data[0])
k = int(data[1])
minIndex = 1
minCost = 0
heights = input().split(' ')
heights = [int(x) for x in heights]
for j in range(k):
	minCost += heights[0 + j]
cost = minCost
for i in range(1, len(heights) - k + 1):
	cost = cost - heights[i - 1] + heights[i + k - 1]
	if cost < minCost:
		minCost = cost
		minIndex = i + 1
print(minIndex)


(n, k) = list(map(int, input().split()))
F = list(map(int, input().split()))
mindex = 0
sofar = 0
for i in range(k):
	sofar += F[i]
minvalue = sofar
for i in range(k, n):
	sofar -= F[i - k]
	sofar += F[i]
	if sofar < minvalue:
		minvalue = sofar
		mindex = i - k + 1
print(mindex + 1)


(n, k) = map(int, input().split())
hs = list(map(int, input().split()))
if n == k:
	print(1)
else:
	sm = [0] * n
	sm[0] = hs[0]
	for i in range(1, n):
		sm[i] = sm[i - 1] + hs[i]
	sm_k = [0] * (n - k + 1)
	sm_k[0] = sm[k - 1]
	for i in range(1, n - k + 1):
		sm_k[i] = sm[i + k - 1] - sm[i - 1]
	print(sm_k.index(min(sm_k)) + 1)


def func():
	(n, k) = map(int, input().split())
	arr = list(map(int, input().split()))
	min_possible = k
	curr_sum = sum(arr[:k])
	min_sum = float('inf')
	index = None
	for i in range(k, n):
		if curr_sum == min_possible:
			return i - k + 1
		if curr_sum < min_sum:
			index = i - k + 1
			min_sum = curr_sum
		curr_sum += arr[i] - arr[i - k]
	if curr_sum < min_sum:
		return n - k + 1
	return index
print(func())


(n, k) = list(map(int, input().split()))
h = list(map(int, input().split()))
(min_height, res) = (sum(h[:k]), 0)
curr_height = min_height
for i in range(1, n - k + 1):
	curr_height = curr_height - h[i - 1] + h[i + k - 1]
	if curr_height < min_height:
		min_height = curr_height
		res = i
print(res + 1)


from typing import List

class Solution:

	@classmethod
	def solve(cls, n: int, k: int, heights: List[int]) -> int:
		sum_arr = [0]
		for (index, element) in enumerate(heights):
			sum_arr.append(element + sum_arr[index])
		min_cost = 15000001
		min_index = 0
		for i in range(k, n + 1):
			cost = sum_arr[i] - sum_arr[i - k]
			if min_cost > sum_arr[i] - sum_arr[i - k]:
				min_cost = sum_arr[i] - sum_arr[i - k]
				min_index = i
		return min_index - k + 1

	@classmethod
	def dp_solve(cls, n: int, k: int, heights: List[int]) -> int:
		if k == n and sum(heights) == n:
			return 1
		else:
			sum_arr = []
			for (index, element) in enumerate(heights):
				if index == 0:
					sum_arr.append(element)
				else:
					sum_arr.append(element + sum_arr[index - 1])
			min_cost = 15000000
			min_index = 0
			for (index, element) in enumerate(sum_arr[:-k]):
				if k == 2:
					cost = abs(heights[index + 1] - heights[index])
				elif index == 0:
					cost = sum_arr[k - 1] - sum_arr[0]
				else:
					cost = sum_arr[index + k - 1] - sum_arr[index]
				if cost < min_cost:
					min_cost = cost
					min_index = index
			return min_index + 1

	@classmethod
	def brute_force_solve(cls, n: int, k: int, heights: List[int]) -> int:
		if k == n and sum(heights) == n:
			return 1
		else:
			min_cost = 500
			reqd_index = -1
			for (index, plank) in enumerate(heights[:k]):
				numbers = heights[index:index + k]
				cost = sum(numbers)
				if cost < min_cost:
					reqd_index = index
					min_cost = cost
			return reqd_index + 1
[n, k] = list(map(lambda x: int(x), input().split()))
heights = list(map(lambda x: int(x), input().split()))
result = Solution.solve(n, k, heights)
print(result)


(n, k) = map(int, input().split(' '))
ar = list(map(int, input().split(' ')))
s = sum(ar[:k])
s1 = s
j = 0
for i in range(k, n):
	s1 = min(s1, s)
	s = s + ar[i] - ar[i - k]
	if s < s1:
		j = i - k + 1
print(j + 1)


(n, k) = list(map(int, input().split()))
boards = list(map(int, input().split()))
s = sum(boards[0:k])
cur_sum = s
j = 0
for i in range(1, n - k + 1):
	cur_sum = cur_sum - boards[i - 1] + boards[i + k - 1]
	if cur_sum < s:
		s = cur_sum
		j = i
print(j + 1)


(n, k) = map(int, input().split())
A = list(map(int, input().split()))
ans_n = 0
cur = sum(A[:k])
ans = cur
cur_n = 1
while cur_n + k - 1 < n:
	cur -= A[cur_n - 1]
	cur += A[cur_n + k - 1]
	if cur < ans:
		ans = cur
		ans_n = cur_n
	cur_n += 1
print(ans_n + 1)


(n, k) = list(map(int, input().split()))
z = [int(x) for x in input().split()]
pref = [0]
for i in range(1, n + 1):
	pref.append(z[i - 1] + pref[i - 1])
minsum = 1000000000
minind = 1
for j in range(1, n - k + 2):
	if pref[j + k - 1] - pref[j - 1] < minsum:
		minsum = pref[j + k - 1] - pref[j - 1]
		minind = j
	else:
		continue
print(minind)


nk = list(map(int, input().rstrip().split()))
n = nk[0]
k = nk[1]
array = list(map(int, input().rstrip().split()))
s = 0
init = 0
for i in range(k):
	s += array[i]
minm = s
for i in range(n - k):
	s += array[i + k] - array[i]
	if minm > s:
		minm = s
		init = i + 1
print(init + 1)


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
(N, K) = map(int, input().split())
A = [int(x) for x in input().split()]
height = sum(A[:K])
minHeigh = height
ans = 1
for i in range(K, N):
	height += A[i]
	height -= A[i - K]
	if height < minHeigh:
		minHeigh = height
		ans = i - K + 2
print(ans)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
min_so_far = sum(h[:k])
s = min_so_far
min_index = 1
for i in range(k, n):
	s += h[i] - h[i - k]
	if s < min_so_far:
		min_index = i - k + 2
		min_so_far = s
print(min_index)


(n, k) = map(int, input().split())
idx = 0
p = list(map(int, input().split()))
w = sum(p[0:k])
m = w
for i in range(k, n):
	w += p[i]
	w -= p[i - k]
	if w < m:
		idx = i - k + 1
		m = w
print(idx + 1)


(n, k) = map(int, input().split())
l = [*map(int, input().split())]
sm = 0
for i in range(k):
	sm += l[i]
mx = sm
m = n - k + 1
index = 0
for i in range(1, m):
	sm -= l[i - 1]
	sm += l[i + k - 1]
	if sm < mx:
		mx = sm
		index = i
index += 1
print(index)


(n, k) = map(int, input().strip().split())
fence = tuple(map(int, input().strip().split()))
smallest = current = sum(fence[:k])
bestindex = 1
for i in range(k, n):
	current += fence[i] - fence[i - k]
	if current < smallest:
		bestindex = i - k + 2
		smallest = current
	if smallest == k:
		break
print(bestindex)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
sh = [0] * (len(h) - k + 1)
sh[0] = sum(h[:k])
for i in range(1, len(sh)):
	sh[i] = sh[i - 1] + (h[i + k - 1] - h[i - 1])
MIN = min(sh)
print(sh.index(MIN) + 1)


(n, k) = map(int, input().split())
h = [int(i) for i in input().split()]
sum = [0] * (n + 1)
for j in range(1, n + 1):
	sum[j] = sum[j - 1] + h[j - 1]
min = sum[k]
i = 0
for j in range(n - k + 1):
	temp_min = sum[j + k] - sum[j]
	if temp_min < min:
		min = temp_min
		i = j
print(i + 1)


st = input().split()
n = int(st[0])
k = int(st[1])
h = []
mp = map(int, input().split())
for j in mp:
	h.append(j)
sum = [0 for i in range(n + 1)]
for i in range(1, n + 1):
	sum[i] = sum[i - 1] + h[i - 1]
min_sum = (n + 100) * 100
min_index = -1
for i in range(k, n + 1):
	temp = sum[i] - sum[i - k]
	if temp < min_sum:
		min_sum = temp
		min_index = i - k + 1
print(min_index)


x = input().split()
(n, k) = (int(x[0]), int(x[1]))
heights = input().split()
heights = [int(height) for height in heights]
sums = heights
index = 0
best = 1000 if k > 1 else sums[0]
for i in range(1, n):
	sums[i] = sums[i] + sums[i - 1]
	if i == k - 1:
		best = sums[i]
		index = 0
	elif i > k - 1:
		if sums[i] - sums[i - k] < best:
			best = sums[i] - sums[i - k]
			index = i - k + 1
print(index + 1)


from copy import deepcopy as dc
(n, k) = input().split()
k = int(k)
list_n = []
elements = input().split()
for element in elements:
	list_n.append(int(element))
list_m = dc(list_n)
sum_first = 0
for i in range(k):
	sum_first += list_m[i]
list_m[k - 1] = sum_first
for i in range(k, len(list_n)):
	list_m[i] = list_m[i - 1] + list_m[i] - list_n[i - k]
list_m = list_m[k - 1:]
minn = min(list_m)
print(list_m.index(minn) + 1)


def main():
	(n, k) = map(int, input().split())
	hh = list(map(int, input().split()))
	s = sum(hh[:k])
	l = [s]
	for (a, b) in zip(hh, hh[k:]):
		s = s + b - a
		l.append(s)
	print(min(range(len(l)), key=l.__getitem__) + 1)
main()


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a.append(0)
m = 1000000000000
l = sum(a[:k])
if n == k:
	print(1)
	exit()
for i in range(len(a) - k):
	if l < m:
		m = l
		s = i + 1
	l = l - a[i] + a[k + i]
print(s)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
s = [11 ** 11, sum(l[0:k])]
for i in range(1, n - k + 1):
	s += [s[-1] - l[i - 1] + l[i + k - 1]]
print(s.index(min(s)))


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
highs = [0]
for i in range(n):
	highs.append(highs[-1] + h[i])
ans = 1
fa = 10 ** 10
for i in range(n - k + 1):
	if highs[i + k] - highs[i] < fa:
		ans = i
		fa = highs[i + k] - highs[i]
print(ans + 1)


(n, k) = map(int, input().split())
L = list(map(int, input().split()))
T = [0 for _ in range(n)]
T[0] = L[0]
for i in range(1, k):
	T[i] = T[i - 1] + L[i]
for i in range(k, n):
	T[i] = T[i - 1] + L[i] - L[i - k]
m = T[k - 1]
ind = k - 1
for i in range(k, n):
	if T[i] < m:
		ind = i
		m = T[i]
print(ind - k + 2)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
if k == n:
	print(1)
else:
	b = [0] * (n - k + 1)
	for i in range(k):
		b[0] += a[i]
	for i in range(1, n - k + 1):
		b[i] = b[i - 1] - a[i - 1] + a[i + k - 1]
	c = min(b)
	print(b.index(c) + 1)


from sys import stdin, stdout
from collections import defaultdict
import heapq as hq

def get_int():
	return int(stdin.readline().strip())

def get_ints():
	return map(int, stdin.readline().strip().split())

def get_array():
	return list(map(int, stdin.readline().strip().split()))

def get_string():
	return stdin.readline().strip()
INF = 10000000000.0
(n, k) = get_ints()
h = get_array()
dp = [0] * (n - k + 1)
for i in range(k):
	dp[0] += h[i]
minh = dp[0]
index = 0
i = 1
for j in range(k, n):
	dp[i] = dp[i - 1] + h[j] - h[j - k]
	if dp[i] < minh:
		minh = dp[i]
		index = j - k + 1
	i += 1
print(index + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
d = sum(a[0:k])
j = [d]
for i in range(n - k):
	d = d - a[i] + a[i + k]
	j.append(d)
print(j.index(min(j)) + 1)


(n, k) = map(int, input().strip().split())
a = list(map(int, input().strip().split()))
w = sum(a[:k])
j = 1
r = sum(a[:k])
for i in range(k, n):
	w += a[i] - a[i - k]
	if w < r:
		j = i - k + 2
		r = w
print(j)


(a, b) = map(int, input().split())
l = list(map(int, input().split()))
l1 = [l[0]]
l2 = []
for i in range(a - 1):
	l1.append(l1[i] + l[i + 1])
l2.append(l1[b - 1])
for j in range(1, a - b + 1):
	l2.append(l1[b - 1 + j] - l1[j - 1])
print(l2.index(min(l2)) + 1)


(n, k) = list(map(int, input().split()))
l = list(map(int, input().split()))
a = [sum(l[0:k])]
for i in range(1, len(l) - k + 1):
	x = a[i - 1] + l[i + k - 1] - l[i - 1]
	a.append(x)
print(a.index(min(a)) + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
pref = [a[0]]
(ans, ans1) = (1, a[0])
for i in range(1, n):
	pref.append(pref[-1] + a[i])
	if i < k:
		ans1 = pref[i]
	else:
		tmp = pref[i] - pref[i - k]
		if tmp < ans1:
			ans = i - k + 2
			ans1 = tmp
print(ans)


(n, k) = map(int, input().split())
boards = list(map(int, input().split()))
j = 0
sub_sum = min_sum = sum(boards[:k])
for i in range(n - k):
	sub_sum += boards[k + i] - boards[i]
	if sub_sum < min_sum:
		(j, min_sum) = (i + 1, sub_sum)
print(j + 1)


(n, k) = map(int, input().split())
g = list(map(int, input().split()))
(s, m) = (0, 0)
r = []
for i in range(len(g)):
	if i <= k - 1:
		s += g[i]
	else:
		r += [s]
		s = s - g[m] + g[i]
		m += 1
r += [s]
g = r.index(min(r)) + 1
print(g)


def actions(n, k, h):
	j = 0
	smin = sum([h[x] for x in range(0, k)])
	last = smin
	for i in range(1, n - k + 1):
		s = last - h[i - 1] + h[i + k - 1]
		last = s
		if s < smin:
			smin = s
			j = i
	return j + 1

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


(n, k) = [int(x) for x in input().split(' ')]
h = [int(x) for x in input().split(' ')]
m = []
sum = 0
for (i, x) in enumerate(h):
	sum += x
	if i + 1 == k:
		m.append(sum)
	elif i >= k:
		sum -= h[i - k]
		m.append(sum)
i = 0
mn = m[0]
for (j, x) in enumerate(m):
	if x < mn:
		i = j
		mn = x
print(i + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
maxi = 10 ** 20
j = 0
sum = 0
for i in range(k):
	sum += h[i]
maxi = sum
for i in range(k, n):
	sum += h[i] - h[i - k]
	if sum < maxi:
		maxi = sum
		j = i - k + 1
print(j + 1)


(n, k) = map(int, input().split())
lst = list(map(int, input().split()))
ss = 0
for i in range(k):
	ss += lst[i]
ans = ss
ind = 1
for i in range(1, n - k + 1):
	ss -= lst[i - 1]
	ss += lst[i + k - 1]
	if ss < ans:
		ind = i + 1
		ans = ss
print(ind)


(n, k) = map(int, input().split())
a = [int(a) for a in input().split()]
ind = 0
for i in range(1, n):
	a[i] += a[i - 1]
mi = a[k - 1]
for i in range(k, n):
	if a[i] - a[i - k] < mi:
		mi = a[i] - a[i - k]
		ind = i - k + 1
print(ind + 1)


(n, k) = map(int, input().split())
heights = list(map(int, input().split()))
score = 0
ret = 0
for i in range(k):
	score += heights[i]
minscore = score
for i in range(1, n - k + 1):
	score += heights[i + k - 1] - heights[i - 1]
	if score < minscore:
		minscore = score
		ret = i
print(ret + 1)


(n, k) = map(int, input().split())
hights = list(map(int, input().split()))
total = sum(hights[:k])
ans = []
for i in range(n - k):
	ans.append(total)
	total = total + hights[i + k] - hights[i]
ans.append(total)
print(ans.index(min(ans)) + 1)


from sys import stdin
(n, k) = [int(x) for x in stdin.readline().split()]
arr = [int(x) for x in stdin.readline().split()]
index = 1
ans = sum(arr[:k])
s = ans
for i in range(1, n - k + 1):
	s += -arr[i - 1] + arr[i + k - 1]
	if s < ans:
		ans = s
		index = i + 1
print(index)


(quantity, width) = [int(x) for x in input().split()]
fences = [int(x) for x in input().split()]
total = sum(fences[0:width])
current = total
leastt = 0
for i in range(width, quantity):
	current = current - fences[i - width] + fences[i]
	if current < total:
		total = current
		leastt = i - width + 1
print(leastt + 1)


l = list(map(int, input().split(' ')))
n = l[0]
k = l[1]
a = list(map(int, input().split(' ')))
b = [0]
count = 0
for i in a:
	count = count + i
	b.append(count)
ans = max(b)
i = 1
t = 1
while i + (k - 1) <= n:
	total = b[i + (k - 1)] - b[i - 1]
	if total < ans:
		ans = total
		t = i
	i = i + 1
if n > 2:
	print(t)
elif n == 2 and k == 1:
	if a[0] > a[1]:
		print('2')
	if a[1] >= a[0]:
		print('1')
elif n == 2 and k > 1:
	print('1')
elif n == 1:
	print('1')


(n, k) = map(int, input().split())
l = [int(x) for x in input().split()]
global_min = sum(l[:k])
cur_min = global_min
pointer = 1
for i in range(k, n):
	cur_min = cur_min - l[i - k] + l[i]
	if global_min > cur_min:
		global_min = cur_min
		pointer = i - k + 2
print(pointer)


(n, k) = map(int, input().split())
h = [int(x) for x in input().split()]
_min = curr = sum(h[:k])
_min_j = 0
for j in range(1, n - k + 1):
	curr -= h[j - 1]
	curr += h[j + k - 1]
	if curr < _min:
		_min = curr
		_min_j = j
print(_min_j + 1)


(n, k) = [int(x) for x in input().split()]
fences = [int(x) for x in input().split()]
minHeight = 50000000
current = 0
height = []
for i in range(0, n - k + 1):
	height.append(0)
for i in range(0, k):
	height[0] += fences[i]
for i in range(1, n - k + 1):
	height[i] = height[i - 1] - fences[i - 1] + fences[i + k - 1]
minHeight = min(height)
for i in range(0, n - k + 1):
	if height[i] == minHeight:
		print(i + 1)
		break


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
dp = [0] * (n - k + 1)
dpv = 1
for i in range(k):
	dp[0] += a[i]
for i in range(k, n):
	dp[dpv] = dp[dpv - 1] - a[i - k] + a[i]
	dpv += 1
print(dp.index(min(dp)) + 1)


def main():
	(n, k) = map(int, input().split())
	planks = list(map(int, input().split()))
	min_ht = float('inf')
	ht = 0
	i = 0
	count = 0
	start = 0
	index = 1
	while i < n:
		ht += planks[i]
		count += 1
		if count == k:
			count -= 1
			if ht < min_ht:
				min_ht = ht
				index = start + 1
			ht -= planks[start]
			start += 1
		i += 1
	print(index)
main()


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
(n, k) = invr()
A = inlt()
curr = 0
for i in range(k):
	curr += A[i]
ind = 0
out = curr
for i in range(k, n, 1):
	curr -= A[i - k]
	curr += A[i]
	if curr < out:
		out = curr
		ind = i - k + 1
print(ind + 1)


(n, k) = map(int, input().split())
f = list(map(int, input().split()))
mn = 0
j = 1
for i in range(k):
	mn += f[i]
current = mn
for i in range(k, n):
	current = current - f[i - k] + f[i]
	if current < mn:
		mn = current
		j = i - k + 2
print(j)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
s = temp = sum(l[:k])
index = 0
i = 0
while i < n - k:
	temp = temp - l[i] + l[i + k]
	if temp < s:
		s = temp
		index = i + 1
	i += 1
print(index + 1)


(n, k) = list(map(int, input().split()))
arr = list(map(int, input().split()))
nums = [0] * n
nums[0] = arr[0]
for i in range(1, n):
	nums[i] = nums[i - 1] + arr[i]
ans = float('inf')
ind = 0
for i in range(n - k + 1):
	if i == 0:
		x = nums[i + k - 1]
	else:
		x = nums[i + k - 1] - nums[i - 1]
	if x < 0:
		x = -1 * x
	if x < ans:
		ans = x
		ind = i
print(ind + 1)


ans = []
(n, l) = list(map(int, input().split()))
fence = list(map(int, input().split()))
summation = sum(fence[:l])
ans.append(summation)
for i in range(1, n - l + 1):
	summation = summation - fence[i - 1] + fence[i + l - 1]
	ans.append(summation)
ind = ans.index(min(ans))
print(ind + 1)


words = []
for word in input().split():
	words.append(word)
n = int(words[0])
k = int(words[1])
v = []
for word in input().split():
	v.append(int(word))
start = 0
minSum = 0
sum = 0
for i in range(k):
	sum += v[i]
	minSum += v[i]
for i in range(k, n):
	sum -= v[i - k]
	sum += v[i]
	if minSum > sum:
		start = i - k + 1
		minSum = sum
print(start + 1)


import sys
input = sys.stdin.readline
read_tuple = lambda _type: map(_type, input().split(' '))

def solve():
	(n, k) = read_tuple(int)
	heights = list(read_tuple(int))
	prefix_sum = [0]
	for i in range(n):
		prefix_sum.append(prefix_sum[-1] + heights[i])
	(ans_j, ans_sum) = (None, float('inf'))
	for j in range(1, n + 2 - k):
		curr_sum = prefix_sum[j + k - 1] - prefix_sum[j - 1]
		if curr_sum < ans_sum:
			(ans_j, ans_sum) = (j, curr_sum)
	print(ans_j)
solve()


(n, k) = map(int, input().split())
arr = [int(x) for x in input().split()]
s = sum(arr[:k])
val = 1
m = s
for i in range(n - k):
	ss = s - arr[i] + arr[i + k]
	if m > ss:
		m = ss
		val = i + 2
	s = ss
print(val)


(n, p) = map(int, input().split())
fence = list(map(int, input().split()))
if p == 1:
	print(fence.index(min(fence)) + 1)
else:
	capt = [fence[0]]
	agre = fence[0]
	for x in range(1, n):
		agre += fence[x]
		capt.append(agre)
	(head, tail) = (0, p)
	cret = [(capt[p - 1], 1)]
	while tail < n:
		cret.append((capt[tail] - capt[head], head + 2))
		tail += 1
		head += 1
	print(min(cret)[1])


(n, k) = map(int, input().split())
f = [*map(int, input().split())]
m = t = sum(f[:k])
j = 0
for i in range(k, n):
	t += f[i] - f[i - k]
	if t < m:
		m = t
		j = i - k + 1
print(j + 1)


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return map(int, input().split())

def array():
	return [int(i) for i in input().split()]
(n, k) = value()
a = array()
s = sum(a[:k])
ans = 1
t = s
i = 1
for i in range(1, n - k + 1):
	t += -a[i - 1] + a[i + k - 1]
	if t < s:
		s = t
		ans = i + 1
print(ans)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
d = [0]
start = 0
min_sum = 10 ** 10
for i in range(n):
	d.append(d[i] + h[i])
for i in range(1, n - k + 2):
	f = d[i + k - 1] - d[i - 1]
	if f < min_sum:
		min_sum = f
		start = i
print(start)


(n, k) = input().split(' ')
a = input().split(' ')
sum = 0
for i in range(0, int(k)):
	sum += int(a[i])
res = sum
ans = 0
for i in range(int(k), int(n)):
	sum += int(a[i])
	sum -= int(a[i - int(k)])
	if sum < res:
		res = sum
		ans = i - int(k) + 1
print(ans + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
sol = [0] * (n - k + 1)
sol[0] = sum(h[:k])
ans = sol[0]
index = 0
for i in range(1, len(sol)):
	sol[i] = sol[i - 1] - h[i - 1] + h[i + k - 1]
	if sol[i] < ans:
		ans = sol[i]
		index = i
print(index + 1)


(n, k) = input().split()
(n, k) = (int(n), int(k))
a = list(map(int, input().split()))
s = 0
for i in range(0, k):
	s += a[i]
dp = [0] * (n - k + 1)
min_s = s
ans = 0
dp[0] = s
for i in range(1, n - k + 1):
	dp[i] = dp[i - 1] + a[i + k - 1] - a[i - 1]
	if dp[i] < min_s:
		min_s = dp[i]
		ans = i
print(ans + 1)


(n, k) = list(map(int, input().split(' ')))
h = list(map(int, input().split(' ')))
cum_sum = [h[0]]
for i in range(1, n):
	cum_sum.append(cum_sum[i - 1] + h[i])
min_ht = cum_sum[k - 1]
index = 0
for i in range(1, n - k + 1):
	sum_ht = cum_sum[i + (k - 1)] - cum_sum[i - 1]
	if min_ht > sum_ht:
		index = i
		min_ht = sum_ht
print(index + 1)


(n, k) = [int(y) for y in input().split()]
h = [int(y) for y in input().split()]
sm = sum(h[:k])
mx = sm
idx = 0
for i in range(1, n - k + 1):
	sm = sm - h[i - 1] + h[i + k - 1]
	if sm < mx:
		mx = sm
		idx = i
print(idx + 1)


l = input().split()
n = int(l[0])
k = int(l[1])
arr = list(map(int, input().split()))
min = 0
sum = 0
r = 1
for i in range(k):
	min += arr[i]
sum = min
for j in range(k, n):
	sum = sum + arr[j] - arr[j - k]
	if sum < min:
		min = sum
		r = j - k + 2
print(r)


import sys
import math
from collections import defaultdict
import itertools
MAXNUM = math.inf
MINNUM = -1 * math.inf

def getInt():
	return int(sys.stdin.readline().rstrip())

def getInts():
	return map(int, sys.stdin.readline().rstrip().split(' '))

def getString():
	return sys.stdin.readline().rstrip()

def printOutput(ans):
	sys.stdout.write()
	pass

def solve(k, planks):
	total = 0
	for i in range(k):
		total += planks[i]
	mn = total
	index = 1
	for i in range(k, len(planks)):
		total -= planks[i - k]
		total += planks[i]
		if total < mn:
			mn = min(total, mn)
			index = i - k + 2
	return index

def readinput():
	(n, k) = getInts()
	planks = list(getInts())
	print(solve(k, planks))
readinput()


[n, k] = [int(item) for item in input().split(' ')]
heights = [int(item) for item in input().split(' ')]
min_index = 1
min_sum = sum(heights[:k])
running_sum = min_sum
for i in range(k, n):
	running_sum -= heights[i - k]
	running_sum += heights[i]
	if running_sum < min_sum:
		min_sum = running_sum
		min_index = i - k + 2
print(min_index)


from sys import stdin, stdout
for _ in range(1):
	(n, k) = map(int, stdin.readline().split())
	a = list(map(int, stdin.readline().split()))
	m = s = sum(a[:k])
	ans = 1
	for i in range(1, n - k + 1):
		s = s - a[i - 1] + a[i + k - 1]
		if s < m:
			ans = i + 1
			m = s
	stdout.write(str(ans) + '\n')


def MinSubArray(P, A=[]):
	(i, k, ret, r) = (1, 0, 0, 0)
	for j in range(0, P):
		ret += A[j]
	r = ret
	while i < len(A) - P + 1:
		r += A[i + P - 1] - A[i - 1]
		if r < ret:
			k = i
			ret = r
		i += 1
	return k + 1
(N, P) = map(int, input().split())
A = list(map(int, input().split()))
print(MinSubArray(P, A))


(n, k) = map(int, input().split())
arr = list(map(int, input().split()[:n]))
s = 0
for i in range(k):
	s += arr[i]
mn = s
ind = 1
i = 0
for j in range(k, n):
	s = s - arr[i] + arr[j]
	if s < mn:
		mn = s
		ind = i + 2
	i += 1
print(ind)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
j = 0
pre = [arr[0]] + [0] * n
m = 2000000000.0
for i in range(1, n):
	pre[i] = pre[i - 1] + arr[i]
for i in range(n - k + 1):
	if pre[i + k - 1] - pre[i - 1] < m:
		j = i
		m = pre[i + k - 1] - pre[i - 1]
print(j + 1)


(n, k) = map(int, input().split())
A = list(map(int, input().split()))
sm = 0
for i in range(k):
	sm += A[i]
result = sm
ri = 0
for i in range(k, n, 1):
	sm += A[i]
	sm -= A[i - k]
	if result > sm:
		result = sm
		ri = i - k + 1
print(ri + 1)


def main():
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	s = sum(l[:k])
	min = s
	x = 0
	for i in range(1, n - k + 1):
		s = s - l[i - 1] + l[k + i - 1]
		if s < min:
			min = s
			x = i
	return x + 1
print(main())


(n, k) = list(map(int, input().split(' ')))
arr = list(map(int, input().split(' ')))
summ = 0
for i in range(k):
	summ += arr[i]
result = summ
index = 1
last = 0
for i in range(k, n):
	summ += arr[i] - arr[last]
	if summ < result:
		result = summ
		index = last + 2
	last += 1
print(index)


import math
import sys
(n, k) = map(int, input().split())
d = list(map(int, input().split()))
gm = sum(d[:k])
cm = gm
pos = 0
for i in range(k, n):
	t = cm - d[i - k] + d[i]
	if t < gm:
		pos = i - k + 1
		gm = t
	cm = t
print(pos + 1)


(n, k) = map(int, input().rstrip().split())
l = list(map(int, input().rstrip().split()))
store = list()
start = l[:k - 1]
sum1 = sum(start)
for i in range(k - 1, n):
	start.append(l[i])
	sum2 = sum1 + l[i]
	store.append(sum2)
	sum1 = sum2 - start[0]
	del start[0]
ind = store.index(min(store))
print(ind + 1)


import sys
import math
from collections import *

def get_ints():
	return map(int, input().split())

def get_list():
	return list(get_ints())

def printspx(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
UGLYMOD = int(1000000000.0 + 7)
SEXYMOD = 998244353
MAXN = int(100000.0)
(n, k) = get_ints()
li = get_list()
ans = -1
count = 0
mn = float('inf')
prefix = [0]
for i in range(1, n + 1):
	count += li[i - 1]
	prefix.append(count)
	if i >= k:
		if prefix[i] - prefix[i - k] < mn:
			mn = prefix[i] - prefix[i - k]
			ans = i - k + 1
print(ans)


in_nums = input().split()
num_posts = int(in_nums[0])
k = int(in_nums[1])
heights = [int(x) for x in input().split()]
current_sum = sum(heights[:k])
current_min = current_sum
min_idx = 0
for n in range(1, num_posts - k + 1):
	current_sum += -1 * heights[n - 1] + heights[n + k - 1]
	if current_sum < current_min:
		current_min = current_sum
		min_idx = n
print(min_idx + 1)


(n, k) = map(int, input().split())
h = [int(x) for x in input().split()]
a = sum(h[:k])
b = a
ind = 0
for i in range(n - k):
	b = b - h[i] + h[i + k]
	if b < a:
		ind = i + 1
		a = b
print(ind + 1)


length = list(map(int, input().split()))
arr = list(map(int, input().split()))
distance = length[1]
indices = finalsum = cursum = 0
for i in range(distance):
	cursum += arr[i]
finalsum = cursum
for i in range(1, len(arr) - distance + 1):
	cursum -= arr[i - 1]
	cursum += arr[i + distance - 1]
	if cursum < finalsum:
		indices = i
		finalsum = cursum
print(indices + 1)


import math, sys, re, itertools, pprint
(ri, rai) = (lambda : int(input()), lambda : list(map(int, input().split())))
(n, k) = rai()
a = rai()
s = [a[0]]
for i in range(1, len(a)):
	s.append(s[-1] + a[i])
(j, sj) = (0, s[k - 1])
for i in range(1, len(a) - k + 1):
	if s[i + k - 1] - s[i - 1] < sj:
		j = i
		sj = s[i + k - 1] - s[i - 1]
print(j + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
c = [0] * len(a)
c[0] = a[0]
for i in range(1, n):
	c[i] = c[i - 1] + a[i]
mini = c[k - 1]
h = 1
for i in range(k, n):
	t = mini
	mini = min(mini, c[i] - c[i - k])
	if mini != t:
		h = i - k + 2
print(h)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
dp = [0 for i in range(n)]
dp[0] = l[0]
for i in range(1, n):
	dp[i] = l[i] + dp[i - 1]
dp.insert(0, 0)
ks = []
try:
	for i in range(0, n - k + 1):
		ks.append([dp[i + k] - dp[i], i])
except:
	pass
print(min(ks)[1] + 1)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
q = n - m
res = [1000000000 for i in range(n)]
res[q] = sum(a[q:n])
for i in range(q - 1, -1, -1):
	res[i] = res[i + 1] - a[i + m] + a[i]
x = min(res)
print(res.index(x) + 1)


a = list(map(int, input().split()))
b = list(map(int, input().split()))
m = c = sum(b[:a[1]])
p = 0
for i in range(a[0] - a[1]):
	c = c - b[i] + b[i + a[1]]
	if c < m:
		m = c
		p = i + 1
print(p + 1)


(n, m) = map(int, input().split())
l = [0] + list(map(int, input().split()))
for i in range(2, n + 1):
	l[i] = l[i - 1] + l[i]
ans = m * 100 + 1
ind = -1
for i in range(m, n + 1):
	if l[i] - l[i - m] < ans:
		ans = l[i] - l[i - m]
		ind = i - m + 1
print(ind)


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
dp = [1] * n
dp[0] = a[0]
for i in range(1, k):
	dp[i] = dp[i - 1] + a[i]
for i in range(k, n):
	dp[i] = dp[i - 1] + a[i] - a[i - k]
dp = dp[k - 1:]
print(dp.index(min(dp)) + 1)


(n, k) = input().split(' ')
n = int(n)
k = int(k)
lengths = list(map(int, input().split(' ')))
s = sum(lengths[0:k])
answer = s
alpha = 0
for i in range(k, n):
	if s + lengths[i] - lengths[i - k] < answer:
		answer = s + lengths[i] - lengths[i - k]
		s = s + lengths[i] - lengths[i - k]
		alpha = i - k + 1
	else:
		s = s + lengths[i] - lengths[i - k]
		continue
print(alpha + 1)


(n, k) = list(map(int, input().split()))
h = list(map(int, input().split()))
sm = 0
for i in range(k):
	sm += h[i]
j = k - 1
temp = sm
for i in range(k, n):
	temp += h[i] - h[i - k]
	if sm > temp:
		j = i
		sm = temp
print(j - k + 2)


import math as mt
import sys, string, bisect
input = sys.stdin.readline
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
(n, k) = M()
l = L()
g = [0, l[0]]
for i in range(1, n):
	g.append(g[-1] + l[i])
m = 10 ** 10
key = 0
for i in range(k, n + 1):
	if g[i] - g[i - k] < m:
		m = g[i] - g[i - k]
		key = i - k + 1
print(key)


(n, k) = list(map(int, input().split()))
fences = list(map(int, input().split()))
prev_sum = sum(fences[:k])
min_sum = prev_sum
ans = 1
for i in range(k, n):
	new_sum = prev_sum - fences[i - k] + fences[i]
	if new_sum < min_sum:
		min_sum = new_sum
		ans = i - k + 2
	prev_sum = new_sum
print(ans)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
r = []
p = sum(a[:k])
s = p
m = 0
for i in range(1, n - k + 1):
	s = s - a[i - 1] + a[i + k - 1]
	if s < p:
		p = s
		m = i
print(m + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
window = 0
for i in range(k):
	window += arr[i]
mi = window
index = 0
for i in range(k, n):
	window += arr[i]
	window -= arr[i - k]
	if window < mi:
		mi = window
		index = i
if index != 0:
	print(index - k + 2)
else:
	print(1)


(n, k) = map(int, input().split())
A = [int(a) for a in input().split()]
j = 0
last = sum(A[:k])
m = last
for i in range(1, n - k + 1):
	aux = last - A[i - 1] + A[i + k - 1]
	last = aux
	if aux < m:
		m = aux
		j = i
print(j + 1)


import sys
(n, k) = map(int, input().split())
l = list(map(int, input().split()))
j = 0
min_so_far = sum(l[0:k])
min_sum = min_so_far
if n == k:
	print(j + 1)
	sys.exit(0)
for i in range(1, n - k + 1):
	min_so_far = min_so_far - l[i - 1] + l[i + k - 1]
	if min_so_far < min_sum:
		min_sum = min_so_far
		j = i
print(j + 1)


from sys import maxsize, stdout, stdin, stderr
import re
tup = lambda : map(int, stdin.readline().split())
I = lambda : int(stdin.readline())
lint = lambda : [int(x) for x in stdin.readline().split()]
S = lambda : stdin.readline().replace('\n', '').strip()

def grid(r, c):
	return [lint() for i in range(r)]

def debug(*args, c=6):
	print('\x1b[3{}m'.format(c), *args, '\x1b[0m', file=stderr)
(n, k) = tup()
ls = lint()
if n == 1:
	print(1)
	exit()
a = sum(ls[:k])
idx = 1
mi = a
for i in range(n - k):
	a = a - ls[i] + ls[i + k]
	if a < mi:
		a = mi
		idx = i + 2
print(idx)


values = list(map(int, input().split()))
n = values[0]
k = values[1]
heights = list(map(int, input().split()))
ks_heights = [sum(heights[:k])]
i = 1
while i <= n - k:
	ks_heights += [ks_heights[-1] - heights[i - 1] + heights[i + k - 1]]
	i += 1
print(ks_heights.index(min(ks_heights)) + 1)


(n, k) = list(map(int, input().strip().split()))
fence = list(map(int, input().strip().split()))
curr_sum = sum(fence[:k])
min_ = curr_sum
j = 0
for i in range(1, len(fence) - k + 1):
	curr_sum = curr_sum - fence[i - 1] + fence[k + i - 1]
	if curr_sum < min_:
		min_ = curr_sum
		j = i
print(j + 1)


import sys
sys.setrecursionlimit(10000)
(n, k) = [int(x) for x in sys.stdin.readline().strip().split()]
h = [int(x) for x in sys.stdin.readline().strip().split()]
cons_h = [0] + h
for i in range(1, n + 1):
	cons_h[i] += cons_h[i - 1]
index = 1
m = 10 ** 8
for i in range(0, n - k + 1):
	k_sum = cons_h[i + k] - cons_h[i]
	if m > k_sum:
		m = k_sum
		index = i + 1
print(index)


(m, k) = list(map(int, input().split()))
lst = list(map(int, input().split()))
minn = float('inf')
ind = 0
val = sum(lst[:k])
(p, n) = (-1, k - 1)
for i in range(m - k + 1):
	if i != 0:
		val += lst[n] - lst[p]
	p += 1
	n += 1
	if minn > val:
		ind = i
		minn = val
print(ind + 1)


(n, k) = list(map(int, input().split()))
h = list(map(int, input().split()))
s = 0
for i in range(k):
	s += h[i]
minSum = s
minJ = 1
for i in range(k, n):
	s -= h[i - k]
	s += h[i]
	if minSum > s:
		minSum = s
		minJ = i - k + 2
print(minJ)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
ans = [0] * (n - k + 1)
ans[0] = sum(h[:k])
minim = ans[0]
aminim = 0
for i in range(1, n - k + 1):
	ans[i] = ans[i - 1] + h[i + k - 1] - h[i - 1]
	if ans[i] < minim:
		minim = ans[i]
		aminim = i
print(aminim + 1)


(n, k) = [int(x) for x in input().split()]
h = [int(x) for x in input().split()]
rsum = [0] * n
s = 0
for i in range(n):
	s += h[i]
	rsum[i] = s
min_sum = 10 ** 10
ans = None
for i in range(n - k + 1):
	if i > 0:
		s = rsum[i + k - 1] - rsum[i - 1]
	else:
		s = rsum[i + k - 1]
	if s < min_sum:
		min_sum = s
		ans = i + 1
print(ans)


(n, k) = map(int, input().split())
l = []
s = 0
a = list(map(int, input().split()))
for i in range(k):
	s = s + a[i]
l.append(s)
p = s
for i in range(n - k):
	p = p - a[i] + a[i + k]
	l.append(p)
m = min(l)
i = l.index(m)
print(i + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
j = 1
minh = sum(h[0:k])
summ = minh
for i in range(1, n - k + 1):
	summ = summ + h[i + k - 1] - h[i - 1]
	if summ < minh:
		minh = summ
		j = i + 1
print(j)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
start = sum(l[0:k])
mi = start
m = 1
c = 0
for (j, x) in enumerate(l[k:]):
	n = start - l[c] + x
	c += 1
	if n < mi:
		m = c + 1
		mi = n
	start = n
print(m)


import sys, threading, os.path
import collections, heapq, math, bisect
import string
from platform import python_version
import itertools
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)

def main():
	if os.path.exists('input.txt'):
		input = open('input.txt', 'r')
	else:
		input = sys.stdin
	(n, k) = list(map(int, input.readline().split()))
	lis = list(map(int, input.readline().split()))
	res = []
	sum = 0
	for i in range(n):
		if i < k:
			sum += lis[i]
		else:
			sum -= lis[i - k]
			sum += lis[i]
		res.append(sum)
	(minnum, ress) = (1e+19, 1)
	for i in range(k - 1, n):
		if res[i] < minnum:
			minnum = res[i]
			ress = i - k + 2
	output = ress
	if os.path.exists('output.txt'):
		open('output.txt', 'w').writelines(str(output))
	else:
		sys.stdout.write(str(output))
main()


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
s = sum(a[:k])
_min = s
_min_pos = 1
start = 0
end = k - 1
while end + 1 < n:
	start += 1
	end += 1
	s -= a[start - 1]
	s += a[end]
	if s < _min:
		s = _min
		_min_pos = start + 1
print(_min_pos)


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


(n, k) = map(int, input().split())
f = list(map(int, input().split()))
ind = 1
ans = tot = sum(f[:k])
for i in range(k, len(f)):
	tot += f[i] - f[i - k]
	if tot < ans:
		tot = ans
		ind = i - k + 2
print(ind)


(n, k) = map(int, input().split())
pf = [0] * n
arr = list(map(int, input().split()))
pf[0] = arr[0]
for i in range(1, n):
	pf[i] = pf[i - 1] + arr[i]
ans = 2 ** 31
index1 = -1

def getPf(i, j):
	if i == 0:
		return pf[j]
	else:
		return pf[j] - pf[i - 1]
for i in range(n - k + 1):
	curr = getPf(i, i + k - 1)
	if curr < ans:
		ans = curr
		index1 = i
print(index1 + 1)


(n, k) = map(int, input().split())
A = [*map(int, input().split())]
wsz = 0
wsum = 0
min_ = float('inf')
mini = 0
for i in range(len(A)):
	wsum += A[i]
	wsz += 1
	if wsz > k:
		wsum -= A[1 + i - wsz]
		wsz -= 1
	if wsum < min_ and wsz == k:
		min_ = wsum
		mini = 1 + i - wsz
print(1 + mini)


import sys
from os import path
from collections import Counter
if path.exists('inp.txt'):
	sys.stdin = open('inp.txt', 'r')
	sys.stdout = open('out.txt', 'w')
import math
(n, k) = map(int, input().split())
li = list(map(int, input().split()))
su = float('inf')
ans = 0
pre = [0]
for i in range(n):
	pre.append(pre[i] + li[i])
for i in range(k, len(pre)):
	if pre[i] - pre[i - k] < su:
		ans = i
		su = pre[i] - pre[i - k]
print(ans - k + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
s = float('inf')
index = None
sm = 0
for i in range(k):
	sm += h[i]
	index = 0
j = 0
s = sm
for i in range(k, n):
	sm -= h[j]
	sm += h[i]
	j += 1
	if sm < s:
		sm = s
		index = j
print(index + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
index = 0
t = sum(h[0:k])
min_ = t
for i in range(k, n):
	t = t - h[i - k] + h[i]
	if t < min_:
		min_ = t
		index = i - k + 1
print(index + 1)


(n, k) = map(int, input().split())
l = [int(y) for y in input().split()]
for i in range(1, n):
	l[i] = l[i] + l[i - 1]
ind = 0
minsum = l[k - 1]
for i in range(k, n):
	height = l[i] - l[i - k]
	if height < minsum:
		ind = i - k + 1
		minsum = height
print(ind + 1)


def fence(n, k, ar):
	j = 0
	result = 0
	acc = sum(ar[0:k])
	min_sum = acc
	while j + k < n:
		acc = acc - ar[j] + ar[j + k]
		if acc < min_sum:
			min_sum = acc
			result = j + 1
		j += 1
	return result + 1
(n, k) = list(map(int, input().rstrip().split(' ')))
ar = list(map(int, input().rstrip().split(' ')))
print(fence(n, k, ar))


(n, k) = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
a = []
c = sum(b[0:k])
a.append((c, 1))
for i in range(1, n - k + 1):
	c += b[i + k - 1] - b[i - 1]
	a.append((c, i + 1))
b = sorted(a, key=lambda x: x[0])
print(b[0][1])


from sys import stdin, stdout
import bisect
from bisect import bisect_left as bl
from bisect import bisect_right as br
import itertools
from collections import Counter
from math import sqrt
import collections
import math
import heapq
import re

def modinv(n, p):
	return pow(n, p - 2, p)

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def most_frequent(list):
	return max(set(list), key=list.count)

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

def Convert(string):
	li = list(string.split(''))
	return li

def SieveOfEratosthenes(n):
	global prime
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	f = []
	for p in range(2, n):
		if prime[p]:
			f.append(p)
	return f
prime = []
q = []

def dfs(n, d, v, c):
	global q
	v[n] = 1
	x = d[n]
	q.append(n)
	j = c
	for i in x:
		if i not in v:
			f = dfs(i, d, v, c + 1)
			j = max(j, f)
	return j

def main():
	(n, k) = map(int, input().split())
	f = list(map(int, input().split()))
	s = sum(f[:k])
	best = s
	j = 1
	for i in range(n - k):
		s -= f[i]
		s += f[k + i]
		if s < best:
			best = s
			j = i + 2
	print(j)
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


(n, k) = map(int, input().split())
l = [int(i) for i in input().split()]
sumi = sum(l[0:k])
mini = sumi
ind = 1
for i in range(k, n):
	sumi = sumi + l[i] - l[i - k]
	if sumi < mini:
		mini = sumi
		ind = i - k + 2
print(ind)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
dp = [0] * (n + 1)
for i in range(n):
	dp[i + 1] = dp[i] + l[i]
mn = 999999999
ans = -1
for i in range(k, n + 1):
	if dp[i] - dp[i - k] < mn:
		mn = dp[i] - dp[i - k]
		ans = i - k + 1
print(ans)


from math import inf
(n, k) = map(int, input().split())
A = [int(i) for i in input().split()]
min = t = sum(A[:k])
j = 1
for i in range(k, n):
	t += A[i] - A[i - k]
	if t < min:
		min = t
		j = i - k + 2
print(j)


(n, k) = input().split()
n = int(n)
k = int(k)
lst1 = list(map(int, input().split()))
dp = [0] * n
i = 0
j = 0
sum1 = 0
while j < k:
	sum1 += lst1[j]
	j += 1
j -= 1
max1 = sum1
max_idx = i
while j < n - 1:
	i += 1
	j += 1
	sum1 = sum1 - lst1[i - 1] + lst1[j]
	if max1 > sum1:
		max1 = sum1
		max_idx = i
print(max_idx + 1)


(n, k) = map(int, input().split())
s = list(map(int, input().split()))
i = 0
j = k - 1
sumation = sum(s[i:j + 1])
pp = sumation + 0
ans = i
while j < n - 1:
	pp -= s[i]
	i += 1
	j += 1
	pp += s[j]
	if pp < sumation:
		sumation = pp
		ans = i
print(ans + 1)


(n, k) = map(int, input().split(' '))
nums = list(map(int, input().split(' ')))
i = 0
j = k - 1
s = 0
for x in range(i, j + 1):
	s += nums[x]
min_sum = s
cur_sum = s
indx = 0
while j < n - 1:
	cur_sum -= nums[i]
	i += 1
	j += 1
	cur_sum += nums[j]
	if cur_sum < min_sum:
		min_sum = cur_sum
		indx = i
print(indx + 1)


(n, k) = map(int, input().split())
lst = list(map(int, input().split()))
(ind, sm) = (1, 0)
for i in range(k):
	sm += lst[i]
sm_min = sm
for i in range(k, n):
	sm = sm - lst[i - k] + lst[i]
	if sm < sm_min:
		sm_min = sm
		ind = i - k + 2
print(ind)


import sys
(n, k) = map(int, input().split())
lst = list(map(int, input().split()))
sum1 = 0
for i in range(k):
	sum1 += lst[i]
min_ele = sum1
ind = 0
for i in range(k, n):
	sum1 = sum1 + lst[i] - lst[i - k]
	if min_ele > sum1:
		ind = i - k + 1
		min_ele = sum1
print(ind + 1)


def f(L, k):
	L2 = [0] * len(L)
	sum = 0
	for i in range(k):
		sum = sum + L[i]
	L2[k - 1] = sum
	i = k
	counter = 0
	while i != len(L):
		L2[i] = L2[i - 1] + L[i] - L[counter]
		i = i + 1
		counter = counter + 1
	min = L2[k - 1]
	min2 = 1
	for i in range(k, len(L2)):
		if L2[i] < min:
			min = L2[i]
			min2 = i + 1 - (k - 1)
	return min2
B = [x for x in input('').split()]
L = [x for x in input('').split()]
for i in range(len(L)):
	L[i] = int(L[i])
print(f(L, int(B[1])))


from collections import defaultdict, Counter

def main():
	(n, k) = map(int, input().split())
	h_list = list(map(int, input().split()))
	dp = [0] * n
	dp[0] = h_list[0]
	for i in range(1, n):
		dp[i] = dp[i - 1] + h_list[i]
	ans = 0
	min_height = 100 ** 7
	dp = [0] + dp
	for i in range(len(dp) - k):
		height = dp[i + k] - dp[i]
		if height < min_height:
			min_height = height
			ans = i + 1
	print(ans)
main()


(n, k) = input().split()
(n, k) = (int(n), int(k))
h = [int(x) for x in input().split()]
t = cur = sum(h[:k])
ind = 0
for i in range(1, n - k + 1):
	cur = cur - h[i - 1] + h[i + k - 1]
	if cur < t:
		t = cur
		ind = i
	else:
		pass
print(ind + 1)


ip = lambda : list(map(int, input().split()))
inp = ip()
(n, k) = (inp[0], inp[1])
h = ip()
dp = []
s = 0
for i in range(0, k):
	s += h[i]
dp.append(s)
for i in range(1, n - k + 1):
	s -= h[i - 1]
	s += h[i - 1 + k]
	dp.append(s)
print(dp.index(min(dp)) + 1)


def solve():
	(n, k) = map(int, input().strip().split())
	l = list(map(int, input().strip().split()))
	r = [0] * (n + 1)
	for i in range(1, n + 1):
		r[i] = r[i - 1] + l[i - 1]
	x = [0] * (n + 1)
	for i in range(k, n + 1):
		x[i] = r[i] - r[i - k]
	x = x[k:]
	print(x.index(min(x)) + 1)
solve()


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
ans = -1
min_val = 0
val = 0
for i in range(n):
	val += h[i]
	j = i - k
	if j >= 0:
		val -= h[j]
	j += 1
	if j >= 0 and (ans < 0 or val < min_val):
		min_val = val
		ans = j
print(ans + 1)


a1 = [int(s) for s in input().split()]
a2 = [int(s) for s in input().split()]
width = a1[1]
runningTotal = 0
best = -1
bestIndex = -1
for i in range(0, width):
	runningTotal += a2[i]
for i in range(width, len(a2) + 1):
	if best == -1 or runningTotal < best:
		best = runningTotal
		bestIndex = 1 + i - width
	if i == len(a2):
		break
	runningTotal -= a2[i - width]
	runningTotal += a2[i]
print(bestIndex)


def solve(k, fences):
	minimum = sum(fences[:k])
	result = minimum
	minimum_index = 1
	for i in range(k, len(fences)):
		result += fences[i] - fences[i - k]
		if result < minimum:
			minimum = result
			minimum_index = i - k + 2
	return minimum_index
(n, k) = map(int, input().split())
fences = [int(x) for x in input().split()]
solution = solve(k, fences)
print(solution)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
maxx = sum(arr[:k])
v = maxx
c = 0
for i in range(1, n - k + 1):
	v = v - arr[i - 1] + arr[i + k - 1]
	if v < maxx:
		maxx = v
		c = i
print(c + 1)


(n, k) = [int(x) for x in input().split()]
hs = [int(x) for x in input().split()]
cur = sum((hs[i] for i in range(k)))
minh = cur
minj = 0
for j in range(1, n - k + 1):
	cur -= hs[j - 1]
	cur += hs[j + k - 1]
	if cur < minh:
		minh = cur
		minj = j
print(minj + 1)


(n, k) = list(map(int, input().split()))
h = list(map(int, input().split()))
a = [[sum(h[:k]), 1]]
for i in range(n - k):
	a.append([a[i][0] + h[i + k] - h[i], i + 2])
print(min(a)[1])


def cum(a):
	(s, summ) = ({}, 0)
	for (idx, item) in enumerate(a):
		summ += item
		s[idx] = summ
	return s

def solve():
	(n, k) = map(int, input().split())
	vals = [int(i) for i in input().split()]
	if k == n:
		return 1
	elif k == 1:
		return vals.index(min(vals)) + 1
	cum_vals = cum(vals)
	(min_, min_idx, idx, came) = (cum_vals[k - 1], 0, 0, False)
	for i in range(k, n):
		curr_min = cum_vals[i] - cum_vals[idx]
		if curr_min < min_:
			min_ = curr_min
			min_idx = idx
			came = True
		idx += 1
	if came:
		return min_idx + 2
	return 1
print(solve())


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
if n == 1 or k >= n:
	print(1)
elif k == 1:
	print(a.index(min(set(a))) + 1)
else:
	s = sum(a[:k])
	m = s
	p = k - 1
	for i in range(k, n):
		s = s - a[i - k] + a[i]
		if s < m:
			m = s
			p = i
	print(p - k + 2)


(n, k) = map(int, input().strip().split(' '))
l = list(map(int, input().strip().split(' ')))
dp = [0] * (n - k + 1)
dp[0] = sum(l[:k])
for i in range(1, n - k + 1):
	dp[i] = dp[i - 1] + l[i + k - 1] - l[i - 1]
m = min(dp)
for i in range(len(dp)):
	if dp[i] == m:
		print(i + 1)
		break


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
x = y = sum(a[:k])
ans = 1
for i in range(k, n):
	x = x - a[i - k] + a[i]
	if x < y:
		y = x
		ans = i - k + 2
print(ans)


(n, k) = list(map(int, input().split(' ')))
lens = list(map(int, input().split(' ')))
sums = [lens[0]]
for i in range(1, n):
	sums.append(sums[i - 1] + lens[i])
min_ans = 10 ** 9
ans = -1
for l in range(n - k + 1):
	r = l + k - 1
	if l == 0:
		sum = sums[r]
	else:
		sum = sums[r] - sums[l - 1]
	if min_ans > sum:
		min_ans = sum
		ans = l
print(ans + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
s = [0]
a = 0
c = 100 * k + 1
res = 0
for i in range(n):
	s.append(l[i] + a)
	a = a + l[i]
for i in range(k, n + 1):
	b = s[i] - s[i - k]
	if b < c:
		c = b
		res = i - k + 1
print(res)


(n, k) = input().split()
n = int(n)
k = int(k)
a = [int(i) for i in input().split()]
sm = 10000000000
b = 0
s = 0
for j in range(k):
	s += a[j]
if s < sm:
	sm = s
	b = 0
for i in range(1, n - k + 1):
	s += a[i + k - 1]
	s -= a[i - 1]
	if s < sm:
		sm = s
		b = i
	if s == k:
		break
print(b + 1)


(n, k) = list(map(int, input().split(' ')))
array = list(map(int, input().split(' ')))
current = 0
index = 0
for i in range(0, k):
	current += array[i]
min = current
for i in range(k, n):
	current += array[i]
	current -= array[i - k]
	if current < min:
		min = current
		index = i - k + 1
print(index + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
sff = 0
suffix = []
for i in arr:
	sff += i
	suffix.append(sff)
minx = suffix[k - 1]
index = 0
temp = -1
for j in range(k, n, 1):
	temp = suffix[j] - suffix[j - k]
	if temp < minx:
		index = j - k + 1
		minx = temp
print(index + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
summ = [0] * n
summ[0] = l[0]
for i in range(1, n):
	summ[i] += summ[i - 1] + l[i]
x = []
t = 0
x.append(summ[k - 1])
for i in range(k, n):
	x.append(summ[i] - summ[t])
	t += 1
print(x.index(min(x)) + 1)


(n, k) = map(int, input().split())
planks = list(map(int, input().split()))
sump = sum(planks)
dp = [sump] * n
dp[0] = sum(planks[:k])
for i in range(1, n - k + 1):
	dp[i] = dp[i - 1] + planks[i + k - 1] - planks[i - 1]
ind = dp.index(min(dp))
print(ind + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
s = sum(arr[:k])
mn = s
index = 1
i = 0
j = k
while j < n:
	s += arr[j]
	s -= arr[i]
	i += 1
	j += 1
	if mn > s:
		mn = s
		index = i + 1
print(index)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
c = 0
m = sum(l[0:k])
s = m
j = 0
i = k
start_index = j + 1
while i < n:
	s = s - l[j] + l[i]
	i = i + 1
	j = j + 1
	if s < m:
		m = s
		start_index = j + 1
print(start_index)


def resolve(i, cerca):
	sum_ = sum(cerca[:i])
	min_idx = 0
	min_sum = sum_
	for j in range(1, len(cerca) - i + 1):
		sum_ = sum_ + cerca[i + j - 1] - cerca[j - 1]
		if sum_ < min_sum:
			min_sum = sum_
			min_idx = j
	return min_idx + 1
(n, m) = list(map(int, input().split()))
cerca = list(map(int, input().split()))
print(resolve(m, cerca))


from sys import stdin, stdout
(n, k) = map(int, stdin.readline().split())
h = list(map(int, stdin.readline().split()))
s = []
s.append(sum(h[:k]))
minn = s[0]
argmin = 0
for i in range(n - k):
	s.append(s[-1] - h[i] + h[i + k])
	if s[-1] < minn:
		minn = s[-1]
		argmin = i + 1
print(argmin + 1)


from collections import deque
(n, k) = [int(r) for r in input().split()]
heights = [int(r) for r in input().split()]
curr_height = 0
d = deque()
min_total_height = -1
found_at = -20
curr_index = 1
for height in heights:
	d.append(height)
	curr_height += height
	if len(d) > k:
		curr_height -= d.popleft()
	if len(d) == k and (min_total_height == -1 or curr_height < min_total_height):
		min_total_height = curr_height
		found_at = curr_index
	curr_index += 1
print(found_at - k + 1)


(n, k) = tuple(map(int, input().split()))
arr = list(map(int, input().split()))
m = sum(arr[:k])
minsum = [m]
(j, i) = (0, k)
while i < n:
	m -= arr[j]
	m += arr[i]
	j += 1
	i += 1
	minsum.append(m)
print(minsum.index(min(minsum)) + 1)


(size, subsetLen) = map(int, input().split())
array = list(map(int, input().split()))
mini = 9999999999
minPos = 0
buffer = 0
for i in range(0, subsetLen):
	buffer += array[i]
if buffer < mini:
	mini = buffer
for i in range(subsetLen, size):
	removal = array[i - subsetLen] - array[i]
	if removal >= 0:
		buffer = buffer - removal
	else:
		buffer = buffer + abs(removal)
	if buffer < mini:
		mini = buffer
		minPos = i
if minPos >= 1:
	print(minPos - (subsetLen - 2))
else:
	print('1')


(n, k) = map(int, input().split())
H = list(map(int, input().split()))
summa = 0
pref = [0] * n
for i in range(n):
	summa += H[i]
	pref[i] = summa
minsh = pref[k - 1]
j = 1
for i in range(1, n - k + 1):
	l = pref[k - 1 + i] - pref[i - 1]
	if minsh > l:
		minsh = l
		j = i + 1
print(j)


line = input().split()
n = int(line[0])
k = int(line[1])
p = [int(i) for i in input().split()]
first = 0
last = k - 1
t = 0
for i in range(0, k):
	t += p[i]
m = t
m_i = 0
while last < n - 1:
	t -= p[first]
	t += p[last + 1]
	first += 1
	last += 1
	if t < m:
		m = t
		m_i = first
print(m_i + 1)


(n, k) = map(int, input().split())
(*l,) = map(int, input().split())
(s, a) = (sum(l[:k]), 0)
f = s
for i in range(1, n - k + 1):
	s = s - l[i - 1] + l[i + k - 1]
	if s < f:
		f = s
		a = i
print(a + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
s = 0
d = [0]
for i in l:
	s += i
	d.append(s)
prev = float('inf')
idx = -1
for i in range(k - 1, n):
	s = d[i + 1] - d[i - k + 1]
	if prev > s:
		prev = s
		idx = i + 1 - k + 1
print(idx)


(n, k) = map(int, input().split())
lst = list(map(int, input().split()))
mt = sum(lst[:k])
st = mt
ans = 1
for i in range(k, n):
	st += lst[i] - lst[i - k]
	if st < mt:
		mt = st
		ans = i - k + 2
print(ans)


l2 = input().split()
n = int(l2[0])
k = int(l2[1])
min = 0
l = [int(x) for x in input().split()]
ans = 1
for i in range(k):
	min = min + l[i]
sum = min
if min == k:
	print(1)
else:
	for i in range(n - k):
		sum = sum + l[i + k] - l[i]
		if sum < min:
			min = sum
			ans = i + 2
	print(ans)


(a, b) = map(int, input().split())
n = list(map(int, input().split()))
(v, s) = ([], 0)
for j in range(b):
	s += n[j]
v.append(s)
for i in range(b, a):
	s -= n[i - b]
	s += n[i]
	v.append(s)
print(v.index(min(v)) + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
s = sum(a[:k])
e = s
d = 0
for i in range(k, n):
	s -= a[i - k]
	s += a[i]
	if e > s:
		e = s
		d = i - k + 1
print(d + 1)


(n, k) = [int(j) for j in input().split()]
l = [int(j) for j in input().split()]
if k == n:
	print(1)
else:
	ls = [0] * n
	ls[0] = l[0]
	for i in range(1, k):
		ls[i] = ls[i - 1] + l[i]
	for i in range(k, n):
		ls[i] = ls[i - 1] + l[i] - l[i - k]
	ls2 = ls[k - 1:]
	ans = ls2.index(min(ls2))
	print(ans + 1)


(n, m) = list(map(int, input().split()))
a = list(map(int, input().split()))
(l, t) = (sum(a[:m]), 0)
k = l
for i in range(n - m):
	k = k - a[i] + a[i + m]
	if k < l:
		l = k
		t = i + 1
print(t + 1)


(n, k) = map(int, input().split())
if n == 1:
	print(1)
else:
	a = [int(x) for x in input().split()]
	s = 0
	for i in range(k):
		s += a[i]
	i = 0
	an = 0
	z = s
	for j in range(k, n):
		s -= a[i]
		s += a[j]
		if s < z:
			an = i + 1
			z = s
		i += 1
	print(an + 1)


(n, k) = input().strip().split(' ')
(n, k) = (int(n), int(k))
list1 = list(map(int, input().strip().split(' ')))
s1 = 0
ans = 0
for i in range(k):
	s1 += list1[i]
s2 = s1
for i in range(1, n - k + 1):
	s2 = s2 + list1[i + k - 1] - list1[i - 1]
	if s2 < s1:
		s1 = s2
		ans = i
print(ans + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
b = 1
value = sum(a[0:k])
ans = value
for i in range(n):
	if k == n:
		break
	value -= a[i]
	value += a[k]
	if value < ans:
		ans = value
		b = i + 2
	k += 1
print(b)


(n, k) = map(int, input().split())
a = [int(i) for i in input().split()]
s = sum(a[:k])
m = s
j = 0
ans = 0
for i in range(k, n):
	s = s + a[i] - a[j]
	j += 1
	if s < m:
		m = s
		ans = j
print(ans + 1)


(n, k) = list(map(int, input().split()))
h = list(map(int, input().split()))
cur_min = (sum(h[0:k]), 0)
prev_sum = cur_min[0]
for i in range(k, n):
	c = prev_sum - h[i - k] + h[i]
	if c < cur_min[0]:
		cur_min = (c, i - (k - 1))
	prev_sum = c
print(cur_min[1] + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
result = 0
for i in range(k):
	result += arr[i]
current_sum = result
j = 0
for i in range(k, n):
	current_sum += arr[i] - arr[i - k]
	if current_sum < result:
		result = current_sum
		j = i - k + 1
print(j + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
if n == k:
	print(1)
else:
	p = l[0]
	m = 10 ** 10
	s = 0
	c = 0
	r = 0
	index = 1
	for i in range(n):
		if i < k:
			s += l[i]
		if c < k:
			c += 1
		if m > s and c == k:
			m = s
		if i >= k:
			s -= p
			s += l[i]
			p = l[r + 1]
			r += 1
			if s < m:
				m = s
				index = r + 1
	print(index)


(n, k) = map(int, input().split())
L = list(map(int, input().split()))
minimo = sum(L[0:k])
suma = minimo
indice = 1
for j in range(k, n):
	suma += L[j] - L[j - k]
	if suma < minimo:
		indice = j - k + 2
		minimo = suma
print(indice)


(n, k) = map(int, input().split())
r = 1
l = list(map(int, input().split()))
t = x = sum(l[0:0 + k])
for i in range(1, n - k + 1):
	x = l[i + k - 1] + x - l[i - 1]
	if x < t:
		t = x
		r = i + 1
print(r)


(n, k) = list(map(int, input().split()))
arr = list(map(int, input().split()))
for i in range(1, len(arr)):
	arr[i] += arr[i - 1]
M = arr[k - 1]
ans = 1
for i in range(k, len(arr)):
	t = arr[i] - arr[i - k]
	if t < M:
		M = t
		ans = i - k + 2
print(ans)


(n, k) = map(int, input().split())
h = [0] + list(map(int, input().split()))
s = [0] * (n + 10)
for i in range(1, n + 1):
	s[i] = s[i - 1] + h[i]
(val, pos) = (1000000000000000000, 0)
for i in range(1, n - k + 2):
	if s[i + k - 1] - s[i - 1] < val:
		val = s[i + k - 1] - s[i - 1]
		pos = i
print(pos)


import operator as op
import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import reduce
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

def inp():
	return int(input())

def inlist():
	return list(map(int, input().split()))

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())

def def_value():
	return 0
(n, k) = invr()
a = inlist()
pref = [0] * n
pref[0] = a[0]
for i in range(1, n):
	pref[i] = pref[i - 1] + a[i]
pref = [0] + pref
minSum = 10000000000
minIndx = 0
for i in range(n - k + 1):
	y = i + k
	x = i
	if pref[y] - pref[x] < minSum:
		minSum = pref[y] - pref[x]
		minIndx = x + 1
print(minIndx)


(n, k) = map(int, input().split())
fence = [int(i) for i in input().split()]
psa = [fence[0]]
for i in range(n):
	psa.append(psa[i] + fence[i])
(best, best_index) = (float('inf'), -1)
for i in range(k, n + 1):
	if psa[i] - psa[i - k] < best:
		best = psa[i] - psa[i - k]
		best_index = i
print(best_index - k + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
ans = max(h) * k
pos = 0
sh = sum(h[0:k])
for i in range(n - k + 1):
	if ans > sh:
		ans = sh
		pos = i
	if i != n - k:
		sh += h[i + k] - h[i]
print(pos + 1)


(n, k) = map(int, input().strip().split(' '))
arr = list(map(int, input().strip().split(' ')))
s = 0
for i in range(k):
	s += arr[i]
ans = s
index = 1
for i in range(n - k):
	s = s - arr[i] + arr[i + k]
	if s < ans:
		ans = s
		index = i + 2
print(index)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
suml = [l[0]]
for i in range(1, n):
	suml.append(suml[-1] + l[i])
ans = [(suml[k - 1], 1)]
for i in range(k, n):
	ans.append((suml[i] - suml[i - k], i - k + 2))
ans.sort()
print(ans[0][1])


(n, k) = map(int, input().split())
arr = [int(i) for i in input().split()]
l = 0
r = k - 1
j = 0
s = sum(arr[l:r + 1])
m = s
l += 1
r += 1
while r < n:
	s = s - arr[l - 1] + arr[r]
	if s < m:
		m = s
		j = l
	l += 1
	r += 1
print(j + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
from math import inf
mn = sum(arr[:k])
sm = 0
res = 0
for (i, a) in enumerate(arr):
	if i < k:
		sm += a
	else:
		sm += a - arr[i - k]
	if i >= k - 1 and sm < mn:
		res = i
		mn = sm
print(max(1, res - k + 1 + 1))


from sys import stdin, stdout, setrecursionlimit
input = stdin.readline
flush = stdout.flush
OUT = []

def write(item, sep=' '):
	if type(item) is int:
		OUT.append(str(item))
	elif type(item) is list:
		if type(item[0]) is int:
			OUT.append(sep.join(map(str, item)))
		else:
			OUT.append(sep.join(item))
	else:
		OUT.append(item)

def PRINT():
	print('\n'.join(OUT))
GI = lambda : int(input())
GS = lambda : input()[:-1]
gi = lambda : list(map(int, input().split()))
gs = lambda : input().split()
(n, k) = gi()
arr = gi()
psa = [0]
for i in arr:
	psa.append(psa[-1] + i)
m = (1000000000.0, -1)
for i in range(k, n + 1):
	m = min(m, (psa[i] - psa[i - k], i - k + 1))
write(m[1])
PRINT()


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
l = sum(arr[:k])
ans = 0
best = l
for i in range(1, n - k + 1):
	l = l + arr[i + k - 1] - arr[i - 1]
	if best > l:
		ans = i
		best = l
print(ans + 1)


(n, m) = map(int, input().split())
arr = list(map(int, input().split()))
sum = 0
for i in range(m):
	sum += arr[i]
ans = m - 1
temp = sum
for i in range(m, n):
	temp += arr[i] - arr[i - m]
	if temp < sum:
		sum = temp
		ans = i
print(ans - m + 2)


(n, k) = map(int, input().split())
A = list(map(int, input().split()))
B = [0]
for i in range(k):
	B[0] += A[i]
for i in range(1, n - k + 1):
	B.append(B[i - 1] - A[i - 1] + A[i + k - 1])
print(B.index(min(B)) + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
if k == 1:
	mn = float('inf')
	for i in range(n):
		if arr[i] < mn:
			mn = arr[i]
			ind = i
else:
	mn = float('inf')
	sm = 0
	ind = 0
	for i in range(n):
		if i > k - 1:
			sm += arr[i]
			sm -= arr[i - k]
		else:
			sm += arr[i]
		if i >= k - 1:
			if sm < mn:
				mn = sm
				ind = i - (k - 1)
print(ind + 1)


(n, k) = [int(x) for x in input().split()]
heights = [int(x) for x in input().split()]
memo = [0] * n
memo[0] = heights[0]
for i in range(1, n):
	memo[i] = memo[i - 1] + heights[i]
sums = [0] * (n - k + 1)
for i in range(n - k + 1):
	sums[i] = memo[i + k - 1] - (0 if i == 0 else memo[i - 1])
print(sums.index(min(sums)) + 1)


from itertools import permutations
from collections import defaultdict
from math import *
import os
import sys
from io import BytesIO, IOBase
from heapq import nlargest
from bisect import *
import copy
import itertools
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')
(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
s = sum(arr[0:k])
ans = [s]
l = 0
for i in range(k, n):
	s += arr[i] - arr[l]
	ans.append(s)
	l += 1
print(ans.index(min(ans)) + 1)


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest, _heapify_max, _heapreplace_max
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
(n, k) = sp()
arr = l()
(window, q) = (0, deque(arr[:]))
for i in range(k):
	window += arr[i]
index = [window]
for i in range(k, n):
	window -= q.popleft()
	window += arr[i]
	index.append(window)
m = min(index)
out(index.index(m) + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
if k == 1:
	mi = 9999999
	for i in range(n):
		if mi > arr[i]:
			mi = arr[i]
			pos = i + 1
	print(pos)
	quit()
mi = sum(arr[:k])
s = mi
pos = 1
for i in range(1, n - k + 1):
	s = s - arr[i - 1] + arr[i + k - 1]
	if mi > s:
		mi = s
		pos = i + 1
print(pos)


def solution():
	(n, k) = map(int, input().split())
	arr = list(map(int, input().split()))
	sol = [0] * (n - k + 1)
	sol[0] = sum(arr[:k])
	mn = sol[0]
	idx = 1
	for i in range(1, n - k + 1):
		sol[i] = sol[i - 1] - arr[i - 1] + arr[i + k - 1]
		if sol[i] < mn:
			mn = sol[i]
			idx = i + 1
	print(idx)
	return
solution()


(n, k) = (int(i) for i in input().split(' '))
h = [int(i) for i in input().split(' ')]
fk = sum(h[:k])
mini = fk
ind = 0
for i in range(1, n - k + 1):
	fk = fk - h[i - 1] + h[i + k - 1]
	if fk < mini:
		mini = fk
		ind = i
print(ind + 1)


import collections

def solve(n, k, lst):
	s = 0
	f = 0
	sums = 0
	indes = []
	minVal = 782378327823783
	ind = -1
	for i in range(n):
		sums += lst[i]
		indes.append(i)
		if i >= k - 1:
			if len(indes) > k:
				sums -= lst[indes[0]]
				indes.pop(0)
			if minVal > sums:
				minVal = sums
				ind = indes[0] + 1
	return ind

def sort(key):
	return key[0]
ans = []
(n, k) = map(int, input().split())
lst = list(map(int, input().split()))
ans.append(solve(n, k, lst))
for i in ans:
	print(i)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
total = sum(a[:k])
count = total
l = 0
for i in range(k, n):
	total -= a[l]
	total += a[i]
	l += 1
	if total < count:
		count = total
		ans = l
print(ans + 1)


from itertools import accumulate
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
p = [0] + list(accumulate(a))
i = 0
mini = 10 ** 9
for j in range(k, len(p)):
	if p[j] - p[i] < mini:
		mini = p[j] - p[i]
		ans = i + 1
	i += 1
print(ans)


(n, k) = map(int, input().split())
f = list(map(int, input().split()))
s = sum(f[:k])
best = s
j = 1
for i in range(n - k):
	s -= f[i]
	s += f[k + i]
	if s < best:
		best = s
		j = i + 2
print(j)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
acc = [0]
for (i, elm) in enumerate(h, 1):
	acc.append(acc[i - 1] + elm)
_sum = float('infinity')
ans = -1
for i in range(k, n + 1):
	cur = acc[i] - acc[i - k]
	if cur < _sum:
		_sum = cur
		ans = i - k + 1
print(ans)


(n, k) = map(int, input().split())
li = list(map(int, input().split()))
dp = [li[0]]
for i in li[1:]:
	dp.append(dp[-1] + i)
(i, j) = (0, k - 1)
res = float('inf')
r = 0
while j < n:
	if i == 0:
		res = min(res, dp[j])
		r = i + 1
	elif dp[j] - dp[i - 1] < res:
		r = i + 1
		res = dp[j] - dp[i - 1]
	j += 1
	i += 1
print(r)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
arr = [0] * (n - k + 1)
for i in range(k):
	arr[0] += l[i]
for i in range(1, n - k + 1):
	arr[i] = arr[i - 1] - l[i - 1] + l[i + k - 1]
print(arr.index(min(arr)) + 1)


def main():
	(n, m) = [int(i) for i in input().split()]
	a = [0] + [int(i) for i in input().split()]
	index_ans = 1
	summ = 0
	temp_sum = 0
	for i in range(1, n + 1):
		if i <= m:
			summ += a[i]
			temp_sum += a[i]
		else:
			temp_sum -= a[i - m]
			temp_sum += a[i]
			if temp_sum < summ:
				index_ans = i - m + 1
				summ = temp_sum
	return index_ans
print(main())


(n, k) = map(int, input().split())
p = [int(i) for i in input().split()]
if n == k:
	print(1)
else:
	index = 0
	addition = 0
	for i in range(k):
		addition += p[k]
		min_sum = addition
	for i in range(len(p) - k):
		addition = addition - p[i] + p[i + k]
		if addition < min_sum:
			min_sum = addition
			index = i + 1
	print(index + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
max_ = sum(arr[:k])
pos = 0
val = max_
for i in range(1, n - k + 1):
	val = val - arr[i - 1] + arr[i + k - 1]
	if val < max_:
		max_ = val
		pos = i
print(pos + 1)


par = input().split(' ')
n = int(par[0])
k = int(par[1])
h = [int(x) if True else x for x in input().split(' ')]
suma = sum(h[0:k])
minSum = suma
J = 1
if n > k:
	for j in range(1, n - k + 1):
		suma += h[j + k - 1] - h[j - 1]
		if suma < minSum:
			minSum = suma
			J = j + 1
print(J)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
x = []
su = sum(a[0:k])
x.append(su)
for i in range(1, n - k + 1):
	su += a[i + k - 1]
	su -= a[i - 1]
	x.append(su)
minn = min(x)
print(x.index(minn) + 1)


arr = []
x = input()
xx = x.split(' ')
n = int(xx[0])
k = int(xx[1])
l = 0
t = 15000001
x = input()
xx = x.split(' ')
arr.append(0)
for i in xx:
	arr.append(int(i))
for i in range(1, n + 1):
	arr[i] += arr[i - 1]
for i in range(k, n + 1):
	if t > arr[i] - arr[i - k]:
		t = arr[i] - arr[i - k]
		z = i
print(z - k + 1)


(a, b) = map(int, input().split())
l = [int(i) for i in input().split()]
n1 = b
n2 = 0
if a == b:
	answer = 1
else:
	sum1 = 0
	while n2 < b:
		sum1 += l[n2]
		n2 += 1
	ans = [(sum1, 1)]
	while n1 < a:
		sum1 = sum1 + l[n1] - l[n1 - b]
		ans.append((sum1, n1 - b + 2))
		n1 += 1
	ans.sort(key=lambda t: t[0])
	answer = ans[0][1]
print(answer)


(n, k) = list(map(int, input().rstrip().split(' ')))
arr = list(map(int, input().rstrip().split(' ')))
idx = 0
minSum = sum(arr[0:k])
curSum = minSum
for i in range(1, n - k + 1):
	curSum = curSum - arr[i - 1] + arr[i + k - 1]
	if curSum < minSum:
		minSum = curSum
		idx = i
print(idx + 1)


(n, k) = [int(i) for i in input().split()]
arr = [int(i) for i in input().split()]
acc = 0
for i in range(n):
	acc += arr[i]
	arr[i] = acc
arr = [0] + arr
min_idx = 0
min_br = arr[-1] + 1
for i in range(n - k + 1):
	if arr[k + i] - arr[i] < min_br:
		min_br = arr[k + i] - arr[i]
		min_idx = i + 1
print(min_idx)


(a, b) = map(int, input().split())
c = list(map(int, input().split()))
d = [0]
for i in range(b):
	d[0] += c[i]
for i in range(1, a - b + 1):
	d.append(d[i - 1] - c[i - 1] + c[i + b - 1])
print(d.index(min(d)) + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
su = [0]
for i in range(1, n + 1):
	su.append(su[i - 1] + l[i - 1])
ans = 0
mins = 10 ** 9 + 1
for i in range(1, n + 1):
	try:
		sum = su[i + k - 1] - su[i - 1]
	except:
		continue
	if sum < mins:
		mins = sum
		ans = i
print(ans)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
(l, h) = (0, 0)
res = 0
mi = 9999999999
curr = mi
while h < n:
	if h > k - 1:
		curr -= a[l]
		l += 1
		curr += a[h]
		if curr < mi:
			mi = curr
			res = l
	h += 1
print(res + 1)


from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left
from bisect import bisect_right

def L():
	return list(map(int, stdin.readline().split()))

def In():
	return map(int, stdin.readline().split())

def I():
	return int(stdin.readline())
P = 1000000007
(n, k) = In()
arr = L()
ix = 1
if k == 1:
	print(arr.index(min(arr)) + 1)
else:
	sm = sum(arr[:k])
	mn = sm
	for i in range(1, n - k + 1):
		sm = sm + arr[i + k - 1] - arr[i - 1]
		if sm < mn:
			mn = sm
			ix = i + 1
	print(ix)


from itertools import accumulate
(n, k) = map(int, input().split())
fence = [0] + list(map(int, input().split()))
height_list = list(accumulate(fence))
if n == k:
	print(1)
else:
	begin = 0
	i = 0
	min_dif = 100 * k
	while i + k <= n:
		if height_list[i + k] - height_list[i] < min_dif:
			min_dif = height_list[i + k] - height_list[i]
			begin = i + 1
		i += 1
	print(begin)


(n, k) = map(int, input().rstrip().split(' '))
l = list(map(int, input().rstrip().split(' ')))
res = [0] * (n - k + 1)
s = sum(l[:k])
res[0] = s
lo = n - k
if k == 1:
	print(l.index(min(l)) + 1)
else:
	for i in range(0, lo):
		s = s - l[i] + l[k + i]
		res[i + 1] = s
	print(res.index(min(res)) + 1)


(n, k) = [int(n) for n in input().split()]
h = [int(h) for h in input().split()]
sum_global = sum(h[0:k + 1])
sum_tmp = sum_global
res = 1
dp = [0] * n
m = 0
j = 1
mark = 0
for i in range(k, n):
	tmp = h[i] - h[i - k]
	dp[i] = h[i] - h[i - k] + dp[i - 1]
	if dp[i] < m:
		m = dp[i]
		res = i
		mark = 1
if mark == 1:
	res = res - k + 2
print(res)


from sys import *
for _ in range(1):
	(n, k) = map(int, stdin.readline().split())
	l = list(map(int, stdin.readline().split()))
	a = 1
	m = t = sum(l[:k])
	for i in range(k, n):
		t += l[i] - l[i - k]
		if t < m:
			a = i - k + 2
			m = t
	print(a)


def prefixSum(lst):
	a = [0] + lst
	s = [0] * len(a)
	(s[0], s[1]) = (0, a[1])
	for i in range(1, len(a)):
		s[i] = s[i - 1] + a[i]
	return s
(n, k) = list(map(int, input().split()))
lst = list(map(int, input().split()))
lst = prefixSum(lst)
reham = 0
mini = 10 ** 9
for i in range(n - k + 1):
	if lst[i + k] - lst[i] < mini:
		reham = i
		mini = lst[i + k] - lst[i]
print(reham + 1)


from functools import reduce
from collections import Counter
import time
import datetime

def time_t():
	print('Current date and time: ', datetime.datetime.now())
	print('Current year: ', datetime.date.today().strftime('%Y'))
	print('Month of year: ', datetime.date.today().strftime('%B'))
	print('Week number of the year: ', datetime.date.today().strftime('%W'))
	print('Weekday of the week: ', datetime.date.today().strftime('%w'))
	print('Day of year: ', datetime.date.today().strftime('%j'))
	print('Day of the month : ', datetime.date.today().strftime('%d'))
	print('Day of week: ', datetime.date.today().strftime('%A'))

def ip():
	return int(input())

def sip():
	return input()

def mip():
	return map(int, input().split())

def mips():
	return map(str, input().split())

def lip():
	return list(map(int, input().split()))

def matip(n, m):
	lst = []
	for i in range(n):
		arr = lip()
		lst.append(arr)
	return lst

def factors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def minJumps(arr, n):
	jumps = [0 for i in range(n)]
	if n == 0 or arr[0] == 0:
		return float('inf')
	jumps[0] = 0
	for i in range(1, n):
		jumps[i] = float('inf')
		for j in range(i):
			if i <= j + arr[j] and jumps[j] != float('inf'):
				jumps[i] = min(jumps[i], jumps[j] + 1)
				break
	return jumps[n - 1]

def dic(arr):
	return Counter(arr)
(n, k) = mip()
arr = lip()
count = sum(arr[:k])
lst = []
j = 0
lst.append(count)
for i in range(k, n):
	count += arr[i]
	count -= arr[j]
	j += 1
	lst.append(count)
m = min(lst)
print(lst.index(m) + 1)


(n, k) = map(int, input().split())
lst = list(map(int, input().split()))
slider = sum(lst[:k])
min_height = slider
min_idx = 1
if n > k:
	for i in range(1, n - k + 1):
		slider += lst[i + k - 1] - lst[i - 1]
		if slider < min_height:
			(min_height, min_idx) = (slider, i + 1)
print(min_idx)


nn = list(map(int, input().rstrip().split()))
n = nn[0]
k = nn[1]
ht = list(map(int, input().rstrip().split()))
htk = ht[0:k]
summk = sum(htk)
maxx = summk
begin = 0
for i in range(1, n - k + 1):
	summk = summk + ht[i + k - 1] - ht[i - 1]
	if summk < maxx:
		maxx = summk
		begin = i
print(begin + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
arrAns = []
indexArr = []
for i in range(n):
	if i == 0:
		arrAns.append(arr[0])
	else:
		arrAns.append(arr[i] + arrAns[i - 1])
for i in range(n - k + 1):
	if i == 0:
		indexArr.append(arrAns[i + k - 1])
	else:
		indexArr.append(arrAns[i + k - 1] - arrAns[i - 1])
if not indexArr:
	print(1)
else:
	print(indexArr.index(min(indexArr)) + 1)


(n, k) = input().split()
n = int(n)
k = int(k)
h = [int(x) for x in input().split()]
summ = [0] * (n - k + 1)
for i in range(k):
	summ[0] += h[i]
for i in range(n - k):
	summ[i + 1] = summ[i] + h[i + k] - h[i]
print(summ.index(min(summ)) + 1)


(n, k) = list(map(int, input().split()))
p = list(map(int, input().split()))
tf = []
ol = 0
pa = k
po = sum(p[0:k])
tf.append(po)
while k < n:
	po = po - p[ol]
	po = po + p[k]
	tf.append(po)
	ol += 1
	k += 1
print(tf.index(min(tf)) + 1)


I = lambda : list(map(int, input().split()))
(n, k) = I()
l = I()
m = t = sum(l[:k])
j = 1
for i in range(k, n):
	t += l[i] - l[i - k]
	if t < m:
		m = t
		j = i - k + 2
print(j)


def mi():
	return map(int, input().split())
(n, k) = mi()
a = list(mi())
maxs = s = sum(a[:k])
index = 0
for i in range(k, n):
	s += a[i]
	s -= a[i - k]
	if s < maxs:
		maxs = s
		index = i - k + 1
print(index + 1)


from sys import stdin, stdout
import math, sys, heapq
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import random
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())
else:

	def I():
		return int(stdin.readline())

	def In():
		return map(int, stdin.readline().split())

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_right(a, x)
	if i != len(a):
		return i
	else:
		return len(a)

def main():
	try:
		(n, k) = In()
		l = list(In())
		su = 0
		for i in range(k):
			su += l[i]
		ans = su
		pos = 0
		for i in range(k, n):
			su += l[i]
			su -= l[i - k]
			if su < ans:
				ans = su
				pos = i - k + 1
		print(pos + 1)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


import sys
input = sys.stdin.readline
(n, k) = map(int, input().strip().split())
a = list(map(int, input().strip().split()))
window = cwindow = sum(a[:k])
ans = 1
for i in range(k, n):
	cwindow += a[i] - a[i - k]
	if cwindow < window:
		window = cwindow
		ans = i - k + 2
print(ans)


(n, k) = map(int, input().split())
ns = list(map(int, input().split()))
(s, best) = (0, float('inf'))
(bl, l) = (0, 0)
for i in range(n):
	if i - l + 1 > k:
		s -= ns[l]
		l += 1
	if i - l + 1 <= k:
		s += ns[i]
	if i - l + 1 == k:
		if best > s:
			bl = l + 1
			best = s
print(bl)


(n, k) = [int(i) for i in input().split()]
arr = [int(i) for i in input().split()]
pre = [0] * n
for i in range(n):
	pre[i] = pre[i - 1] + arr[i]
s = 1000000000
val = -1
for i in range(k - 1, n):
	if i == k - 1:
		temp = pre[i]
	else:
		temp = pre[i] - pre[i - k]
	if temp < s:
		val = i - k + 2
		s = temp
print(val)


def sumList(arrayLi):
	result = 0
	for inte in arrayLi:
		result += inte
	return result

def getMap(arrayLi):
	custom = {}
	for item in arrayLi:
		if item in custom:
			custom[item] = custom[item] + 1
		else:
			custom[item] = 1
	return custom
(fenceWidth, pianoWidth) = list(map(int, input().split()))
fenceHeights = list(map(int, input().split()))
lesserIndex = 0
lesserSum = sumList(fenceHeights[:pianoWidth])
currentSum = sumList(fenceHeights[:pianoWidth])
for i in range(pianoWidth, fenceWidth):
	currentSum = currentSum - fenceHeights[i - pianoWidth] + fenceHeights[i]
	if lesserSum > currentSum:
		lesserSum = currentSum
		lesserIndex = i - pianoWidth + 1
print(lesserIndex + 1)


(n, k) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
min_s = sum(a[:k])
min_i = 0
sums = [min_s]
for i in range(1, n - k + 1):
	x = sums[i - 1] - a[i - 1] + a[i + k - 1]
	sums.append(x)
	if x < min_s:
		min_s = x
		min_i = i
print(min_i + 1)


import math as mt
import sys, string, bisect
input = sys.stdin.readline
import random
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
(n, k) = M()
l = L()
x = [0]
ans = 10 ** 10
s = 0
for i in range(n):
	s += l[i]
	if i + 1 == k:
		ans = s
		key = i + 2 - k
	elif i + 1 > k:
		s -= l[i - k]
		if ans > s:
			key = i + 2 - k
			ans = s
print(key)


(n, d) = map(int, input().split())
p = list(map(int, input().split()))
for j in range(n):
	if j == 0:
		p[j] = p[j]
	else:
		p[j] = p[j] + p[j - 1]
d -= 1
s = p[d]
mi = 0
for i in range(1, n - d):
	t = p[d + i] - p[i - 1]
	if s > t:
		s = t
		mi = i
print(mi + 1)


(n, k) = map(int, input().split())
L = [int(i) for i in input().split()]
val = sum(L[0:k])
A = [val]
for i in range(0, n - k):
	val += L[k + i]
	val -= L[i]
	A.append(val)
print(A.index(min(A)) + 1)


(n, k) = map(int, input().split(' '))
l = list(map(int, input().split(' ')))
for i in range(1, n):
	l[i] += l[i - 1]
min1 = l[k - 1]
index = 1
for i in range(k, n):
	res = l[i] - l[i - k]
	if res < min1:
		index = i - k + 2
		min1 = res
if n != k:
	print(index)
else:
	print('1')


from collections import defaultdict
from math import ceil
(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
s = 0
for i in range(k):
	s = s + arr[i]
minimum = s
idx = 1
i = 0
j = k
while j <= n:
	if minimum > s:
		minimum = s
		idx = i + 1
	if j < n:
		s -= arr[i]
		s += arr[j]
	j += 1
	i += 1
print(idx)


firstline = input()
h = input()
firstline = firstline.split()
n = int(firstline[0])
k = int(firstline[1])
h = h.split()
h = list(map(int, h))
temp = 0
for x in range(k):
	temp += h[x]
min = temp
minx = 0
x = 0
while True:
	try:
		temp = temp - h[x] + h[x + k]
		if temp < min:
			min = temp
			minx = x + 1
		x += 1
	except:
		break
print(minx + 1)


(n, k) = map(int, input().split())
h = [int(i) for i in input().split()]
pref_sums = [0] * (n + 1)
for i in range(1, n + 1):
	pref_sums[i] = pref_sums[i - 1] + h[i - 1]
mn = float('inf')
mn_index = 1
for i in range(n - k + 1):
	tmp = pref_sums[i + k] - pref_sums[i]
	if tmp < mn:
		mn = tmp
		mn_index = i + 1
print(mn_index)


(n, k) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
(left, right) = (0, 0)
ans = 0
curr = sum(arr[:k])
m = curr
for i in range(1, n):
	if i + k <= n:
		curr = curr - arr[i - 1] + arr[i + k - 1]
	if curr < m:
		m = curr
		ans = i
print(ans + 1)


def main():
	(n, k) = map(int, input().split())
	h = list(map(int, input().split()))
	s = sum(h[0:k])
	d = {1: s}
	for i in range(1, len(h) - k + 1):
		s = s - h[i - 1] + h[i + k - 1]
		d[i + 1] = s
	v = list(d.values())
	key = list(d.keys())
	print(key[v.index(min(v))])
main()


import math
p = input().rstrip().split(' ')
q = input().rstrip().split(' ')
n = int(p[0])
k = int(p[1])
s = 0
l = []
w = []
for i in range(0, k):
	s = s + int(q[i])
l.append(s)
w.append(0)
for i in range(1, n - k + 1):
	s = s - int(q[i - 1])
	s = s + int(q[i + k - 1])
	l.append(s)
	w.append(i)
f = min(l)
print(w[l.index(f)] + 1)


(x, y) = map(int, input().split())
a = list(map(int, input().split()))
d = sum(a[:y])
i = 1
p = 0
l = d
while i <= x - y:
	l = l + a[i + y - 1] - a[i - 1]
	if l < d:
		d = l
		p = i
	i += 1
print(p + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
dp = [a[0]] + [0] * (len(a) - 1)
for i in range(1, n):
	dp[i] = dp[i - 1] + a[i]
(mn, r) = (dp[k - 1], 1)
for i in range(k, n):
	if mn > dp[i] - dp[i - k]:
		mn = dp[i] - dp[i - k]
		r = i - k + 2
print(r)


(n, k) = map(int, input().split())
h = [int(i) for i in input().split()]
smallest = 0
sums = []
su = sum(h[:k - 1])
for i in range(n - k + 1):
	su += h[i + k - 1]
	if i > 0:
		su -= h[i - 1]
	sums.append(su)
	if su < sums[smallest]:
		smallest = i
print(smallest + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
s = s1 = sum(l[:k])
a = 1
for i in range(k, n):
	s += l[i] - l[i - k]
	if s < s1:
		a = i - k + 2
		s1 = s
print(a)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
b = sum(a[:k])
l = b
ind = 1
for i in range(n - k):
	l = min(l, b)
	b -= a[i]
	b += a[k + i]
	if b < l:
		ind = i + 2
print(ind)


import sys
(n, k) = map(int, input().split())
l = list(map(int, input().split()))
min = check = sum(l[:k])
store = 1
for i in range(k, n):
	check += l[i] - l[i - k]
	if check < min:
		min = check
		store = i - k + 2
print(store)


(n, k) = input().split()
n = int(n)
k = int(k)
f = [int(x) for x in input().split()]
tmp = 0
for i in range(k):
	tmp += f[i]
mini = tmp
pos = 0
for i in range(k, n):
	tmp += f[i] - f[i - k]
	if tmp < mini:
		mini = tmp
		pos = i - k + 1
print(pos + 1)


def readInput():
	return [int(x) for x in input().split()]
inputdata = readInput()
data = readInput()
n = inputdata[0]
k = inputdata[1]
sums = list(range(n))
for i in range(n):
	sums[i] = data[i]
	if i > 0:
		sums[i] += sums[i - 1]
index = -1
minVal = -1
i = 0
while i + k - 1 <= n - 1:
	if index == -1:
		index = 0
		minVal = sums[k - 1]
	else:
		curr = sums[i + k - 1] - sums[i - 1]
		if curr < minVal:
			minVal = curr
			index = i
	i += 1
print(index + 1)


def prefix_sum(n, h):
	sums = [0] * n
	sums[0] = h[0]
	for i in range(1, n):
		sums[i] = sums[i - 1] + h[i]
	return sums

def part_sum(S, n, m):
	if n == 0:
		return S[m]
	else:
		return S[m] - S[n - 1]

def solution(n, k, h):
	sums = prefix_sum(n, h)
	ans = 0
	maxSum = -1
	for i in range(0, n - k + 1):
		nSum = part_sum(sums, i, i + k - 1)
		if maxSum == -1 or nSum < maxSum:
			ans = i
			maxSum = nSum
	return ans + 1
(n, k) = [int(x) for x in input().split(' ')]
h = [int(x) for x in input().split(' ')]
print(solution(n, k, h))


(n, m) = map(int, input().split())
arr = list(map(int, input().split()))
mini = 0
i = 0
ind = 0
while i < m:
	mini += arr[i]
	i += 1
k = mini
for i in range(1, n - m + 1):
	k -= arr[i - 1]
	k += arr[i + m - 1]
	if k < mini:
		mini = k
		ind = i
print(ind + 1)


(n, k) = map(int, input().split())
h = [int(i) for i in input().split()]
prefix = [0] * (n + 1)
for i in range(1, n + 1):
	prefix[i] = prefix[i - 1] + h[i - 1]
minimum = prefix[k]
ans = 1
for i in range(1, n - k + 1):
	if minimum > prefix[i + k] - prefix[i]:
		ans = i + 1
		minimum = prefix[i + k] - prefix[i]
print(ans)


(a, b) = list(map(int, input().strip().split()))
c = list(map(int, input().strip().split()))
su = 0
for i in range(b):
	su += c[i]
mem = [su]
pointer = 0
for i in range(b, a):
	su = su + c[i] - c[pointer]
	mem.append(su)
	pointer += 1
print(mem.index(min(mem)) + 1)


(n1, k1) = input().split()
n = int(n1)
k = int(k1)
s = input().split()
s = list(map(int, s))
s1 = sum(s[0:k])
s2 = s1
ans = 0
for i in range(k, n):
	if s1 + s[i] - s[i - k] < s2:
		s2 = s1 + s[i] - s[i - k]
		s1 = s1 + s[i] - s[i - k]
		ans = i - k + 1
	else:
		s1 = s1 + s[i] - s[i - k]
		continue
print(ans + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
d = [l[0]]
s = l[0]
for i in range(1, n):
	s = s + l[i]
	d.append(s)
m = d[k - 1]
j = 1
for i in range(k, n):
	x = d[i] - d[i - k]
	if m > x:
		m = x
		j = i - k + 2
print(j)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
ans = []
sum_height = 0
for j in range(0, k):
	sum_height = sum_height + arr[j]
ans.append(sum_height)
mini = sum_height
j += 1
i = 0
while j < n:
	sum_height = sum_height - arr[i] + arr[j]
	ans.append(sum_height)
	mini = min(sum_height, mini)
	j += 1
	i += 1
print(ans.index(mini) + 1)


import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd, inf, sqrt
from bisect import bisect_right, bisect_left
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)

def factorial(n):
	if n == 0:
		return 1
	return n * factorial(n - 1)

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom

def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return len(set(factors))

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def factors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def printp(p):
	for i in p:
		print(i)
MOD = 10 ** 9 + 7
T = 1
for _ in range(T):
	(n, k) = list(map(int, stdin.readline().split()))
	a = list(map(int, stdin.readline().split()))
	ans = sum(a[:k])
	if k == 1:
		print(a.index(min(a)) + 1)
		continue
	(ms, s, e) = (0, 0, k - 1)
	minAns = ans
	while e < n - 1:
		t = ans - a[s] + a[e + 1]
		if t < minAns:
			minAns = t
			ms = s + 1
		ans = t
		s += 1
		e += 1
	print(ms + 1)


def arr_sum(arr):
	new_arr = [0, arr[0]]
	for (i, j) in enumerate(arr[1:]):
		new_arr.append(new_arr[i + 1] + j)
	return new_arr

def inp():
	return map(int, input().split())

def arr_inp():
	return [int(x) for x in input().split()]
from math import *
(n, k) = inp()
a = arr_inp()
(a_sum, ans, ix) = (arr_sum(a), inf, 0)
for i in range(k, n + 1):
	sum = a_sum[i] - a_sum[i - k]
	if ans > sum:
		ix = i - k + 1
		ans = sum
print(ix)


(n, k) = tuple(map(int, input().split()))
fence = list(map(int, input().split()))
s = 0
m = -1
ind = 0
j = 0
for i in range(k):
	s += fence[i]
while j + k <= n:
	if m == -1 or s < m:
		m = s
		ind = j
	s -= fence[j]
	if j + k < n:
		s += fence[j + k]
	j += 1
print(ind + 1)


(n, k) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
(sum, c, pos) = (0, 1000000009, -1)
for i in range(n):
	sum += a[i] - (a[i - k] if i >= k else 0)
	if i >= k - 1 and sum < c:
		c = min(c, sum)
		pos = i + 1
print(pos - k + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
min_height = 900000000000000000
index_min_height = 0
cur_sum = sum(h[:k])
for i in range(n - k + 1):
	if cur_sum < min_height:
		min_height = cur_sum
		index_min_height = i
	if i != n - k:
		cur_sum = cur_sum - h[i] + h[i + k]
print(index_min_height + 1)


for _ in range(1):
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	mn = 99999999999
	i = 0
	temp = a[i:i + k]
	s = sum(temp)
	i = k
	j = 0
	ans = 1
	while i - k < n:
		if s < mn:
			mn = s
			ans = i - k + 1
		if i < n and i - k < n:
			s = s - a[i - k] + a[i]
		i = i + 1
	print(ans)


(n, k) = map(int, input().strip().split(' '))
l = list(map(int, input().strip().split(' ')))
addition = 0
if k == 1:
	print(l.index(min(l)) + 1)
else:
	for i in range(k):
		addition += l[i]
	j = 0
	p = 0
	lowest = addition
	for i in range(k, n):
		if lowest > addition - l[i - k] + l[i]:
			lowest = addition - l[i - k] + l[i]
			addition = addition - l[i - k] + l[i]
			p = i - k + 1
		else:
			addition = addition - l[i - k] + l[i]
	print(p + 1)


from itertools import accumulate
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
acc = [0] + list(accumulate(a))
ans = None
mn = float('inf')
for i in range(k, n + 1):
	v = acc[i] - acc[i - k]
	if v < mn:
		mn = v
		ans = i - k + 1
print(ans)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
p = 0
dp = [0] * n
dp[0] = l[0]
for i in range(1, n):
	dp[i] = l[i] + dp[i - 1]
min_ = dp[k - 1]
for i in range(1, n - k + 1):
	if dp[i + k - 1] - dp[i - 1] < min_:
		min_ = dp[i + k - 1] - dp[i - 1]
		p = i
print(p + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
mi = float('inf')
ind = -1
s = 0
for i in range(n):
	s += h[i]
	if i >= k - 1:
		if s < mi:
			mi = s
			ind = i - k + 1
		s -= h[i - k + 1]
print(ind + 1)


import sys
(n, k) = map(int, sys.stdin.readline().split())
his = list(map(int, sys.stdin.readline().split()))
minn = sum(his[:k])
curr = 0
new = minn
for i in range(1, n - k + 1):
	new = new - his[i - 1] + his[i + k - 1]
	if minn > new:
		minn = new
		curr = i
print(curr + 1)


(n, k) = map(int, input().split())
hi = list(map(int, input().split()))
ans = 0
for i in range(k):
	ans += hi[i]
j = 1
num = ans
for i in range(k, n):
	num = num + hi[i] - hi[i - k]
	if num < ans:
		j = i - k + 2
		ans = num
print(j)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
min_index = 0
min_sum = sum(h[:k])
current_sum = min_sum
for i in range(1, n - k + 1):
	current_sum += h[i + k - 1] - h[i - 1]
	if current_sum < min_sum:
		(min_index, min_sum) = (i, current_sum)
print(min_index + 1)


(m, k) = map(int, input().split())
x = list(map(int, input().split()))
y = []
su = 0
if k == 1:
	h = 1
	su = x[0]
	for i in range(len(x)):
		if x[i] < su:
			su = x[i]
			h = i + 1
else:
	for i in range(k):
		su += x[i]
	y.append(su)
	for i in range(1, len(x) - k + 1):
		y.append(su + x[i + k - 1] - x[i - 1])
		su += x[i + k - 1] - x[i - 1]
	h = 1
	su = 1000000000
	for i in range(len(y)):
		if y[i] < su:
			su = y[i]
			h = i + 1
print(h)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
s = sum(l)
res = 0
mn = s
for i in range(1, n - k + 1):
	s = s - l[i - 1] + l[i + k - 1]
	if mn > s:
		mn = s
		res = i
print(res + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
dp = [0] * (n - k + 1)
dp[0] = sum(a[0:k])
for i in range(k, n):
	dp[i - k + 1] = dp[i - k] - a[i - k] + a[i]
print(min(((v, i) for (i, v) in enumerate(dp)))[1] + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
res = 0
pos = 1
temp = 0
for i in range(k):
	temp += arr[i]
	res = temp
	pos = 1
for i in range(k, n):
	temp += arr[i]
	temp -= arr[i - k]
	if temp < res:
		res = temp
		pos = i - k + 2
print(pos)


(n, k) = map(int, input().split())
A = list(map(int, input().split()))
(l, r, s) = (0, k, 0)
for i in range(k):
	s += A[i]
ans = s
j = 0
while r < n:
	s = s - A[l] + A[r]
	l += 1
	r += 1
	if ans > s:
		ans = s
		j = l
print(j + 1)


(n, m) = map(int, input().split())
arr = list(map(int, input().split()))
ans = 0
i = 0
j = m - 1
sm = sum(arr[:j + 1])
temp = sm
mn = 0
while j < n - 1:
	sm -= arr[i]
	i += 1
	j += 1
	sm += arr[j]
	if sm < temp:
		ans = i
		temp = sm
print(ans + 1)


(n, m) = map(int, input().split())
lis = list(map(int, input().split()))
ans = [0] * (n + 1)
for i in range(1, n + 1):
	ans[i] = ans[i - 1] + lis[i - 1]
a = 1000000000
ind = 0
for i in range(m, n + 1):
	if a > ans[i] - ans[i - m]:
		a = ans[i] - ans[i - m]
		ind = i - m + 1
print(ind)


(n, k) = [int(x) for x in input().split()]
h = [int(x) for x in input().split()]
s = sum(h[:k])
res = s
pos = 0
for i in range(n - k):
	s += h[i + k] - h[i]
	if s < res:
		res = s
		pos = i + 1
print(pos + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
ans = sum(l[:k])
s = ans
po = 0
for f1 in range(n - k):
	s -= l[f1]
	s += l[f1 + k]
	if s < ans:
		ans = s
		po = f1 + 1
print(po + 1)


(a, b) = [int(i) for i in input().split()]
c = [int(i) for i in input().split()]
msum = 10 ** 9
wsum = sum((c[i] for i in range(b)))
d = wsum
e = 1
f = e
for i in range(a - b):
	e = e + 1
	wsum = wsum - c[i] + c[i + b]
	if wsum < msum and wsum < d:
		msum = wsum
		f = e
print(f)


def main():
	k = [int(e) for e in input().split()][1]
	arr = [int(e) for e in input().split()]
	acc = [0]
	for n in arr:
		acc.append(n + acc[-1])
	best = 1 << 30
	idx = 0
	for i in range(k, len(arr) + 1):
		if best > acc[i] - acc[i - k]:
			idx = i - k + 1
			best = acc[i] - acc[i - k]
	print(idx)
	return 0
main()


(n, k) = tuple(map(int, input().split()))
a = list(map(int, input().split()))
minfence = sum(a[:k])
runningsum = minfence
result = 0
for j in range(n - k):
	runningsum = runningsum + a[k + j] - a[j]
	if runningsum < minfence:
		result = j + 1
		minfence = runningsum
print(result + 1)


s = input().split(' ')
(nVertical, pianoSize) = (int(s[0]), int(s[1]))
s = input().split(' ')
fence = [int(n) for n in s]
index = 0
sumes = []
sumaActual = sum(fence[0:pianoSize])
indActual = 0
sumaProvisional = sumaActual
for i in range(1, nVertical - pianoSize + 1):
	sumaProvisional = sumaProvisional - fence[i - 1] + fence[i + (pianoSize - 1)]
	aux = sumaProvisional
	if aux < sumaActual:
		sumaActual = aux
		indActual = i
print(indActual + 1)


(n, k) = map(int, input().strip().split())
arr = list(map(int, input().strip().split()))
sums = sum(arr[:k])
mins = sum(arr[:k])
ind = 1
for x in range(k, n):
	sums += arr[x]
	sums -= arr[x - k]
	if mins > sums:
		mins = sums
		ind = x + 1
		ind -= k - 1
print(ind)


from sys import stdin, stdout

def ai():
	return list(map(int, input().split()))

def ei():
	return map(int, input().split())

def ip():
	return int(stdin.readline())

def op(ans):
	return stdout.write(str(ans) + '\n')
(n, k) = ei()
li = ai()
li = [0] + li
i = 1
j = k
index = []
maximum = []
sum_ = 0
minus = 0
sum_ = sum(li[i:j + 1])
maximum.append(sum_)
while i < n + 1 and j < n + 1:
	index.append(i)
	i += 1
	j += 1
	if i < n + 1 and j < n + 1:
		sum_ += li[j]
		sum_ -= li[i - 1]
		maximum.append(sum_)
min_ = float('inf')
min_index = 0
for i in range(len(index)):
	if maximum[i] < min_:
		min_ = maximum[i]
		min_index = i
op(min_index + 1)


(n, k) = map(int, input().split())
h = [int(x) for x in input().split()]
pos = 1
min = 0
for i in range(k):
	min += h[i]
cur = min
for i in range(1, n - k + 1):
	cur = cur - h[i - 1] + h[i + k - 1]
	if cur < min:
		min = cur
		pos = i + 1
print(pos)


(n, k) = map(int, input().split())
A = [0]
for i in input().split():
	A.append(A[-1] + int(i))
B = []
for i in range(k, n + 1):
	B.append([A[i] - A[i - k], i - k + 1])
B.sort()
print(B[0][1])


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
minh = sum(arr[:k])
min_j = 0
curr = minh
for i in range(1, n - k + 1):
	curr = curr + arr[i + k - 1] - arr[i - 1]
	if curr < minh:
		minh = curr
		min_j = i
print(min_j + 1)


import math
import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input().strip()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())
(n, k) = invr()
l = inlt()
mn = sum(l[:k])
temp = mn
idx = 1
for i in range(k, n):
	temp += -l[i - k] + l[i]
	if temp < mn:
		idx = i - k + 2
		mn = temp
print(idx)


def main():
	(n, k) = map(int, input().split())
	dp = [0] * (n - k + 1)
	h = [0] + list(map(int, input().split()))
	h_sum = 0
	for i in range(1, n + 1):
		h_sum += h[i]
		if i >= k:
			h_sum -= h[i - k]
			dp[i - k] = h_sum
	(min_h, index) = (dp[0], 0)
	for i in range(1, len(dp)):
		if dp[i] < min_h:
			min_h = dp[i]
			index = i
	print(index + 1)
main()


(a, b) = map(int, input().split())
c = list(map(int, input().split()))
s = k = sum(c[:b])
j = 0
for i in range(1, a - b + 1):
	n = s - c[i - 1] + c[i + b - 1]
	if k > n:
		j = i
		k = n
	s = n
print(j + 1)


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
f = sum(l[:m])
k = [f]
for i in range(1, n - m + 1):
	f = f - l[i - 1] + l[i + m - 1]
	k.append(f)
a = min(k)
print(k.index(a) + 1)


R = lambda : map(int, input().split())
(n, k) = R()
a = list(R())
s = sum(a[0:k])
h = s
index = 0
for i in range(k, n):
	s = s + a[i] - a[i - k]
	if s < h:
		h = s
		index = i - k + 1
print(index + 1)


(n, k) = [int(x) for x in input().split()]
h = [int(x) for x in input().split()]
s = 0
for i in range(k):
	s += h[i]
mn = s
j = 1
for i in range(n - k):
	s -= h[i]
	s += h[k + i]
	if s < mn:
		mn = s
		j = i + 1 + 1
print(j)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
ans = 1000000007
cur = 0
pos = 0
for i in range(k):
	cur = cur + arr[i]
for i in range(k, n):
	if cur < ans:
		ans = cur
		pos = i - k
	cur = cur - arr[i - k]
	cur = cur + arr[i]
if cur < ans:
	ans = cur
	pos = n - k
pos = pos + 1
print(pos)


import random, math
from copy import deepcopy as dc

def solution(li, k):
	s = 0
	for i in range(k):
		s += li[i]
	mini = dc(s)
	mini_i = 1
	for i in range(k, len(li)):
		s += li[i]
		s -= li[i - k]
		if s < mini:
			mini = dc(s)
			mini_i = i + 2 - k
	return mini_i

def input_test():
	(n, k) = map(int, input().strip().split(' '))
	li = list(map(int, input().strip().split(' ')))
	out = solution(li, k)
	print(out)
input_test()


__author__ = 'asmn'
(n, k) = tuple(map(int, input().split()))
h = [0] + list(map(int, input().split()))
for i in range(1, n + 1):
	h[i] += h[i - 1]
s = [h[i] - h[i - k] for i in range(k, n + 1)]
print(s.index(min(s)) + 1)


(n, k) = [int(x) for x in input().split()]
q = [int(x) for x in input().split()]
dp = [0] * (n - k + 1)
dp[0] = sum([q[x] for x in range(k)])
temp = dp[0]
ans = 1
for i in range(1, n - k + 1):
	dp[i] = dp[i - 1] - q[i - 1] + q[i + k - 1]
	if temp > dp[i]:
		temp = dp[i]
		ans = i + 1
print(ans)


(n, k) = list(map(int, input().split(' ')))
l = list(map(int, input().split(' ')))
minSum = 0
newSum = 0
minIndex = 0
if k == 1:
	minIndex = 0
	min = l[0]
	for i in range(0, n):
		if min > l[i]:
			min = l[i]
			minIndex = i
	print(minIndex + 1)
else:
	for i in range(0, k):
		minSum += l[i]
		minIndex = 0
	newSum = minSum
	for i in range(1, n - k + 1):
		newSum = newSum - l[i - 1] + l[k + i - 1]
		if minSum > newSum:
			minSum = newSum
			minIndex = i
	print(minIndex + 1)


(a, b) = map(int, input().split())
s = list(map(int, input().split()))
r = 0
for i in range(b):
	r += s[i]
m = r
res = 1
for i in range(a - b):
	r += -s[i] + s[i + b]
	if m > r:
		res = i + 2
	m = min(m, r)
print(res)


import heapq as hp
import collections
import bisect
import math

def unpack(func=int):
	return map(func, input().split())

def l_unpack(func=int):
	return list(map(func, input().split()))

def s_unpack(func=int):
	return sorted(map(func, input().split()))

def range_n():
	return range(int(input()))

def counter(a):
	d = {}
	for x in a:
		if x in d:
			d[x] += 1
		else:
			d[x] = 1
	return d

def getint():
	return int(input())

def main():
	(n, k) = unpack()
	a = l_unpack()
	window = sum(a[:k])
	ans = window
	j = 1
	for i in range(1, n - k + 1):
		window += a[i + k - 1] - a[i - 1]
		if ans > window:
			ans = window
			j = i + 1
	print(j)
main()


(n, k) = map(int, input().split())
hl = list(map(int, input().split()))
J = 0
minS = 0
S = 0
for j in range(n - k):
	S += hl[j + k] - hl[j]
	if S < minS:
		minS = S
		J = j + 1
print(J + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
temp = 0
minsum = 0
pos = 0
for i in range(k):
	temp += a[i]
	minsum = temp
for i in range(k, n):
	temp = temp + a[i] - a[i - k]
	if minsum > temp:
		minsum = temp
		pos = i - k + 1
print(pos + 1)


(n, m) = map(int, input().split())
a = list(map(int, input().split()))
j = 0
k = sum(a[:m])
d = sum(a[:m])
for i in range(1, n - m + 1):
	d = d - a[i - 1] + a[i + m - 1]
	if k > d:
		k = d
		j = i
print(j + 1)


(n, k) = [int(i) for i in input().split()]
h = [int(i) for i in input().split()]
j = 0
s = sum(h[:k])
s1 = s
if k == 1:
	print(h.index(min(h)) + 1)
else:
	for i in range(1, len(h) - k + 1):
		s1 += h[i + k - 1] - h[i - 1]
		if s1 < s:
			s = s1
			j = i
	print(j + 1)


(n, k) = map(int, input().split())
a = [int(i) for i in input().split()]
if k == 1:
	print(a.index(min(a)) + 1)
	exit()
else:
	m = sum(a[0:k])
	s = m
	ans = 1
	for i in range(1, n - k + 1):
		s += -a[i - 1] + a[i + k - 1]
		if s < m:
			m = s
			ans = i + 1
	print(ans)


(n, k) = map(int, input().split())
x = [int(q) for q in input().split()]
s = [sum(x[:k])]
for i in range(len(x) - k):
	s.append(s[-1] - x[i] + x[i + k])
j = 1 + s.index(min(s))
print(j)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
m = sum(h[:k])
p = sum(h[:k])
ans = 1
for i in range(k, n):
	p += h[i] - h[i - k]
	if p < m:
		ans = i - k + 2
		m = p
print(ans)


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
inp = lambda : int(input())
strng = lambda : input().strip()
jn = lambda x, l: x.join(map(str, l))
strl = lambda : list(input().strip())
mul = lambda : map(int, input().strip().split())
mulf = lambda : map(float, input().strip().split())
seq = lambda : list(map(int, input().strip().split()))
ceil = lambda x: int(x) if x == int(x) else int(x) + 1
ceildiv = lambda x, d: x // d if x % d == 0 else x // d + 1
flush = lambda : stdout.flush()
stdstr = lambda : stdin.readline()
stdint = lambda : int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
mod = 1000000007
(n, k) = map(int, stdstr().split())
arr = list(map(int, stdstr().split()))
su = sum(arr[:k])
mi = su
j = 1
for i in range(k, n):
	s = su + arr[i] - arr[i - k]
	if s < mi:
		mi = s
		j = i - k + 2
	su = s
stdpr(str(j) + '\n')


(n, k) = input().split()
n = int(n)
k = int(k)
h = [int(i) for i in input().split()]
total = sum(h[:k])
min_height = total
pos = 0
for i in range(k, n):
	total = total - h[i - k] + h[i]
	if min_height > total:
		pos = i - k + 1
		min_height = total
print(pos + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
s = [0] * (n - k + 1)
s[0] = m = sum(h[:k])
d = 0
for i in range(1, n - k + 1):
	s[i] = s[i - 1] - h[i - 1] + h[i + k - 1]
	if s[i] < m:
		m = s[i]
		d = i
print(d + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
c = 0
ind = 1
for i in range(k):
	c += l[i]
maxi = c
for i in range(k, n):
	c = c + l[i] - l[i - k]
	if c < maxi:
		maxi = c
		ind = i + 1
if ind - k + 1 <= 0:
	print(1)
else:
	print(ind - k + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
p = []
p.append(l[0])
for i in range(1, n):
	p.append(p[-1] + l[i])
mi = 0
ms = 10 ** 9
for i in range(n - k + 1):
	if i == 0:
		if p[i + k - 1] < ms:
			ms = p[i + k - 1]
			mi = i
	elif p[i + k - 1] - p[i - 1] < ms:
		ms = p[i + k - 1] - p[i - 1]
		mi = i
print(mi + 1)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
h.insert(0, 0)
for i in range(1, n + 1):
	h[i] += h[i - 1]
cMin = 10 ** 10
for i in range(1, n - k + 2):
	s = h[i + k - 1] - h[i - 1]
	if cMin > s:
		cMin = s
		hMin = i
print(hMin)


(N, K) = input().strip().split(' ')
N = int(N)
K = int(K)
ar = input().strip().split(' ')
sum_con = []
index = 0
s = 0
for i in range(K):
	s += int(ar[i])
sum_con.append(s)
for i in range(K, N):
	s = s - int(ar[i - K]) + int(ar[i])
	sum_con.append(s)
val = 10000000000000
for i in range(len(sum_con)):
	if sum_con[i] < val:
		index = i
		val = sum_con[i]
print(index + 1)


(n, k) = map(int, input().split())
ls = list(map(int, input().split()))
s = sum(ls[:k])
sums = [s]
if len(ls) == k:
	print(1)
else:
	for i in range(k, len(ls)):
		s = s + ls[i] - ls[i - k]
		sums.append(s)
	j = min(sums)
	for i in range(len(sums)):
		if sums[i] == j:
			print(i + 1)
			break


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
if k == 1:
	ind = a.index(min(a)) + 1
	print(ind)
elif n == k:
	print(1)
else:
	ans = [0] * (n - k + 1)
	ans[0] = sum(a[:k])
	for i in range(1, len(ans)):
		ans[i] = ans[i - 1] - a[i - 1] + a[i + k - 1]
	print(ans.index(min(ans)) + 1)


(n, k) = map(int, input().split())
A = list(map(int, input().split()))
S = [0]
s = 0
for i in range(n):
	s += A[i]
	S.append(s)
ans = 10 ** 9
index = 0
i = 1
while i <= n - k + 1:
	if S[i + k - 1] - S[i - 1] < ans:
		ans = S[i + k - 1] - S[i - 1]
		index = i
	i += 1
print(index)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
s = 0
for i in range(k):
	s += a[i]
r = (s, 0)
for i in range(k, n):
	s += a[i] - a[i - k]
	r = min(r, (s, i - k + 1))
print(r[1] + 1)


def sol():
	(n, k) = map(int, input().split())
	A = [int(i) for i in input().split()]
	dp = [sum(A[:k])]
	for i in range(1, n - k + 1):
		dp.append(dp[i - 1] + A[i + k - 1] - A[i - 1])
	print(dp.index(min(dp)) + 1)
sol()


from sys import stdin
hat = stdin.readlines()
(n, x) = map(int, hat[0].split())
lst = [int(x) for x in hat[1].split()]
cursor = x
ans = 10 ** 10
pos = 0
itera = sum(lst[0:x])
for i in range(x, n):
	if itera < ans:
		ans = itera
		pos = i - x
	itera -= lst[i - x]
	itera += lst[i]
if itera < ans:
	ans = itera
	pos = n - x
print(pos + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
dp = [x for x in arr]
for i in range(1, k):
	dp[i] += dp[i - 1]
for i in range(k, n):
	dp[i] += dp[i - 1]
	dp[i] -= arr[i - k]
ans = float('inf')
idx = -1
for i in range(k - 1, n):
	if dp[i] < ans:
		idx = i - (k - 2)
		ans = dp[i]
print(idx)


(n, k) = map(int, input().split())
heights = list(map(int, input().split()))
min_i = 0
min_height = sum(heights[:k])
curr_height = min_height
for i in range(1, n - k + 1):
	curr_height += -heights[i - 1] + heights[i + k - 1]
	if curr_height < min_height:
		min_i = i
		min_height = curr_height
print(min_i + 1)


(n, k) = map(int, input().split())
lis = list(map(int, input().split()))
s = sum(lis[:k])
ans = s
index = 0
for i in range(k, n):
	s -= lis[i - k]
	s += lis[i]
	if ans > s:
		ans = s
		index = 1 + i - k
print(index + 1)


[n, k] = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
maxx = 10 ** 5 + 1
hold = 0
if k == n or a.count(a[0]) == n:
	print(1)
else:
	maxx = sum(a[0:0 + k])
	hold = 0
	c = maxx
	for i in range(k, n):
		c -= a[i - k]
		c += a[i]
		if c < maxx:
			maxx = c
			hold = i - k + 1
	print(hold + 1)


(n, k) = map(int, input().split())
x = list(map(int, input().split()))
m = t = sum(x[:k])
a = 1
for i in range(k, n):
	t += x[i] - x[i - k]
	if t < m:
		m = t
		a = i - k + 2
print(a)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
j = 0
t = sum(a[None:k])
mn = t
for i in range(k, n):
	t -= a[i - k]
	t += a[i]
	if t < mn:
		mn = t
		j = i - k + 1
print(j + 1)


inp = input()
inp = inp.split()
n = int(inp[0])
k = int(inp[1])
high = []
hig = input()
hig = hig.split()
high.append(int(hig[0]))
for i in range(1, len(hig)):
	high.append(high[i - 1] + int(hig[i]))
initi = 0
index = 1
sum = high[k - 1]
for initi in range(1, len(high) - k + 1):
	if high[initi + k - 1] - high[initi - 1] < sum:
		index = initi + 1
		sum = high[initi + k - 1] - high[initi - 1]
	initi += 1
	if sum == 1:
		break
	elif sum == k:
		break
print(index)


(n, m) = map(int, input().split())
s = list(map(int, input().split()))
jump = sum(s[0:m])
step = jump
ans = 0
for i in range(1, n - m + 1):
	jump += s[i + m - 1] - s[i - 1]
	if step > jump:
		step = jump
		ans = i
print(ans + 1)


import sys
from itertools import accumulate
input = lambda : sys.stdin.readline().strip('\r\n')
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a = list(accumulate(a))
a = [0] + a
ind = 0
for i in range(n - k + 1):
	if a[i + k] - a[i] < a[ind + k] - a[ind]:
		ind = i
print(ind + 1)


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
index = 1
small = minisum = sum(a[:k])
for i in range(k, n):
	minisum += a[i] - a[i - k]
	if minisum < small:
		small = minisum
		index = i - k + 2
print(index)


from itertools import accumulate
(n, k) = map(int, input().split())
h = list(map(int, input().split()))
acc = [0]
acc += accumulate(h)
_sum = float('infinity')
ans = -1
for i in range(k, n + 1):
	cur = acc[i] - acc[i - k]
	if cur < _sum:
		_sum = cur
		ans = i - k + 1
print(ans)


(n, k) = [int(x) for x in input().split(' ')]
h = [int(x) for x in input().split(' ')]
s = sum(h[:k])
m = s
index = -1
for i in range(n - k):
	s -= h[i]
	s += h[i + k]
	if s < m:
		m = s
		index = i
print(index + 2)


(n, c) = input().split()
h = []
n = int(n)
h = list(map(int, input().split()))[:n]
plank = float('inf')
ind = 0
result = []
c = int(c)
if c == 1:
	print(h.index(min(h)) + 1)
else:
	result.append(h[0])
	for i in range(1, len(h)):
		result.append(h[i] + result[i - 1])
	for i in range(0, len(result)):
		if i >= c:
			if result[i] - result[i - c] < plank:
				plank = result[i] - result[i - c]
				ind = i - c + 1
		else:
			plank = result[i]
	print(ind + 1)


(n, k) = map(int, input().split())
l = [int(x) for x in input().split()]
m = sum(l[:k])
x = m
mi = 0
for i in range(1, len(l) - k + 1):
	x = x - l[i - 1] + l[i + k - 1]
	if x < m:
		mi = i
		m = x
print(mi + 1)


[n, k] = list(map(int, input().split()))
h = list(map(int, input().split()))
mn = sum(h[:k])
s = sum(h[:k])
mni = 0
for i in range(n - k + 1):
	if s < mn:
		mn = s
		mni = i
	if i + k < n:
		s += h[i + k]
		s -= h[i]
print(mni + 1)


from itertools import accumulate
(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
prefix = list(accumulate(arr))
mn = prefix[k - 1]
indx = 0
for i in range(1, n):
	x = i + k
	if x <= n:
		x2 = prefix[x - 1] - prefix[i - 1]
		if x2 < mn:
			mn = x2
			indx = i
	else:
		continue
print(indx + 1)


import math
from collections import defaultdict, Counter, deque
INF = float('inf')

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def isPrime(n):
	if n <= 1:
		return False
	i = 2
	while i ** 2 <= n:
		if n % i == 0:
			return False
		i += 1
	return True

def vars():
	return map(int, input().split())

def array():
	return list(map(int, input().split()))

def main():
	(n, k) = vars()
	arr = array()
	l = 0
	r = k - 1
	s = sum(arr[l:r + 1])
	ans = (s, 1)
	r += 1
	while r < n:
		s -= arr[l]
		l += 1
		s += arr[r]
		r += 1
		if s < ans[0]:
			ans = (s, l + 1)
	print(ans[1])
t = 1
for _ in range(t):
	main()


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
ps = [0] * n
ps[0] = a[0]
ans_val = 10000000000
ans_idx = 0
for i in range(1, n):
	ps[i] = ps[i - 1] + a[i]
for i in range(n - k + 1):
	if i == 0:
		t_sum = ps[k - 1]
	else:
		t_sum = ps[i + k - 1] - ps[i - 1]
	if t_sum < ans_val:
		ans_val = t_sum
		ans_idx = i
print(ans_idx + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
b = [a[0]]
for i in range(1, n):
	b.append(b[i - 1] + a[i])
mina = b[k - 1]
x = k - 1
for i in range(k, n):
	if b[i] - b[i - k] < mina:
		x = i
		mina = b[i] - b[i - k]
print(x - k + 2)


(n, k) = list(map(int, input().split()))
h = list(map(int, input().split()))
sum_j = sum(h[0:k])
checksum = sum(h[0:k])
j_index = 0
if len(h) - k == 0:
	print(1)
	exit()
if len(h) - k == 1:
	if sum(h[0:k]) <= sum(h[1:k + 1]):
		print(1)
	else:
		print(2)
	exit()
for i in range(1, len(h) - k + 1):
	checksum = checksum - h[i - 1] + h[i + k - 1]
	if checksum < sum_j:
		sum_j = checksum
		j_index = i
	if sum_j == k:
		print(j_index + 1)
		exit()
print(j_index + 1)


(n, k) = map(int, input().split())
array = list(map(int, input().split()))
dp = []
dp.append(array[0])
for i in range(1, n):
	dp.append(dp[i - 1] + array[i])
mindiff = dp[k - 1]
minIndex = 1
for i in range(0, n - k):
	if mindiff > dp[i + k] - dp[i]:
		mindiff = dp[i + k] - dp[i]
		minIndex = i + 2
print(minIndex)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	(n, m) = LI()
	a = LI()
	r = -1
	u = t = sum(a[:m])
	for i in range(m, n):
		t -= a[i - m]
		t += a[i]
		if u > t:
			u = t
			r = i - m
	return r + 2
print(main())


z = input().split()
l = int(z[0])
k = int(z[1])
a = [int(x) for x in input().split()]
least = 0
sum = 0
lowest = 0
for i in range(k):
	sum += a[i]
least = sum
for i in range(k, l):
	sum = sum - a[i - k] + a[i]
	if sum < least:
		least = sum
		lowest = i - k + 1
print(lowest + 1)


z = list(map(int, input().split()))
x = list(map(int, input().split()))
if z[0] == 1:
	print(1)
	exit()
elif z[0] == 2:
	if z[1] == 1:
		print(x.index(min(x)) + 1)
		exit()
	else:
		print(1)
		exit()
fi = [0] * (z[0] + 1)
for i in range(z[0]):
	fi[i + 1] = x[i] + fi[i]
ans = []
for i in range(z[0] - z[1] + 1):
	ans.append([fi[i + z[1]] - fi[i], i + z[1], i])
try:
	a = min(ans)[2] + 1
	print(a)
except:
	print(1)


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
t = s = sum(l[:m])
a = 1
for i in range(m, n):
	t += l[i] - l[i - m]
	if t < s:
		a = i - m + 2
		s = t
print(a)


import sys
(planks, consecutive) = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
ans = arr[0:consecutive]
ans = sum(ans)
lowest = int(ans)
final = 1
for (index, x) in enumerate(range(1, planks - (consecutive - 1))):
	temp = ans - arr[x - 1] + arr[consecutive + index]
	if temp < lowest:
		lowest = temp
		final = x + 1
	ans = int(temp)
sys.stdout.write(str(final))


import sys
import math
(n, k) = [int(x) for x in sys.stdin.readline().split()]
hn = [int(x) for x in sys.stdin.readline().split()]
firstSum = sum(hn[:k])
c = 0
res = 0
vmin = 1000000000
for i in range(k, n):
	if firstSum < vmin:
		vmin = firstSum
		res = c
	firstSum = firstSum + hn[i] - hn[c]
	c += 1
if firstSum < vmin:
	vmin = firstSum
	res = c
print(res + 1)


def main():
	(n_planks, k) = map(int, input().split(' '))
	heights = [int(item) for item in input().split(' ')]
	prefix_sum = []
	sum_n = 0
	for plank in heights:
		sum_n += plank
		prefix_sum.append(sum_n)
	min_planks = prefix_sum[k - 1]
	min_index = 0
	i = 1
	j = i + k - 1
	while j < len(heights):
		if prefix_sum[j] - prefix_sum[i - 1] < min_planks:
			min_planks = prefix_sum[j] - prefix_sum[i - 1]
			min_index = i
		i += 1
		j = i + k - 1
	min_index += 1
	print(min_index)
main()


def CF363B():
	(n, k) = map(int, input().split())
	arr = tuple(map(int, input().split()))
	curr_sum = sum(arr[:k])
	min_sum = curr_sum
	index = 1
	for i in range(k, n):
		curr_sum = curr_sum - arr[i - k] + arr[i]
		if min_sum > curr_sum:
			index = i - k + 2
			min_sum = curr_sum
	return index
res = CF363B()
print(res)


(N, K) = [int(i) for i in input().split(' ')]
A = [int(i) for i in input().split(' ')]
sum = 0
for i in range(K):
	sum += A[i]
min = sum
Change = False
index = 0
for i in range(N - K):
	sum = sum - A[i] + A[i + K]
	if sum < min:
		min = sum
		index = i
		Change = True
if index == 0 and (not Change):
	print(1)
else:
	print(index + 2)


import sys
read = lambda : sys.stdin.readline().strip()
(N, K) = map(int, read().split())
A = [0, *map(int, read().split())]
psum = [0] * (N + 1)
for i in range(1, N + 1):
	psum[i] += psum[i - 1] + A[i]
ans = 0
mx = 1000000000.0
for i in range(K, N + 1):
	if mx > psum[i] - psum[i - K]:
		mx = psum[i] - psum[i - K]
		ans = i - K + 1
print(ans)


(n, m) = map(int, input().split())
num = [int(x) for x in input().split()]
Min = Sum = Pos = 0
for i in range(m):
	Sum += num[i]
Min = Sum
for i in range(m, n):
	Sum += num[i] - num[i - m]
	if Min > Sum:
		Min = Sum
		Pos = i - m + 1
print(Pos + 1)


(n, k) = input().split()
n = int(n)
k = int(k)
l = list(map(int, input().split()))
min1 = sum(l[0:k])
a = 1
min2 = min1
for i in range(k, len(l)):
	min2 = min2 + l[i] - l[i - k]
	if min2 < min1:
		min1 = min2
		a = i - k + 2
print(a)


(n, k) = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
if n == k:
	print(1)
else:
	b = [0] * (n + 1)
	count = 0
	for i in range(n):
		count += a[i]
		b[i + 1] = count
	ans = [0] * (n - k + 1)
	for i in range(1, n - k + 2):
		ans[i - 1] = b[i + k - 1] - b[i - 1]
	index = ans.index(min(ans))
	print(index + 1)


[n, k] = [int(x) for x in input().split()]
H = [int(x) for x in input().split()]
minVal = 0
ind = 0
for i in range(k):
	minVal += H[i]
currSum = minVal
for i in range(k, n):
	currSum -= H[i - k]
	currSum += H[i]
	if currSum < minVal:
		minVal = currSum
		ind = i - k + 1
print(ind + 1)


[n, k] = [int(x) for x in input().split()]
q = [int(x) for x in input().split()]
res = 0
bres = n * 1111
for i in range(k):
	res += q[i]
bres = res
x = 0
for i in range(1, n):
	if i + k - 1 >= n:
		break
	res = res - q[i - 1] + q[i - 1 + k]
	if res < bres:
		[bres, x] = [res, i]
print(x + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
s = []
si = 0
for i in range(n):
	si += a[i]
	s.append(si)
mino = 999999999999
index = -1
s.append(0)
for i in range(n - k + 1):
	d = s[i + k - 1] - s[i - 1]
	if d < mino:
		mino = d
		index = i
print(index + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
fe = sum(arr[:k])
ans = [fe]
for i in range(1, n - k + 1):
	fe = fe - arr[i - 1] + arr[i + k - 1]
	ans.append(fe)
print(ans.index(min(ans)) + 1)


(n, k) = map(int, input().strip().split())
arr = list(map(int, input().strip().split()))
currSum = sum(arr[:k])
ans = currSum
ind = 1
for i in range(k, len(arr)):
	currSum -= arr[i - k]
	currSum += arr[i]
	if currSum < ans:
		ind = i - k + 2
		ans = currSum
print(ind)


from copy import copy

def solve(n, l, c):
	s = copy(c)
	for i in range(1, n):
		s[i] += s[i - 1]
	dp = [0 for _ in range(n - l + 1)]
	for i in range(n - l + 1):
		if i == 0:
			dp[i] = s[l - 1]
		else:
			dp[i] = s[i + l - 1] - s[i - 1]
	return dp.index(min(dp)) + 1
args = list(map(int, input().split()))
num_planks = args[0]
window_length = args[1]
planks = list(map(int, input().split()))
print(solve(num_planks, window_length, planks))


(n, k) = map(int, input().split())
heights = list(map(int, input().split()))
s = 0
for i in range(k):
	s += heights[i]
(ans, prev) = (0, s)
for i in range(k, n):
	s += heights[i]
	s -= heights[i - k]
	if s < prev:
		ans = i - k + 1
		prev = s
print(ans + 1)


aantal = input().split(' ')
planken = list(map(int, input().split(' ')))
laagste = 10000000000
index = 1
som = 0
for i in range(0, int(aantal[1])):
	som += planken[i]
laagste = som
for i in range(1, int(aantal[0]) - int(aantal[1]) + 1):
	som = som + planken[i + int(aantal[1]) - 1] - planken[i - 1]
	if som < laagste:
		index = i + 1
		laagste = som
print(index)


(n, k) = map(int, input().split(' '))
L = [int(x) for x in input().split()]
best = sum(L[0:k])
id = 0
s = best
for i in range(1, n - k + 1):
	s += L[i + k - 1] - L[i - 1]
	if s < best:
		(best, id) = (s, i)
print(id + 1)


import math

def s():
	(n, k) = [int(x) for x in input().split(' ')]
	h = [int(x) for x in input().split(' ')]
	mn = sum(h[0:k])
	temp = mn
	mn_indx = 1
	for i in range(k, n):
		temp = temp - h[i - k] + h[i]
		if temp < mn:
			mn = temp
			mn_indx = i - k + 2
	print(mn_indx)
s()


(num_planks, required_width) = map(int, input().split())
planks = list(map(int, input().split()))
minimun_height = sum(planks[0:required_width])
current_height = minimun_height
solution = 1
for pos in range(1, num_planks - required_width + 1):
	current_height = current_height - planks[pos - 1] + planks[pos - 1 + required_width]
	if current_height < minimun_height:
		solution = pos + 1
		minimun_height = current_height
print(solution)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
x = sum(h[:k])
y = x
j = 1
for i in range(n - k):
	x = x - h[i] + h[i + k]
	if y > x:
		y = x
		j = i + 2
print(j)


from sys import stdin, stdout
cin = stdin.readline
cout = stdout.write
mp = lambda : list(map(int, cin().split()))
(n, k) = mp()
h = mp()
mini = summ = sum(h[:k])
x = 0
for i in range(1, n - k + 1):
	summ += -h[i - 1] + h[i + k - 1]
	if summ < mini:
		x = i
		mini = summ
cout(str(x + 1))


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
acc = _min = sum(h[:k])
ans = 1
for i in range(n - k):
	acc += h[i + k] - h[i]
	if acc < _min:
		_min = acc
		ans = i + 2
print(ans)


(n, k) = list(map(int, input().split()))
fenceHeights = list(map(int, input().split()))
currentSum = sum(fenceHeights[0:k])
minSum = currentSum
location = 1
for j in range(k, n):
	currentSum = currentSum + fenceHeights[j] - fenceHeights[j - k]
	if currentSum < minSum:
		minSum = currentSum
		location = j - k + 2
print(location)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
window = sum(arr[:k])
pmin = window
pindex = 0
for i in range(1, n - k + 1):
	window = window - arr[i - 1] + arr[i + k - 1]
	if pmin > window:
		pmin = window
		pindex = i
print(pindex + 1)


(n, k) = input().split()
(n, k) = (int(n), int(k))
a = input().split()
a = [int(i) for i in a]
ans = [0] * (n + 1)
ans[0] = 0
m = 15000000
ans[0] = a[0]
j = 0
for i in range(1, n + 1):
	ans[i] = ans[i - 1] + a[i - 1]
	if i >= k and ans[i] - ans[i - k] < m:
		m = ans[i] - ans[i - k]
		j = i - k
print(j + 1)


(n, k) = [int(x) for x in input().split()]
h = [int(x) for x in input().split()]
last = 0
for i in range(k):
	last += h[i]
answer = last
index = 0
for i in range(k, n):
	next = last + h[i] - h[i - k]
	if next < answer:
		answer = next
		index = i - k + 1
	last = next
print(index + 1)


(N, K) = input().split()
(N, K) = (int(N), int(K))
planks = tuple(map(int, input().split()))
min_poss = 999999999
sum_array = sorted(planks)
sum_array[K - 1] = sum(planks[:K])
for i in range(K, N):
	sum_array[i] = cur = sum_array[i - 1] + planks[i] - planks[i - K]
print(sum_array.index(min(sum_array[K - 1:])) - K + 2)


(n, k) = map(int, input().split())
lis = [int(i) for i in input().split()]
sm = sum(lis[:k])
ind = 0
val = [[0, sm]]
for i in range(k, n):
	sm += lis[i]
	sm -= lis[ind]
	ind += 1
	val.append([ind, sm])
val.sort(key=lambda x: x[1])
print(val[0][0] + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
minpos = 0
nextsum = sum(a[0:k])
minsum = nextsum
for i in range(1, n - k + 1):
	nextsum = nextsum - a[i - 1] + a[i + k - 1]
	if nextsum < minsum:
		minpos = i
		minsum = nextsum
print(minpos + 1)


(x, y) = map(int, input().split())
l = list(map(int, input().split()))
winsum = 0
for i in range(y):
	winsum += l[i]
minsum = winsum
h = 1
if x > y:
	for j in range(x - y):
		winsum = winsum - l[j] + l[j + y]
		if winsum < minsum:
			minsum = winsum
			h = j + 2
print(h)


import sys
input = sys.stdin.readline
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
min_hole = 0
hole = 0
j = 0
ans = 0
for i in range(0, n):
	if i < k:
		hole += a[i]
		min_hole = hole
	else:
		hole += a[i] - a[j]
		j += 1
		if min_hole > hole:
			ans = j
			min_hole = hole
print(ans + 1)


(n, k) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
ans = 0
hole = 0
min_hole = 0
j = 0
for i in range(len(arr)):
	if i < k:
		hole += arr[i]
		min_hole = hole
	else:
		hole += arr[i] - arr[j]
		j += 1
		if min_hole > hole:
			ans = j
			min_hole = hole
print(ans + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
mi = sum(a[0:k])
i = 0
ind = 0
prev = mi
while i + k < n:
	i += 1
	prev = prev - a[i - 1] + a[i + k - 1]
	if prev < mi:
		mi = prev
		ind = i
print(ind + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
j = 0
pre = [a[0]] + [0] * n
m = 10000000007
for i in range(1, n):
	pre[i] = pre[i - 1] + a[i]
for i in range(n - k + 1):
	if pre[i + k - 1] - pre[i - 1] < m:
		j = i
		m = pre[i + k - 1] - pre[i - 1]
print(j + 1)


def solN():
	(n, m) = map(int, input().split())
	r = list(map(int, input().split()))
	(i, res, t) = (0, pow(10, 9), 0)
	for (j, k) in enumerate(r):
		i += k
		if j > m - 1:
			i -= r[j - m]
		if j >= m - 1 and i < res:
			res = i
			t = j - m + 1
	print(t + 1)

def main():
	solN()
main()


[n, k] = list(map(int, input().split()))
arr = list(map(int, input().split()))
dp = [0] * n
dp[0] = arr[0]
for i in range(1, n):
	dp[i] = dp[i - 1] + arr[i]
sol = dp[k - 1]
ind = k - 1
for i in range(k, n):
	prevsol = sol
	sol = min(sol, dp[i] - dp[i - k])
	if prevsol != sol:
		ind = i
print(ind - k + 2)


(n, k) = str(input()).split()
(n, k) = (int(n), int(k))
line = str(input()).split()
line = [int(t) for t in line]
v = s = sum(line[0:k])
d = 0
for i in range(1, n + 1 - k):
	s = s + line[i + k - 1] - line[i - 1]
	if s < v:
		(d, v) = (i, s)
print(d + 1)


(n, k) = [int(i) for i in input().split()]
h = [int(i) for i in input().split()]
minsum = sum(h[:k])
thissum = minsum
ans = 0
for i in range(k, n):
	thissum += h[i]
	thissum -= h[i - k]
	if thissum < minsum:
		thissum = minsum
		ans = i - k + 1
print(ans + 1)


a = input().split()
fences = int(a[0])
minFences = int(a[1])
fenceList = input().split()
total = 0
out = 0
for i in range(fences):
	fenceList[i] = int(fenceList[i])
for i in range(minFences):
	out += fenceList[i]
total = out
start = 1
for i in range(minFences, fences):
	total -= fenceList[i - minFences]
	total += fenceList[i]
	if total < out:
		out = total
		start = i - minFences + 2
print(start)


(n, k) = map(int, input().split())
h = list(map(int, input().split()))
Min_s = 0
for i in range(k):
	Min_s += h[i]
S = Min_s
ans = 0
for i in range(1, n - k + 1):
	New = S - h[i - 1] + h[i + k - 1]
	if New < Min_s:
		Min_s = New
		ans = i
	S = New
print(ans + 1)


R = lambda : list(map(int, input().split()))
(a, b) = R()
s = R()
m = r = sum(s[:b])
res = 1
for i in range(a - b):
	r += -s[i] + s[i + b]
	if m > r:
		res = i + 2
		m = r
print(res)


from sys import stdin
(n, k) = map(int, stdin.readline().split())
h = list(map(int, stdin.readline().split()))
now = 0
ind = 0
for i in range(k):
	now += h[i]
m = now
for i in range(k, n):
	now = now + h[i] - h[i - k]
	if m > now:
		m = now
		ind = i - k + 1
print(ind + 1)


import os
import sys
from collections import Counter
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def main():
	t = 1
	for _ in range(t):
		(n, k) = map(int, input().split())
		a = list(map(int, input().split()))
		s = sum(a[:k])
		mins = s
		idx = 0
		for i in range(1, n - k + 1):
			s = s - a[i - 1] + a[i + k - 1]
			if s < mins:
				mins = s
				idx = i
		print(idx + 1)
main()


import sys
import bisect
from collections import deque
RI = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

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

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
(n, k) = RI()
a = RI()
pre = [1] * n
pre[0] = a[0]
for i in range(1, n):
	pre[i] = pre[i - 1] + a[i]
minn = INF
index = -1
for i in range(k - 1, n):
	if i == k - 1:
		minn = pre[i]
		index = i
	elif pre[i] - pre[i - k] < minn:
		minn = pre[i] - pre[i - k]
		index = i
print(index - k + 2)


(n, k) = map(int, input().split())
j = mn = s = 0
p = [None] * k
for (i, h) in enumerate(map(int, input().split())):
	if i < k:
		s += h
		mn = s
	else:
		s += h - p[i % k]
		if mn > s:
			j = i - k + 1
			mn = s
	p[i % k] = h
print(j + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
mli = []
minpos = 0
prevmi = sli = sum(arr[:k])
for x in range(1, n):
	sli -= arr[x - 1]
	if x + k - 1 < n:
		sli += arr[x + k - 1]
	else:
		break
	if sli < prevmi:
		minpos = x
		prevmi = sli
print(minpos + 1)


(n, k) = list(map(int, input().split()))
heights = list(map(int, input().split()))
cost = []
if n == k:
	print(1)
else:
	cost.append(sum(heights[0:k]))
	for i in range(1, n - k + 1):
		new_sum = cost[i - 1] - heights[i - 1] + heights[i + k - 1]
		cost.append(new_sum)
	print(cost.index(min(cost)) + 1)


(n, k) = map(int, input().split())
t = list(map(int, input().split()))
g = sum(t[:k])
u = sum(t[:k])
a = 0
h = 1
for j in range(k, n):
	u -= t[a]
	u += t[j]
	a += 1
	if u < g:
		h = a + 1
		g = u
print(h)


import sys
x = sys.stdin.readline().split()
x = [int(i) for i in x]
n = x[0]
k = x[1]
f = sys.stdin.readline().split()
f = [int(i) for i in f]
s = 0
for i in range(0, len(f) - k + 1):
	if i == 0:
		for i in range(k):
			s += f[i]
		minimum = s
		minimum_index = 1
	else:
		s -= f[i - 1]
		s += f[i + k - 1]
		if s < minimum:
			minimum = s
			minimum_index = i + 1
print(minimum_index)


(N, K) = map(int, input().split())
H = list(map(int, input().split()))
now = 0
for i in range(K):
	now += H[i]
minv = now
ans = 0
left = 0
right = K - 1
while right < N - 1:
	now -= H[left]
	left += 1
	right += 1
	now += H[right]
	if now < minv:
		minv = now
		ans = left
print(ans + 1)


test = [int(x) for x in input().split()]
l = test[0]
ques = test[1]
ans = 0
poi = 0
list = [int(x) for x in input().split()]
ans = t = sum(list[:ques])
for i in range(ques, l):
	t += list[i] - list[i - ques]
	if t < ans:
		ans = t
		poi = i - ques + 1
print(poi + 1)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
if n < k:
	print(-1)
else:
	sum_ = sum(arr[:k])
	min_ = sum_
	(index, x) = (0, 0)
	for i in range(k, n):
		sum_ += arr[i]
		sum_ -= arr[x]
		x += 1
		if min_ > sum_:
			index = x
			min_ = sum_
	print(index + 1)


from sys import stdin, stdout, setrecursionlimit
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log, log2
from random import seed, randint
from datetime import datetime
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
from collections import defaultdict as dd
mod = pow(10, 9) + 7
mod2 = 998244353

def inp():
	return stdin.readline().strip()

def iinp():
	return int(inp())

def out(var, end='\n'):
	stdout.write(str(var) + '\n')

def outa(*var, end='\n'):
	stdout.write(' '.join(map(str, var)) + end)

def lmp():
	return list(mp())

def mp():
	return map(int, inp().split())

def smp():
	return map(str, inp().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(m, val) for j in range(n)]

def remadd(x, y):
	return 1 if x % y else 0

def ceil(a, b):
	return (a + b - 1) // b

def def_value():
	return 0

def def_inf():
	return inf
(n, k) = mp()
a = [0] + lmp()
for i in range(1, n + 1):
	a[i] += a[i - 1]
mn = inf
pos = 1
for i in range(1, n - k + 2):
	if a[i + k - 1] - a[i - 1] < mn:
		pos = i
		mn = a[i + k - 1] - a[i - 1]
print(pos)


(n, piano) = map(int, input().split())
wall = [j for j in map(int, input().split())]
ans = []
temp = 0
for i in range(piano):
	temp += wall[i]
ans.append(temp)
for i in range(1, n):
	if i > n - piano:
		break
	ans.append(ans[i - 1] - wall[i - 1] + wall[i + piano - 1])
print(ans.index(min(ans)) + 1)


import math
(n, k) = map(int, input().split())
entrada = list(map(int, input().split()))
acumulado = [0]
for (i, num) in enumerate(entrada):
	acumulado.append(acumulado[i] + num)
index = 0
menor = math.inf
for i in range(n - k + 1):
	soma = acumulado[i + k] - acumulado[i]
	if soma < menor:
		index = i
		menor = soma
print(index + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
if k == 1:
	print(a.index(min(a)) + 1)
elif k == n:
	print(1)
else:
	s = []
	sum = 0
	for i in range(n - k + 1):
		if i == 0:
			for j in range(k):
				sum += a[j]
			s.append(sum)
		else:
			sum = s[i - 1] - a[i - 1] + a[k + i - 1]
			s.append(sum)
	print(s.index(min(s)) + 1)


def minSum(arr, n, k):
	if n < k:
		return -1
	res = 0
	index = 0
	for i in range(k):
		res += arr[i]
	curr_sum = res
	for i in range(k, n):
		curr_sum += arr[i] - arr[i - k]
		if res > curr_sum:
			res = curr_sum
			index = i - k + 1
	return index + 1
(n, k) = map(int, input().split())
l = list(map(int, input().split()))
print(minSum(l, n, k))


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict, Counter
from os import path
import bisect as bi
import heapq
mod = 10 ** 9 + 7

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def inp():
		return int(input())

	def minp():
		return map(int, input().split())
else:

	def inp():
		return int(stdin.readline())

	def minp():
		return map(int, stdin.readline().split())
(n, k) = minp()
a = list(minp())
total = 0
for i in range(k):
	total += a[i]
min_sum = total
index = 0
for i in range(k, n):
	total -= a[i - k]
	total += a[i]
	if total < min_sum:
		min_sum = total
		index = i - k + 1
print(index + 1)


(n, k) = [int(p) for p in input().split()]
arr = [int(p) for p in input().split()]
currSum = sum(arr[:k])
globSum = currSum
minIndex = 0
i = 0
while i + k < n:
	currSum -= arr[i]
	currSum += arr[i + k]
	i += 1
	if currSum < globSum:
		globSum = currSum
		minIndex = i
print(minIndex + 1)


(n, k) = map(int, input().split())
s = [int(i) for i in input().split()]
d = [0] * (n - k + 1)
a = sum(s[0:k])
d[0] = a
for i in range(1, n - k + 1):
	d[i] = d[i - 1] + s[i + k - 1] - s[i - 1]
print(d.index(min(d)) + 1)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
s = sum(a[:k])
mn = s
ind = 1
for i in range(k, n):
	s -= a[i - k]
	s += a[i]
	if s < mn:
		mn = s
		ind = i - k + 2
print(ind)


nk = list(map(int, input().split()))
h = list(map(int, input().split()))
step = 0
temp = 0
minimum_index = 1
for i in range(nk[0]):
	temp += h[i]
minimum = temp
for i in range(1, nk[0] - nk[1] + 1):
	temp -= h[step]
	temp += h[nk[1] + i - 1]
	step += 1
	if temp < minimum:
		minimum_index = i + 1
		minimum = temp
print(minimum_index)


(n, k) = map(int, input().split())
ht = list(map(int, input().split()))
(ind, minSum, tot) = (0, 0, 0)
for i in range(n - k):
	tot += ht[i + k] - ht[i]
	if tot < minSum:
		minSum = tot
		ind = i + 1
print(ind + 1)


(n, k) = map(int, input().split())
hs = list(map(int, input().split()))
mins = [sum(hs[:k])]
for i in range(n - k):
	mins.append(mins[-1] - hs[i] + hs[i + k])
print(mins.index(min(mins)) + 1)


(f_len, p_len) = [int(x) for x in input().split()]
fence = [int(x) for x in input().split()]
cur_len = 0
len_list = []
for i in range(0, p_len):
	cur_len += fence[i]
len_list.append(cur_len)
for j in range(p_len, f_len):
	cur_len += fence[j]
	cur_len -= fence[j - p_len]
	len_list.append(cur_len)
print(len_list.index(min(len_list)) + 1)


(n, k) = map(int, input().split())
p = list(map(int, input().split()))
pos = 0
mi = s = sum(p[:k])
for i in range(k, n):
	s += p[i]
	s -= p[i - k]
	if s < mi:
		mi = s
		pos = i - k + 1
print(pos + 1)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
ans = 1
su = sum(l[:k])
min_ = su
for i in range(n - k):
	su += l[i + k] - l[i]
	if su < min_:
		min_ = su
		ans = i + 2
print(ans)