message stringlengths 2 65.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 0 108k | cluster float64 14 14 | __index_level_0__ int64 0 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive. | instruction | 0 | 89,777 | 14 | 179,554 |
Tags: *special, dp
Correct Solution:
```
import sys
# sys.stdin = open("actext.txt","r")
n,k = map(int,input().split())
s = input()
dp = [-1 for i in range(n+1)]
count = 0
mxcount = 0
for i in s:
if(i=='N'):
count+=1
else:
if(mxcount<count):
mxcount = count
count = 0
if(mxcount<count):
mxcount = count
status = 0
if(mxcount>k):
print("NO")
status = 1
elif(mxcount==k):
print("YES")
else:
s = s+"Y"
# print(s)
for i in range(k,n+1):
if(s[i]!='N' and s[i-k-1]!='N'):
temp = False
# print(s[i-k:i])
for j in range(i-k,i):
if(s[j]=='Y'):
temp = True
break
# print(temp)
if(not temp):
print("YES")
exit()
print("NO")
``` | output | 1 | 89,777 | 14 | 179,555 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive. | instruction | 0 | 89,778 | 14 | 179,556 |
Tags: *special, dp
Correct Solution:
```
n, m = list(map(int, input().split()))
s = input()
cnt = int(0)
for ch in s:
if ch == 'N':
cnt += 1
elif cnt > m:
print("NO")
exit(0);
else:
cnt = int(0)
if cnt > m:
print("NO")
exit(0);
s = "Y"+s
for i in range(0, n+1):
if s[i] == '?' or s[i] == 'Y':
cnt = int(0)
for j in range(i+1, n+1):
#print(i, j, cnt, end = "\n")
if s[j] == 'Y':
if cnt == m:
print("YES")
exit(0)
break
if s[j] == '?':
if cnt == m:
print("YES")
exit(0)
cnt += 1
if cnt == m:
print("YES")
exit(0)
print("NO")
``` | output | 1 | 89,778 | 14 | 179,557 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive. | instruction | 0 | 89,779 | 14 | 179,558 |
Tags: *special, dp
Correct Solution:
```
n, k = map(int, input().split())
k = int(k)
s = input()
s = "Y" + s + "Y"
res = "NO"
cnt = 0
can = True
for ch in s:
if(ch == 'N'):
cnt += 1
if(cnt > k):
can = False
else:
cnt = 0
for i in range(1,n+1):
if(i + k - 2 < n):
subs = s[i:i+k]
# print(subs)
flag = True
for ch in subs:
if(not ch in "N?"):
flag = False
if((s[i-1] in "Y?" and s[i+k] in "Y?") and flag):
res = "YES"
# print(s[i-1], subs, s[i+k])
if can:
print(res)
else:
print("NO")
``` | output | 1 | 89,779 | 14 | 179,559 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive. | instruction | 0 | 89,780 | 14 | 179,560 |
Tags: *special, dp
Correct Solution:
```
# from Crypto.Util.number import *
# from Crypto.PublicKey import RSA
# from Crypto.Cipher import PKCS1_OAEP
#
#
# def gcd(a, b):
# if a == 0:
# return b, 0, 1
# d, x1, y1 = gcd(b % a, a)
# x = y1 - (b // a) * x1
# y = x1
# return d, x, y
#
#
# def find_private_key(p, q, e):
# f = (p - 1) * (q - 1)
# d = gcd(e, f)[1]
# while d < 0:
# d += f
# return d
#
#
# n = 114603416258617277914112950886933842277017613048768896986887063295795075651032133331342538430388087616693581335924733790772692053706860660493046367184589390096319068611843480381499933909451620838321468620579057390519217231379164202675046840772638142625114303262708400933811096588213415014292281310788830121449
#
# q = 8931970881300680082796820734365022222452747937209215859340339248013322229502496422895802649243487560690551112016430906973314030768362034269763079075131391
#
# p = 12830697477814509540399242283518279629025340392811455061638565349197540239841408191167449256086467748949090279070442786996339222196995600246150833643209239
#
# e = 78078409585916972042386784533013985111341440946219174025831418904974306682701
#
# f = 114603416258617277914112950886933842277017613048768896986887063295795075651032133331342538430388087616693581335924733790772692053706860660493046367184589368333650709496653857185436916026149769360233138599908136411614620020516694858770432777520732812669804663621317314060117126934960449656657765396876111780820
#
# d = 95617909040393155444786936446642179824041050920013801086828472351343249663960737590719979187458429568264589317317553181803837347371438624774016758221657991995265788792118497392951947899512373618098318332328397239065334523447713343639400315086378757038001615086063906730779984567240713176171007926923058722581
#
# rsa = RSA.construct((n, e, d))
#
#
# #key = RSA.importKey(open('11.txt', 'r').read())
# key = RSA.importKey(open('public_key', 'r').read())
#
# print(key.__dict__)
#
# n = 5629218730419894595823026663331501597897818160771697280840122531313799328035654852733468829411876184951508514832506002593002170978628016095067716010208905588870963783855109137307480667920058731486899983319164243850148229252772614367640165351224879369373847162133237931086116505957707781534245331485441
# p = 2372597464893675257469711937093671629348264195072192501684944517176070474701064022851367306150417447503454422147341366642712704243329694637078892947639
# q = n // p
# e = 17
#
# d = find_private_key(p, q, e)
#
# encrypted = 1111861507760457047964156325933048837925622938918416900082721305322555941153755195985545404321101492441045781915244282849548935206776118071569007445626459132036648013508921232096378109573160336245447392600788211167388900011173139344891307651852665571685713133157519571136012382352182349879574471249590
# result = pow(encrypted, d, n)
#
# result = hex(result)[2:]
#
# ans = b''
# for i in range(0, len(result), 2):
# ans += bytes([int(result[i:i+2], 16)])
#
# print(ans)
#
# exit()
#
# key = RSA.construct((n, e, d))
#
# with open('22.txt', 'wb') as fi:
# fi.write(key.exportKey('PEM'))
#
# print('d =', d)
# import time
# import requests
#
# url = 'http://sql.training.hackerdom.ru/10lastlevel.php?text='
# condition = 'ORD(SUBSTRING(COLUMN_NAME, {}, 1)) = {}'
# query = "IF(ORD(SUBSTRING(chocolate, {}, 1)) = {}, SLEEP(1), 1) FROM davidblayne;"
# pos = 1
# sleep_time = 1
# a = {''}
#
# s = ''
# for i in range(1, 30):
# for c in range(32, 128):
# start = time.time()
# requests.get(url + query.format(i, c))
# end = time.time()
#
# d = end - start
#
# if d >= sleep_time:
# print(chr(c))
# s += chr(c)
# break
# else:
# break
#
# print(s)
def calc(s):
max_len = 0
cur_len = 0
for i in range(len(s)):
if s[i] == 'N':
cur_len += 1
else:
cur_len = 0
max_len = max(max_len, cur_len)
return max_len
n, k = map(int, input().split())
s = input()
if calc(s) > k:
print('NO')
exit()
start = 0
while start + k - 1 < len(s):
good = True
for i in range(start, start + k):
if s[i] == 'Y':
good = False
break
if start - 1 >= 0 and s[start - 1] == 'N':
good = False
if start + k < len(s) and s[start + k] == 'N':
good = False
if good:
print('YES')
exit()
start += 1
print('NO')
``` | output | 1 | 89,780 | 14 | 179,561 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive. | instruction | 0 | 89,781 | 14 | 179,562 |
Tags: *special, dp
Correct Solution:
```
n, k = map(int, input().split())
s = input()
cnt, mx = 0, 0
for i in range(n):
if s[i] == "N":
cnt += 1
else:
cnt = 0
mx = max(mx, cnt)
if mx > k:
print("NO\n")
exit()
for r in range(k, n + 1):
l = r - k
if l > 0 and s[l - 1] == "N":
continue
if r < n and s[r] == "N":
continue
bad = False
for i in range(l, r):
if s[i] == "Y":
bad = True
break
if not bad:
print("YES\n")
exit()
print("NO\n")
``` | output | 1 | 89,781 | 14 | 179,563 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive. | instruction | 0 | 89,782 | 14 | 179,564 |
Tags: *special, dp
Correct Solution:
```
n, k = map(int, input().split())
string = input()
series = []
now = ""
for elem in string:
if elem == "Y":
if now:
series.append(now)
now = ""
else:
now += elem
if now:
series.append(now)
answer = False
no_max = True
if not k:
for elem in series:
if elem.count('N'):
answer = True
print("YES" if not answer else "NO")
else:
for elem in series:
m = len(elem)
for i in range(m - k + 1):
if (not i or elem[i - 1] == '?') and ((i + k - 1) == m - 1 or elem[i + k] == '?'):
answer = True
counter = 0
for letter in elem:
if letter == 'N':
counter += 1
if counter > k:
no_max = False
else:
counter = 0
print("YES" if answer and no_max else "NO")
``` | output | 1 | 89,782 | 14 | 179,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive.
Submitted Solution:
```
import sys
n, k = map(int, input().split(' '))
s = input()
def max_streak(s):
result = 0
for i in range(len(s)):
j = i
while j < len(s) and s[j] == 'N':
j += 1
result = max(result, j - i)
return result
for i in range(n - k + 1):
cur = list(s)
for j in range(i, i + k):
if cur[j] == '?':
cur[j] = 'N'
for j in range(i):
if cur[j] == '?':
cur[j] = 'Y'
for j in range(i + k, n):
if cur[j] == '?':
cur[j] = 'Y'
if max_streak(cur) == k:
print('YES')
sys.exit(0)
print('NO')
``` | instruction | 0 | 89,783 | 14 | 179,566 |
Yes | output | 1 | 89,783 | 14 | 179,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive.
Submitted Solution:
```
n, k = map(int, input().split())
s = list(input())
ans = False
for i in range(len(s) - k + 1):
flag = True
for j in range(i, i + k):
if (s[j] == 'Y'):
flag = False
break
if ((i + k) < len(s)) and s[i + k] == 'N': flag = False
if (i > 0) and (s[i - 1] == 'N'): flag = False
#print(i, flag)
if (flag):
ans = True
break
maximum = 0
i = 0
while (i < len(s)):
now = 0
while (s[i] != 'N'):
i += 1
if (i >= len(s)):
break
if (i >= len(s)): break
while (i < len(s)) and (s[i] == 'N'):
i += 1
now += 1
maximum = max(maximum, now)
if ans and (maximum <= k):
print('YES')
else: print('NO')
``` | instruction | 0 | 89,784 | 14 | 179,568 |
Yes | output | 1 | 89,784 | 14 | 179,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive.
Submitted Solution:
```
n, k = map(int, input().split())
s = input()
mnx = 0
mn = 0
mx = 0
ok = 0
for j in range(0, n-1):
if (s[j] == "N"):
mn += 1
mx += 1
if (mn > mnx):
mnx = mn
if (s[j] == "Y"):
mn = 0
mx = 0
if (s[j] == "?"):
mx += 1
if (k >= mn and k <= mx):
ok = 1
for i in range(j+1, n):
if (s[i] == "N"):
mn += 1
mx += 1
if (mn > mnx):
mnx = mn
if (s[i] == "Y"):
mn = 0
mx = 0
if (s[i] == "?"):
mx += 1
if (mn > mnx):
mnx = mn
if (k >= mn and k <= mx):
ok = 1
if (k < mnx):
ok = 0
if (ok == 1):
print("YES")
else:
print("NO")
``` | instruction | 0 | 89,785 | 14 | 179,570 |
No | output | 1 | 89,785 | 14 | 179,571 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive.
Submitted Solution:
```
n, k = map(int, input().split())
s = input()
mnx = 0
mn = 0
mx = 0
ok = 0
for j in range(0, n-1):
mn = 0
mx = 0
if (s[j] == "N"):
mn += 1
mx += 1
if (mn > mnx):
mnx = mn
if (s[j] == "?"):
mx += 1
if (k >= mn and k <= mx):
ok = 1
for i in range(j+1, n):
if (s[i] == "N"):
mn += 1
mx += 1
if (mn > mnx):
mnx = mn
if (s[i] == "Y"):
mn = 0
mx = 0
if (s[i] == "?"):
mx += 1
if (mn > mnx):
mnx = mn
if (k >= mn and k <= mx):
ok = 1
if (k < mnx):
ok = 0
if (ok == 1):
print("YES")
else:
print("NO")
``` | instruction | 0 | 89,786 | 14 | 179,572 |
No | output | 1 | 89,786 | 14 | 179,573 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive.
Submitted Solution:
```
n, relax = map(int, input().split())
x = []
s = input()
for i in range(len(s)):
x.append(s[i])
reader = []
while 'N' in x:
reader.append(x.index('N'))
del x[reader[-1]]
while '?' in x:
reader.append(x.index('?'))
del x[reader[-1]]
k = 0
for i in reader:
if i == reader[0]:
dno = i
elif i == dno + 1:
k += 1
else:
k = 0
if k == relax:
print('YES')
else:
print('NO')
'''
5 2
NYNNY
6 1
????NN
'''
``` | instruction | 0 | 89,787 | 14 | 179,574 |
No | output | 1 | 89,787 | 14 | 179,575 |
Provide a correct Python 3 solution for this coding contest problem.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone. | instruction | 0 | 90,138 | 14 | 180,276 |
"Correct Solution:
```
I = lambda: map(int, input().split())
_, k = I()
B = []
C = [0]*(k+1)
for a,b in zip(I(),I()):
if C[a]:
B.append(min(C[a],b))
else:
k -= 1
C[a] = max(C[a],b)
print(sum(sorted(B)[:k]))
``` | output | 1 | 90,138 | 14 | 180,277 |
Provide a correct Python 3 solution for this coding contest problem.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone. | instruction | 0 | 90,139 | 14 | 180,278 |
"Correct Solution:
```
#from sys import stdin
###
n, k = map(int, input().split())
jobs = list(map(int, input().split()))
t = list(map(int, input().split()))
exch = k - len(set(jobs))
doubleJobs = [0] * (k + 1)
timeOfDouble = []
for l in range(len(jobs)):
if doubleJobs[jobs[l]] < t[l]:
if doubleJobs[jobs[l]] != 0:
timeOfDouble.append(doubleJobs[jobs[l]])
doubleJobs[jobs[l]] = t[l]
else:
timeOfDouble.append(t[l])
#print("timeOfDouble", timeOfDouble)
timeOfDouble.sort()
#print("timeOfDouble", timeOfDouble)
print(sum(timeOfDouble[:exch]))
``` | output | 1 | 90,139 | 14 | 180,279 |
Provide a correct Python 3 solution for this coding contest problem.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone. | instruction | 0 | 90,140 | 14 | 180,280 |
"Correct Solution:
```
from collections import Counter
n, k = map(int, input().split())
jobs = list(map(int, input().split()))
time = list(map(int, input().split()))
chosen = len(set(jobs))
if chosen == k:
print(0)
else:
total = 0
c = Counter(jobs)
for i in range(n):
time[i] = (time[i], jobs[i])
time = sorted(time)
for t in time:
if c[t[1]] > 1:
c[t[1]] -= 1
total += t[0]
chosen += 1
if chosen == k:
break
print(total)
``` | output | 1 | 90,140 | 14 | 180,281 |
Provide a correct Python 3 solution for this coding contest problem.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone. | instruction | 0 | 90,141 | 14 | 180,282 |
"Correct Solution:
```
n,k=(int(i)for i in input().split())
a=[int(i) for i in input().split()]
b=[int(i)for i in input().split()]
t=[[a[i],b[i]]for i in range(n)]
t.sort(key=lambda x:[x[0],-x[1]])
now=t[0][0]
time=[]
chosen=1
for i in range(1,n):
if t[i][0]!=now:
chosen+=1
now=t[i][0]
else:
time.append(t[i][1])
time.sort()
print(sum(time[:(k-chosen)]))
``` | output | 1 | 90,141 | 14 | 180,283 |
Provide a correct Python 3 solution for this coding contest problem.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone. | instruction | 0 | 90,142 | 14 | 180,284 |
"Correct Solution:
```
from collections import defaultdict
def ans(a, b):
tmp = defaultdict(list)
for i in range(0, n):
tmp[a[i]].append(i)
if(len(tmp.keys()) == k):
return 0
length = k - len(tmp.keys())
dmp = []
for i in tmp.keys():
if(len(tmp[i]) > 1):
dmp.append(tmp[i])
dmp = sorted(dmp, key = lambda x : len(x))
cnt = 0
temp = []
for i in dmp:
max_ = []
for j in i:
max_.append([b[j], j])
max_.sort(reverse=True)
max_.pop(0)
temp += max_[::]
temp.sort()
temp = temp[:length]
for i in temp:
cnt += i[0]
return(cnt)
if __name__ == '__main__':
nk = list(map(int, input().strip().split()))
n, k = nk[0], nk[1]
a = list(map(int, input().strip().split()))
b = list(map(int, input().strip().split()))
print(ans(a, b))
``` | output | 1 | 90,142 | 14 | 180,285 |
Provide a correct Python 3 solution for this coding contest problem.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone. | instruction | 0 | 90,143 | 14 | 180,286 |
"Correct Solution:
```
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
def rl(proc=None):
if proc is not None:
return proc(sys.stdin.readline())
else:
return sys.stdin.readline().rstrip()
def srl(proc=None):
if proc is not None:
return list(map(proc, rl().split()))
else:
return rl().split()
def main():
n, k = srl(int)
A = srl(int)
B = srl(int)
spare = []
done = [-1] * k
for i in range(n):
task = A[i] - 1
if done[task] == -1:
done[task] = B[i]
continue
spare.append(min(done[task], B[i]))
done[task] = max(done[task], B[i])
spare.sort()
i = 0
r = 0
for d in done:
if d == -1:
r += spare[i]
i += 1
print(r)
if __name__ == '__main__':
main()
``` | output | 1 | 90,143 | 14 | 180,287 |
Provide a correct Python 3 solution for this coding contest problem.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone. | instruction | 0 | 90,144 | 14 | 180,288 |
"Correct Solution:
```
n,k = map(int,input().split())
s = list(map(int,input().split()))
p = list(map(int,input().split()))
r = {}
r2 = []
for i in range(n):
if s[i] in r:
if r[s[i]]>p[i]:
r2.append(p[i])
else:
r2.append(r[s[i]])
r[s[i]] = p[i]
else:
r[s[i]] = p[i]
r1 = k-len(r)
#print(r,r2)
print(sum(sorted(r2)[:r1]))
``` | output | 1 | 90,144 | 14 | 180,289 |
Provide a correct Python 3 solution for this coding contest problem.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone. | instruction | 0 | 90,145 | 14 | 180,290 |
"Correct Solution:
```
n, k = list(map(int, str(input()).split()))
a = list(map(int, str(input()).split(' ')))
b = list(map(int, str(input()).split(' ')))
l = []
for i in range(0, k):
l.append(0)
for i in range(0, n):
if (b[i] > l[a[i]-1]):
t = b[i]
b[i] = l[a[i]-1]
l[a[i] - 1] = t
b.sort(reverse=True)
for i in range(0, n-k):
b[i] = 0
print(sum(b))
``` | output | 1 | 90,145 | 14 | 180,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone.
Submitted Solution:
```
n, k = map(int, input().split())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
c = [0] * k
d = []
for (ai, bi) in zip(a,b):
if(c[ai - 1] != 0):
d.append(min(c[ai - 1], bi))
else:
k -= 1
c[ai - 1] = max(c[ai - 1], bi)
d.sort()
print(sum(d[:k]))
``` | instruction | 0 | 90,146 | 14 | 180,292 |
Yes | output | 1 | 90,146 | 14 | 180,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone.
Submitted Solution:
```
from sys import stdin
n, k = map(int, input().split())
jobs = list(map(int, next(stdin).split()))
t = list(map(int, next(stdin).split()))
exch = k - len(set(jobs))
doubleJobs = [0] * (k + 1)
timeOfDouble = []
for l in range(len(jobs)):
if doubleJobs[jobs[l]] < t[l]:
if doubleJobs[jobs[l]] != 0:
timeOfDouble.append(doubleJobs[jobs[l]])
doubleJobs[jobs[l]] = t[l]
else:
timeOfDouble.append(t[l])
#print("timeOfDouble", timeOfDouble)
timeOfDouble.sort()
#print("timeOfDouble", timeOfDouble)
print(sum(timeOfDouble[:exch]))
``` | instruction | 0 | 90,147 | 14 | 180,294 |
Yes | output | 1 | 90,147 | 14 | 180,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone.
Submitted Solution:
```
l1 = [int(x) for x in input().split()]
n,k = l1[0],l1[1]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
c = []
d= []
for x in range(len(a)):
if a[x] not in c:
c.append(a[x])
d.append([b[x]])
else:
d[c.index(a[x])].append(b[x])
for x in d:
x.remove(max(x))
f=[]
for x in d:
for y in x:
f.append(y)
f.sort()
print(sum(f[:k-len(d)]))
``` | instruction | 0 | 90,148 | 14 | 180,296 |
Yes | output | 1 | 90,148 | 14 | 180,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone.
Submitted Solution:
```
n, k = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
dic = {}
for i, f in zip(a,b):
if i in dic:
dic[i] +=[f]
else:
dic[i] =[f]
for _,value in dic.items():
value.sort()
value.pop()
k-=1
res = []
for _,value in dic.items():
for v in value:
res.append(v)
res.sort()
print(sum(res[:k]))
``` | instruction | 0 | 90,149 | 14 | 180,298 |
Yes | output | 1 | 90,149 | 14 | 180,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone.
Submitted Solution:
```
from collections import defaultdict as dd
from bisect import insort as ins
def solve(a, b, n, q):
jobs = dd(list)
v = []
n1 = q
for i in range(n):
ins(jobs[a[i]], b[i])
for job in jobs:
k = len(jobs[job])
for i in range(k - 1):
ins(v, jobs[job][i])
n1 -= 1
return sum(v[:n1])
def bruh():
n, k = [int(i)for i in input().split()]
a = [int(i)for i in input().split()]
b = [int(i)for i in input().split()]
print(solve(a, b, n, k))
bruh()
``` | instruction | 0 | 90,150 | 14 | 180,300 |
No | output | 1 | 90,150 | 14 | 180,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone.
Submitted Solution:
```
b=input().split( )
nas=int(b[0])
rab=int(b[1])
z=[]
c=0
pred=input()
time=input()
pred=pred.split( )
time=time.split( )
for i in range(nas):
pred[i]=int(pred[i])
time[i]=int(time[i])
z=[0]*rab
for i in range(nas):
z[pred[i]-1]+=1
i=0
while 0 in z:
try:
if z[i]>1:
mac=9999999999999999999999999
for j in range(nas):
if pred[j]==i+1 and time[j]<mac:
mac=time[j]
k=j
time[k]=999999999999999999999999999
z[i]-=1
c+=mac
l=z.index(0)
z[l]=1
except:
i=-1
i+=1
print(c)
``` | instruction | 0 | 90,151 | 14 | 180,302 |
No | output | 1 | 90,151 | 14 | 180,303 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone.
Submitted Solution:
```
try:
n,k=map(int,input().split(' '))
inp = list(map(int,input().split()))
inp2 = list(map(int,input().split()))
inp2.sort()
inp=set(inp)
inp=list(inp)
cnt=n-len(inp)
ans=0
for i in range(cnt):
ans=inp2[i]+ans
print(ans)
except:
print(n,k,inp)
``` | instruction | 0 | 90,152 | 14 | 180,304 |
No | output | 1 | 90,152 | 14 | 180,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The kingdom of Lazyland is the home to n idlers. These idlers are incredibly lazy and create many problems to their ruler, the mighty King of Lazyland.
Today k important jobs for the kingdom (k ≤ n) should be performed. Every job should be done by one person and every person can do at most one job. The King allowed every idler to choose one job they wanted to do and the i-th idler has chosen the job a_i.
Unfortunately, some jobs may not be chosen by anyone, so the King has to persuade some idlers to choose another job. The King knows that it takes b_i minutes to persuade the i-th idler. He asked his minister of labour to calculate the minimum total time he needs to spend persuading the idlers to get all the jobs done. Can you help him?
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 10^5) — the number of idlers and the number of jobs.
The second line of the input contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ k) — the jobs chosen by each idler.
The third line of the input contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 10^9) — the time the King needs to spend to persuade the i-th idler.
Output
The only line of the output should contain one number — the minimum total time the King needs to spend persuading the idlers to get all the jobs done.
Examples
Input
8 7
1 1 3 1 5 3 7 1
5 7 4 8 1 3 5 2
Output
10
Input
3 3
3 1 2
5 3 4
Output
0
Note
In the first example the optimal plan is to persuade idlers 1, 6, and 8 to do jobs 2, 4, and 6.
In the second example each job was chosen by some idler, so there is no need to persuade anyone.
Submitted Solution:
```
b=input().split( )
nas=int(b[0])
rab=int(b[1])
z=[]
c=0
pred=input()
time=input()
pred=pred.split( )
time=time.split( )
for i in range(nas):
pred[i]=int(pred[i])
time[i]=int(time[i])
z=[0]*rab
for i in range(nas):
z[pred[i]-1]+=1
i=0
while 0 in z:
try:
if z[i]>1:
mac=10000000
for j in range(nas):
if pred[j]==i+1 and time[j]<mac:
mac=time[j]
k=j
time[k]=10000000000
z[i]-=1
c+=mac
l=z.index(0)
z[l]=1
except:
i=-1
i+=1
print(c)
``` | instruction | 0 | 90,153 | 14 | 180,306 |
No | output | 1 | 90,153 | 14 | 180,307 |
Provide tags and a correct Python 3 solution for this coding contest problem.
New Year is coming! Vasya has prepared a New Year's verse and wants to recite it in front of Santa Claus.
Vasya's verse contains n parts. It takes a_i seconds to recite the i-th part. Vasya can't change the order of parts in the verse: firstly he recites the part which takes a_1 seconds, secondly — the part which takes a_2 seconds, and so on. After reciting the verse, Vasya will get the number of presents equal to the number of parts he fully recited.
Vasya can skip at most one part of the verse while reciting it (if he skips more than one part, then Santa will definitely notice it).
Santa will listen to Vasya's verse for no more than s seconds. For example, if s = 10, a = [100, 9, 1, 1], and Vasya skips the first part of verse, then he gets two presents.
Note that it is possible to recite the whole verse (if there is enough time).
Determine which part Vasya needs to skip to obtain the maximum possible number of gifts. If Vasya shouldn't skip anything, print 0. If there are multiple answers, print any of them.
You have to process t test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and s (1 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of parts in the verse and the maximum number of seconds Santa will listen to Vasya, respectively.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the time it takes to recite each part of the verse.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case print one integer — the number of the part that Vasya needs to skip to obtain the maximum number of gifts. If Vasya shouldn't skip any parts, print 0.
Example
Input
3
7 11
2 9 1 3 18 1 4
4 35
11 9 10 7
1 8
5
Output
2
1
0
Note
In the first test case if Vasya skips the second part then he gets three gifts.
In the second test case no matter what part of the verse Vasya skips.
In the third test case Vasya can recite the whole verse. | instruction | 0 | 90,259 | 14 | 180,518 |
Tags: binary search, brute force, implementation
Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
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')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
class BIT:
def __init__(self, n):
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def get(self, l, r=None):
if r is None: r = l + 1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
def bisearch_fore(self, l, r, x):
l_sm = self.sum(l-1)
ok = r + 1
ng = l - 1
while ng+1 < ok:
mid = (ok+ng) // 2
if self.sum(mid) - l_sm >= x:
ok = mid
else:
ng = mid
if ok != r + 1:
return ok
else:
return INF
def bisearch_back(self, l, r, x):
r_sm = self.sum(r)
ok = l - 1
ng = r + 1
while ok+1 < ng:
mid = (ok+ng) // 2
if r_sm - self.sum(mid-1) >= x:
ok = mid
else:
ng = mid
if ok != l - 1:
return ok
else:
return -INF
for _ in range(INT()):
N, K = MAP()
A = LIST()
if sum(A) <= K:
print(0)
continue
bit = BIT(N)
for i, a in enumerate(A):
bit.add(i, a)
mx = 0
for i in range(N):
bit.add(i, -A[i])
idx = bit.bisearch_fore(0, N-1, K+1)
if idx > mx:
mx = idx
ans = i + 1
bit.add(i, A[i])
print(ans)
``` | output | 1 | 90,259 | 14 | 180,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
New Year is coming! Vasya has prepared a New Year's verse and wants to recite it in front of Santa Claus.
Vasya's verse contains n parts. It takes a_i seconds to recite the i-th part. Vasya can't change the order of parts in the verse: firstly he recites the part which takes a_1 seconds, secondly — the part which takes a_2 seconds, and so on. After reciting the verse, Vasya will get the number of presents equal to the number of parts he fully recited.
Vasya can skip at most one part of the verse while reciting it (if he skips more than one part, then Santa will definitely notice it).
Santa will listen to Vasya's verse for no more than s seconds. For example, if s = 10, a = [100, 9, 1, 1], and Vasya skips the first part of verse, then he gets two presents.
Note that it is possible to recite the whole verse (if there is enough time).
Determine which part Vasya needs to skip to obtain the maximum possible number of gifts. If Vasya shouldn't skip anything, print 0. If there are multiple answers, print any of them.
You have to process t test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and s (1 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of parts in the verse and the maximum number of seconds Santa will listen to Vasya, respectively.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the time it takes to recite each part of the verse.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case print one integer — the number of the part that Vasya needs to skip to obtain the maximum number of gifts. If Vasya shouldn't skip any parts, print 0.
Example
Input
3
7 11
2 9 1 3 18 1 4
4 35
11 9 10 7
1 8
5
Output
2
1
0
Note
In the first test case if Vasya skips the second part then he gets three gifts.
In the second test case no matter what part of the verse Vasya skips.
In the third test case Vasya can recite the whole verse. | instruction | 0 | 90,260 | 14 | 180,520 |
Tags: binary search, brute force, implementation
Correct Solution:
```
from collections import defaultdict as dc
'''from collections import deque as dq
from bisect import bisect_left,bisect_right,insort_left'''
import sys
import math
#define of c++ as inl=input()
mod=10**9 +7
def bs(a,x):
i=bisect_left(a,x)
if i!=len(a):
return i
else:
return len(a)
def binarysearchforsolvingeqautions(a,i,l,r):
while(1):
mid=(l+r)/2
p,q=force(a,mid,i)
if abs(p-q)<0.0000000000001:
return mid
elif p>q:
l=mid
else:
r=mid
def bs(a,b):
l=a
r=b+1
x=b
ans=0
while(l<r):
mid=(l+r)//2
if x|mid>ans:
ans=x|mid
l=mid+1
else:
r=mid
return ans
def digit(n):
a=[]
while(n>0):
a.append(n%10)
n=n//10
return a
def inp():
p=int(input())
return p
def line():
p=list(map(int,input().split()))
return p
def ans(n,s,a):
if s>=sum(a):
return 0
m=-1
j=0
for i in range(n):
s=s-a[i]
if m<a[i]:
m=a[i]
j=i+1
if s<0:
return j
return 0
for _ in range(inp()):
n,s=line()
a=line()
print(ans(n,s,a))
``` | output | 1 | 90,260 | 14 | 180,521 |
Provide tags and a correct Python 3 solution for this coding contest problem.
New Year is coming! Vasya has prepared a New Year's verse and wants to recite it in front of Santa Claus.
Vasya's verse contains n parts. It takes a_i seconds to recite the i-th part. Vasya can't change the order of parts in the verse: firstly he recites the part which takes a_1 seconds, secondly — the part which takes a_2 seconds, and so on. After reciting the verse, Vasya will get the number of presents equal to the number of parts he fully recited.
Vasya can skip at most one part of the verse while reciting it (if he skips more than one part, then Santa will definitely notice it).
Santa will listen to Vasya's verse for no more than s seconds. For example, if s = 10, a = [100, 9, 1, 1], and Vasya skips the first part of verse, then he gets two presents.
Note that it is possible to recite the whole verse (if there is enough time).
Determine which part Vasya needs to skip to obtain the maximum possible number of gifts. If Vasya shouldn't skip anything, print 0. If there are multiple answers, print any of them.
You have to process t test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and s (1 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of parts in the verse and the maximum number of seconds Santa will listen to Vasya, respectively.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the time it takes to recite each part of the verse.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case print one integer — the number of the part that Vasya needs to skip to obtain the maximum number of gifts. If Vasya shouldn't skip any parts, print 0.
Example
Input
3
7 11
2 9 1 3 18 1 4
4 35
11 9 10 7
1 8
5
Output
2
1
0
Note
In the first test case if Vasya skips the second part then he gets three gifts.
In the second test case no matter what part of the verse Vasya skips.
In the third test case Vasya can recite the whole verse. | instruction | 0 | 90,261 | 14 | 180,522 |
Tags: binary search, brute force, implementation
Correct Solution:
```
T = int(input())
for t in range(T):
n, s = map(int, input().split())
v = list(map(int, input().split()))
tot = 0
j = 0
for i in range(n):
tot += v[i]
if tot - max(v[i], v[j]) > s:
tot -= v[i]
break
if v[i] > v[j]:
j = i
if tot <= s:
print(0)
else:
print(j+1)
``` | output | 1 | 90,261 | 14 | 180,523 |
Provide tags and a correct Python 3 solution for this coding contest problem.
New Year is coming! Vasya has prepared a New Year's verse and wants to recite it in front of Santa Claus.
Vasya's verse contains n parts. It takes a_i seconds to recite the i-th part. Vasya can't change the order of parts in the verse: firstly he recites the part which takes a_1 seconds, secondly — the part which takes a_2 seconds, and so on. After reciting the verse, Vasya will get the number of presents equal to the number of parts he fully recited.
Vasya can skip at most one part of the verse while reciting it (if he skips more than one part, then Santa will definitely notice it).
Santa will listen to Vasya's verse for no more than s seconds. For example, if s = 10, a = [100, 9, 1, 1], and Vasya skips the first part of verse, then he gets two presents.
Note that it is possible to recite the whole verse (if there is enough time).
Determine which part Vasya needs to skip to obtain the maximum possible number of gifts. If Vasya shouldn't skip anything, print 0. If there are multiple answers, print any of them.
You have to process t test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and s (1 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of parts in the verse and the maximum number of seconds Santa will listen to Vasya, respectively.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the time it takes to recite each part of the verse.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case print one integer — the number of the part that Vasya needs to skip to obtain the maximum number of gifts. If Vasya shouldn't skip any parts, print 0.
Example
Input
3
7 11
2 9 1 3 18 1 4
4 35
11 9 10 7
1 8
5
Output
2
1
0
Note
In the first test case if Vasya skips the second part then he gets three gifts.
In the second test case no matter what part of the verse Vasya skips.
In the third test case Vasya can recite the whole verse. | instruction | 0 | 90,262 | 14 | 180,524 |
Tags: binary search, brute force, implementation
Correct Solution:
```
t=int(input())
for i in range(t):
n,s=map(int,input().split())
a=list(map(int,input().split()))
b=[0]*n
c=[0]*n
for h in range(n):
b[h]=b[h-1]+a[h]
c[h]=max(c[h-1],a[h])
for j in range(n)[::-1]:
if b[j]<=s:
print(0)
break
elif b[j]-c[j]<=s:
print(a.index(c[j])+1)
break
``` | output | 1 | 90,262 | 14 | 180,525 |
Provide tags and a correct Python 3 solution for this coding contest problem.
New Year is coming! Vasya has prepared a New Year's verse and wants to recite it in front of Santa Claus.
Vasya's verse contains n parts. It takes a_i seconds to recite the i-th part. Vasya can't change the order of parts in the verse: firstly he recites the part which takes a_1 seconds, secondly — the part which takes a_2 seconds, and so on. After reciting the verse, Vasya will get the number of presents equal to the number of parts he fully recited.
Vasya can skip at most one part of the verse while reciting it (if he skips more than one part, then Santa will definitely notice it).
Santa will listen to Vasya's verse for no more than s seconds. For example, if s = 10, a = [100, 9, 1, 1], and Vasya skips the first part of verse, then he gets two presents.
Note that it is possible to recite the whole verse (if there is enough time).
Determine which part Vasya needs to skip to obtain the maximum possible number of gifts. If Vasya shouldn't skip anything, print 0. If there are multiple answers, print any of them.
You have to process t test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and s (1 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of parts in the verse and the maximum number of seconds Santa will listen to Vasya, respectively.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the time it takes to recite each part of the verse.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case print one integer — the number of the part that Vasya needs to skip to obtain the maximum number of gifts. If Vasya shouldn't skip any parts, print 0.
Example
Input
3
7 11
2 9 1 3 18 1 4
4 35
11 9 10 7
1 8
5
Output
2
1
0
Note
In the first test case if Vasya skips the second part then he gets three gifts.
In the second test case no matter what part of the verse Vasya skips.
In the third test case Vasya can recite the whole verse. | instruction | 0 | 90,263 | 14 | 180,526 |
Tags: binary search, brute force, implementation
Correct Solution:
```
t=int(input())
for i in range(t):
n,s=list(map(int,input().split()))
l=list(map(int,input().split()))
maxval=-1
done = False
skip=0
for i in range(n):
if(maxval==-1 or l[i]>l[maxval]):
maxval=i
if(s>=l[i]):
s-=l[i]
if(not done):
skip+=1
else:
s-=l[i]
if(not done):
skip=maxval
done=True
s+=l[maxval]
else:
break
skip+=1
if(skip>n):
skip=0
print(skip)
``` | output | 1 | 90,263 | 14 | 180,527 |
Provide tags and a correct Python 3 solution for this coding contest problem.
New Year is coming! Vasya has prepared a New Year's verse and wants to recite it in front of Santa Claus.
Vasya's verse contains n parts. It takes a_i seconds to recite the i-th part. Vasya can't change the order of parts in the verse: firstly he recites the part which takes a_1 seconds, secondly — the part which takes a_2 seconds, and so on. After reciting the verse, Vasya will get the number of presents equal to the number of parts he fully recited.
Vasya can skip at most one part of the verse while reciting it (if he skips more than one part, then Santa will definitely notice it).
Santa will listen to Vasya's verse for no more than s seconds. For example, if s = 10, a = [100, 9, 1, 1], and Vasya skips the first part of verse, then he gets two presents.
Note that it is possible to recite the whole verse (if there is enough time).
Determine which part Vasya needs to skip to obtain the maximum possible number of gifts. If Vasya shouldn't skip anything, print 0. If there are multiple answers, print any of them.
You have to process t test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and s (1 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of parts in the verse and the maximum number of seconds Santa will listen to Vasya, respectively.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the time it takes to recite each part of the verse.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case print one integer — the number of the part that Vasya needs to skip to obtain the maximum number of gifts. If Vasya shouldn't skip any parts, print 0.
Example
Input
3
7 11
2 9 1 3 18 1 4
4 35
11 9 10 7
1 8
5
Output
2
1
0
Note
In the first test case if Vasya skips the second part then he gets three gifts.
In the second test case no matter what part of the verse Vasya skips.
In the third test case Vasya can recite the whole verse. | instruction | 0 | 90,264 | 14 | 180,528 |
Tags: binary search, brute force, implementation
Correct Solution:
```
t = int(input())
for tc in range(t):
n,s = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
m = 0
mi = 0
i = 0
while i < n and s >= 0:
s -= a[i]
if a[i] > m:
m = a[i]
mi = i
i += 1
if i == n and s >= 0:
print(0)
else:
print(mi+1)
``` | output | 1 | 90,264 | 14 | 180,529 |
Provide tags and a correct Python 3 solution for this coding contest problem.
New Year is coming! Vasya has prepared a New Year's verse and wants to recite it in front of Santa Claus.
Vasya's verse contains n parts. It takes a_i seconds to recite the i-th part. Vasya can't change the order of parts in the verse: firstly he recites the part which takes a_1 seconds, secondly — the part which takes a_2 seconds, and so on. After reciting the verse, Vasya will get the number of presents equal to the number of parts he fully recited.
Vasya can skip at most one part of the verse while reciting it (if he skips more than one part, then Santa will definitely notice it).
Santa will listen to Vasya's verse for no more than s seconds. For example, if s = 10, a = [100, 9, 1, 1], and Vasya skips the first part of verse, then he gets two presents.
Note that it is possible to recite the whole verse (if there is enough time).
Determine which part Vasya needs to skip to obtain the maximum possible number of gifts. If Vasya shouldn't skip anything, print 0. If there are multiple answers, print any of them.
You have to process t test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and s (1 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of parts in the verse and the maximum number of seconds Santa will listen to Vasya, respectively.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the time it takes to recite each part of the verse.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case print one integer — the number of the part that Vasya needs to skip to obtain the maximum number of gifts. If Vasya shouldn't skip any parts, print 0.
Example
Input
3
7 11
2 9 1 3 18 1 4
4 35
11 9 10 7
1 8
5
Output
2
1
0
Note
In the first test case if Vasya skips the second part then he gets three gifts.
In the second test case no matter what part of the verse Vasya skips.
In the third test case Vasya can recite the whole verse. | instruction | 0 | 90,265 | 14 | 180,530 |
Tags: binary search, brute force, implementation
Correct Solution:
```
t = int(input())
def solve():
n,s = map(int, input().split())
a = list(map(int, input().split()))
maxId = -1
maxVerse = 0
i = 0
while i < n and a[i] <= s:
s -= a[i]
if a[i] > maxVerse:
maxId = i
maxVerse = a[i]
i += 1
if i == n:
print(0)
return
if a[i] <= maxVerse:
print(maxId+1)
return
if a[i] > maxVerse:
print(i+1)
return
for _ in range(t):
solve()
``` | output | 1 | 90,265 | 14 | 180,531 |
Provide tags and a correct Python 3 solution for this coding contest problem.
New Year is coming! Vasya has prepared a New Year's verse and wants to recite it in front of Santa Claus.
Vasya's verse contains n parts. It takes a_i seconds to recite the i-th part. Vasya can't change the order of parts in the verse: firstly he recites the part which takes a_1 seconds, secondly — the part which takes a_2 seconds, and so on. After reciting the verse, Vasya will get the number of presents equal to the number of parts he fully recited.
Vasya can skip at most one part of the verse while reciting it (if he skips more than one part, then Santa will definitely notice it).
Santa will listen to Vasya's verse for no more than s seconds. For example, if s = 10, a = [100, 9, 1, 1], and Vasya skips the first part of verse, then he gets two presents.
Note that it is possible to recite the whole verse (if there is enough time).
Determine which part Vasya needs to skip to obtain the maximum possible number of gifts. If Vasya shouldn't skip anything, print 0. If there are multiple answers, print any of them.
You have to process t test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains two integers n and s (1 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of parts in the verse and the maximum number of seconds Santa will listen to Vasya, respectively.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the time it takes to recite each part of the verse.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case print one integer — the number of the part that Vasya needs to skip to obtain the maximum number of gifts. If Vasya shouldn't skip any parts, print 0.
Example
Input
3
7 11
2 9 1 3 18 1 4
4 35
11 9 10 7
1 8
5
Output
2
1
0
Note
In the first test case if Vasya skips the second part then he gets three gifts.
In the second test case no matter what part of the verse Vasya skips.
In the third test case Vasya can recite the whole verse. | instruction | 0 | 90,266 | 14 | 180,532 |
Tags: binary search, brute force, implementation
Correct Solution:
```
t= int(input())
for _ in range(t):
n,s = list(map(int,input().split()))
a = list(map(int,input().split()))
m = [-1,-1]
res = 0
flag=0
i=0
while(i<n):
# print("res",res," a[i] ",a[i])
if m[0] < a[i]:
m[0] = a[i]
m[1] = i
if res>s and a[i]>s:
print(0)
flag=1
break
elif res>s and a[i]<=s:
flag=1
print(m[1]+1)
break
res+=a[i]
i+=1
if(flag==0 and res>s):
print(i)
elif flag==0:
print(0)
``` | output | 1 | 90,266 | 14 | 180,533 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Piegirl was asked to implement two table join operation for distributed database system, minimizing the network traffic.
Suppose she wants to join two tables, A and B. Each of them has certain number of rows which are distributed on different number of partitions. Table A is distributed on the first cluster consisting of m partitions. Partition with index i has ai rows from A. Similarly, second cluster containing table B has n partitions, i-th one having bi rows from B.
In one network operation she can copy one row from any partition to any other partition. At the end, for each row from A and each row from B there should be a partition that has both rows. Determine the minimal number of network operations to achieve this.
Input
First line contains two integer numbers, m and n (1 ≤ m, n ≤ 105). Second line contains description of the first cluster with m space separated integers, ai (1 ≤ ai ≤ 109). Similarly, third line describes second cluster with n space separated integers, bi (1 ≤ bi ≤ 109).
Output
Print one integer — minimal number of copy operations.
Examples
Input
2 2
2 6
3 100
Output
11
Input
2 3
10 10
1 1 1
Output
6
Note
In the first example it makes sense to move all the rows to the second partition of the second cluster which is achieved in 2 + 6 + 3 = 11 operations
In the second example Piegirl can copy each row from B to the both partitions of the first cluster which needs 2·3 = 6 copy operations. | instruction | 0 | 90,483 | 14 | 180,966 |
Tags: greedy
Correct Solution:
```
import sys
n,m=map(int,sys.stdin.readline().split())
A=list(map(int,sys.stdin.readline().split()))
B=list(map(int,sys.stdin.readline().split()))
A.sort(reverse=True)
B.sort(reverse=True)
a=sum(A)
b=sum(B)
ans=0
left=0
for i in range(n):
left+=A[i]
temp=b*(i+1)+a-left
if(ans==0):
ans=temp
ans=min(ans,temp)
left=0
for i in range(m):
left+=B[i]
temp=a*(i+1)+b-left
if(ans==0):
ans=temp
ans=min(ans,temp)
print(ans)
# Made By Mostafa_Khaled
``` | output | 1 | 90,483 | 14 | 180,967 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Piegirl was asked to implement two table join operation for distributed database system, minimizing the network traffic.
Suppose she wants to join two tables, A and B. Each of them has certain number of rows which are distributed on different number of partitions. Table A is distributed on the first cluster consisting of m partitions. Partition with index i has ai rows from A. Similarly, second cluster containing table B has n partitions, i-th one having bi rows from B.
In one network operation she can copy one row from any partition to any other partition. At the end, for each row from A and each row from B there should be a partition that has both rows. Determine the minimal number of network operations to achieve this.
Input
First line contains two integer numbers, m and n (1 ≤ m, n ≤ 105). Second line contains description of the first cluster with m space separated integers, ai (1 ≤ ai ≤ 109). Similarly, third line describes second cluster with n space separated integers, bi (1 ≤ bi ≤ 109).
Output
Print one integer — minimal number of copy operations.
Examples
Input
2 2
2 6
3 100
Output
11
Input
2 3
10 10
1 1 1
Output
6
Note
In the first example it makes sense to move all the rows to the second partition of the second cluster which is achieved in 2 + 6 + 3 = 11 operations
In the second example Piegirl can copy each row from B to the both partitions of the first cluster which needs 2·3 = 6 copy operations. | instruction | 0 | 90,484 | 14 | 180,968 |
Tags: greedy
Correct Solution:
```
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
A.sort(reverse=True)
B.sort(reverse=True)
sumA = sum(A)
sumB = sum(B)
ansA = sumB
ansB = sumA
for i in range(1, n):
ansA += min(A[i],sumB)
for i in range(1, m):
ansB += min(B[i], sumA)
print(min(ansA,ansB))
``` | output | 1 | 90,484 | 14 | 180,969 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Piegirl was asked to implement two table join operation for distributed database system, minimizing the network traffic.
Suppose she wants to join two tables, A and B. Each of them has certain number of rows which are distributed on different number of partitions. Table A is distributed on the first cluster consisting of m partitions. Partition with index i has ai rows from A. Similarly, second cluster containing table B has n partitions, i-th one having bi rows from B.
In one network operation she can copy one row from any partition to any other partition. At the end, for each row from A and each row from B there should be a partition that has both rows. Determine the minimal number of network operations to achieve this.
Input
First line contains two integer numbers, m and n (1 ≤ m, n ≤ 105). Second line contains description of the first cluster with m space separated integers, ai (1 ≤ ai ≤ 109). Similarly, third line describes second cluster with n space separated integers, bi (1 ≤ bi ≤ 109).
Output
Print one integer — minimal number of copy operations.
Examples
Input
2 2
2 6
3 100
Output
11
Input
2 3
10 10
1 1 1
Output
6
Note
In the first example it makes sense to move all the rows to the second partition of the second cluster which is achieved in 2 + 6 + 3 = 11 operations
In the second example Piegirl can copy each row from B to the both partitions of the first cluster which needs 2·3 = 6 copy operations. | instruction | 0 | 90,485 | 14 | 180,970 |
Tags: greedy
Correct Solution:
```
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
# asum=0
# bsum=0
a.sort()
b.sort()
asum=sum(a)
bsum=sum(b)
ans=9999999999999999999999999999999999999999
# print(a[0])
le=0
for i in range(0,n):
tmp=le+(n-i)*(bsum)
ans=min(ans,tmp)
le=le+a[i]
le=0
for i in range(0,m):
tmp=le+(m-i)*(asum)
ans=min(ans,tmp)
le=le+b[i]
print(ans)
``` | output | 1 | 90,485 | 14 | 180,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Piegirl was asked to implement two table join operation for distributed database system, minimizing the network traffic.
Suppose she wants to join two tables, A and B. Each of them has certain number of rows which are distributed on different number of partitions. Table A is distributed on the first cluster consisting of m partitions. Partition with index i has ai rows from A. Similarly, second cluster containing table B has n partitions, i-th one having bi rows from B.
In one network operation she can copy one row from any partition to any other partition. At the end, for each row from A and each row from B there should be a partition that has both rows. Determine the minimal number of network operations to achieve this.
Input
First line contains two integer numbers, m and n (1 ≤ m, n ≤ 105). Second line contains description of the first cluster with m space separated integers, ai (1 ≤ ai ≤ 109). Similarly, third line describes second cluster with n space separated integers, bi (1 ≤ bi ≤ 109).
Output
Print one integer — minimal number of copy operations.
Examples
Input
2 2
2 6
3 100
Output
11
Input
2 3
10 10
1 1 1
Output
6
Note
In the first example it makes sense to move all the rows to the second partition of the second cluster which is achieved in 2 + 6 + 3 = 11 operations
In the second example Piegirl can copy each row from B to the both partitions of the first cluster which needs 2·3 = 6 copy operations.
Submitted Solution:
```
[n,m]=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
sum1=sum(a);sum2=sum(b)
max1=max(a);max2=max(b)
ans=min(sum1+sum2-max2,sum1*m,sum1+sum2-max1,sum2*n)
print(ans)
``` | instruction | 0 | 90,486 | 14 | 180,972 |
No | output | 1 | 90,486 | 14 | 180,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Piegirl was asked to implement two table join operation for distributed database system, minimizing the network traffic.
Suppose she wants to join two tables, A and B. Each of them has certain number of rows which are distributed on different number of partitions. Table A is distributed on the first cluster consisting of m partitions. Partition with index i has ai rows from A. Similarly, second cluster containing table B has n partitions, i-th one having bi rows from B.
In one network operation she can copy one row from any partition to any other partition. At the end, for each row from A and each row from B there should be a partition that has both rows. Determine the minimal number of network operations to achieve this.
Input
First line contains two integer numbers, m and n (1 ≤ m, n ≤ 105). Second line contains description of the first cluster with m space separated integers, ai (1 ≤ ai ≤ 109). Similarly, third line describes second cluster with n space separated integers, bi (1 ≤ bi ≤ 109).
Output
Print one integer — minimal number of copy operations.
Examples
Input
2 2
2 6
3 100
Output
11
Input
2 3
10 10
1 1 1
Output
6
Note
In the first example it makes sense to move all the rows to the second partition of the second cluster which is achieved in 2 + 6 + 3 = 11 operations
In the second example Piegirl can copy each row from B to the both partitions of the first cluster which needs 2·3 = 6 copy operations.
Submitted Solution:
```
mn = [int(i) for i in input().split()]
a = [int(j) for j in input().split()]
b = [int(k) for k in input().split()]
c = a+b
print(c.count(max(c))*(sum(c)-(c.count(max(c))*max(c))))
``` | instruction | 0 | 90,487 | 14 | 180,974 |
No | output | 1 | 90,487 | 14 | 180,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Piegirl was asked to implement two table join operation for distributed database system, minimizing the network traffic.
Suppose she wants to join two tables, A and B. Each of them has certain number of rows which are distributed on different number of partitions. Table A is distributed on the first cluster consisting of m partitions. Partition with index i has ai rows from A. Similarly, second cluster containing table B has n partitions, i-th one having bi rows from B.
In one network operation she can copy one row from any partition to any other partition. At the end, for each row from A and each row from B there should be a partition that has both rows. Determine the minimal number of network operations to achieve this.
Input
First line contains two integer numbers, m and n (1 ≤ m, n ≤ 105). Second line contains description of the first cluster with m space separated integers, ai (1 ≤ ai ≤ 109). Similarly, third line describes second cluster with n space separated integers, bi (1 ≤ bi ≤ 109).
Output
Print one integer — minimal number of copy operations.
Examples
Input
2 2
2 6
3 100
Output
11
Input
2 3
10 10
1 1 1
Output
6
Note
In the first example it makes sense to move all the rows to the second partition of the second cluster which is achieved in 2 + 6 + 3 = 11 operations
In the second example Piegirl can copy each row from B to the both partitions of the first cluster which needs 2·3 = 6 copy operations.
Submitted Solution:
```
[n,m]=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
sum1=sum(a);sum2=sum(b)
max1=max(a);max2=max(b)
if sum1<sum2:
ans=min(sum1+sum2-max2,sum1*m)
else:
ans=min(sum2+sum1-max1,sum2*n)
print(ans)
``` | instruction | 0 | 90,488 | 14 | 180,976 |
No | output | 1 | 90,488 | 14 | 180,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Piegirl was asked to implement two table join operation for distributed database system, minimizing the network traffic.
Suppose she wants to join two tables, A and B. Each of them has certain number of rows which are distributed on different number of partitions. Table A is distributed on the first cluster consisting of m partitions. Partition with index i has ai rows from A. Similarly, second cluster containing table B has n partitions, i-th one having bi rows from B.
In one network operation she can copy one row from any partition to any other partition. At the end, for each row from A and each row from B there should be a partition that has both rows. Determine the minimal number of network operations to achieve this.
Input
First line contains two integer numbers, m and n (1 ≤ m, n ≤ 105). Second line contains description of the first cluster with m space separated integers, ai (1 ≤ ai ≤ 109). Similarly, third line describes second cluster with n space separated integers, bi (1 ≤ bi ≤ 109).
Output
Print one integer — minimal number of copy operations.
Examples
Input
2 2
2 6
3 100
Output
11
Input
2 3
10 10
1 1 1
Output
6
Note
In the first example it makes sense to move all the rows to the second partition of the second cluster which is achieved in 2 + 6 + 3 = 11 operations
In the second example Piegirl can copy each row from B to the both partitions of the first cluster which needs 2·3 = 6 copy operations.
Submitted Solution:
```
[n,m]=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
sum1=sum(a);sum2=sum(b)
max1=max(a);max2=max(b)
ans=min(sum1+sum2-max2,sum1*m,sum1+sum2-max2,sum2*n)
print(ans)
``` | instruction | 0 | 90,489 | 14 | 180,978 |
No | output | 1 | 90,489 | 14 | 180,979 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The busses in Berland are equipped with a video surveillance system. The system records information about changes in the number of passengers in a bus after stops.
If x is the number of passengers in a bus just before the current bus stop and y is the number of passengers in the bus just after current bus stop, the system records the number y-x. So the system records show how number of passengers changed.
The test run was made for single bus and n bus stops. Thus, the system recorded the sequence of integers a_1, a_2, ..., a_n (exactly one number for each bus stop), where a_i is the record for the bus stop i. The bus stops are numbered from 1 to n in chronological order.
Determine the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w (that is, at any time in the bus there should be from 0 to w passengers inclusive).
Input
The first line contains two integers n and w (1 ≤ n ≤ 1 000, 1 ≤ w ≤ 10^{9}) — the number of bus stops and the capacity of the bus.
The second line contains a sequence a_1, a_2, ..., a_n (-10^{6} ≤ a_i ≤ 10^{6}), where a_i equals to the number, which has been recorded by the video system after the i-th bus stop.
Output
Print the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w. If the situation is contradictory (i.e. for any initial number of passengers there will be a contradiction), print 0.
Examples
Input
3 5
2 1 -3
Output
3
Input
2 4
-1 1
Output
4
Input
4 10
2 4 1 2
Output
2
Note
In the first example initially in the bus could be 0, 1 or 2 passengers.
In the second example initially in the bus could be 1, 2, 3 or 4 passengers.
In the third example initially in the bus could be 0 or 1 passenger. | instruction | 0 | 90,678 | 14 | 181,356 |
Tags: combinatorics, math
Correct Solution:
```
n,w = map(int, input().split())
a = list(map(int, input().split()))
from itertools import accumulate
b = list(accumulate(a))
c1, c2 = max(b), min(b)
if c1 < 0:
c1 = abs(c2)
elif c2 < 0:
c1, c2 = c1-c2, 0
if c1 > w:
print(0)
else:
print(w - c1+1)
``` | output | 1 | 90,678 | 14 | 181,357 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The busses in Berland are equipped with a video surveillance system. The system records information about changes in the number of passengers in a bus after stops.
If x is the number of passengers in a bus just before the current bus stop and y is the number of passengers in the bus just after current bus stop, the system records the number y-x. So the system records show how number of passengers changed.
The test run was made for single bus and n bus stops. Thus, the system recorded the sequence of integers a_1, a_2, ..., a_n (exactly one number for each bus stop), where a_i is the record for the bus stop i. The bus stops are numbered from 1 to n in chronological order.
Determine the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w (that is, at any time in the bus there should be from 0 to w passengers inclusive).
Input
The first line contains two integers n and w (1 ≤ n ≤ 1 000, 1 ≤ w ≤ 10^{9}) — the number of bus stops and the capacity of the bus.
The second line contains a sequence a_1, a_2, ..., a_n (-10^{6} ≤ a_i ≤ 10^{6}), where a_i equals to the number, which has been recorded by the video system after the i-th bus stop.
Output
Print the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w. If the situation is contradictory (i.e. for any initial number of passengers there will be a contradiction), print 0.
Examples
Input
3 5
2 1 -3
Output
3
Input
2 4
-1 1
Output
4
Input
4 10
2 4 1 2
Output
2
Note
In the first example initially in the bus could be 0, 1 or 2 passengers.
In the second example initially in the bus could be 1, 2, 3 or 4 passengers.
In the third example initially in the bus could be 0 or 1 passenger. | instruction | 0 | 90,679 | 14 | 181,358 |
Tags: combinatorics, math
Correct Solution:
```
# your code goes here
# your code goes here
n,w = map(int,input().split())
a = list(map(int,input().split()))
maxi,mini = 0,0
total = 0
for i in range(n):
total += a[i]
if total > maxi:
maxi = total
if total < mini:
mini = total
ans = w - max(maxi,0) + 1 - max(-mini,0)
if ans < 0:
print(0)
else:
print(ans)
``` | output | 1 | 90,679 | 14 | 181,359 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The busses in Berland are equipped with a video surveillance system. The system records information about changes in the number of passengers in a bus after stops.
If x is the number of passengers in a bus just before the current bus stop and y is the number of passengers in the bus just after current bus stop, the system records the number y-x. So the system records show how number of passengers changed.
The test run was made for single bus and n bus stops. Thus, the system recorded the sequence of integers a_1, a_2, ..., a_n (exactly one number for each bus stop), where a_i is the record for the bus stop i. The bus stops are numbered from 1 to n in chronological order.
Determine the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w (that is, at any time in the bus there should be from 0 to w passengers inclusive).
Input
The first line contains two integers n and w (1 ≤ n ≤ 1 000, 1 ≤ w ≤ 10^{9}) — the number of bus stops and the capacity of the bus.
The second line contains a sequence a_1, a_2, ..., a_n (-10^{6} ≤ a_i ≤ 10^{6}), where a_i equals to the number, which has been recorded by the video system after the i-th bus stop.
Output
Print the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w. If the situation is contradictory (i.e. for any initial number of passengers there will be a contradiction), print 0.
Examples
Input
3 5
2 1 -3
Output
3
Input
2 4
-1 1
Output
4
Input
4 10
2 4 1 2
Output
2
Note
In the first example initially in the bus could be 0, 1 or 2 passengers.
In the second example initially in the bus could be 1, 2, 3 or 4 passengers.
In the third example initially in the bus could be 0 or 1 passenger. | instruction | 0 | 90,680 | 14 | 181,360 |
Tags: combinatorics, math
Correct Solution:
```
a = input().split(" ")
a = [int(e) for e in a]
capacity = a[1]
l = input().split(" ")
l = [int(e) for e in l]
assert a[0] == len(l)
min_num = 0
max_num = 0
num = 0
for change in l:
num += change
if min_num == None or num < min_num:
min_num = num
if max_num == None or num > max_num:
max_num = num
print(max(capacity - max_num + min_num + 1, 0))
``` | output | 1 | 90,680 | 14 | 181,361 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The busses in Berland are equipped with a video surveillance system. The system records information about changes in the number of passengers in a bus after stops.
If x is the number of passengers in a bus just before the current bus stop and y is the number of passengers in the bus just after current bus stop, the system records the number y-x. So the system records show how number of passengers changed.
The test run was made for single bus and n bus stops. Thus, the system recorded the sequence of integers a_1, a_2, ..., a_n (exactly one number for each bus stop), where a_i is the record for the bus stop i. The bus stops are numbered from 1 to n in chronological order.
Determine the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w (that is, at any time in the bus there should be from 0 to w passengers inclusive).
Input
The first line contains two integers n and w (1 ≤ n ≤ 1 000, 1 ≤ w ≤ 10^{9}) — the number of bus stops and the capacity of the bus.
The second line contains a sequence a_1, a_2, ..., a_n (-10^{6} ≤ a_i ≤ 10^{6}), where a_i equals to the number, which has been recorded by the video system after the i-th bus stop.
Output
Print the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w. If the situation is contradictory (i.e. for any initial number of passengers there will be a contradiction), print 0.
Examples
Input
3 5
2 1 -3
Output
3
Input
2 4
-1 1
Output
4
Input
4 10
2 4 1 2
Output
2
Note
In the first example initially in the bus could be 0, 1 or 2 passengers.
In the second example initially in the bus could be 1, 2, 3 or 4 passengers.
In the third example initially in the bus could be 0 or 1 passenger. | instruction | 0 | 90,681 | 14 | 181,362 |
Tags: combinatorics, math
Correct Solution:
```
z,s,a,b=input,0,0,0;n,m=map(int,z().split())
for i in map(int,z().split()):s+=i;a,b=min(a,s),max(b,s)
print(max(m-b+a+1,0))
``` | output | 1 | 90,681 | 14 | 181,363 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The busses in Berland are equipped with a video surveillance system. The system records information about changes in the number of passengers in a bus after stops.
If x is the number of passengers in a bus just before the current bus stop and y is the number of passengers in the bus just after current bus stop, the system records the number y-x. So the system records show how number of passengers changed.
The test run was made for single bus and n bus stops. Thus, the system recorded the sequence of integers a_1, a_2, ..., a_n (exactly one number for each bus stop), where a_i is the record for the bus stop i. The bus stops are numbered from 1 to n in chronological order.
Determine the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w (that is, at any time in the bus there should be from 0 to w passengers inclusive).
Input
The first line contains two integers n and w (1 ≤ n ≤ 1 000, 1 ≤ w ≤ 10^{9}) — the number of bus stops and the capacity of the bus.
The second line contains a sequence a_1, a_2, ..., a_n (-10^{6} ≤ a_i ≤ 10^{6}), where a_i equals to the number, which has been recorded by the video system after the i-th bus stop.
Output
Print the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w. If the situation is contradictory (i.e. for any initial number of passengers there will be a contradiction), print 0.
Examples
Input
3 5
2 1 -3
Output
3
Input
2 4
-1 1
Output
4
Input
4 10
2 4 1 2
Output
2
Note
In the first example initially in the bus could be 0, 1 or 2 passengers.
In the second example initially in the bus could be 1, 2, 3 or 4 passengers.
In the third example initially in the bus could be 0 or 1 passenger. | instruction | 0 | 90,682 | 14 | 181,364 |
Tags: combinatorics, math
Correct Solution:
```
n,w = map(int,input().split())
a = [int(s) for s in input().split()]
mi,ma,s = 0,0,0
for i in a:
s += i
if s < mi:
mi = s
elif s > ma:
ma = s
if -mi <= w-ma:
print(w-ma+mi+1)
else:
print(0)
``` | output | 1 | 90,682 | 14 | 181,365 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The busses in Berland are equipped with a video surveillance system. The system records information about changes in the number of passengers in a bus after stops.
If x is the number of passengers in a bus just before the current bus stop and y is the number of passengers in the bus just after current bus stop, the system records the number y-x. So the system records show how number of passengers changed.
The test run was made for single bus and n bus stops. Thus, the system recorded the sequence of integers a_1, a_2, ..., a_n (exactly one number for each bus stop), where a_i is the record for the bus stop i. The bus stops are numbered from 1 to n in chronological order.
Determine the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w (that is, at any time in the bus there should be from 0 to w passengers inclusive).
Input
The first line contains two integers n and w (1 ≤ n ≤ 1 000, 1 ≤ w ≤ 10^{9}) — the number of bus stops and the capacity of the bus.
The second line contains a sequence a_1, a_2, ..., a_n (-10^{6} ≤ a_i ≤ 10^{6}), where a_i equals to the number, which has been recorded by the video system after the i-th bus stop.
Output
Print the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w. If the situation is contradictory (i.e. for any initial number of passengers there will be a contradiction), print 0.
Examples
Input
3 5
2 1 -3
Output
3
Input
2 4
-1 1
Output
4
Input
4 10
2 4 1 2
Output
2
Note
In the first example initially in the bus could be 0, 1 or 2 passengers.
In the second example initially in the bus could be 1, 2, 3 or 4 passengers.
In the third example initially in the bus could be 0 or 1 passenger. | instruction | 0 | 90,683 | 14 | 181,366 |
Tags: combinatorics, math
Correct Solution:
```
"""Codeforces Round #481 (Div. 3) - Bus Video System.
http://codeforces.com/contest/978/problem/E
The busses in Berland are equipped with a video surveillance system. The
system records information about changes in the number of passengers in a bus
after stops.
If ``x`` is the number of passengers in a bus just before the current bus
stop and ``y`` is the number of passengers in the bus just after current bus
stop, the system records the number y - x. So the system records show how
number of passengers changed.
The test run was made for single bus and ``n`` bus stops. Thus, the system
recorded the sequence of integers a[1], a[2], ..., a[n] (exactly one
number for each bus stop), where a[i] is the record for the bus stop
``i``. The bus stops are numbered from 1 to n in chronological order.
Determine the number of possible ways how many people could be in the bus
before the first bus stop, if the bus has a capacity equals to ``w`` (that
is, at any time in the bus there should be from 0 to w passengers inclusive).
"""
def solve(capacity, sequence):
diff = 0
lb, ub = float('inf'), -float('inf')
for record in sequence:
diff += record
ub = max(ub, diff)
lb = min(lb, diff)
return max(0, capacity - max(0, ub) + min(0, lb) + 1)
def main():
_, capacity = [int(x) for x in input().strip().split()]
sequence = [int(x) for x in input().strip().split()]
result = solve(capacity, sequence)
print(result)
if __name__ == '__main__':
main()
``` | output | 1 | 90,683 | 14 | 181,367 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The busses in Berland are equipped with a video surveillance system. The system records information about changes in the number of passengers in a bus after stops.
If x is the number of passengers in a bus just before the current bus stop and y is the number of passengers in the bus just after current bus stop, the system records the number y-x. So the system records show how number of passengers changed.
The test run was made for single bus and n bus stops. Thus, the system recorded the sequence of integers a_1, a_2, ..., a_n (exactly one number for each bus stop), where a_i is the record for the bus stop i. The bus stops are numbered from 1 to n in chronological order.
Determine the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w (that is, at any time in the bus there should be from 0 to w passengers inclusive).
Input
The first line contains two integers n and w (1 ≤ n ≤ 1 000, 1 ≤ w ≤ 10^{9}) — the number of bus stops and the capacity of the bus.
The second line contains a sequence a_1, a_2, ..., a_n (-10^{6} ≤ a_i ≤ 10^{6}), where a_i equals to the number, which has been recorded by the video system after the i-th bus stop.
Output
Print the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w. If the situation is contradictory (i.e. for any initial number of passengers there will be a contradiction), print 0.
Examples
Input
3 5
2 1 -3
Output
3
Input
2 4
-1 1
Output
4
Input
4 10
2 4 1 2
Output
2
Note
In the first example initially in the bus could be 0, 1 or 2 passengers.
In the second example initially in the bus could be 1, 2, 3 or 4 passengers.
In the third example initially in the bus could be 0 or 1 passenger. | instruction | 0 | 90,684 | 14 | 181,368 |
Tags: combinatorics, math
Correct Solution:
```
n, w = map(int, input().split())
a = list(map(int, input().split()))
minw, maxw = 0, w
k = 0
for e in a:
w -= e
k -= e
maxw = min(w, maxw)
minw = max(minw, k)
if minw > maxw:
print(0)
else:
print(maxw - minw + 1)
``` | output | 1 | 90,684 | 14 | 181,369 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The busses in Berland are equipped with a video surveillance system. The system records information about changes in the number of passengers in a bus after stops.
If x is the number of passengers in a bus just before the current bus stop and y is the number of passengers in the bus just after current bus stop, the system records the number y-x. So the system records show how number of passengers changed.
The test run was made for single bus and n bus stops. Thus, the system recorded the sequence of integers a_1, a_2, ..., a_n (exactly one number for each bus stop), where a_i is the record for the bus stop i. The bus stops are numbered from 1 to n in chronological order.
Determine the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w (that is, at any time in the bus there should be from 0 to w passengers inclusive).
Input
The first line contains two integers n and w (1 ≤ n ≤ 1 000, 1 ≤ w ≤ 10^{9}) — the number of bus stops and the capacity of the bus.
The second line contains a sequence a_1, a_2, ..., a_n (-10^{6} ≤ a_i ≤ 10^{6}), where a_i equals to the number, which has been recorded by the video system after the i-th bus stop.
Output
Print the number of possible ways how many people could be in the bus before the first bus stop, if the bus has a capacity equals to w. If the situation is contradictory (i.e. for any initial number of passengers there will be a contradiction), print 0.
Examples
Input
3 5
2 1 -3
Output
3
Input
2 4
-1 1
Output
4
Input
4 10
2 4 1 2
Output
2
Note
In the first example initially in the bus could be 0, 1 or 2 passengers.
In the second example initially in the bus could be 1, 2, 3 or 4 passengers.
In the third example initially in the bus could be 0 or 1 passenger. | instruction | 0 | 90,685 | 14 | 181,370 |
Tags: combinatorics, math
Correct Solution:
```
n, w = map(int, input().split())
a = list(map(int, input().split()))
L = 0
R = w
c = [0] * (n + 1)
for i in range(1, n + 1):
c[i] = c[i - 1] + a[i - 1]
L = - min(c)
R = w - max(c)
if R - L + 1 < 0:
print(0)
else:
print(R - L + 1)
``` | output | 1 | 90,685 | 14 | 181,371 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.