text stringlengths 1.02k 43.5k | conversation_id int64 853 107k | embedding list | cluster int64 24 24 |
|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is an experienced participant in Codehorses programming contests. Now he wants to become a problemsetter.
He sent to the coordinator a set of n problems. Each problem has it's quality, the quality of the i-th problem is ai (ai can be positive, negative or equal to zero). The problems are ordered by expected difficulty, but the difficulty is not related to the quality in any way. The easiest problem has index 1, the hardest problem has index n.
The coordinator's mood is equal to q now. After reading a problem, the mood changes by it's quality. It means that after the coordinator reads a problem with quality b, the value b is added to his mood. The coordinator always reads problems one by one from the easiest to the hardest, it's impossible to change the order of the problems.
If after reading some problem the coordinator's mood becomes negative, he immediately stops reading and rejects the problemset.
Polycarp wants to remove the minimum number of problems from his problemset to make the coordinator's mood non-negative at any moment of time. Polycarp is not sure about the current coordinator's mood, but he has m guesses "the current coordinator's mood q = bi".
For each of m guesses, find the minimum number of problems Polycarp needs to remove so that the coordinator's mood will always be greater or equal to 0 while he reads problems from the easiest of the remaining problems to the hardest.
Input
The first line of input contains two integers n and m (1 ≤ n ≤ 750, 1 ≤ m ≤ 200 000) — the number of problems in the problemset and the number of guesses about the current coordinator's mood.
The second line of input contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the qualities of the problems in order of increasing difficulty.
The third line of input contains m integers b1, b2, ..., bm (0 ≤ bi ≤ 1015) — the guesses of the current coordinator's mood q.
Output
Print m lines, in i-th line print single integer — the answer to the problem with q = bi.
Example
Input
6 3
8 -5 -4 1 -7 4
0 7 3
Output
2
0
1
Submitted Solution:
```
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
for i in range(0,m):
start = b[i]
k = 0
i = 0
tmp = a[:]
while i < len(tmp):
start += tmp[i]
if start >= 0:
i += 1
else:
index = tmp[0:i+1].index(min(tmp[0:i+1]))
#start-=tmp.pop(index)
start -= tmp[index]
tmp[index] = 1
k += 1
print(k)
```
No
| 53,536 | [
0.469970703125,
0.1422119140625,
0.0309906005859375,
-0.08056640625,
-0.63671875,
-0.365966796875,
-0.2529296875,
0.2147216796875,
-0.2022705078125,
0.537109375,
0.5244140625,
-0.376220703125,
-0.27099609375,
-0.79638671875,
-0.17431640625,
-0.51318359375,
-0.77783203125,
-0.316650... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is an experienced participant in Codehorses programming contests. Now he wants to become a problemsetter.
He sent to the coordinator a set of n problems. Each problem has it's quality, the quality of the i-th problem is ai (ai can be positive, negative or equal to zero). The problems are ordered by expected difficulty, but the difficulty is not related to the quality in any way. The easiest problem has index 1, the hardest problem has index n.
The coordinator's mood is equal to q now. After reading a problem, the mood changes by it's quality. It means that after the coordinator reads a problem with quality b, the value b is added to his mood. The coordinator always reads problems one by one from the easiest to the hardest, it's impossible to change the order of the problems.
If after reading some problem the coordinator's mood becomes negative, he immediately stops reading and rejects the problemset.
Polycarp wants to remove the minimum number of problems from his problemset to make the coordinator's mood non-negative at any moment of time. Polycarp is not sure about the current coordinator's mood, but he has m guesses "the current coordinator's mood q = bi".
For each of m guesses, find the minimum number of problems Polycarp needs to remove so that the coordinator's mood will always be greater or equal to 0 while he reads problems from the easiest of the remaining problems to the hardest.
Input
The first line of input contains two integers n and m (1 ≤ n ≤ 750, 1 ≤ m ≤ 200 000) — the number of problems in the problemset and the number of guesses about the current coordinator's mood.
The second line of input contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the qualities of the problems in order of increasing difficulty.
The third line of input contains m integers b1, b2, ..., bm (0 ≤ bi ≤ 1015) — the guesses of the current coordinator's mood q.
Output
Print m lines, in i-th line print single integer — the answer to the problem with q = bi.
Example
Input
6 3
8 -5 -4 1 -7 4
0 7 3
Output
2
0
1
Submitted Solution:
```
def check(plank, points):
summ = 0
for point in points:
summ += point
if plank + summ < 0:
return False
return True
_ = input()
inpt = input()
tasks = list(map(lambda x: int(x), str(inpt).split(" ")))
alt = list(tasks)
moods = list(map(lambda x: int(x), str(input()).split(" ")))
alt.sort()
for tsk in range(len(alt)):
if alt[tsk] > 0:
b = alt[tsk:]
b.reverse()
alt[tsk:] = b
break
for mood in moods:
count = 0
tasks = list(map(lambda x: int(x), str(inpt).split(" ")))
if check(mood, tasks): print(0)
else:
for i in range(len(tasks)):
count += 1
try:
tasks.remove(alt[0])
except:
print(count)
break
del alt[0]
if check(mood, tasks):
print(count)
break
```
No
| 53,537 | [
0.469970703125,
0.1422119140625,
0.0309906005859375,
-0.08056640625,
-0.63671875,
-0.365966796875,
-0.2529296875,
0.2147216796875,
-0.2022705078125,
0.537109375,
0.5244140625,
-0.376220703125,
-0.27099609375,
-0.79638671875,
-0.17431640625,
-0.51318359375,
-0.77783203125,
-0.316650... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is an experienced participant in Codehorses programming contests. Now he wants to become a problemsetter.
He sent to the coordinator a set of n problems. Each problem has it's quality, the quality of the i-th problem is ai (ai can be positive, negative or equal to zero). The problems are ordered by expected difficulty, but the difficulty is not related to the quality in any way. The easiest problem has index 1, the hardest problem has index n.
The coordinator's mood is equal to q now. After reading a problem, the mood changes by it's quality. It means that after the coordinator reads a problem with quality b, the value b is added to his mood. The coordinator always reads problems one by one from the easiest to the hardest, it's impossible to change the order of the problems.
If after reading some problem the coordinator's mood becomes negative, he immediately stops reading and rejects the problemset.
Polycarp wants to remove the minimum number of problems from his problemset to make the coordinator's mood non-negative at any moment of time. Polycarp is not sure about the current coordinator's mood, but he has m guesses "the current coordinator's mood q = bi".
For each of m guesses, find the minimum number of problems Polycarp needs to remove so that the coordinator's mood will always be greater or equal to 0 while he reads problems from the easiest of the remaining problems to the hardest.
Input
The first line of input contains two integers n and m (1 ≤ n ≤ 750, 1 ≤ m ≤ 200 000) — the number of problems in the problemset and the number of guesses about the current coordinator's mood.
The second line of input contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the qualities of the problems in order of increasing difficulty.
The third line of input contains m integers b1, b2, ..., bm (0 ≤ bi ≤ 1015) — the guesses of the current coordinator's mood q.
Output
Print m lines, in i-th line print single integer — the answer to the problem with q = bi.
Example
Input
6 3
8 -5 -4 1 -7 4
0 7 3
Output
2
0
1
Submitted Solution:
```
n, m = list(map(int,input().split()))
spikes = []
a = list(map(int,input().split()))
s = 0
for i in range(len(a)):
s += a[i]
if s < 0:
spikes.append(s)
b = list(map(int,input().split()))
for i in b:
r = 0
delta = 0
for j in spikes:
if i + j + delta < 0:
r += 1
delta -= j
print(r)
```
No
| 53,538 | [
0.469970703125,
0.1422119140625,
0.0309906005859375,
-0.08056640625,
-0.63671875,
-0.365966796875,
-0.2529296875,
0.2147216796875,
-0.2022705078125,
0.537109375,
0.5244140625,
-0.376220703125,
-0.27099609375,
-0.79638671875,
-0.17431640625,
-0.51318359375,
-0.77783203125,
-0.316650... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Tags: brute force, strings, two pointers
Correct Solution:
```
t = int(input())
for i in range(t):
s = input()
ans = ""
j=0
while(j<len(s)):
if(j==len(s)-1):
if s[j] not in ans:
ans += s[j]
break
elif (s[j]==s[j+1]):
j+=2
continue
else:
if s[j] not in ans:
ans += s[j]
j+=1
ans = sorted(list(set(ans)))
ans = ''.join(ans)
print(ans)
```
| 54,893 | [
0.1591796875,
-0.20703125,
0.452392578125,
0.466064453125,
-0.343994140625,
-0.58447265625,
-0.1766357421875,
0.03533935546875,
0.54931640625,
0.59716796875,
0.64501953125,
0.06890869140625,
-0.276123046875,
-0.87939453125,
-0.56884765625,
-0.1417236328125,
-0.3779296875,
-0.432617... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Tags: brute force, strings, two pointers
Correct Solution:
```
def broken_keyboard(s1):
if len(s1) == 1:
return s1
size = len(s1)
letters = []
count = 0
for i in range(size):
if(i == size-1) or (s1[i] != s1[i+1]):
count += 1
if(count % 2 != 0):
letters.append(s1[i])
count = 0
else:
count += 1
letters = set(letters)
letters = list(letters)
letters.sort()
result = ""
return result.join(letters)
t = int(input())
for i in range(t):
s1 = input()
print(broken_keyboard(s1))
```
| 54,894 | [
0.128662109375,
-0.1949462890625,
0.43310546875,
0.5517578125,
-0.3408203125,
-0.5859375,
-0.1573486328125,
0.0416259765625,
0.57177734375,
0.62451171875,
0.595703125,
0.07501220703125,
-0.246826171875,
-0.90673828125,
-0.5986328125,
-0.1314697265625,
-0.3828125,
-0.4560546875,
-... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Tags: brute force, strings, two pointers
Correct Solution:
```
for item in [0]*int(input()):
x = input()
d = sorted(set(x))
answer = ''
for tiem in d:
if x.count(tiem)>2*x.count(tiem+tiem):
answer = answer+tiem
print(answer)
```
| 54,895 | [
0.132568359375,
-0.1834716796875,
0.447998046875,
0.495361328125,
-0.344482421875,
-0.5751953125,
-0.15771484375,
0.050323486328125,
0.54833984375,
0.61767578125,
0.64892578125,
0.05877685546875,
-0.276611328125,
-0.9267578125,
-0.587890625,
-0.1383056640625,
-0.376953125,
-0.42895... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Tags: brute force, strings, two pointers
Correct Solution:
```
t = int(input())
def run_length_compress(string):
"""文字列をランレングス圧縮する
例) string = "aabccaaabb" -> [(2, a), (1, b), (2, c), (3, a), (2, b)]
"""
string = string + "@" # string中に絶対に現れない文字を番兵とする
n = len(string)
begin = 0
end = 1
cnt = 1
ans = []
while True:
if end >= n:
break
if string[begin] == string[end]:
end += 1
cnt += 1
else:
ans.append((cnt, string[begin]))
begin = end
end = begin + 1
cnt = 1
return ans
for _ in range(t):
s = input()
r = run_length_compress(s)
memo = {}
for i, char in r:
if i %2 == 1:
memo[char] = 1
ans = []
for i in memo:
ans.append(i)
ans = sorted(ans)
print("".join(ans))
```
| 54,896 | [
0.1640625,
-0.2230224609375,
0.492431640625,
0.53515625,
-0.322021484375,
-0.56005859375,
-0.1773681640625,
0.0526123046875,
0.53515625,
0.59033203125,
0.662109375,
0.039031982421875,
-0.30126953125,
-0.9482421875,
-0.560546875,
-0.0999755859375,
-0.337890625,
-0.45751953125,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Tags: brute force, strings, two pointers
Correct Solution:
```
n = int(input())
for _ in range(n):
s = input()
l = len(s)
if l == 1:
print(s)
continue
inx = 0
ones = set()
while inx < l-1:
if s[inx] == s[inx+1]:
inx += 1
else:
ones.update(s[inx])
inx+=1
if inx == l-1:
ones.update(s[-1])
print(''.join(sorted(ones)))
```
| 54,897 | [
0.157958984375,
-0.2052001953125,
0.452880859375,
0.471923828125,
-0.3359375,
-0.58251953125,
-0.1717529296875,
0.03265380859375,
0.548828125,
0.60009765625,
0.64599609375,
0.06634521484375,
-0.27294921875,
-0.87744140625,
-0.57275390625,
-0.1455078125,
-0.384521484375,
-0.43798828... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Tags: brute force, strings, two pointers
Correct Solution:
```
for _ in range(int(input())):
s = input()
i = 0
correct = set()
while i < len(s):
if i == len(s) - 1:
correct.add(s[i])
break
if s[i] == s[i+1]:
i += 2
continue
correct.add(s[i])
i += 1
r = list(correct)
r.sort()
print("".join(r))
```
| 54,898 | [
0.1317138671875,
-0.174072265625,
0.441650390625,
0.4921875,
-0.3408203125,
-0.578125,
-0.1580810546875,
0.0390625,
0.53271484375,
0.58935546875,
0.65234375,
0.059814453125,
-0.275390625,
-0.9345703125,
-0.59375,
-0.114013671875,
-0.38330078125,
-0.4248046875,
-0.43505859375,
-... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Tags: brute force, strings, two pointers
Correct Solution:
```
t=int(input())
while t:
t-=1
s=input()
i=0
if(len(s)==1):
print(s)
continue
ans=[]
while(i<len(s)-1):
if(s[i] != s[i+1]):
ans+=[s[i]]
i+=1
else:
i+=2
if(i==len(s)-1):
ans+=[s[i]]
#ans.sort()
print("".join(sorted(set(ans))))
```
| 54,899 | [
0.147216796875,
-0.1898193359375,
0.441162109375,
0.49365234375,
-0.3408203125,
-0.5888671875,
-0.163330078125,
0.04803466796875,
0.5283203125,
0.6005859375,
0.64990234375,
0.06158447265625,
-0.278076171875,
-0.90869140625,
-0.583984375,
-0.135498046875,
-0.37841796875,
-0.44165039... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Tags: brute force, strings, two pointers
Correct Solution:
```
N = int(input())
counts = []
for _ in range(N):
s = input()
last_c = None
last_count = 0
ans = set()
for c in s:
if last_c == None:
last_c = c
last_count = 1
else:
if c == last_c:
last_count += 1
else:
if last_count %2 == 1:
ans.add(last_c)
last_c = c
last_count = 1
if last_count % 2 == 1:
ans.add(c)
print(''.join(sorted(list(ans))))
```
| 54,900 | [
0.1295166015625,
-0.187744140625,
0.447021484375,
0.50830078125,
-0.327880859375,
-0.5712890625,
-0.1551513671875,
0.058013916015625,
0.54150390625,
0.61328125,
0.64453125,
0.04962158203125,
-0.27587890625,
-0.92333984375,
-0.5888671875,
-0.131591796875,
-0.38720703125,
-0.43994140... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Submitted Solution:
```
t = int(input())
for _ in range(t):
a = input().strip()
n = len(a)
a += "0"
ans = set()
lo = 0
hi = 0
while lo < n:
while a[hi] == a[lo]:
hi += 1
count = hi - lo
if count % 2 == 1:
ans.add(a[lo])
lo = hi
print(*sorted(ans), sep='')
```
Yes
| 54,901 | [
0.1676025390625,
-0.1573486328125,
0.341796875,
0.42578125,
-0.436279296875,
-0.447021484375,
-0.2281494140625,
0.1458740234375,
0.428466796875,
0.546875,
0.57958984375,
0.00911712646484375,
-0.307373046875,
-0.90771484375,
-0.66455078125,
-0.2113037109375,
-0.334716796875,
-0.4682... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Submitted Solution:
```
vezes = int(input())
for __ in range(vezes):
letras = []
string = input()
tamanho =1
if len(string) == 1:
print(string[0])
else:
for i in range(len(string)-1):
if string[i] == string[i+1]:
tamanho += 1
if i == len(string) - 2:
if tamanho % 2 != 0 and string[i] not in letras:
letras.append(string[i])
else:
if tamanho % 2 != 0 and string[i] not in letras:
letras.append(string[i])
tamanho = 1
if string[len(string) - 1] != string[len(string) - 2]:
if string[len(string) - 1] not in letras:
letras.append(string[len(string)-1])
letras.sort()
print(*letras,sep="")
```
Yes
| 54,902 | [
0.1683349609375,
-0.16796875,
0.34814453125,
0.4248046875,
-0.455078125,
-0.442138671875,
-0.233642578125,
0.142578125,
0.390625,
0.55029296875,
0.5576171875,
0.0224456787109375,
-0.298095703125,
-0.88916015625,
-0.65234375,
-0.2113037109375,
-0.33056640625,
-0.472900390625,
-0.4... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Submitted Solution:
```
# for testes in range(int(input())):
# s = input()
# i = 0
# cont = 0
# while i < len(s):
# c = s[i]
# for x in s[i:]:
# if x == c:
# cont += 1
for testes in range(int(input())):
s = input()
ult = s[0]
cont = 1
res = []
for c in s[1:]:
if c != ult:
if cont % 2 == 1 and ult not in res:
res.append(ult)
ult = c
cont = 1
else:
cont += 1
if cont % 2 == 1 and ult not in res:
res.append(ult)
for c in sorted(res):
print(c,end="")
print()
```
Yes
| 54,903 | [
0.184326171875,
-0.17236328125,
0.35009765625,
0.420166015625,
-0.4423828125,
-0.451416015625,
-0.24267578125,
0.152587890625,
0.4140625,
0.56103515625,
0.5830078125,
0.01678466796875,
-0.302978515625,
-0.88134765625,
-0.64599609375,
-0.2022705078125,
-0.3330078125,
-0.470703125,
... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Submitted Solution:
```
numberTestCases = int(input())
allWorkingCharactersLists = []
for test in range(numberTestCases):
guaranteedWorkingCharactersPerCase = []
testString = input() + " "
for i in range(1, len(testString) - 1):
previousCharacter = testString[i-1]
if testString[i] == previousCharacter:
testStringList = list(testString)
testStringList[i] = " "
testStringList[i-1] = " "
testString = ''.join(testStringList)
for character in testString:
if character != " " and character not in guaranteedWorkingCharactersPerCase:
guaranteedWorkingCharactersPerCase.append(character)
allWorkingCharactersLists.append(guaranteedWorkingCharactersPerCase)
for characterList in allWorkingCharactersLists:
characterList.sort()
if characterList == []:
characterList.append("")
answer = ''.join(characterList)
print(answer)
```
Yes
| 54,904 | [
0.206787109375,
-0.1607666015625,
0.3369140625,
0.420166015625,
-0.455078125,
-0.4931640625,
-0.2333984375,
0.11444091796875,
0.4296875,
0.57275390625,
0.607421875,
-0.00754547119140625,
-0.28173828125,
-0.86962890625,
-0.64111328125,
-0.2164306640625,
-0.3193359375,
-0.46020507812... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Submitted Solution:
```
#Ashish Sagar
q=int(input())
for _ in range(q):
s=list(input())
ans=""
i=0
n=len(s)
if n==1:
print(s[0])
else:
while(i<n-1):
if s[i]!=s[i+1]:
ans+=s[i]
ans+=s[i+1]
i+=2
if s[n-1]!=s[n-2]:
ans+=s[n-1]
ans=list(ans)
ans.sort()
print(''.join(ans))
```
No
| 54,905 | [
0.1884765625,
-0.1678466796875,
0.34423828125,
0.416259765625,
-0.44482421875,
-0.465087890625,
-0.2252197265625,
0.1466064453125,
0.408447265625,
0.564453125,
0.587890625,
0.0240478515625,
-0.318603515625,
-0.8984375,
-0.6689453125,
-0.2052001953125,
-0.3408203125,
-0.463134765625... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Submitted Solution:
```
t=int(input())
for i in range(t):
s=input()
res = sorted(set(s))
for j in res:
if s.count(j) != 2 * s.count(j + j):
print(j,end='')
print('\n')
```
No
| 54,906 | [
0.1693115234375,
-0.158447265625,
0.339599609375,
0.423095703125,
-0.44287109375,
-0.44775390625,
-0.2318115234375,
0.151123046875,
0.426513671875,
0.5478515625,
0.57861328125,
0.01482391357421875,
-0.31103515625,
-0.90576171875,
-0.6669921875,
-0.2122802734375,
-0.329833984375,
-0... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Submitted Solution:
```
q = int(input())
for re in range(q):
s = input()
dob = set()
n = len(s)
s = '0' + s + '0'
for i in range(1, n+1):
if s[i] != s[i-1] and s[i] != s[i+1]:
dob.add(s[i])
l = []
for i in dob:
if i != '0':
l.append(i)
l.sort()
if len(l) == 0:
print("")
else:
for i in range(len(l)):
if i < len(l) - 1:
print(l[i], end = "")
else:
print(l[i])
```
No
| 54,907 | [
0.1700439453125,
-0.157470703125,
0.3388671875,
0.427490234375,
-0.445556640625,
-0.449462890625,
-0.234130859375,
0.1507568359375,
0.4267578125,
0.5546875,
0.58154296875,
0.01537322998046875,
-0.310546875,
-0.90576171875,
-0.6611328125,
-0.2130126953125,
-0.329833984375,
-0.473876... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Polycarp noticed that some of the buttons of his keyboard are malfunctioning. For simplicity, we assume that Polycarp's keyboard contains 26 buttons (one for each letter of the Latin alphabet). Each button is either working fine or malfunctioning.
To check which buttons need replacement, Polycarp pressed some buttons in sequence, and a string s appeared on the screen. When Polycarp presses a button with character c, one of the following events happened:
* if the button was working correctly, a character c appeared at the end of the string Polycarp was typing;
* if the button was malfunctioning, two characters c appeared at the end of the string.
For example, suppose the buttons corresponding to characters a and c are working correctly, and the button corresponding to b is malfunctioning. If Polycarp presses the buttons in the order a, b, a, c, a, b, a, then the string he is typing changes as follows: a → abb → abba → abbac → abbaca → abbacabb → abbacabba.
You are given a string s which appeared on the screen after Polycarp pressed some buttons. Help Polycarp to determine which buttons are working correctly for sure (that is, this string could not appear on the screen if any of these buttons was malfunctioning).
You may assume that the buttons don't start malfunctioning when Polycarp types the string: each button either works correctly throughout the whole process, or malfunctions throughout the whole process.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases in the input.
Then the test cases follow. Each test case is represented by one line containing a string s consisting of no less than 1 and no more than 500 lowercase Latin letters.
Output
For each test case, print one line containing a string res. The string res should contain all characters which correspond to buttons that work correctly in alphabetical order, without any separators or repetitions. If all buttons may malfunction, res should be empty.
Example
Input
4
a
zzaaz
ccff
cbddbb
Output
a
z
bc
Submitted Solution:
```
n=int(input())
for i in range(n):
p=input()
#p=p.split()
#p=list(map(int,p))
#p.sort()
if(len(p)==1):
print(p[0])
else:
curr=0
ans=list()
for j in range(len(p)-1):
if(p[j]==p[j+1]):
curr+=1
else:
break
if(curr%2==0):
ans.append(p[j])
curr=1
last=-1
for j in range(1,len(p)):
if(p[j]==p[j-1]):
curr+=1
else:
if(curr%2==1 and p[j-1] not in ans):
ans.append(p[j-1])
curr=1
curr=0
for j in range(len(p)-1,0,-1):
if(p[j]==p[j-1]):
curr+=1
else:
break
if(curr%2==0):
ans.append(p[j])
ans.sort()
for j in range(len(ans)):
print(ans[j],end="")
print()
```
No
| 54,908 | [
0.1710205078125,
-0.158447265625,
0.342041015625,
0.426025390625,
-0.443603515625,
-0.448486328125,
-0.2373046875,
0.1552734375,
0.423828125,
0.55078125,
0.5791015625,
0.0169830322265625,
-0.307373046875,
-0.90234375,
-0.6640625,
-0.20849609375,
-0.3310546875,
-0.46875,
-0.428222... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Tags: implementation
Correct Solution:
```
n = int(input())
s = input()
ans = ""
array_from_s = s.split("0")
for c in array_from_s:
ans += str(len(c))
print(ans)
```
| 55,323 | [
0.3544921875,
-0.150390625,
0.2744140625,
0.20947265625,
0.01511383056640625,
-0.476318359375,
-0.07342529296875,
-0.0133056640625,
0.131103515625,
0.81298828125,
0.7021484375,
-0.249267578125,
0.27783203125,
-0.374755859375,
-0.6494140625,
-0.09588623046875,
-0.203369140625,
-0.56... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Tags: implementation
Correct Solution:
```
n=int(input())
s=input()+'0'
i=0
for x in range(n):
if s[x]=='1':
i+=1
elif s[x]=='0':
print(i,end='')
i=0
print(i,end='')
```
| 55,324 | [
0.3642578125,
-0.1605224609375,
0.294677734375,
0.206787109375,
0.064208984375,
-0.472412109375,
-0.0609130859375,
-0.014495849609375,
0.1337890625,
0.81884765625,
0.7099609375,
-0.2325439453125,
0.277587890625,
-0.36962890625,
-0.62060546875,
-0.10504150390625,
-0.2353515625,
-0.5... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Tags: implementation
Correct Solution:
```
n = int(input())
a = input()
new = ""
c = 0
m = "1"
for i in a:
if(i == m):
c += 1
else:
if(m == "0"):
new += ("0" * (c - 1))
else:
new += str(c)
m = i
c = 1
if(m == "0"):
new += ("0" * (c))
else:
new += str(c)
print(new)
```
| 55,325 | [
0.3349609375,
-0.149658203125,
0.26953125,
0.22265625,
0.029937744140625,
-0.48095703125,
-0.055267333984375,
-0.0249786376953125,
0.0970458984375,
0.798828125,
0.7158203125,
-0.24658203125,
0.296875,
-0.39990234375,
-0.61669921875,
-0.08843994140625,
-0.2462158203125,
-0.599609375... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Tags: implementation
Correct Solution:
```
length = input("")
string = input("")
string = string.split('0')
result = ""
for i in string:
result += str(len(i))
print(int(result))
```
| 55,326 | [
0.347900390625,
-0.1622314453125,
0.26025390625,
0.2039794921875,
0.005535125732421875,
-0.467041015625,
-0.0408935546875,
0.00970458984375,
0.1746826171875,
0.80517578125,
0.71728515625,
-0.219970703125,
0.296875,
-0.367431640625,
-0.65185546875,
-0.080078125,
-0.19970703125,
-0.5... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Tags: implementation
Correct Solution:
```
n=input()
s=input()
d=0
c=0
for i in range(len(s)):
if s[i]=='0':
c=c*10+d
d=0
else:
d=d+1
c=c*10+d
print(c)
```
| 55,327 | [
0.35888671875,
-0.1419677734375,
0.30859375,
0.2115478515625,
0.035430908203125,
-0.46826171875,
-0.04681396484375,
-0.021240234375,
0.1351318359375,
0.82080078125,
0.69287109375,
-0.2415771484375,
0.267578125,
-0.37744140625,
-0.619140625,
-0.09173583984375,
-0.22509765625,
-0.581... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Tags: implementation
Correct Solution:
```
n = int(input())
s = input() + '0'
ans = ''
c = 0
for i in s:
if i == '0':
ans += str(c)
c = 0
else:
c += 1
print(ans)
```
| 55,328 | [
0.347412109375,
-0.1529541015625,
0.30224609375,
0.1893310546875,
0.046295166015625,
-0.47509765625,
-0.0516357421875,
-0.0254058837890625,
0.12548828125,
0.79541015625,
0.7119140625,
-0.255859375,
0.28271484375,
-0.376953125,
-0.62646484375,
-0.10040283203125,
-0.2352294921875,
-0... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Tags: implementation
Correct Solution:
```
input()
print(''.join([str(len(i)) for i in input().strip().split('0')]))
```
| 55,329 | [
0.3642578125,
-0.163330078125,
0.2705078125,
0.1605224609375,
0.0164642333984375,
-0.458251953125,
-0.061431884765625,
-0.003925323486328125,
0.1649169921875,
0.8212890625,
0.681640625,
-0.2421875,
0.3017578125,
-0.35546875,
-0.6328125,
-0.10009765625,
-0.2205810546875,
-0.60107421... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Tags: implementation
Correct Solution:
```
n=int(input())
s=input()
c=0
r=''
if(n==1):
print(s)
else:
for i in range(n-1):
if(s[0]=='0'):
c=0
elif(s[i]=='1'):
c=c+1
elif(s[i-1]=='1' and s[i]=='0'):
r=r+str(c)
c=0
elif(s[i-1]=='0' and s[i]=='0'):
r=r+'0'
c=0
if(s[-1]=='1' and s[-2]=='0'):
r=r+'1'
elif(s[-1]=='1' and s[-2]=='1'):
c=c+1
r=r+str(c)
elif(s[-1]=='0' and s[-2]=='0'):
r=r+'00'
elif(s[-1]=='0' and s[-2]=='1'):
r=r+str(c)+'0'
print(r)
```
| 55,330 | [
0.354736328125,
-0.14404296875,
0.26806640625,
0.17333984375,
0.042388916015625,
-0.47021484375,
-0.028167724609375,
0.0287017822265625,
0.128173828125,
0.83251953125,
0.6943359375,
-0.2578125,
0.27880859375,
-0.346435546875,
-0.611328125,
-0.11956787109375,
-0.312744140625,
-0.536... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Submitted Solution:
```
input()
s = input().split('0')
for i in s:
print(len(i), end='')
```
Yes
| 55,331 | [
0.445068359375,
-0.054412841796875,
0.08795166015625,
0.121826171875,
-0.127685546875,
-0.2435302734375,
-0.09796142578125,
0.179443359375,
0.106201171875,
0.814453125,
0.5791015625,
-0.282470703125,
0.222412109375,
-0.491943359375,
-0.59765625,
-0.16796875,
-0.15234375,
-0.6000976... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Submitted Solution:
```
N = int(input())
li = input().split('0')
for i in range(len(li)):
li[i] = li[i].count('1')
if len(li) == 0:
print ("0")
else:
li = map(str,li)
print ("".join(li))
```
Yes
| 55,332 | [
0.426513671875,
-0.0709228515625,
0.099853515625,
0.11260986328125,
-0.10150146484375,
-0.2744140625,
-0.1025390625,
0.206787109375,
0.072998046875,
0.81201171875,
0.56982421875,
-0.277099609375,
0.24560546875,
-0.419189453125,
-0.57763671875,
-0.1702880859375,
-0.182373046875,
-0.... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Submitted Solution:
```
n = int(input())
s = input()
v = s.split('0')
ans = ""
for x in v:
ans += str(len(x))
print(ans)
```
Yes
| 55,333 | [
0.450927734375,
-0.053131103515625,
0.08197021484375,
0.144775390625,
-0.1318359375,
-0.2498779296875,
-0.1043701171875,
0.1680908203125,
0.09307861328125,
0.79541015625,
0.5908203125,
-0.28271484375,
0.2037353515625,
-0.470458984375,
-0.59326171875,
-0.1746826171875,
-0.145141601562... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Submitted Solution:
```
n=int(input())
s=input()
j=-1
for i in range(n):
if s[i]=='0':
print(i-j-1,end='')
j=i
print(n-j-1)
```
Yes
| 55,334 | [
0.44482421875,
-0.056884765625,
0.09503173828125,
0.1649169921875,
-0.11859130859375,
-0.251953125,
-0.11676025390625,
0.1763916015625,
0.0819091796875,
0.81005859375,
0.57666015625,
-0.26318359375,
0.2064208984375,
-0.49365234375,
-0.5966796875,
-0.1629638671875,
-0.165771484375,
... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Submitted Solution:
```
n=int(input())
b=list(input())
count=0
for i in range(n-1):
if b[i]=='1':
count+=1
else:
print(count,end='')
count=0
print(count+int(b[-1]),end='')
```
No
| 55,335 | [
0.454833984375,
-0.077880859375,
0.09637451171875,
0.1461181640625,
-0.08575439453125,
-0.296875,
-0.07568359375,
0.173583984375,
0.07183837890625,
0.81640625,
0.60205078125,
-0.292724609375,
0.2181396484375,
-0.451171875,
-0.60498046875,
-0.17333984375,
-0.1849365234375,
-0.588867... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Submitted Solution:
```
n = int(input())
encoded_number = input()
decoded_number = []
current_digit = 0
for i, bit in enumerate(encoded_number):
if bit is '1':
current_digit += 1
elif bit is '0':
if current_digit != 0:
decoded_number.append(current_digit)
current_digit = 0
else:
decoded_number.append(current_digit)
if current_digit != 0:
decoded_number.append(current_digit)
print("".join(map(str, decoded_number)))
```
No
| 55,336 | [
0.40673828125,
-0.0767822265625,
0.02313232421875,
0.1119384765625,
-0.1258544921875,
-0.29833984375,
-0.07257080078125,
0.149169921875,
0.0657958984375,
0.78271484375,
0.609375,
-0.263671875,
0.212646484375,
-0.4560546875,
-0.55078125,
-0.1708984375,
-0.171142578125,
-0.576171875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Submitted Solution:
```
s = input().strip()
n = 0
for c in s:
if c == '1':
n += 1
else:
print(n, end='')
n = 0
print()
```
No
| 55,337 | [
0.44677734375,
-0.044708251953125,
0.14111328125,
0.1265869140625,
-0.13134765625,
-0.272705078125,
-0.07073974609375,
0.138427734375,
0.0819091796875,
0.8203125,
0.60693359375,
-0.279296875,
0.2169189453125,
-0.470947265625,
-0.59375,
-0.1790771484375,
-0.1964111328125,
-0.5864257... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just invented a new binary protocol for data transmission. He is encoding positive integer decimal number to binary string using following algorithm:
* Each digit is represented with number of '1' characters equal to the value of that digit (for 0 it is zero ones).
* Digits are written one by one in order corresponding to number and separated by single '0' character.
Though Polycarp learnt how to encode the numbers, he has no idea how to decode them back. Help him calculate the decoded number.
Input
The first line contains one integer number n (1 ≤ n ≤ 89) — length of the string s.
The second line contains string s — sequence of '0' and '1' characters, number in its encoded format. It is guaranteed that the number corresponding to the string is positive and doesn't exceed 109. The string always starts with '1'.
Output
Print the decoded number.
Examples
Input
3
111
Output
3
Input
9
110011101
Output
2031
Submitted Solution:
```
def find(s):
A=[]
count=0
for i in range(len(s)):
if s[i]=='1':
count+=1
else:
A+=[count]
count=0
if s[-1]=='1':
A+=[count]
TT=''
for i in range(len(A)):
TT+=str(A[i])
return TT
N=input()
s=input()
print(find(s))
```
No
| 55,338 | [
0.409912109375,
-0.08856201171875,
0.0643310546875,
0.1207275390625,
-0.122314453125,
-0.27392578125,
-0.09417724609375,
0.1856689453125,
0.1356201171875,
0.82275390625,
0.623046875,
-0.35498046875,
0.1798095703125,
-0.471435546875,
-0.5810546875,
-0.1864013671875,
-0.12158203125,
... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Tags: greedy
Correct Solution:
```
t = int(input())
for i in range(t):
input()
m, k = [int(l) for l in input().split()]
a = [int(j) for j in input().split()]
upset = -1
unknown = 0
unknownBeforeUpset = 0
ti, r = [], []
for i1 in range(m-1):
n = input().split()
ti.append(int(n[0]))
r.append(int(n[1]))
ti[i1] -= 1
if r[i1] == 1 and upset == -1:
upset = i1
if ti[i1] != -1:
a[ti[i1]] -= 1
else:
unknown+=1
if upset == -1:
unknownBeforeUpset+=1
st = ["N" for j in range(k)]
if upset == -1:
for j in range(k):
if a[j] <= unknown:
st[j] = "Y"
else:
usedAfter = [False for i in range(k)]
for j in range(upset, m-1):
if ti[j] != -1:
usedAfter[ti[j]] = True
minFirstFinished = -1
for j in range(k):
if not usedAfter[j] and unknownBeforeUpset >= a[j]:
st[j] = 'Y'
if minFirstFinished == -1 or a[minFirstFinished] > a[j]:
minFirstFinished = j
if minFirstFinished != -1:
restUnknown = unknown - a[minFirstFinished]
for j in range(k):
if a[j] <= restUnknown:
st[j] = 'Y'
print("".join(st))
```
| 56,019 | [
0.473876953125,
-0.01114654541015625,
0.11749267578125,
0.270751953125,
-0.349365234375,
-0.425537109375,
-0.214599609375,
-0.042236328125,
0.2626953125,
0.33154296875,
0.765625,
-0.28466796875,
0.276611328125,
-1.03515625,
-0.755859375,
0.040252685546875,
-0.59716796875,
-0.397949... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Tags: greedy
Correct Solution:
```
t = int(input())
for i in range(t):
input()
m,k = map(int,input().split())
ak = list(map(int,input().split()))
ak2 = [0]*k
tjrj = [list(map(int,input().split())) for j in range(m-1)]
num = 0
num2 = 0
num3 = 100002
for j in range(m-1):
if num2 == 1 or tjrj[j][1] == 0:
if tjrj[j][0] != 0:
ak[tjrj[j][0]-1] -= 1
else:
num += 1
else:
for z in range(k):
if ak[z] - num < 1:
ak2[z] = 1
num2 = 1
if tjrj[j][0] != 0:
ak[tjrj[j][0]-1] -= 1
else:
num += 1
for f in range(j,m-1):
if tjrj[f][0] != 0:
ak2[tjrj[f][0]-1] = 0
for f in range(k):
if ak2[f] == 1:
if num3 > ak[f]:
num3 = ak[f]
num -= num3
for z in range(k):
if ak[z] - num < 1 or ak2[z] == 1:
print("Y",end="")
else:
print("N",end="")
print()
```
| 56,020 | [
0.473876953125,
-0.01114654541015625,
0.11749267578125,
0.270751953125,
-0.349365234375,
-0.425537109375,
-0.214599609375,
-0.042236328125,
0.2626953125,
0.33154296875,
0.765625,
-0.28466796875,
0.276611328125,
-1.03515625,
-0.755859375,
0.040252685546875,
-0.59716796875,
-0.397949... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Tags: greedy
Correct Solution:
```
import sys
test_count = int(sys.stdin.readline())
for test in range(test_count):
sys.stdin.readline()
m, k = map(int, sys.stdin.readline().split())
counts = list(map(int, sys.stdin.readline().split()))
took = []
unhappy = []
for i in range(m - 1):
t, r = map(int, sys.stdin.readline().split())
t -= 1 # -1 means unknown
took.append(t)
unhappy.append(r)
took_in_total = [0 for dish_count in counts]
for i in range(m - 1):
if took[i] != -1:
took_in_total[took[i]] += 1
took_already = [0 for dish_count in counts]
left = [dish_count for dish_count in counts]
answer = [False for dish_count in counts]
unknown = 0
all_present = True
for i in range(m - 1):
if unhappy[i] == 1 and all_present:
could_exhaust = []
for j in range(k):
if took_already[j] < took_in_total[j]:
continue
if left[j] > unknown:
continue
could_exhaust.append(j)
if len(could_exhaust) == 0:
raise AssertionError
for j in could_exhaust:
answer[j] = True
unknown -= min(map(lambda j: left[j], could_exhaust))
all_present = False
if took[i] != -1:
left[took[i]] -= 1
took_already[took[i]] += 1
if left[took[i]] == 0:
all_present = False
else:
unknown += 1
for j in range(k):
if left[j] <= unknown:
answer[j] = True
sys.stdout.write(
''.join(map(lambda x: 'Y' if x else 'N', answer)) + '\n'
)
```
| 56,021 | [
0.473876953125,
-0.01114654541015625,
0.11749267578125,
0.270751953125,
-0.349365234375,
-0.425537109375,
-0.214599609375,
-0.042236328125,
0.2626953125,
0.33154296875,
0.765625,
-0.28466796875,
0.276611328125,
-1.03515625,
-0.755859375,
0.040252685546875,
-0.59716796875,
-0.397949... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Tags: greedy
Correct Solution:
```
n=int(input())
for i in range(n):
input().strip()
q,w=map(int,input().strip().split())
kol=list(map(int,input().strip().split()))
r=[]
e=[]
for ii in range(q-1):
a,s=map(int,input().strip().split())
a-=1
r.append(a)
e.append(s)
rw=[0 for uu in kol]
for ii in range(q-1):
if r[ii]!=-1:
rw[r[ii]]+=1
nd=[0 for uu in kol]
l=[uu for uu in kol]
rez=[False for uu in kol]
qw=0
tr=True
for ii in range(q-1):
if e[ii]==1 and tr:
su=[]
for iii in range(w):
if nd[iii]<rw[iii]:
continue
if l[iii]>qw:
continue
su.append(iii)
if len(su)==0:
raise AssertionError
for iii in su:
rez[iii]=True
qw-=min(map(lambda iii:l[iii],su))
tr=False
if r[ii]!=-1:
l[r[ii]]-=1
nd[r[ii]]+=1
if l[r[ii]]==0:
tr=False
else:
qw+=1
for iii in range(w):
if l[iii]<=qw:
rez[iii]=True
print(''.join(map(lambda x:'Y' if x else 'N',rez)))
```
| 56,022 | [
0.473876953125,
-0.01114654541015625,
0.11749267578125,
0.270751953125,
-0.349365234375,
-0.425537109375,
-0.214599609375,
-0.042236328125,
0.2626953125,
0.33154296875,
0.765625,
-0.28466796875,
0.276611328125,
-1.03515625,
-0.755859375,
0.040252685546875,
-0.59716796875,
-0.397949... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Tags: greedy
Correct Solution:
```
def ris():
return map(int, input().split())
def testCase():
m, k = ris()
q = 0
a = list(ris())
some_is_out = False
tmp = set()
for i in range(m - 1):
t, r = ris()
t -= 1
if r == 1 and not some_is_out:
some_is_out = True
tmp = tmp.union(set(filter(lambda x: a[x] <= q, range(k))))
if t == -1:
q += 1
else:
if t in tmp:
tmp.remove(t)
a[t] -= 1
if a[t] < 0:
a[t] = 0
q += 1
if tmp:
q -= min(map(lambda x: a[x], tmp))
print("".join(list(map(lambda x: 'Y' if a[x] - q <= 0 or x in tmp else 'N', range(len(a))))))
for i in range(int(input())):
input()
testCase()
```
| 56,023 | [
0.473876953125,
-0.01114654541015625,
0.11749267578125,
0.270751953125,
-0.349365234375,
-0.425537109375,
-0.214599609375,
-0.042236328125,
0.2626953125,
0.33154296875,
0.765625,
-0.28466796875,
0.276611328125,
-1.03515625,
-0.755859375,
0.040252685546875,
-0.59716796875,
-0.397949... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Tags: greedy
Correct Solution:
```
t = int(input())
for j in range(t):
e = input()
m, k = map(int, input().split())
arr = [int(i) for i in input().split()]
sum, bfail = [0] * k, [0] * k
ffail, undef = -1, 0
used = [False] * k
ubfail = 0
for i in range(m - 1):
c, ns = map(int, input().split())
if c == 0:
undef += 1
if ns == 0 and ffail == -1:
ubfail += 1
else:
sum[c - 1] += 1
if ns == 0 and ffail == -1:
bfail[c - 1] += 1
if ns and ffail == -1:
ffail = i
if ffail != -1 and c > 0:
used[c - 1] = True
if ffail == -1:
for i in range(k):
if sum[i] + undef >= arr[i]:
print('Y', end = '')
else:
print('N', end = '')
print()
continue
minu = 10 ** 6
for i in range(k):
if not used[i] and arr[i] - bfail[i] < minu:
minu = arr[i] - bfail[i]
best = i
for i in range(k):
if i == best or undef - minu + sum[i] >= arr[i]:
print('Y', end = '')
elif bfail[i] + ubfail >= arr[i] and not used[i]:
print('Y', end = '')
else:
print('N', end = '')
print()
```
| 56,024 | [
0.473876953125,
-0.01114654541015625,
0.11749267578125,
0.270751953125,
-0.349365234375,
-0.425537109375,
-0.214599609375,
-0.042236328125,
0.2626953125,
0.33154296875,
0.765625,
-0.28466796875,
0.276611328125,
-1.03515625,
-0.755859375,
0.040252685546875,
-0.59716796875,
-0.397949... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Tags: greedy
Correct Solution:
```
import sys
n=int(input())
for i in range(n):
sys.stdin.readline()
q,w=map(int,sys.stdin.readline().split())
kol=list(map(int,sys.stdin.readline().split()))
r=[]
e=[]
for ii in range(q-1):
a,s=map(int,sys.stdin.readline().split())
a-=1
r.append(a)
e.append(s)
rw=[0 for uu in kol]
for ii in range(q-1):
if r[ii]!=-1:
rw[r[ii]]+=1
nd=[0 for uu in kol]
l=[uu for uu in kol]
rez=[False for uu in kol]
qw=0
tr=True
for ii in range(q-1):
if e[ii]==1 and tr:
su=[]
for iii in range(w):
if nd[iii]<rw[iii]:
continue
if l[iii]>qw:
continue
su.append(iii)
if len(su)==0:
raise AssertionError
for iii in su:
rez[iii]=True
qw-=min(map(lambda iii:l[iii],su))
tr=False
if r[ii]!=-1:
l[r[ii]]-=1
nd[r[ii]]+=1
if l[r[ii]]==0:
tr=False
else:
qw+=1
for iii in range(w):
if l[iii]<=qw:
rez[iii]=True
sys.stdout.write(''.join(map(lambda x:'Y' if x else 'N',rez))+'\n')
```
| 56,025 | [
0.473876953125,
-0.01114654541015625,
0.11749267578125,
0.270751953125,
-0.349365234375,
-0.425537109375,
-0.214599609375,
-0.042236328125,
0.2626953125,
0.33154296875,
0.765625,
-0.28466796875,
0.276611328125,
-1.03515625,
-0.755859375,
0.040252685546875,
-0.59716796875,
-0.397949... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Tags: greedy
Correct Solution:
```
import sys
t = int(input())
for i in range(t):
remove_from_all = 0
input()
m, k = (int(x) for x in input().split())
dishes = [int(x) for x in input().split()]
inputs = []
for j in range(m - 1):
t, r = (int(x) for x in input().split())
inputs.append((t - 1, r))
seen_upset = False
for i, v in enumerate(inputs):
t, r = v
if r == 1 and not seen_upset:
impossible = set()
for j in range(i, len(inputs)):
_t, _r = inputs[j]
impossible.add(_t)
for j in range(len(dishes)):
if dishes[j] > remove_from_all:
impossible.add(j)
minimal = float("inf")
for j in range(len(dishes)):
if j not in impossible:
minimal = min(dishes[j], minimal)
dishes[j] = 0
remove_from_all -= minimal
seen_upset = True
if t == -1:
remove_from_all += 1
else:
dishes[t] -= 1
for j in dishes:
sys.stdout.write("Y" if j - remove_from_all <= 0 else "N")
print("")
```
| 56,026 | [
0.473876953125,
-0.01114654541015625,
0.11749267578125,
0.270751953125,
-0.349365234375,
-0.425537109375,
-0.214599609375,
-0.042236328125,
0.2626953125,
0.33154296875,
0.765625,
-0.28466796875,
0.276611328125,
-1.03515625,
-0.755859375,
0.040252685546875,
-0.59716796875,
-0.397949... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Submitted Solution:
```
def ris():
return map(int, input().split())
def testCase():
m, k = ris()
q = 0
a = list(ris())
some_is_out = False
tmp = set()
for i in range(m - 1):
t, r = ris()
t -= 1
if r == 1 and not some_is_out:
some_is_out = True
tmp = tmp.union(set(filter(lambda x: a[x] <= q, range(k))))
if t == -1:
q += 1
else:
if t in tmp:
tmp.remove(t)
a[t] -= 1
if a[t] < 0:
a[t] = 0
q += 1
if tmp:
q -= min(map(lambda x: a[x], tmp))
print("".join(list(map(lambda x: 'Y' if a[x] - q <= 0 or x in tmp else 'N', range(len(a))))))
for i in range(int(input())):
input()
testCase()
# Made By Mostafa_Khaled
```
Yes
| 56,027 | [
0.61572265625,
0.074462890625,
0.041473388671875,
0.2685546875,
-0.399658203125,
-0.2919921875,
-0.299072265625,
-0.00650787353515625,
0.264404296875,
0.315185546875,
0.732421875,
-0.2027587890625,
0.23095703125,
-0.93115234375,
-0.744140625,
0.03570556640625,
-0.499755859375,
-0.3... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Submitted Solution:
```
for i in range(int(input())):
_ = input()
m, k = [int(x) for x in input().split()]
foods = [[int(x), 0] for x in input().split()]
n = 0
for i in range(m-1):
eat, sad = [int(x) for x in input().split()]
if sad:
maybe = [(i, x) for i, x in enumerate(foods) if x[0] - x[1] - n <= 0]
if len(maybe) == 1:
i = maybe[0][0]
x = maybe[0][1]
dif = x[0] - x[1]
foods[i] = [x[0], x[0]]
n -= dif
if not eat: n += 1
else: foods[eat-1][1] += 1
print(''.join(['N' if x[0] - x[1] - n > 0 else 'Y' for x in foods]))
```
No
| 56,028 | [
0.61572265625,
0.074462890625,
0.041473388671875,
0.2685546875,
-0.399658203125,
-0.2919921875,
-0.299072265625,
-0.00650787353515625,
0.264404296875,
0.315185546875,
0.732421875,
-0.2027587890625,
0.23095703125,
-0.93115234375,
-0.744140625,
0.03570556640625,
-0.499755859375,
-0.3... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Submitted Solution:
```
import sys
t = int(input())
for i in range(t):
remove_from_all = 0
input()
m, k = (int(x) for x in input().split())
dishes = [int(x) for x in input().split()]
for j in range(m - 1):
t, r = (int(x) for x in input().split())
if t == 0:
remove_from_all += 1
else:
dishes[t - 1] -= 1
for j in dishes:
sys.stdout.write("Y" if j - remove_from_all <= 0 else "N")
print("")
```
No
| 56,029 | [
0.61572265625,
0.074462890625,
0.041473388671875,
0.2685546875,
-0.399658203125,
-0.2919921875,
-0.299072265625,
-0.00650787353515625,
0.264404296875,
0.315185546875,
0.732421875,
-0.2027587890625,
0.23095703125,
-0.93115234375,
-0.744140625,
0.03570556640625,
-0.499755859375,
-0.3... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Submitted Solution:
```
n = int(input())
for _ in range(n):
input()
m, k = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
unknowns = 0
firstDispleased = False
for i in range(m - 1):
t, r = [int(s) for s in input().split()]
if r == 1:
unknowns += 1
if not firstDispleased:
firstDispleased = True
for j in range(len(a)):
if a[j] + unknowns < j:
a[j] = 0
if t == 0:
a = [v - 1 for v in a]
else:
a[t - 1] -= 1
for v in a:
if v <= 0:
print('Y', end='')
else:
print('N', end='')
print()
```
No
| 56,030 | [
0.61572265625,
0.074462890625,
0.041473388671875,
0.2685546875,
-0.399658203125,
-0.2919921875,
-0.299072265625,
-0.00650787353515625,
0.264404296875,
0.315185546875,
0.732421875,
-0.2027587890625,
0.23095703125,
-0.93115234375,
-0.744140625,
0.03570556640625,
-0.499755859375,
-0.3... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is flying in the airplane. Finally, it is his favorite time — the lunchtime. The BerAvia company stewardess is giving food consecutively to all the passengers from the 1-th one to the last one. Polycarp is sitting on seat m, that means, he will be the m-th person to get food.
The flight menu has k dishes in total and when Polycarp boarded the flight, he had time to count the number of portions of each dish on board. Thus, he knows values a1, a2, ..., ak, where ai is the number of portions of the i-th dish.
The stewardess has already given food to m - 1 passengers, gave Polycarp a polite smile and asked him what he would prefer. That's when Polycarp realized that they might have run out of some dishes by that moment. For some of the m - 1 passengers ahead of him, he noticed what dishes they were given. Besides, he's heard some strange mumbling from some of the m - 1 passengers ahead of him, similar to phrase 'I'm disappointed'. That happened when a passenger asked for some dish but the stewardess gave him a polite smile and said that they had run out of that dish. In that case the passenger needed to choose some other dish that was available. If Polycarp heard no more sounds from a passenger, that meant that the passenger chose his dish at the first try.
Help Polycarp to find out for each dish: whether they could have run out of the dish by the moment Polyarp was served or that dish was definitely available.
Input
Each test in this problem consists of one or more input sets. First goes a string that contains a single integer t (1 ≤ t ≤ 100 000) — the number of input data sets in the test. Then the sets follow, each set is preceded by an empty line.
The first line of each set of the input contains integers m, k (2 ≤ m ≤ 100 000, 1 ≤ k ≤ 100 000) — the number of Polycarp's seat and the number of dishes, respectively.
The second line contains a sequence of k integers a1, a2, ..., ak (1 ≤ ai ≤ 100 000), where ai is the initial number of portions of the i-th dish.
Then m - 1 lines follow, each line contains the description of Polycarp's observations about giving food to a passenger sitting in front of him: the j-th line contains a pair of integers tj, rj (0 ≤ tj ≤ k, 0 ≤ rj ≤ 1), where tj is the number of the dish that was given to the j-th passenger (or 0, if Polycarp didn't notice what dish was given to the passenger), and rj — a 1 or a 0, depending on whether the j-th passenger was or wasn't disappointed, respectively.
We know that sum ai equals at least m, that is,Polycarp will definitely get some dish, even if it is the last thing he wanted. It is guaranteed that the data is consistent.
Sum m for all input sets doesn't exceed 100 000. Sum k for all input sets doesn't exceed 100 000.
Output
For each input set print the answer as a single line. Print a string of k letters "Y" or "N". Letter "Y" in position i should be printed if they could have run out of the i-th dish by the time the stewardess started serving Polycarp.
Examples
Input
2
3 4
2 3 2 1
1 0
0 0
5 5
1 2 1 3 1
3 0
0 0
2 1
4 0
Output
YNNY
YYYNY
Note
In the first input set depending on the choice of the second passenger the situation could develop in different ways:
* If he chose the first dish, then by the moment the stewardess reaches Polycarp, they will have run out of the first dish;
* If he chose the fourth dish, then by the moment the stewardess reaches Polycarp, they will have run out of the fourth dish;
* Otherwise, Polycarp will be able to choose from any of the four dishes.
Thus, the answer is "YNNY".
In the second input set there is, for example, the following possible scenario. First, the first passenger takes the only third dish, then the second passenger takes the second dish. Then, the third passenger asks for the third dish, but it is not available, so he makes disappointed muttering and ends up with the second dish. Then the fourth passenger takes the fourth dish, and Polycarp ends up with the choice between the first, fourth and fifth dish.
Likewise, another possible scenario is when by the time the stewardess comes to Polycarp, they will have run out of either the first or the fifth dish (this can happen if one of these dishes is taken by the second passenger). It is easy to see that there is more than enough of the fourth dish, so Polycarp can always count on it. Thus, the answer is "YYYNY".
Submitted Solution:
```
b = []
t = int(input())
s = ""
for i in range(t):
input()
m, k = [int(l) for l in input().split()]
a = [int(j) for j in input().split()]
upset = -1
unknownBeforeUpset = 0
for i1 in range(m-1):
ti, r = [int(i) for i in input().split()]
ti-=1
#if r == 0:
if ti != -1:
a[ti] -= 1
else:
a = [j-1 for j in a]
#if upset == -1:
# unknownBeforeUpset += 1
#else:
# upset = i1
s += "".join(["Y" if j <=0 else "N" for j in a]) + '\n'
print(s)
```
No
| 56,031 | [
0.61572265625,
0.074462890625,
0.041473388671875,
0.2685546875,
-0.399658203125,
-0.2919921875,
-0.299072265625,
-0.00650787353515625,
0.264404296875,
0.315185546875,
0.732421875,
-0.2027587890625,
0.23095703125,
-0.93115234375,
-0.744140625,
0.03570556640625,
-0.499755859375,
-0.3... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Tags: bitmasks, combinatorics, dp
Correct Solution:
```
import sys
input=sys.stdin.readline
mod=10**9+7
n,t=map(int,input().split())
a=[] #Denote song number by it's index in this list
for i in range(n):
time,genre=map(int,input().split())
genre-=1 #converting to 0-based indexing
a.append((time,genre))
dp=[[0 for j in range(3)] for i in range(1<<n)] #dp[permuation of song][last genre of that permutation]
for i in range(n):
dp[1<<i][a[i][1]]=1
for i in range(1<<n):
for j in range(3):
if(dp[i][j]==0):
continue
mask=1 #Will correspond to the kth bit, i.e 1<<k for each iteration, for the case of including the kth song
for k in range(n):
if(i&mask or a[k][1]==j): #as we are not allowed to repeat same song or have same genre successively
mask<<=1
continue
dp[i|mask][a[k][1]]=(dp[i|mask][a[k][1]]+dp[i][j])%mod
mask<<=1
ans=0
for i in range(1<<n):
mask=1
duration=0
for j in range(n):
if(i&mask):
duration+=a[j][0]
mask<<=1
if(duration==t):
ans=(ans+sum(dp[i]))%mod
print(ans)
```
| 56,458 | [
0.1986083984375,
0.52587890625,
0.62646484375,
0.06475830078125,
-0.095458984375,
-0.22509765625,
-0.62109375,
-0.0570068359375,
0.30615234375,
0.70458984375,
0.86865234375,
-0.3466796875,
0.345947265625,
-0.83447265625,
-0.372802734375,
0.210205078125,
-0.79833984375,
-0.527832031... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Tags: bitmasks, combinatorics, dp
Correct Solution:
```
import sys
input = sys.stdin.readline
n,T=map(int,input().split())
S=[list(map(int,input().split())) for i in range(n)]
DP=[[0]*(4) for i in range(T+1)]
mod=10**9+7
from functools import lru_cache
@lru_cache(maxsize=None)
def calc(used,recent,time):
ANS=0
for i in range(n):
#print(i,used)
if i in used:
continue
if time+S[i][0]>T:
continue
if S[i][1]==recent:
continue
if time+S[i][0]==T:
ANS+=1
if time+S[i][0]<T:
used2=list(used)+[i]
used2.sort()
recent2=S[i][1]
time2=time+S[i][0]
ANS=(ANS+calc(tuple(used2),recent2,time2))%mod
return ANS
print(calc(tuple(),-1,0)%mod)
```
| 56,459 | [
0.1986083984375,
0.52587890625,
0.62646484375,
0.06475830078125,
-0.095458984375,
-0.22509765625,
-0.62109375,
-0.0570068359375,
0.30615234375,
0.70458984375,
0.86865234375,
-0.3466796875,
0.345947265625,
-0.83447265625,
-0.372802734375,
0.210205078125,
-0.79833984375,
-0.527832031... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Tags: bitmasks, combinatorics, dp
Correct Solution:
```
from itertools import combinations
def out1(a,b,c):
if a<0 or b<0 or c<0:
return 0
if a==1 and b==0 and c==0:
return 1
return a*(out2(a-1,b,c)+out3(a-1,b,c))
def out2(a,b,c):
if a<0 or b<0 or c<0:
return 0
if a==0 and b==1 and c==0:
return 1
return b*(out1(a,b-1,c)+out3(a,b-1,c))
def out3(a,b,c):
if a<0 or b<0 or c<0:
return 0
if a==0 and b==0 and c==1:
return 1
return c*(out2(a,b,c-1)+out1(a,b,c-1))
def column(matrix, i):
return [row[i] for row in matrix]
N, T = [int(x) for x in input().split()]
A = []
s = 0
for i in range(N):
A.append([int(x) for x in input().split()])
for i in range(1,N+1):
comb = list(combinations(A, i))
for x in comb:
if sum(column(x,0))==T:
a = column(x,1).count(1)
b = column(x,1).count(2)
c = column(x,1).count(3)
s+=(out1(a,b,c)+out2(a,b,c)+out3(a,b,c))
print(s%1000000007)
```
| 56,460 | [
0.1986083984375,
0.52587890625,
0.62646484375,
0.06475830078125,
-0.095458984375,
-0.22509765625,
-0.62109375,
-0.0570068359375,
0.30615234375,
0.70458984375,
0.86865234375,
-0.3466796875,
0.345947265625,
-0.83447265625,
-0.372802734375,
0.210205078125,
-0.79833984375,
-0.527832031... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Tags: bitmasks, combinatorics, dp
Correct Solution:
```
def popcount(i):
assert 0 <= i < 0x100000000
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24
N, T = map(int, input().split())
TG = [list(map(int, input().split())) for _ in range(N)]
mod = 10**9+7
dp = [[0]*(2**N) for _ in range(4)]
for i in range(1, 4):
dp[i][0] = 1
for S in range(2**N):
if popcount(S) == 1:
dp[TG[(S&(-S)).bit_length() - 1][1]][S] = 1
for i in range(1, 4):
for j in range(N):
if S & (2**j) or i == TG[j][1]:
continue
dp[TG[j][1]][S|(2**j)] = (dp[TG[j][1]][S|(2**j)] + dp[i][S]) % mod
table = [0]*(2**N)
for S in range(2**N):
table[S] = sum(TG[j][0] for j in range(N) if 2**j & S)
ans = 0
for S in range(2**N):
if table[S] == T:
for i in range(1, 4):
ans = (ans + dp[i][S]) % mod
print(ans)
```
| 56,461 | [
0.1986083984375,
0.52587890625,
0.62646484375,
0.06475830078125,
-0.095458984375,
-0.22509765625,
-0.62109375,
-0.0570068359375,
0.30615234375,
0.70458984375,
0.86865234375,
-0.3466796875,
0.345947265625,
-0.83447265625,
-0.372802734375,
0.210205078125,
-0.79833984375,
-0.527832031... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Tags: bitmasks, combinatorics, dp
Correct Solution:
```
from itertools import combinations
def findsum(comb):
sum = 0
for song in comb:
sum += song[0]
return sum
def finda(a,b,c):
if a == 0:
return 0
if a == 1 and b == 0 and c == 0:
return 1
else:
return (a * findb(a-1,b,c)+ a*findc(a-1,b,c))
def findb(a,b,c):
if b == 0:
return 0
if b == 1 and a == 0 and c == 0:
return 1
else:
return (b * finda(a,b-1,c)+ b*findc(a,b-1,c))
def findc(a,b,c):
if c == 0:
return 0
if c == 1 and a == 0 and b == 0:
return 1
else:
return (c * finda(a,b,c-1)+ c*findb(a,b,c-1))
n, T = map(int,input().split())
songs = []
total_combinations = 0
for i in range(n):
t, g = map(int,input().split())
songs.append([t,g])
for i in range(1, n+1):
allcomb = list(combinations(songs,i))
for comb in allcomb:
sum = findsum(comb)
if sum == T:
a = 0
b = 0
c = 0
for song in comb:
if song[1] == 1:
a += 1
elif song[1] == 2:
b += 1
else:
c += 1
total_combinations += finda(a,b,c)+findb(a,b,c)+findc(a,b,c)
total_combinations = total_combinations%1000000007
print(total_combinations)
```
| 56,462 | [
0.1986083984375,
0.52587890625,
0.62646484375,
0.06475830078125,
-0.095458984375,
-0.22509765625,
-0.62109375,
-0.0570068359375,
0.30615234375,
0.70458984375,
0.86865234375,
-0.3466796875,
0.345947265625,
-0.83447265625,
-0.372802734375,
0.210205078125,
-0.79833984375,
-0.527832031... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Tags: bitmasks, combinatorics, dp
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
def main():
mod = 10**9+7
n,T = map(int,input().split())
y = 1<<n
dp = [[0]*3 for _ in range(y)]
# already taken ; genre
peo = [list(map(int,input().split())) for _ in range(n)]
# duration ; genre
for ind,i in enumerate(peo):
peo[ind][1] -= 1
dp[1<<ind][i[1]] = 1
for i in range(y):
for j in range(3):
if not dp[i][j]:
continue
mask = 1
for k in range(n):
if i&mask or peo[k][1] == j:
mask <<= 1
continue
dp[i|mask][peo[k][1]] = (dp[i|mask][peo[k][1]]+dp[i][j])%mod
mask <<= 1
ans = 0
for i in range(y):
ans1,mask = 0,1
for j in range(n):
if i&mask:
ans1 += peo[j][0]
mask <<= 1
if ans1 == T:
ans = (ans+sum(dp[i]))%mod
print(ans)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
```
| 56,463 | [
0.1986083984375,
0.52587890625,
0.62646484375,
0.06475830078125,
-0.095458984375,
-0.22509765625,
-0.62109375,
-0.0570068359375,
0.30615234375,
0.70458984375,
0.86865234375,
-0.3466796875,
0.345947265625,
-0.83447265625,
-0.372802734375,
0.210205078125,
-0.79833984375,
-0.527832031... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Tags: bitmasks, combinatorics, dp
Correct Solution:
```
from math import factorial
def lol(n):
if n == 1:
yield [0]
yield [1]
else:
for p in lol(n - 1):
p.append(0)
yield p
p[-1] = 1
yield p
p.pop()
def sp(g1, g2, g3, f):
if g1 == 0:
if g2 == g3:
return 2
elif abs(g2 - g3) == 1:
return 1
else:
return 0
elif g2 == 0:
if g1 == g3:
return 2
elif abs(g1 - g3) == 1:
return 1
else:
return 0
elif g3 == 0:
if g2 == g1:
return 2
elif abs(g2 - g1) == 1:
return 1
else:
return 0
else:
if f == 1:
b = sp(g1, g2 - 1, g3, 2)
c = sp(g1, g2, g3 - 1, 3)
return b + c
elif f == 2:
a = sp(g1 - 1, g2, g3, 1)
c = sp(g1, g2, g3 - 1, 3)
return a + c
elif f == 3:
a = sp(g1 - 1, g2, g3, 1)
b = sp(g1, g2 - 1, g3, 2)
return a + b
else:
a = sp(g1 - 1, g2, g3, 1)
b = sp(g1, g2 - 1, g3, 2)
c = sp(g1, g2, g3 - 1, 3)
return a + b + c
n, T = map(int, input().split())
S = []
cnt = 0
M = 10 ** 9 + 7
for i in range(n):
S.append(list(map(int, input().split())))
for p in lol(n):
d = 0
g1, g2, g3 = 0, 0, 0
for i in range(n):
if p[i]:
d += S[i][0]
if S[i][1] == 1:
g1 += 1
elif S[i][1] == 2:
g2 += 1
elif S[i][1] == 3:
g3 += 1
if d == T:
cnt += factorial(g1) * factorial(g2) * factorial(g3) * sp(g1, g2, g3, 0)
cnt %= M
print(cnt)
```
| 56,464 | [
0.1986083984375,
0.52587890625,
0.62646484375,
0.06475830078125,
-0.095458984375,
-0.22509765625,
-0.62109375,
-0.0570068359375,
0.30615234375,
0.70458984375,
0.86865234375,
-0.3466796875,
0.345947265625,
-0.83447265625,
-0.372802734375,
0.210205078125,
-0.79833984375,
-0.527832031... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Tags: bitmasks, combinatorics, dp
Correct Solution:
```
n,tnow=map(int,input().split())
left=int("".join(["1" for i in range(n)]),2)
arr=[]
dp={}
for i in range(n):
a,b=map(int,input().split())
arr.append([a,b])
def recur(tnow,prevgenre,left):
key=str(left)+"_"+str(prevgenre)
if tnow==0:
return 1
elif key in dp:
return dp[key]
else:
ans=0
for i in range(n):
if (left&(1<<i))!=0:
if arr[i][0]<=tnow and arr[i][1]!=prevgenre:
left=left&(~(1<<i))
ans+=recur(tnow-arr[i][0],arr[i][1],left)
left=left|(1<<i)
dp[key]= ans
return ans
print(recur(tnow,4,left)%(10**9+7))
```
| 56,465 | [
0.1986083984375,
0.52587890625,
0.62646484375,
0.06475830078125,
-0.095458984375,
-0.22509765625,
-0.62109375,
-0.0570068359375,
0.30615234375,
0.70458984375,
0.86865234375,
-0.3466796875,
0.345947265625,
-0.83447265625,
-0.372802734375,
0.210205078125,
-0.79833984375,
-0.527832031... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Submitted Solution:
```
from functools import lru_cache
P = 10**9+7
N, T = map(int, input().split())
A = [[], [], []]
X = []
for _ in range(N):
t, g = map(int, input().split())
X.append((t, g))
@lru_cache(maxsize=None)
def calc(x, pr, t):
if t < 0:
return 0
if t == 0:
return 1
if x == 0:
return 0
ans = 0
for i in range(15):
if x & (1<<i):
if X[i][1] != pr:
y = x ^ (1<<i)
ans = (ans + calc(y, X[i][1], t-X[i][0])) % P
return ans
print(calc(2**N-1, -1, T))
```
Yes
| 56,466 | [
0.260986328125,
0.5048828125,
0.6044921875,
0.070556640625,
-0.135986328125,
-0.21240234375,
-0.615234375,
-0.0250701904296875,
0.233154296875,
0.7490234375,
0.88623046875,
-0.297119140625,
0.328125,
-0.84619140625,
-0.4140625,
0.1942138671875,
-0.8056640625,
-0.60205078125,
-0.8... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Submitted Solution:
```
print(1)
A = [i for i in range(1, 2 * 10 ** 5 + 1)]
print(200000)
print(*A)
```
No
| 56,467 | [
0.260986328125,
0.5048828125,
0.6044921875,
0.070556640625,
-0.135986328125,
-0.21240234375,
-0.615234375,
-0.0250701904296875,
0.233154296875,
0.7490234375,
0.88623046875,
-0.297119140625,
0.328125,
-0.84619140625,
-0.4140625,
0.1942138671875,
-0.8056640625,
-0.60205078125,
-0.8... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Submitted Solution:
```
from itertools import combinations
def findsum(comb):
sum = 0
for song in comb:
sum += song[0]
return sum
def finda(a,b,c):
if a == 0:
return 0
if a == 1 and b == 0 and c == 0:
return 1
else:
return (a * findb(a-1,b,c)+ a*findc(a-1,b,c))
def findb(a,b,c):
if b == 0:
return 0
if b == 1 and a == 0 and c == 0:
return 1
else:
return (b * finda(a,b-1,c)+ b*findc(a,b-1,c))
def findc(a,b,c):
if c == 0:
return 0
if c == 1 and a == 0 and b == 0:
return 1
else:
return (c * finda(a,b,c-1)+ c*findb(a,b,c-1))
n, T = map(int,input().split())
songs = []
total_combinations = 0
for i in range(n):
t, g = map(int,input().split())
songs.append([t,g])
for i in range(1, n+1):
allcomb = list(combinations(songs,i))
for comb in allcomb:
sum = findsum(comb)
if sum == T:
a = 0
b = 0
c = 0
for song in comb:
if song[1] == 1:
a += 1
elif song[1] == 2:
b += 1
else:
c += 1
total_combinations += finda(a,b,c)+findb(a,b,c)+findc(a,b,c)
print(total_combinations)
```
No
| 56,468 | [
0.260986328125,
0.5048828125,
0.6044921875,
0.070556640625,
-0.135986328125,
-0.21240234375,
-0.615234375,
-0.0250701904296875,
0.233154296875,
0.7490234375,
0.88623046875,
-0.297119140625,
0.328125,
-0.84619140625,
-0.4140625,
0.1942138671875,
-0.8056640625,
-0.60205078125,
-0.8... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Submitted Solution:
```
print ("Down Journey :)\n" * 1)
```
No
| 56,469 | [
0.260986328125,
0.5048828125,
0.6044921875,
0.070556640625,
-0.135986328125,
-0.21240234375,
-0.615234375,
-0.0250701904296875,
0.233154296875,
0.7490234375,
0.88623046875,
-0.297119140625,
0.328125,
-0.84619140625,
-0.4140625,
0.1942138671875,
-0.8056640625,
-0.60205078125,
-0.8... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is constraints.
Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly T minutes.
In the player, Polycarp stores n songs, each of which is characterized by two parameters: t_i and g_i, where t_i is the length of the song in minutes (1 ≤ t_i ≤ 15), g_i is its genre (1 ≤ g_i ≤ 3).
Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the i-th song, he would spend exactly t_i minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.
Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.
Input
The first line of the input contains two integers n and T (1 ≤ n ≤ 15, 1 ≤ T ≤ 225) — the number of songs in the player and the required total duration, respectively.
Next, the n lines contain descriptions of songs: the i-th line contains two integers t_i and g_i (1 ≤ t_i ≤ 15, 1 ≤ g_i ≤ 3) — the duration of the i-th song and its genre, respectively.
Output
Output one integer — the number of different sequences of songs, the total length of exactly T, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo 10^9 + 7 (that is, the remainder when dividing the quantity by 10^9 + 7).
Examples
Input
3 3
1 1
1 2
1 3
Output
6
Input
3 3
1 1
1 1
1 3
Output
2
Input
4 10
5 3
2 1
3 2
5 1
Output
10
Note
In the first example, Polycarp can make any of the 6 possible playlist by rearranging the available songs: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2] and [3, 2, 1] (indices of the songs are given).
In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of 2 possible ways: [1, 3, 2] and [2, 3, 1] (indices of the songs are given).
In the third example, Polycarp can make the following playlists: [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [1, 4], [4, 1], [2, 3, 4] and [4, 3, 2] (indices of the songs are given).
Submitted Solution:
```
inputs = [int(x) for x in input().split()]
n, T = inputs[0], inputs[1]
songs = []
s = 0
songs_infos = {}
genres = {1: [], 2: [], 3: []}
i = 2
while i < len(inputs):
songs += [s]
songs_infos[s] = [inputs[i], inputs[i + 1]]
genres[songs_infos[s][1]] += [s]
i += 2
s += 1
```
No
| 56,470 | [
0.260986328125,
0.5048828125,
0.6044921875,
0.070556640625,
-0.135986328125,
-0.21240234375,
-0.615234375,
-0.0250701904296875,
0.233154296875,
0.7490234375,
0.88623046875,
-0.297119140625,
0.328125,
-0.84619140625,
-0.4140625,
0.1942138671875,
-0.8056640625,
-0.60205078125,
-0.8... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Tags: greedy, two pointers
Correct Solution:
```
t = int(input())
for _ in range(t):
bb = input().split()
while bb == []:
bb = input().split()
k, n, m = int(bb[0]), int(bb[1]), int(bb[2])
s1 = input().split()
s2 = input().split()
for i in range(n):
s1[i] = int(s1[i])
for i in range(m):
s2[i] = int(s2[i])
l = 0
r = 0
out = []
flag = True
n,m=m,n
while l < m or r < n:
if l == m:
if s2[r] > k:
if s2[r] == 0:
out.append(s2[r])
r+=1
k+=1
else:
print(-1)
flag = False
break
elif s2[r] <= k:
out.append(s2[r])
if s2[r] == 0: k+=1
r +=1
elif r == n:
if s1[l] > k:
if s1[l] == 0:
out.append(s1[l])
l+=1
k+=1
else:
print(-1)
flag = False
break
elif s1[l] <= k:
out.append(s1[l])
if s1[l] == 0:
k+=1
l +=1
else:
if min(s1[l], s2[r]) > k:
maa = min(s1[l], s2[r])
if maa == 0:
out.append(maa)
if maa == s1[l]: l+=1
else: r+=1
k +=1
else:
print(-1)
flag = False
break
elif min(s1[l], s2[r]) <= k:
maa = min(s1[l], s2[r])
if maa == 0: k+=1
out.append(maa)
if maa == s1[l]:
l += 1
else:
r += 1
if flag == False: continue
print(*out)
```
| 57,332 | [
0.262451171875,
0.5322265625,
0.006748199462890625,
0.259521484375,
0.0110015869140625,
-0.472900390625,
-0.5517578125,
-0.259765625,
0.51513671875,
0.736328125,
0.59033203125,
0.10760498046875,
0.1575927734375,
-1.0673828125,
-0.7294921875,
-0.148193359375,
-0.431884765625,
-0.576... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Tags: greedy, two pointers
Correct Solution:
```
for _ in range(int(input())):
tab = input()
k,n,m = map(int,input().split())
listn = list(map(int,input().split()))
listm = list(map(int,input().split()))
ans = []
status = True
stuck = False
noOfTries = 0
while(len(listm)>0 or len(listn)>0):
if noOfTries>3:
break
if(len(listn)==0):
status = False
noOfTries+=1
if(len(listm)==0):
status = True
noOfTries+=1
if(status and listn[0]!=0):
if(k>=listn[0]):
ans.append(listn[0])
listn = listn[1:]
noOfTries = 0
else:
status = False
noOfTries+=1
elif(status and listn[0]==0):
ans.append(listn[0])
listn = listn[1:]
noOfTries=0
k+=1
elif(not status and listm[0]!=0):
if(k>=listm[0]):
ans.append(listm[0])
listm = listm[1:]
noOfTries = 0
else:
status = True
noOfTries+=1
else:
ans.append(listm[0])
listm = listm[1:]
noOfTries = 0
k+=1
if(noOfTries>3):
print(-1)
else:
ans = list(map(str,ans))
print(" ".join(ans))
```
| 57,333 | [
0.262451171875,
0.5322265625,
0.006748199462890625,
0.259521484375,
0.0110015869140625,
-0.472900390625,
-0.5517578125,
-0.259765625,
0.51513671875,
0.736328125,
0.59033203125,
0.10760498046875,
0.1575927734375,
-1.0673828125,
-0.7294921875,
-0.148193359375,
-0.431884765625,
-0.576... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Tags: greedy, two pointers
Correct Solution:
```
t = int(input())
for i in range(t):
a = input()
k, 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()]
now = k
i=0
j=0
ans = []
while i<n or j<m:
if i!=n:
if a[i]==0:
k+=1
ans.append(0)
i+=1
continue
elif k>=a[i]:
ans.append(a[i])
i+=1
continue
if j!=m:
if b[j]==0:
k+=1
ans.append(0)
j+=1
continue
elif k>=b[j]:
ans.append(b[j])
j+=1
continue
break
if len(ans)< n+m:
print(-1)
else:
for i in range(n+m):
print(ans[i], end =' ')
print()
```
| 57,334 | [
0.262451171875,
0.5322265625,
0.006748199462890625,
0.259521484375,
0.0110015869140625,
-0.472900390625,
-0.5517578125,
-0.259765625,
0.51513671875,
0.736328125,
0.59033203125,
0.10760498046875,
0.1575927734375,
-1.0673828125,
-0.7294921875,
-0.148193359375,
-0.431884765625,
-0.576... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Tags: greedy, two pointers
Correct Solution:
```
for _ in range(int(input())):
s=input()
k,n,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
ans=[]
i=0
j=0
flag=1
while(i<n and j<m):
if(a[i]==0):
ans.append(a[i])
i+=1
k+=1
elif(b[j]==0):
ans.append(b[j])
j+=1
k+=1
elif(a[i]<b[j]):
if(a[i]>k):
flag=0
break
else:
ans.append(a[i])
i+=1
else:
if(b[j]>k):
flag=0
break
else:
ans.append(b[j])
j+=1
if(i==n):
while(j<m):
if(b[j]>k):
flag=0
break
else:
if(b[j]==0):
k+=1
ans.append(b[j])
j+=1
else:
while(i<n):
if(a[i]>k):
flag=0
break
else:
ans.append(a[i])
if(a[i]==0):
k+=1
i+=1
if(flag):
print(*ans)
else:
print("-1")
```
| 57,335 | [
0.262451171875,
0.5322265625,
0.006748199462890625,
0.259521484375,
0.0110015869140625,
-0.472900390625,
-0.5517578125,
-0.259765625,
0.51513671875,
0.736328125,
0.59033203125,
0.10760498046875,
0.1575927734375,
-1.0673828125,
-0.7294921875,
-0.148193359375,
-0.431884765625,
-0.576... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Tags: greedy, two pointers
Correct Solution:
```
def verify_result(k , arr):
for i in arr:
if i == 0:
k+=1
else:
if k >= i:
continue
else:
return [-1]
return arr
def solve():
input()
k,n,m = list(map(int , input().split()))
a = list(map(int , input().split()))
b = list(map(int , input().split()))
p1 = 0;
p2 = 0;
result = []
while p1<n or p2<m:
value_1 = float('inf')
value_2 = float('inf')
if p1<n:
value_1 = a[p1]
if value_1 == 0:
result.append(value_1)
p1 += 1
continue
if p2<m:
value_2 = b[p2]
if value_2 == 0:
result.append(value_2)
p2 += 1
continue
if value_1 < value_2:
result.append(value_1)
p1+=1
continue
else:
result.append(value_2)
p2 += 1
continue
print( *verify_result(k , result) , sep = ' ')
for i in range(int(input())):
solve()
```
| 57,336 | [
0.262451171875,
0.5322265625,
0.006748199462890625,
0.259521484375,
0.0110015869140625,
-0.472900390625,
-0.5517578125,
-0.259765625,
0.51513671875,
0.736328125,
0.59033203125,
0.10760498046875,
0.1575927734375,
-1.0673828125,
-0.7294921875,
-0.148193359375,
-0.431884765625,
-0.576... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Tags: greedy, two pointers
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
import io
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
from collections import Counter
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: max(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
class SegmentTree1:
def __init__(self, data, default=10**6, func=lambda a, b: min(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
MOD=10**9+7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod=10**9+7
omod=998244353
#-------------------------------------------------------------------------
prime = [True for i in range(10001)]
prime[0]=prime[1]=False
#pp=[0]*10000
def SieveOfEratosthenes(n=10000):
p = 2
c=0
while (p <= n):
if (prime[p] == True):
c+=1
for i in range(p, n+1, p):
#pp[i]=1
prime[i] = False
p += 1
#-----------------------------------DSU--------------------------------------------------
class DSU:
def __init__(self, R, C):
#R * C is the source, and isn't a grid square
self.par = range(R*C + 1)
self.rnk = [0] * (R*C + 1)
self.sz = [1] * (R*C + 1)
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
if xr == yr: return
if self.rnk[xr] < self.rnk[yr]:
xr, yr = yr, xr
if self.rnk[xr] == self.rnk[yr]:
self.rnk[xr] += 1
self.par[yr] = xr
self.sz[xr] += self.sz[yr]
def size(self, x):
return self.sz[self.find(x)]
def top(self):
# Size of component at ephemeral "source" node at index R*C,
# minus 1 to not count the source itself in the size
return self.size(len(self.sz) - 1) - 1
#---------------------------------Lazy Segment Tree--------------------------------------
# https://github.com/atcoder/ac-library/blob/master/atcoder/lazysegtree.hpp
class LazySegTree:
def __init__(self, _op, _e, _mapping, _composition, _id, v):
def set(p, x):
assert 0 <= p < _n
p += _size
for i in range(_log, 0, -1):
_push(p >> i)
_d[p] = x
for i in range(1, _log + 1):
_update(p >> i)
def get(p):
assert 0 <= p < _n
p += _size
for i in range(_log, 0, -1):
_push(p >> i)
return _d[p]
def prod(l, r):
assert 0 <= l <= r <= _n
if l == r:
return _e
l += _size
r += _size
for i in range(_log, 0, -1):
if ((l >> i) << i) != l:
_push(l >> i)
if ((r >> i) << i) != r:
_push(r >> i)
sml = _e
smr = _e
while l < r:
if l & 1:
sml = _op(sml, _d[l])
l += 1
if r & 1:
r -= 1
smr = _op(_d[r], smr)
l >>= 1
r >>= 1
return _op(sml, smr)
def apply(l, r, f):
assert 0 <= l <= r <= _n
if l == r:
return
l += _size
r += _size
for i in range(_log, 0, -1):
if ((l >> i) << i) != l:
_push(l >> i)
if ((r >> i) << i) != r:
_push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
_all_apply(l, f)
l += 1
if r & 1:
r -= 1
_all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, _log + 1):
if ((l >> i) << i) != l:
_update(l >> i)
if ((r >> i) << i) != r:
_update((r - 1) >> i)
def _update(k):
_d[k] = _op(_d[2 * k], _d[2 * k + 1])
def _all_apply(k, f):
_d[k] = _mapping(f, _d[k])
if k < _size:
_lz[k] = _composition(f, _lz[k])
def _push(k):
_all_apply(2 * k, _lz[k])
_all_apply(2 * k + 1, _lz[k])
_lz[k] = _id
_n = len(v)
_log = _n.bit_length()
_size = 1 << _log
_d = [_e] * (2 * _size)
_lz = [_id] * _size
for i in range(_n):
_d[_size + i] = v[i]
for i in range(_size - 1, 0, -1):
_update(i)
self.set = set
self.get = get
self.prod = prod
self.apply = apply
MIL = 1 << 20
def makeNode(total, count):
# Pack a pair into a float
return (total * MIL) + count
def getTotal(node):
return math.floor(node / MIL)
def getCount(node):
return node - getTotal(node) * MIL
nodeIdentity = makeNode(0.0, 0.0)
def nodeOp(node1, node2):
return node1 + node2
# Equivalent to the following:
return makeNode(
getTotal(node1) + getTotal(node2), getCount(node1) + getCount(node2)
)
identityMapping = -1
def mapping(tag, node):
if tag == identityMapping:
return node
# If assigned, new total is the number assigned times count
count = getCount(node)
return makeNode(tag * count, count)
def composition(mapping1, mapping2):
# If assigned multiple times, take first non-identity assignment
return mapping1 if mapping1 != identityMapping else mapping2
#---------------------------------Pollard rho--------------------------------------------
def memodict(f):
"""memoization decorator for a function taking a single argument"""
class memodict(dict):
def __missing__(self, key):
ret = self[key] = f(key)
return ret
return memodict().__getitem__
def pollard_rho(n):
"""returns a random factor of n"""
if n & 1 == 0:
return 2
if n % 3 == 0:
return 3
s = ((n - 1) & (1 - n)).bit_length() - 1
d = n >> s
for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
p = pow(a, d, n)
if p == 1 or p == n - 1 or a % n == 0:
continue
for _ in range(s):
prev = p
p = (p * p) % n
if p == 1:
return math.gcd(prev - 1, n)
if p == n - 1:
break
else:
for i in range(2, n):
x, y = i, (i * i + 1) % n
f = math.gcd(abs(x - y), n)
while f == 1:
x, y = (x * x + 1) % n, (y * y + 1) % n
y = (y * y + 1) % n
f = math.gcd(abs(x - y), n)
if f != n:
return f
return n
@memodict
def prime_factors(n):
"""returns a Counter of the prime factorization of n"""
if n <= 1:
return Counter()
f = pollard_rho(n)
return Counter([n]) if f == n else prime_factors(f) + prime_factors(n // f)
def distinct_factors(n):
"""returns a list of all distinct factors of n"""
factors = [1]
for p, exp in prime_factors(n).items():
factors += [p**i * factor for factor in factors for i in range(1, exp + 1)]
return factors
def all_factors(n):
"""returns a sorted list of all distinct factors of n"""
small, large = [], []
for i in range(1, int(n**0.5) + 1, 2 if n & 1 else 1):
if not n % i:
small.append(i)
large.append(n // i)
if small[-1] == large[-1]:
large.pop()
large.reverse()
small.extend(large)
return small
#---------------------------------Binary Search------------------------------------------
def binarySearch(arr, n, key):
left = 0
right = n-1
mid = 0
res=arr[n-1]
while (left <= right):
mid = (right + left)//2
if (arr[mid] >= key):
res=arr[mid]
right = mid-1
else:
left = mid + 1
return res
def binarySearch1(arr, n, key):
left = 0
right = n-1
mid = 0
res=-1
while (left <= right):
mid = (right + left)//2
if (arr[mid][0] >= key):
right = mid-1
else:
res=mid
left = mid + 1
return res
#---------------------------------running code------------------------------------------
t=1
t=int(input())
for _ in range (t):
#n=int(input())
x=input()
k,n,m=map(int,input().split())
#a=list(map(int,input().split()))
#s=input()
#n=len(s)
a=list(map(int,input().split()))
b=list(map(int,input().split()))
i,j=0,0
res=[]
ch=1
line=k
for x in range (n+m):
if i<n and a[i]==0:
line+=1
i+=1
res.append(0)
elif j<m and b[j]==0:
line+=1
j+=1
res.append(0)
else:
if i<n and a[i]<=line:
res.append(a[i])
i+=1
elif j<m and b[j]<=line:
res.append(b[j])
j+=1
else:
res=[-1]
break
print(*res)
```
| 57,337 | [
0.262451171875,
0.5322265625,
0.006748199462890625,
0.259521484375,
0.0110015869140625,
-0.472900390625,
-0.5517578125,
-0.259765625,
0.51513671875,
0.736328125,
0.59033203125,
0.10760498046875,
0.1575927734375,
-1.0673828125,
-0.7294921875,
-0.148193359375,
-0.431884765625,
-0.576... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Tags: greedy, two pointers
Correct Solution:
```
t = int(input())
for _ in range(t):
input()
k, n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
i, j = 0, 0
c = []
f = 1
while f == 1:
f = 0
while i < n and a[i] <= k:
c.append(a[i])
if a[i] == 0:
k += 1
i += 1
f = 1
while j < m and b[j] <= k:
c.append(b[j])
if b[j] == 0:
k += 1
j += 1
f = 1
if f == 0 and (i < n or j < m):
print(-1)
else:
print(*c)
```
| 57,338 | [
0.262451171875,
0.5322265625,
0.006748199462890625,
0.259521484375,
0.0110015869140625,
-0.472900390625,
-0.5517578125,
-0.259765625,
0.51513671875,
0.736328125,
0.59033203125,
0.10760498046875,
0.1575927734375,
-1.0673828125,
-0.7294921875,
-0.148193359375,
-0.431884765625,
-0.576... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Tags: greedy, two pointers
Correct Solution:
```
import sys,math
from collections import deque,defaultdict
import operator as op
from functools import reduce
from itertools import permutations
import heapq
# sys.setrecursionlimit(10**6)
# OneDrive\Documents\codeforces
I=sys.stdin.readline
alpha="abcdefghijklmnopqrstuvwxyz"
mod=10**9 + 7
"""
x_move=[-1,0,1,0,-1,1,1,-1]
y_move=[0,1,0,-1,1,1,-1,-1]
"""
def ii():
return int(I().strip())
def li():
return list(map(int,I().strip().split()))
def mi():
return map(int,I().strip().split())
def ncr(n, r):
r = min(r, n-r)
numer = reduce(op.mul, range(n, n-r, -1), 1)
denom = reduce(op.mul, range(1, r+1), 1)
return numer // denom
def isPrime(n):
if n<=1:
return False
elif n<=2:
return True
else:
for i in range(2,int(n**.5)+1):
if n%i==0:
return False
return True
def main():
# ans=""
for _ in range(ii()):
I()
k,n,m=mi()
arr=li()
brr=li()
f=1
i=0
j=0
ans=[]
while i<n and j<m:
if arr[i]<=k:
ans.append(arr[i])
if arr[i]==0:
k+=1
i+=1
elif brr[j]<=k:
ans.append(brr[j])
if brr[j]==0:
k+=1
j+=1
else:
f=0
break
while i<n:
ans.append(arr[i])
if arr[i]>k:
f=0
break
elif arr[i]==0:
k+=1
i+=1
while j<m:
ans.append(brr[j])
if brr[j]>k:
f=0
break
elif brr[j]==0:
k+=1
j+=1
if f==0:
print(-1)
else:
print(*ans)
if __name__ == '__main__':
main()
```
| 57,339 | [
0.262451171875,
0.5322265625,
0.006748199462890625,
0.259521484375,
0.0110015869140625,
-0.472900390625,
-0.5517578125,
-0.259765625,
0.51513671875,
0.736328125,
0.59033203125,
0.10760498046875,
0.1575927734375,
-1.0673828125,
-0.7294921875,
-0.148193359375,
-0.431884765625,
-0.576... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Submitted Solution:
```
def pair_programming(n,a,b):
res = []
i,j = 0,0
num = n
while i < len(a) and j < len(b):
if a[i] == 0 and b[j] == 0:
res.extend([0,0])
i += 1
j += 1
num += 2
elif a[i] == 0:
res.append(0)
num += 1
i += 1
elif b[j] == 0:
res.append(0)
num += 1
j += 1
else:
if a[i] < b[j]:
if a[i] <= num:
res.append(a[i])
i += 1
else:
return None
else:
if b[j] <= num:
res.append(b[j])
j += 1
else:
return None
idx, arr = None, None
if i == len(a):
idx = j
arr = b
else:
idx = i
arr = a
for i in range(idx,len(arr)):
if arr[i] == 0:
res.append(0)
num += 1
else:
if arr[i] <= num:
res.append(arr[i])
else:
return None
return res
N = int(input())
for _ in range(N):
input()
k = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
b = [int(s) for s in input().split()]
res = pair_programming(k[0],a,b)
if res:
print(*res)
else:
print(-1)
```
Yes
| 57,340 | [
0.408935546875,
0.52392578125,
-0.0224456787109375,
0.2301025390625,
-0.11187744140625,
-0.341064453125,
-0.67431640625,
-0.1688232421875,
0.455810546875,
0.6279296875,
0.479736328125,
0.0885009765625,
0.1390380859375,
-1.0146484375,
-0.734375,
-0.2470703125,
-0.428955078125,
-0.54... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Submitted Solution:
```
# Problem: C. Pair Programming
# Contest: Codeforces - Codeforces Round #731 (Div. 3)
# URL: https://codeforces.com/contest/1547/problem/C
# Memory Limit: 512 MB
# Time Limit: 2000 ms
#
# Powered by CP Editor (https://cpeditor.org)
# ____ ____ ___ # skeon19
#| | / | | | |\ | #
#|____ |/ |___ | | | \ | # EON_KID
# | |\ | | | | \ | #
# ____| | \ ___ |____ |___| | \| # Soul_Silver
from collections import defaultdict
import sys,io,os
INP=sys.stdin.readline
inp=lambda:[*map(int,INP().encode().split())]
sinp=lambda:[*map(str,INP().split())]
out=sys.stdout.write
#from functools import reduce
#from bisect import bisect_right,bisect_left
#from sortedcontainers import SortedList, SortedSet, SortedDict
#import sympy #Prime number library
#import heapq
def main():
for _ in range(inp()[0]):
d=inp()
k,n,m=inp()
l=inp()
p=inp()
i=j=0
ans=[]
check=1
while i<n and j<m:
if l[i]==0:
ans.append(0)
k+=1
i+=1
elif p[j]==0:
ans.append(0)
k+=1
j+=1
else:
if l[i]>=p[j] and p[j]<=k:
ans.append(p[j])
j+=1
elif l[i]<=p[j] and l[i]<=k:
ans.append(l[i])
i+=1
else:
check=0
break
if not check:
break
if check:
while i<n:
if l[i]==0:
ans.append(0)
k+=1
i+=1
elif l[i]<=k:
ans.append(l[i])
i+=1
else:
check=0
break
while j<m:
if p[j]==0:
ans.append(0)
k+=1
j+=1
elif p[j]<=k:
ans.append(p[j])
j+=1
else:
check=0
break
if check:
print(*ans)
else:
print(-1)
else:
print(-1)
###############################################################
def SumOfExpOfFactors(a):
fac = 0
lis=SortedList()
if not a&1:
lis.add(2)
while not a&1:
a >>= 1
fac += 1
for i in range(3,int(a**0.5)+1,2):
if not a%i:
lis.add(i)
while not a%i:
a //= i
fac += 1
if a != 1:
lis.add(a)
fac += 1
return fac,lis
###############################################################
div=[0]*(1000001)
def NumOfDivisors(n): #O(nlog(n))
for i in range(1,n+1):
for j in range(i,n+1,i):
div[j]+=1
###############################################################
def primes1(n): #return a list having prime numbers from 2 to n
""" Returns a list of primes < n """
sieve = [True] * (n//2)
for i in range(3,int(n**0.5)+1,2):
if sieve[i//2]:
sieve[i*i//2::i] = [False] * ((n-i*i-1)//(2*i)+1)
return [2] + [2*i+1 for i in range(1,n//2) if sieve[i]]
##############################################################
def GCD(a,b):
if(b==0):
return a
else:
return GCD(b,a%b)
##############################################################
#
# 1
# / \
# 2 3
# /\ / \ \ \
#4 5 6 7 8 9
# \
# 10
class Graph:
def __init__(self):
self.Graph = defaultdict(list)
def addEdge(self, u, v):
self.Graph[u].append(v)
self.Graph[v].append(u)
#DFS Graph / tree
def DFSUtil(self, v, visited):
visited.add(v)
#print(v, end=' ')
for neighbour in self.Graph[v]:
if neighbour not in visited: #not needed if its a tree
self.DFSUtil(neighbour, visited)
def DFS(self, v):
visited = set() #not needed if its a tree
self.DFSUtil(v, visited) #Visited not needed if its a tree
#BFS Graph / tree
def BFS(self, s):
# Mark all the vertices as not visited
visited = set()
# Create a queue for BFS
queue = []
queue.append(s)
visited.add(s)
while queue:
s = queue.pop(0)
#print (s, end = " ")
for i in self.Graph[s]:
if i not in visited:
queue.append(i)
visited.add(i)
'''
g = Graph()
g.addEdge(1, 2)
g.addEdge(1, 3)
g.addEdge(2, 4)
g.addEdge(2, 5)
g.addEdge(3, 6)
g.addEdge(3, 7)
g.addEdge(3, 8)
g.addEdge(3, 9)
g.addEdge(6,10)
g.DFS(1)
g.BFS(1) '''
##############################################################
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
# https://github.com/cheran-senthil/PyRival/blob/master/pyrival/data_structures/SortedList.py
###################################################################################################
if __name__ == '__main__':
main()
```
Yes
| 57,341 | [
0.408935546875,
0.52392578125,
-0.0224456787109375,
0.2301025390625,
-0.11187744140625,
-0.341064453125,
-0.67431640625,
-0.1688232421875,
0.455810546875,
0.6279296875,
0.479736328125,
0.0885009765625,
0.1390380859375,
-1.0146484375,
-0.734375,
-0.2470703125,
-0.428955078125,
-0.54... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Submitted Solution:
```
T = int(input())
for i in range(T):
input()
K,N,M = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
# standart_input
if A.count(0)+B.count(0)+K < max(A+B):
print(-1)
# Expection handling
else:
ans = []
l_A = 0
l_B = 0
for i in range(N+M):
# print(N,M,i,l_A,l_B,"A,B:",A[l_A:],B[l_B:])
if l_A < N and l_B < M:
if A[l_A] < B[l_B]:
ans.append(A[l_A])
l_A += 1
else:
ans.append(B[l_B])
l_B += 1
elif l_A < N:
ans.append(A[l_A])
l_A += 1
else:
ans.append(B[l_B])
l_B += 1
rows = K
f = True
# f is (ans == correct)
for j in range(N+M):
if ans[j] == 0:
rows += 1
elif ans[j] > rows:
f = False
if f:
print(*ans)
else:
print(-1)
```
Yes
| 57,342 | [
0.408935546875,
0.52392578125,
-0.0224456787109375,
0.2301025390625,
-0.11187744140625,
-0.341064453125,
-0.67431640625,
-0.1688232421875,
0.455810546875,
0.6279296875,
0.479736328125,
0.0885009765625,
0.1390380859375,
-1.0146484375,
-0.734375,
-0.2470703125,
-0.428955078125,
-0.54... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Submitted Solution:
```
cases = int(input())
for _ in range(cases):
input()
k, n, m = map(int, input().split())
arr1 = list(map(int, input().split()))[::-1]
arr2 = list(map(int, input().split()))[::-1]
ans = []
cur_line = k
for i in range(n+m):
if arr1 and arr2:
if arr1[-1] <= arr2[-1]:
last = arr1.pop()
else:
last = arr2.pop()
elif arr1:
last = arr1.pop()
elif arr2:
last = arr2.pop()
if last > cur_line:
print(-1)
break
if last == 0:
cur_line += 1
ans.append(last)
else:
print(*ans)
```
Yes
| 57,343 | [
0.408935546875,
0.52392578125,
-0.0224456787109375,
0.2301025390625,
-0.11187744140625,
-0.341064453125,
-0.67431640625,
-0.1688232421875,
0.455810546875,
0.6279296875,
0.479736328125,
0.0885009765625,
0.1390380859375,
-1.0146484375,
-0.734375,
-0.2470703125,
-0.428955078125,
-0.54... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Submitted Solution:
```
# DEFINING SOME GOOD STUFF
import heapq
import sys
from math import *
import threading
from heapq import *
from itertools import count
from pprint import pprint
from collections import defaultdict
'''
intialise defaultdict by any kind of value by default you want to take ( int -> 0 | list -> [] )
'''
from heapq import heapify, heappop, heappush
sys.setrecursionlimit(300000)
# threading.stack_size(10**8)
'''
-> if you are increasing recursionlimit then remember submitting using python3 rather pypy3
-> sometimes increasing stack size don't work locally but it will work on CF
'''
mod = 10 ** 9+7
inf = 10 ** 15
decision = ['NO', 'YES']
yes = 'YES'
no = 'NO'
# ------------------------------FASTIO----------------------------
import os
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n")+(not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# _______________________________________________________________#
def npr(n, r):
return (factorial(n)%mod) // (factorial(n-r)%mod) if n >= r else 0
def ncr(n, r):
return (factorial(n)%mod) // ((factorial(r)%mod) * (factorial(n-r)%mod)) if n >= r else 0
def lower_bound(li, num):
answer = -1
start = 0
end = len(li)-1
while (start <= end):
middle = (end+start) // 2
if li[middle] >= num:
answer = middle
end = middle-1
else:
start = middle+1
return answer # min index where x is not less than num
def upper_bound(li, num):
answer = -1
start = 0
end = len(li)-1
while (start <= end):
middle = (end+start) // 2
if li[middle] <= num:
answer = middle
start = middle+1
else:
end = middle-1
return answer # max index where x is not greater than num
def abs(x):
return x if x >= 0 else -x
def binary_search(li, val):
# print(lb, ub, li)
ans = -1
lb = 0
ub = len(li)-1
while (lb <= ub):
mid = (lb+ub) // 2
# print('mid is',mid, li[mid])
if li[mid] > val:
ub = mid-1
elif val > li[mid]:
lb = mid+1
else:
ans = mid # return index
break
return ans
def kadane(x): # maximum sum contiguous subarray
sum_so_far = 0
current_sum = 0
for i in x:
current_sum += i
if current_sum < 0:
current_sum = 0
else:
sum_so_far = max(sum_so_far, current_sum)
return sum_so_far
def pref(li):
pref_sum = [0]
for i in li:
pref_sum.append(pref_sum[-1]+i)
return pref_sum
def SieveOfEratosthenes(n):
prime = [{1, i} for i in range(n+1)]
p = 2
while (p <= n):
for i in range(p * 2, n+1, p):
prime[i].add(p)
p += 1
return prime
def primefactors(n):
factors = []
while (n % 2 == 0):
factors.append(2)
n //= 2
for i in range(3, int(sqrt(n))+1, 2): # only odd factors left
while n % i == 0:
factors.append(i)
n //= i
if n > 2: # incase of prime
factors.append(n)
return factors
def prod(li):
ans = 1
for i in li:
ans *= i
return ans
def sumk(a, b):
print('called for', a, b)
ans = a * (a+1) // 2
ans -= b * (b+1) // 2
return ans
def sumi(n):
ans = 0
if len(n) > 1:
for x in n:
ans += int(x)
return ans
else:
return int(n)
def checkwin(x, a):
if a[0][0] == a[1][1] == a[2][2] == x:
return 1
if a[0][2] == a[1][1] == a[2][0] == x:
return 1
if (len(set(a[0])) == 1 and a[0][0] == x) or (len(set(a[1])) == 1 and a[1][0] == x) or (len(set(a[2])) == 1 and a[2][0] == x):
return 1
if (len(set(a[0][:])) == 1 and a[0][0] == x) or (len(set(a[1][:])) == 1 and a[0][1] == x) or (len(set(a[2][:])) == 1 and a[0][0] == x):
return 1
return 0
# _______________________________________________________________#
# def main():
karmanya = int(input())
# karmanya = 1
# divisors = SieveOfEratosthenes(200010)
# print(divisors)
while karmanya != 0:
karmanya -= 1
n = input()
k,n,m = map(int, input().split())
# a = [int(x) for x in list(input())]
a = list(map(int, input().split()))
b = list(map(int, input().split()))
# c = list(map(int, input().split()))
# d = defaultdict(list)
za,zb = a.count(0), a.count(0)
mxa, mxb = max(a), max(b)
if za + zb + k < max(mxa, mxb):
print(-1)
else:
ans = [0 for i in range(za + zb)]
for i in a:
if i != 0:
ans.append(i)
for i in b:
if i != 0:
ans.append(i)
print(*ans)
# t = threading.Thread(target=main)
# t.start()
# t.join()
```
No
| 57,344 | [
0.408935546875,
0.52392578125,
-0.0224456787109375,
0.2301025390625,
-0.11187744140625,
-0.341064453125,
-0.67431640625,
-0.1688232421875,
0.455810546875,
0.6279296875,
0.479736328125,
0.0885009765625,
0.1390380859375,
-1.0146484375,
-0.734375,
-0.2470703125,
-0.428955078125,
-0.54... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Submitted Solution:
```
#DaRk DeveLopeR
import sys
#taking input as string
input = lambda: sys.stdin.readline().rstrip("\r\n")
inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
mod = 10**9+7; Mod = 998244353; INF = float('inf')
#______________________________________________________________________________________________________
import math
from bisect import *
from heapq import *
from collections import defaultdict as dd
from collections import OrderedDict as odict
from collections import Counter as cc
from collections import deque
from itertools import groupby
sys.setrecursionlimit(20*20*20*20+10) #this is must for dfs
def solve():
input()
k,n,m=takeivr()
arr1=takeiar()
arr2=takeiar()
arr=[]
count0=0
for i in arr1:
if i==0:
count0+=1
arr.append(i)
for i in arr2:
if i==0:
count0+=1
arr.append(i)
arr.sort()
k+=count0
for i in arr:
if i==0:
continue
elif i>k:
print(-1)
return
print(*arr)
return
def main():
global tt
if not ONLINE_JUDGE:
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
t = 1
t = takein()
#t = 1
for tt in range(1,t + 1):
solve()
if not ONLINE_JUDGE:
print("Time Elapsed :",time.time() - start_time,"seconds")
sys.stdout.close()
#---------------------- USER DEFINED INPUT FUNCTIONS ----------------------#
def takein():
return (int(sys.stdin.readline().rstrip("\r\n")))
# input the string
def takesr():
return (sys.stdin.readline().rstrip("\r\n"))
# input int array
def takeiar():
return (list(map(int, sys.stdin.readline().rstrip("\r\n").split())))
# input string array
def takesar():
return (list(map(str, sys.stdin.readline().rstrip("\r\n").split())))
# innut values for the diffrent variables
def takeivr():
return (map(int, sys.stdin.readline().rstrip("\r\n").split()))
def takesvr():
return (map(str, sys.stdin.readline().rstrip("\r\n").split()))
#------------------ USER DEFINED PROGRAMMING FUNCTIONS ------------------#
def ispalindrome(s):
return s==s[::-1]
def invert(bit_s):
# convert binary string
# into integer
temp = int(bit_s, 2)
# applying Ex-or operator
# b/w 10 and 31
inverse_s = temp ^ (2 ** (len(bit_s) + 1) - 1)
# convert the integer result
# into binary result and then
# slicing of the '0b1'
# binary indicator
rslt = bin(inverse_s)[3 : ]
return str(rslt)
def counter(a):
q = [0] * max(a)
for i in range(len(a)):
q[a[i] - 1] = q[a[i] - 1] + 1
return(q)
def counter_elements(a):
q = dict()
for i in range(len(a)):
if a[i] not in q:
q[a[i]] = 0
q[a[i]] = q[a[i]] + 1
return(q)
def string_counter(a):
q = [0] * 26
for i in range(len(a)):
q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
return(q)
def factorial(n,m = 1000000007):
q = 1
for i in range(n):
q = (q * (i + 1)) % m
return(q)
def factors(n):
q = []
for i in range(1,int(n ** 0.5) + 1):
if n % i == 0: q.append(i); q.append(n // i)
return(list(sorted(list(set(q)))))
def prime_factors(n):
q = []
while n % 2 == 0: q.append(2); n = n // 2
for i in range(3,int(n ** 0.5) + 1,2):
while n % i == 0: q.append(i); n = n // i
if n > 2: q.append(n)
return(list(sorted(q)))
def transpose(a):
n,m = len(a),len(a[0])
b = [[0] * n for i in range(m)]
for i in range(m):
for j in range(n):
b[i][j] = a[j][i]
return(b)
def power_two(x):
return (x and (not(x & (x - 1))))
def ceil(a, b):
return -(-a // b)
def seive(n):
a = [1]
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p ** 2,n + 1, p):
prime[i] = False
p = p + 1
for p in range(2,n + 1):
if prime[p]:
a.append(p)
return(a)
def pref(li):
pref_sum = [0]
for i in li:
pref_sum.append(pref_sum[-1]+i)
return pref_sum
def kadane(x): # maximum sum contiguous subarray
sum_so_far = 0
current_sum = 0
for i in x:
current_sum += i
if current_sum < 0:
current_sum = 0
else:
sum_so_far = max(sum_so_far, current_sum)
return sum_so_far
def binary_search(li, val):
# print(lb, ub, li)
ans = -1
lb = 0
ub = len(li)-1
while (lb <= ub):
mid = (lb+ub) // 2
# print('mid is',mid, li[mid])
if li[mid] > val:
ub = mid-1
elif val > li[mid]:
lb = mid+1
else:
ans = mid # return index
break
return ans
def upper_bound(li, num):
answer = -1
start = 0
end = len(li)-1
while (start <= end):
middle = (end+start) // 2
if li[middle] <= num:
answer = middle
start = middle+1
else:
end = middle-1
return answer # max index where x is not greater than num
def lower_bound(li, num):
answer = -1
start = 0
end = len(li)-1
while (start <= end):
middle = (end+start) // 2
if li[middle] >= num:
answer = middle
end = middle-1
else:
start = middle+1
return answer # min index where x is not less than num
#-----------------------------------------------------------------------#
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
input = sys.stdin.readline
main()
```
No
| 57,345 | [
0.408935546875,
0.52392578125,
-0.0224456787109375,
0.2301025390625,
-0.11187744140625,
-0.341064453125,
-0.67431640625,
-0.1688232421875,
0.455810546875,
0.6279296875,
0.479736328125,
0.0885009765625,
0.1390380859375,
-1.0146484375,
-0.734375,
-0.2470703125,
-0.428955078125,
-0.54... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Submitted Solution:
```
# Problem: C. Pair Programming
# Contest: Codeforces - Codeforces Round #731 (Div. 3)
# URL: https://codeforces.com/contest/1547/problem/C
# Memory Limit: 512 MB
# Time Limit: 2000 ms
#
# Powered by CP Editor (https://cpeditor.org)
# ____ ____ ___ # skeon19
#| | / | | | |\ | #
#|____ |/ |___ | | | \ | # EON_KID
# | |\ | | | | \ | #
# ____| | \ ___ |____ |___| | \| # Soul_Silver
from collections import defaultdict
import sys,io,os
INP=sys.stdin.readline
inp=lambda:[*map(int,INP().encode().split())]
sinp=lambda:[*map(str,INP().split())]
out=sys.stdout.write
#from functools import reduce
#from bisect import bisect_right,bisect_left
#from sortedcontainers import SortedList, SortedSet, SortedDict
#import sympy #Prime number library
#import heapq
def main():
for _ in range(inp()[0]):
d=inp()
k,n,m=inp()
l=inp()
p=inp()
i=j=0
ans=[]
check=1
while i<n and j<m:
if l[i]==0 and p[j]!=0:
ans.append(0)
k+=1
i+=1
elif p[j]==0 and l[i]!=0:
ans.append(0)
k+=1
j+=1
else:
if l[i]>=p[j] and p[j]<=k:
ans.append(p[j])
j+=1
elif l[i]<=p[j] and l[i]<=k:
ans.append(l[i])
i+=1
else:
check=0
break
if not check:
break
if check:
while i<n:
if l[i]==0:
ans.append(0)
k+=1
i+=1
elif l[i]<=k:
ans.append(l[i])
i+=1
else:
check=0
break
while j<m:
if p[j]==0:
ans.append(0)
k+=1
j+=1
elif p[j]<=k:
ans.append(p[j])
j+=1
else:
check=0
break
if check:
print(*ans)
else:
print(-1)
else:
print(-1)
###############################################################
def SumOfExpOfFactors(a):
fac = 0
lis=SortedList()
if not a&1:
lis.add(2)
while not a&1:
a >>= 1
fac += 1
for i in range(3,int(a**0.5)+1,2):
if not a%i:
lis.add(i)
while not a%i:
a //= i
fac += 1
if a != 1:
lis.add(a)
fac += 1
return fac,lis
###############################################################
div=[0]*(1000001)
def NumOfDivisors(n): #O(nlog(n))
for i in range(1,n+1):
for j in range(i,n+1,i):
div[j]+=1
###############################################################
def primes1(n): #return a list having prime numbers from 2 to n
""" Returns a list of primes < n """
sieve = [True] * (n//2)
for i in range(3,int(n**0.5)+1,2):
if sieve[i//2]:
sieve[i*i//2::i] = [False] * ((n-i*i-1)//(2*i)+1)
return [2] + [2*i+1 for i in range(1,n//2) if sieve[i]]
##############################################################
def GCD(a,b):
if(b==0):
return a
else:
return GCD(b,a%b)
##############################################################
#
# 1
# / \
# 2 3
# /\ / \ \ \
#4 5 6 7 8 9
# \
# 10
class Graph:
def __init__(self):
self.Graph = defaultdict(list)
def addEdge(self, u, v):
self.Graph[u].append(v)
self.Graph[v].append(u)
#DFS Graph / tree
def DFSUtil(self, v, visited):
visited.add(v)
#print(v, end=' ')
for neighbour in self.Graph[v]:
if neighbour not in visited: #not needed if its a tree
self.DFSUtil(neighbour, visited)
def DFS(self, v):
visited = set() #not needed if its a tree
self.DFSUtil(v, visited) #Visited not needed if its a tree
#BFS Graph / tree
def BFS(self, s):
# Mark all the vertices as not visited
visited = set()
# Create a queue for BFS
queue = []
queue.append(s)
visited.add(s)
while queue:
s = queue.pop(0)
#print (s, end = " ")
for i in self.Graph[s]:
if i not in visited:
queue.append(i)
visited.add(i)
'''
g = Graph()
g.addEdge(1, 2)
g.addEdge(1, 3)
g.addEdge(2, 4)
g.addEdge(2, 5)
g.addEdge(3, 6)
g.addEdge(3, 7)
g.addEdge(3, 8)
g.addEdge(3, 9)
g.addEdge(6,10)
g.DFS(1)
g.BFS(1) '''
##############################################################
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
# https://github.com/cheran-senthil/PyRival/blob/master/pyrival/data_structures/SortedList.py
###################################################################################################
if __name__ == '__main__':
main()
```
No
| 57,346 | [
0.408935546875,
0.52392578125,
-0.0224456787109375,
0.2301025390625,
-0.11187744140625,
-0.341064453125,
-0.67431640625,
-0.1688232421875,
0.455810546875,
0.6279296875,
0.479736328125,
0.0885009765625,
0.1390380859375,
-1.0146484375,
-0.734375,
-0.2470703125,
-0.428955078125,
-0.54... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp and Polycarp are learning new programming techniques. Now they decided to try pair programming.
It's known that they have worked together on the same file for n + m minutes. Every minute exactly one of them made one change to the file. Before they started, there were already k lines written in the file.
Every minute exactly one of them does one of two actions: adds a new line to the end of the file or changes one of its lines.
Monocarp worked in total for n minutes and performed the sequence of actions [a_1, a_2, ..., a_n]. If a_i = 0, then he adds a new line to the end of the file. If a_i > 0, then he changes the line with the number a_i. Monocarp performed actions strictly in this order: a_1, then a_2, ..., a_n.
Polycarp worked in total for m minutes and performed the sequence of actions [b_1, b_2, ..., b_m]. If b_j = 0, then he adds a new line to the end of the file. If b_j > 0, then he changes the line with the number b_j. Polycarp performed actions strictly in this order: b_1, then b_2, ..., b_m.
Restore their common sequence of actions of length n + m such that all actions would be correct — there should be no changes to lines that do not yet exist. Keep in mind that in the common sequence Monocarp's actions should form the subsequence [a_1, a_2, ..., a_n] and Polycarp's — subsequence [b_1, b_2, ..., b_m]. They can replace each other at the computer any number of times.
Let's look at an example. Suppose k = 3. Monocarp first changed the line with the number 2 and then added a new line (thus, n = 2, \: a = [2, 0]). Polycarp first added a new line and then changed the line with the number 5 (thus, m = 2, \: b = [0, 5]).
Since the initial length of the file was 3, in order for Polycarp to change line number 5 two new lines must be added beforehand. Examples of correct sequences of changes, in this case, would be [0, 2, 0, 5] and [2, 0, 0, 5]. Changes [0, 0, 5, 2] (wrong order of actions) and [0, 5, 2, 0] (line 5 cannot be edited yet) are not correct.
Input
The first line contains an integer t (1 ≤ t ≤ 1000). Then t test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains three integers k, n, m (0 ≤ k ≤ 100, 1 ≤ n, m ≤ 100) — the initial number of lines in file and lengths of Monocarp's and Polycarp's sequences of changes respectively.
The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 300).
The third line contains m integers b_1, b_2, ..., b_m (0 ≤ b_j ≤ 300).
Output
For each test case print any correct common sequence of Monocarp's and Polycarp's actions of length n + m or -1 if such sequence doesn't exist.
Example
Input
5
3 2 2
2 0
0 5
4 3 2
2 0 5
0 6
0 2 2
1 0
2 3
5 4 4
6 0 8 0
0 7 0 9
5 4 1
8 7 8 0
0
Output
2 0 0 5
0 2 0 6 5
-1
0 6 0 7 0 8 0 9
-1
Submitted Solution:
```
import math
inp=int(input())
for _ in range(inp):
input()
k,n,m=map(int,input().split(" "))
nl=list(map(int,input().split(" ")))
ml=list(map(int,input().split(" ")))
final=nl+ml
final.sort()
flag=True
d=k
for i in final:
if i==0:
d+=1
else:
if d<i:
flag=False
break
if flag:
q=[]
while 0 in final:
q.append(final.pop(0))
res=[]
print(*res)
else:
print(-1)
# from wrapt_timeout_decorator import *
# @timeout(2.5)
# def i():
# p=0
# try:
# i()
# except Exception:
# print("TLE")
```
No
| 57,347 | [
0.408935546875,
0.52392578125,
-0.0224456787109375,
0.2301025390625,
-0.11187744140625,
-0.341064453125,
-0.67431640625,
-0.1688232421875,
0.455810546875,
0.6279296875,
0.479736328125,
0.0885009765625,
0.1390380859375,
-1.0146484375,
-0.734375,
-0.2470703125,
-0.428955078125,
-0.54... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Tags: implementation
Correct Solution:
```
online = set()
answer = 0
try:
while True:
line = input()
if line[0] == '+' or line[0] == '-':
name = line[1:]
if line[0] == '+':
online.add(name)
else:
online.remove(name)
else:
answer += len(line.split(':')[1]) * len(online)
except:
pass
print(answer)
```
| 57,571 | [
0.301025390625,
0.19970703125,
0.0416259765625,
0.81103515625,
-0.3388671875,
-0.59521484375,
-0.37548828125,
0.1962890625,
0.36474609375,
0.69921875,
0.53125,
0.1595458984375,
0.210205078125,
-0.955078125,
-0.65625,
-0.2177734375,
-0.50244140625,
-0.6171875,
-0.68896484375,
-0... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Tags: implementation
Correct Solution:
```
c=0
l=[]
x=0
while x==0:
try:
s=input()
if "+" in s and s[1:] not in l:
l.append(s[1:])
if "-" in s and s[1:] in l:
l.remove(s[1:])
if ":" in s:
a,m=s.split(":")
c+=len(m)*len(l)
except:
x=1
print(c)
```
| 57,572 | [
0.301025390625,
0.1973876953125,
0.062469482421875,
0.79052734375,
-0.355712890625,
-0.59326171875,
-0.400634765625,
0.1873779296875,
0.30908203125,
0.6884765625,
0.509765625,
0.1771240234375,
0.2132568359375,
-0.96923828125,
-0.666015625,
-0.197509765625,
-0.484619140625,
-0.59619... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Tags: implementation
Correct Solution:
```
import sys
people,bits = 0,0
for i in sys.stdin:
if i[0] == "+": people += 1;
elif i[0] == "-": people -= 1
else: bits += people*(len(i)-i.find(":")-2)
print(bits)
```
| 57,573 | [
0.273681640625,
0.1768798828125,
0.077880859375,
0.75634765625,
-0.359130859375,
-0.6201171875,
-0.42919921875,
0.1229248046875,
0.26904296875,
0.65576171875,
0.5048828125,
0.093017578125,
0.2176513671875,
-0.93017578125,
-0.6328125,
-0.1695556640625,
-0.47119140625,
-0.61474609375... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Tags: implementation
Correct Solution:
```
# @author: guoyc
# @date: 2018/7/20
res = 0
n = 0
import sys
for s in sys.stdin:
if s[0] == '+':
n += 1
elif s[0] == '-':
n -= 1
elif s.find(':') != -1:
name, msg = s.split(':')
res += n * (len(msg)-1)
print(res)
```
| 57,574 | [
0.2734375,
0.1590576171875,
0.051788330078125,
0.7822265625,
-0.35302734375,
-0.60400390625,
-0.38134765625,
0.1654052734375,
0.32568359375,
0.716796875,
0.51220703125,
0.1373291015625,
0.2099609375,
-0.93408203125,
-0.65869140625,
-0.2020263671875,
-0.476318359375,
-0.6064453125,
... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Tags: implementation
Correct Solution:
```
"""f = open("input.txt", "r")
if f.mode == 'r':
contents = f.readlines()
"""
import sys
contents = []
participants = 0
sum = 0
while True:
try:
s = input()
contents.append(s)
except:
break
for content in contents:
if content[0] == "+":
participants += 1
elif content[0] == "-":
participants -= 1
else:
flash = ":"
message = content.partition(flash)[2]
message = message.rstrip('\n')
traffic = len(message)
traffic *= participants
sum += traffic
print(sum)
```
| 57,575 | [
0.289306640625,
0.148681640625,
0.06842041015625,
0.7822265625,
-0.354248046875,
-0.5810546875,
-0.39501953125,
0.17236328125,
0.318603515625,
0.68408203125,
0.5244140625,
0.13525390625,
0.2188720703125,
-0.9248046875,
-0.646484375,
-0.1767578125,
-0.482421875,
-0.61865234375,
-0... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Tags: implementation
Correct Solution:
```
names = []
res = 0
while True:
try:
s = input()
except:
break
if s[0] == '+':
names.append(s[1:])
elif s[0] == '-':
names.remove(s[1:])
else:
if ':' in s:
length = len(s.split(':')[1])
res = res + length * len(names)
else:
break
print(res)
```
| 57,576 | [
0.287109375,
0.1683349609375,
0.072509765625,
0.765625,
-0.3447265625,
-0.5986328125,
-0.38916015625,
0.1693115234375,
0.302001953125,
0.6884765625,
0.52880859375,
0.1455078125,
0.2193603515625,
-0.94189453125,
-0.6474609375,
-0.1881103515625,
-0.472900390625,
-0.62548828125,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Tags: implementation
Correct Solution:
```
d = set()
count = 0
try:
while(1):
s = input()
if(s.startswith("+")):
d.add(s[1:])
elif(s.startswith("-")):
d.remove(s[1:])
else:
count += len(s.split(":")[-1]) * len(d)
except:
pass
print(count)
```
| 57,577 | [
0.296142578125,
0.17919921875,
0.0667724609375,
0.7734375,
-0.340087890625,
-0.59765625,
-0.40478515625,
0.166259765625,
0.31103515625,
0.69287109375,
0.521484375,
0.1502685546875,
0.218505859375,
-0.93994140625,
-0.64404296875,
-0.2005615234375,
-0.48388671875,
-0.6064453125,
-0... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Tags: implementation
Correct Solution:
```
guys = set()
res = 0
while 1:
try:
curRequest = input()
except:
break
if curRequest[0] == '+':
guys.add(curRequest[1:])
elif curRequest[0] == '-':
guys.remove(curRequest[1:])
else:
proReq = curRequest[curRequest.find(':') + 1:]
# print(proReq)
res += len(proReq)*len(guys)
print(res)
```
| 57,578 | [
0.3173828125,
0.1571044921875,
0.0638427734375,
0.76025390625,
-0.365234375,
-0.5888671875,
-0.380126953125,
0.1705322265625,
0.329345703125,
0.69873046875,
0.5087890625,
0.1290283203125,
0.21875,
-0.9326171875,
-0.6572265625,
-0.1962890625,
-0.47607421875,
-0.65576171875,
-0.686... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Submitted Solution:
```
import sys
trafic = 0
s = set()
for request in sys.__stdin__:
if request[0] == "+":
s.add(request[1:])
elif request[0] == "-":
s.remove(request[1:])
else:
trafic += len(request[request.find(":")+1:-1])*len(s)
print(trafic)
```
Yes
| 57,579 | [
0.3115234375,
0.24755859375,
-0.048980712890625,
0.78662109375,
-0.38720703125,
-0.439453125,
-0.459228515625,
0.3486328125,
0.2646484375,
0.5966796875,
0.4443359375,
0.1785888671875,
0.1517333984375,
-1.0400390625,
-0.671875,
-0.2099609375,
-0.447998046875,
-0.54150390625,
-0.52... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Submitted Solution:
```
import sys
users = list()
ans = 0
for line in sys.stdin:
line = line.rstrip()
if line[0] == '+':
users.append(line[1:])
elif line[0] == '-':
users.remove(line[1:])
else:
msg = line[line.index(':') + 1:]
ans += len(msg) * len(users)
print(ans)
```
Yes
| 57,580 | [
0.31982421875,
0.2264404296875,
-0.039337158203125,
0.7900390625,
-0.369384765625,
-0.445556640625,
-0.45751953125,
0.35888671875,
0.239013671875,
0.5966796875,
0.43505859375,
0.15234375,
0.2056884765625,
-1.0380859375,
-0.67822265625,
-0.1959228515625,
-0.458984375,
-0.52783203125... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Submitted Solution:
```
import sys
a = b = 0
for m in sys.stdin:
a += m[0] == '+'
a -= m[0] == '-'
b += (':' in m)*(len(m) - m.find(':') - 2) * a
print(b)
```
Yes
| 57,581 | [
0.312744140625,
0.2259521484375,
-0.0396728515625,
0.79345703125,
-0.388671875,
-0.435791015625,
-0.463623046875,
0.34912109375,
0.22607421875,
0.5966796875,
0.4365234375,
0.1497802734375,
0.188720703125,
-1.044921875,
-0.68603515625,
-0.1954345703125,
-0.4345703125,
-0.53564453125... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Submitted Solution:
```
import sys
nums=ans=0
for s in sys.stdin:
jj=s[0]
if jj=='+':
nums+=1
elif jj=='-':
nums-=1
else:
n,t=s.split(':')
ans+=(len(t)-1)*nums
print(ans)
```
Yes
| 57,582 | [
0.31298828125,
0.2286376953125,
-0.04638671875,
0.79443359375,
-0.3916015625,
-0.444091796875,
-0.453857421875,
0.354736328125,
0.235595703125,
0.59912109375,
0.44140625,
0.1507568359375,
0.187255859375,
-1.0498046875,
-0.68212890625,
-0.208740234375,
-0.4482421875,
-0.54248046875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Submitted Solution:
```
import sys
k=0
s=0
for line in sys.stdin:
print(line[0])
if line[0]=='+':
k+=1
if line[0]=='-':
k-=1
if line[0]!='+' and line[0]!='-':
s+=len(line)-line.index(':')
print(s)
```
No
| 57,583 | [
0.31494140625,
0.2330322265625,
-0.04083251953125,
0.79296875,
-0.389892578125,
-0.439697265625,
-0.45751953125,
0.357177734375,
0.2344970703125,
0.5966796875,
0.437255859375,
0.1531982421875,
0.183837890625,
-1.04296875,
-0.68212890625,
-0.20458984375,
-0.4462890625,
-0.5439453125... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Submitted Solution:
```
# @author: guoyc
# @date: 2018/7/20
res = 0
n = 0
import sys
for s in sys.stdin:
if s[0] == '+':
n += 1
elif s[0] == '-':
n -= 1
else:
name, msg = s.split(':')
res += n * (len(msg)-2)
print(res)
# import sys
#
# z = x = 0
# for s in sys.stdin:
# if s[0] == '+':
# x += 1
# elif s[0] == '-':
# x -= 1
# else:
# z += (len(s) - s.find(':') - 2) * x
# print(z)
```
No
| 57,584 | [
0.275390625,
0.21044921875,
-0.035614013671875,
0.81298828125,
-0.38427734375,
-0.445556640625,
-0.431640625,
0.35546875,
0.26708984375,
0.63427734375,
0.436767578125,
0.15625,
0.17822265625,
-1.052734375,
-0.7255859375,
-0.228515625,
-0.4365234375,
-0.4970703125,
-0.488525390625... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Submitted Solution:
```
import sys
serverTraffic = 0
activeUsers = 0
for line in sys.stdin:
if line[0] == '+':
activeUsers += 1
elif line[0] == '-':
activeUsers -= 1
else:
serverTraffic += (activeUsers - 1) * (len(line) - line.find(':') - 1)
#serverTraffic += activeUsers * (len(line) - line.find(':') - 2)
print(serverTraffic)
```
No
| 57,585 | [
0.31884765625,
0.2410888671875,
-0.06793212890625,
0.80712890625,
-0.36376953125,
-0.448486328125,
-0.463134765625,
0.341796875,
0.2548828125,
0.6044921875,
0.430419921875,
0.1331787109375,
0.208251953125,
-1.037109375,
-0.701171875,
-0.20947265625,
-0.462158203125,
-0.55322265625,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp is working on a new project called "Polychat". Following modern tendencies in IT, he decided, that this project should contain chat as well. To achieve this goal, Polycarp has spent several hours in front of his laptop and implemented a chat server that can process three types of commands:
* Include a person to the chat ('Add' command).
* Remove a person from the chat ('Remove' command).
* Send a message from a person to all people, who are currently in the chat, including the one, who sends the message ('Send' command).
Now Polycarp wants to find out the amount of outgoing traffic that the server will produce while processing a particular set of commands.
Polycarp knows that chat server sends no traffic for 'Add' and 'Remove' commands. When 'Send' command is processed, server sends l bytes to each participant of the chat, where l is the length of the message.
As Polycarp has no time, he is asking for your help in solving this problem.
Input
Input file will contain not more than 100 commands, each in its own line. No line will exceed 100 characters. Formats of the commands will be the following:
* +<name> for 'Add' command.
* -<name> for 'Remove' command.
* <sender_name>:<message_text> for 'Send' command.
<name> and <sender_name> is a non-empty sequence of Latin letters and digits. <message_text> can contain letters, digits and spaces, but can't start or end with a space. <message_text> can be an empty line.
It is guaranteed, that input data are correct, i.e. there will be no 'Add' command if person with such a name is already in the chat, there will be no 'Remove' command if there is no person with such a name in the chat etc.
All names are case-sensitive.
Output
Print a single number — answer to the problem.
Examples
Input
+Mike
Mike:hello
+Kate
+Dmitry
-Dmitry
Kate:hi
-Kate
Output
9
Input
+Mike
-Mike
+Mike
Mike:Hi I am here
-Mike
+Kate
-Kate
Output
14
Submitted Solution:
```
import sys
users = []
ans = 0
for s in sys.stdin:
if s[0] == "+":
users.append(s[1:])
elif s[0] == "-":
del users[users.index(s[1:])]
else:
ans += len(users)*len(s[s.index(":")+1:])
print(ans)
```
No
| 57,586 | [
0.308837890625,
0.2178955078125,
-0.0293731689453125,
0.79296875,
-0.360595703125,
-0.45654296875,
-0.456787109375,
0.337646484375,
0.2215576171875,
0.603515625,
0.456787109375,
0.1429443359375,
0.18994140625,
-1.033203125,
-0.6708984375,
-0.1884765625,
-0.44384765625,
-0.521972656... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus develops an interesting theory about the interrelation of arithmetic progressions with just everything in the world. His current idea is that the population of the capital of Berland changes over time like an arithmetic progression. Well, or like multiple arithmetic progressions.
Polycarpus believes that if he writes out the population of the capital for several consecutive years in the sequence a1, a2, ..., an, then it is convenient to consider the array as several arithmetic progressions, written one after the other. For example, sequence (8, 6, 4, 2, 1, 4, 7, 10, 2) can be considered as a sequence of three arithmetic progressions (8, 6, 4, 2), (1, 4, 7, 10) and (2), which are written one after another.
Unfortunately, Polycarpus may not have all the data for the n consecutive years (a census of the population doesn't occur every year, after all). For this reason, some values of ai may be unknown. Such values are represented by number -1.
For a given sequence a = (a1, a2, ..., an), which consists of positive integers and values -1, find the minimum number of arithmetic progressions Polycarpus needs to get a. To get a, the progressions need to be written down one after the other. Values -1 may correspond to an arbitrary positive integer and the values ai > 0 must be equal to the corresponding elements of sought consecutive record of the progressions.
Let us remind you that a finite sequence c is called an arithmetic progression if the difference ci + 1 - ci of any two consecutive elements in it is constant. By definition, any sequence of length 1 is an arithmetic progression.
Input
The first line of the input contains integer n (1 ≤ n ≤ 2·105) — the number of elements in the sequence. The second line contains integer values a1, a2, ..., an separated by a space (1 ≤ ai ≤ 109 or ai = - 1).
Output
Print the minimum number of arithmetic progressions that you need to write one after another to get sequence a. The positions marked as -1 in a can be represented by any positive integers.
Examples
Input
9
8 6 4 2 1 4 7 10 2
Output
3
Input
9
-1 6 -1 2 -1 4 7 -1 2
Output
3
Input
5
-1 -1 -1 -1 -1
Output
1
Input
7
-1 -1 4 5 1 2 3
Output
2
Tags: greedy, implementation, math
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
i = 0
ans = 0
while i < n:
ans += 1
i1 = i
while i1 < n and a[i1] == -1:
i1 += 1
if i1 == n:
break
i2 = i1 + 1
while i2 < n and a[i2] == -1:
i2 += 1
if i2 == n:
break
dist = i2 - i1
step = (a[i2] - a[i1]) // dist
if (a[i2] - a[i1]) % dist != 0 or (step > 0 and a[i1] - (i1 - i) * step <= 0):
i = i2
continue
i3 = i2 + 1
while i3 < n:
nxt = a[i2] + step * (i3 - i2)
if nxt <= 0 or (a[i3] != -1 and a[i3] != nxt):
break
i3 += 1
i = i3
print(ans)
```
| 58,371 | [
0.2763671875,
0.40625,
0.390625,
0.0107574462890625,
-0.263916015625,
-0.199462890625,
-0.475341796875,
-0.1693115234375,
0.18505859375,
0.80712890625,
0.740234375,
-0.3876953125,
-0.00000864267349243164,
-0.88916015625,
-0.65966796875,
-0.179443359375,
-0.85400390625,
-0.958496093... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarpus develops an interesting theory about the interrelation of arithmetic progressions with just everything in the world. His current idea is that the population of the capital of Berland changes over time like an arithmetic progression. Well, or like multiple arithmetic progressions.
Polycarpus believes that if he writes out the population of the capital for several consecutive years in the sequence a1, a2, ..., an, then it is convenient to consider the array as several arithmetic progressions, written one after the other. For example, sequence (8, 6, 4, 2, 1, 4, 7, 10, 2) can be considered as a sequence of three arithmetic progressions (8, 6, 4, 2), (1, 4, 7, 10) and (2), which are written one after another.
Unfortunately, Polycarpus may not have all the data for the n consecutive years (a census of the population doesn't occur every year, after all). For this reason, some values of ai may be unknown. Such values are represented by number -1.
For a given sequence a = (a1, a2, ..., an), which consists of positive integers and values -1, find the minimum number of arithmetic progressions Polycarpus needs to get a. To get a, the progressions need to be written down one after the other. Values -1 may correspond to an arbitrary positive integer and the values ai > 0 must be equal to the corresponding elements of sought consecutive record of the progressions.
Let us remind you that a finite sequence c is called an arithmetic progression if the difference ci + 1 - ci of any two consecutive elements in it is constant. By definition, any sequence of length 1 is an arithmetic progression.
Input
The first line of the input contains integer n (1 ≤ n ≤ 2·105) — the number of elements in the sequence. The second line contains integer values a1, a2, ..., an separated by a space (1 ≤ ai ≤ 109 or ai = - 1).
Output
Print the minimum number of arithmetic progressions that you need to write one after another to get sequence a. The positions marked as -1 in a can be represented by any positive integers.
Examples
Input
9
8 6 4 2 1 4 7 10 2
Output
3
Input
9
-1 6 -1 2 -1 4 7 -1 2
Output
3
Input
5
-1 -1 -1 -1 -1
Output
1
Input
7
-1 -1 4 5 1 2 3
Output
2
Tags: greedy, implementation, math
Correct Solution:
```
import sys
import math
n = int(sys.stdin.readline())
if n <= 2:
print(1)
sys.exit(0)
a = [int(s) for s in sys.stdin.readline().split()]
st = -1 # index of first positive number in current subset of a
ed = -1 # index last positive number in current subset of a
# differation is (a[ed] - a[st])/(ed - st)
leading_zeros = 0 # -1 before a[st]
seg_count = 1
for (i, v) in enumerate(a):
if v == -1:
if st == -1:
leading_zeros += 1
else:
if ed != -1:
# check if v should be a non-positive number
if a[ed] + (i-ed) * (a[ed] - a[st])/(ed-st) <= 0:
st = -1
ed = -1
leading_zeros = 1
seg_count += 1
else:
pass
else:
pass
else:
if st == -1:
st = i # find first positive number
else:
if ed == -1:
ed = i
#print(i)
if (v - a[st]) % (i-st) != 0 or a[st] - (v-a[st])/(i-st) * leading_zeros <= 0:
# a[st..i] can't be an arithmetic progression
st = i
ed = -1
seg_count += 1
leading_zeros = 0
else:
ed = i
else:
if (v-a[ed])%(i-ed) != 0 or (v-a[ed]) * (ed - st) != (a[ed] - a[st]) * (i-ed):
st = i
ed = -1
seg_count += 1
leading_zeros = 0
else:
ed = i #leave ed the first positive number after a[st] is also ok
#print( "[" +str(st) + " " + str(ed) + "] " + str(seg_count) + " " + str(leading_zeros) )
print(seg_count)
```
| 58,372 | [
0.2763671875,
0.40625,
0.390625,
0.0107574462890625,
-0.263916015625,
-0.199462890625,
-0.475341796875,
-0.1693115234375,
0.18505859375,
0.80712890625,
0.740234375,
-0.3876953125,
-0.00000864267349243164,
-0.88916015625,
-0.65966796875,
-0.179443359375,
-0.85400390625,
-0.958496093... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus develops an interesting theory about the interrelation of arithmetic progressions with just everything in the world. His current idea is that the population of the capital of Berland changes over time like an arithmetic progression. Well, or like multiple arithmetic progressions.
Polycarpus believes that if he writes out the population of the capital for several consecutive years in the sequence a1, a2, ..., an, then it is convenient to consider the array as several arithmetic progressions, written one after the other. For example, sequence (8, 6, 4, 2, 1, 4, 7, 10, 2) can be considered as a sequence of three arithmetic progressions (8, 6, 4, 2), (1, 4, 7, 10) and (2), which are written one after another.
Unfortunately, Polycarpus may not have all the data for the n consecutive years (a census of the population doesn't occur every year, after all). For this reason, some values of ai may be unknown. Such values are represented by number -1.
For a given sequence a = (a1, a2, ..., an), which consists of positive integers and values -1, find the minimum number of arithmetic progressions Polycarpus needs to get a. To get a, the progressions need to be written down one after the other. Values -1 may correspond to an arbitrary positive integer and the values ai > 0 must be equal to the corresponding elements of sought consecutive record of the progressions.
Let us remind you that a finite sequence c is called an arithmetic progression if the difference ci + 1 - ci of any two consecutive elements in it is constant. By definition, any sequence of length 1 is an arithmetic progression.
Input
The first line of the input contains integer n (1 ≤ n ≤ 2·105) — the number of elements in the sequence. The second line contains integer values a1, a2, ..., an separated by a space (1 ≤ ai ≤ 109 or ai = - 1).
Output
Print the minimum number of arithmetic progressions that you need to write one after another to get sequence a. The positions marked as -1 in a can be represented by any positive integers.
Examples
Input
9
8 6 4 2 1 4 7 10 2
Output
3
Input
9
-1 6 -1 2 -1 4 7 -1 2
Output
3
Input
5
-1 -1 -1 -1 -1
Output
1
Input
7
-1 -1 4 5 1 2 3
Output
2
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
i = 0
while i < len(a) and a[i] == -1:
i += 1
j = i + 1
while j < len(a) and a[j] == -1:
j += 1
if j >= len(a):
print(1)
exit()
ans = 1
m = j + 1
if (a[j] - a[i]) % (j - i) != 0 or a[i] - (a[j] - a[i]) / (j - i) * i <= 0:
i, j = j, -1
ans += 1
for k in range(m, len(a)):
if a[k] == -1:
continue
if j == -1 and (a[k] - a[i]) % (k - i) == 0 or j != -1 and (a[k] - a[j]) * (j - i) == (a[j] - a[i]) * (k - j):
j = k
else:
i = k
ans += 1
print(ans)
```
No
| 58,373 | [
0.362060546875,
0.420166015625,
0.30517578125,
0.0191650390625,
-0.3544921875,
-0.06201171875,
-0.5478515625,
-0.056396484375,
0.154296875,
0.77490234375,
0.6435546875,
-0.375732421875,
-0.002460479736328125,
-0.8671875,
-0.6533203125,
-0.16162109375,
-0.83984375,
-0.9423828125,
... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus develops an interesting theory about the interrelation of arithmetic progressions with just everything in the world. His current idea is that the population of the capital of Berland changes over time like an arithmetic progression. Well, or like multiple arithmetic progressions.
Polycarpus believes that if he writes out the population of the capital for several consecutive years in the sequence a1, a2, ..., an, then it is convenient to consider the array as several arithmetic progressions, written one after the other. For example, sequence (8, 6, 4, 2, 1, 4, 7, 10, 2) can be considered as a sequence of three arithmetic progressions (8, 6, 4, 2), (1, 4, 7, 10) and (2), which are written one after another.
Unfortunately, Polycarpus may not have all the data for the n consecutive years (a census of the population doesn't occur every year, after all). For this reason, some values of ai may be unknown. Such values are represented by number -1.
For a given sequence a = (a1, a2, ..., an), which consists of positive integers and values -1, find the minimum number of arithmetic progressions Polycarpus needs to get a. To get a, the progressions need to be written down one after the other. Values -1 may correspond to an arbitrary positive integer and the values ai > 0 must be equal to the corresponding elements of sought consecutive record of the progressions.
Let us remind you that a finite sequence c is called an arithmetic progression if the difference ci + 1 - ci of any two consecutive elements in it is constant. By definition, any sequence of length 1 is an arithmetic progression.
Input
The first line of the input contains integer n (1 ≤ n ≤ 2·105) — the number of elements in the sequence. The second line contains integer values a1, a2, ..., an separated by a space (1 ≤ ai ≤ 109 or ai = - 1).
Output
Print the minimum number of arithmetic progressions that you need to write one after another to get sequence a. The positions marked as -1 in a can be represented by any positive integers.
Examples
Input
9
8 6 4 2 1 4 7 10 2
Output
3
Input
9
-1 6 -1 2 -1 4 7 -1 2
Output
3
Input
5
-1 -1 -1 -1 -1
Output
1
Input
7
-1 -1 4 5 1 2 3
Output
2
Submitted Solution:
```
"""
Codeforces Round 241 Div 1 Problem D
Author : chaotic_iak
Language: Python 3.3.4
"""
class InputHandlerObject(object):
inputs = []
def getInput(self, n = 0):
res = ""
inputs = self.inputs
if not inputs: inputs.extend(input().split(" "))
if n == 0:
res = inputs[:]
inputs[:] = []
while n > len(inputs):
inputs.extend(input().split(" "))
if n > 0:
res = inputs[:n]
inputs[:n] = []
return res
InputHandler = InputHandlerObject()
g = InputHandler.getInput
############################## SOLUTION ##############################
n = int(input().strip())
q = [int(x) for x in g()]
diffs = []
indices = []
ct = 0
stillstart = True
for i in range(len(q)):
if q[i] == 0: q[i] = -1 # because it's easier to type 0 than -1
if q[i] == -1 and stillstart: continue
if stillstart:
stillstart = False
ct = 1
indices.append(i)
continue
if q[i] == -1:
ct += 1
else:
d = q[i] - q[i-ct]
if d % ct:
diffs.append("X")
else:
diffs.append(d//ct)
indices.append(i)
ct = 1
if not diffs:
print(1)
else:
res = 1
if diffs[0] != "X" and q[indices[0]] - diffs[0] * indices[0] <= 0:
res += 1
diffs.pop(0)
indices.pop(0)
prevok = False
for i in range(len(diffs)):
if diffs[i] == "X":
res += 1
notenough = False
if 0 < i < len(diffs)-1:
if diffs[i-1] != "X" and diffs[i+1] != "X":
leftmx = n if diffs[i-1] >= 0 else (- q[indices[i]] // diffs[i-1] + indices[i])
if diffs[i-1] < 0 and not q[indices[i]] % diffs[i-1]: leftmx -= 1
rightmn = 0 if diffs[i+1] <= 0 else (- q[indices[i+1]] // diffs[i+1] + indices[i+1])
if diffs[i+1] > 0 and not q[indices[i+1]] % diffs[i+1]: rightmn += 1
if leftmx + 1 < rightmn: notenough = True
if notenough:
res += 1
prevok = False
continue
if prevok and diffs[i-1] == diffs[i]:
continue
if prevok:
res += 1
notenough = False
if 0 < i < len(diffs)-1:
if diffs[i-1] != "X" and diffs[i+1] != "X":
leftmx = n if diffs[i-1] >= 0 else (- q[indices[i]] // diffs[i-1] + indices[i])
if diffs[i-1] < 0 and not q[indices[i]] % diffs[i-1]: leftmx -= 1
rightmn = 0 if diffs[i+1] <= 0 else (- q[indices[i+1]] // diffs[i+1] + indices[i+1])
if diffs[i+1] > 0 and not q[indices[i+1]] % diffs[i+1]: rightmn += 1
if leftmx + 1 < rightmn: notenough = True
if notenough:
passed = True
if i > 1:
i -= 1
if diffs[i-1] != "X" and diffs[i+1] != "X":
leftmx = n if diffs[i-1] >= 0 else (- q[indices[i]] // diffs[i-1] + indices[i])
if diffs[i-1] < 0 and not q[indices[i]] % diffs[i-1]: leftmx -= 1
rightmn = 0 if diffs[i+1] <= 0 else (- q[indices[i+1]] // diffs[i+1] + indices[i+1])
if diffs[i+1] > 0 and not q[indices[i+1]] % diffs[i+1]: rightmn += 1
if leftmx + 1 < rightmn: notenough = True
i += 1
if i < len(diffs) - 2:
i += 1
if diffs[i-1] != "X" and diffs[i+1] != "X":
leftmx = n if diffs[i-1] >= 0 else (- q[indices[i]] // diffs[i-1] + indices[i])
if diffs[i-1] < 0 and not q[indices[i]] % diffs[i-1]: leftmx -= 1
rightmn = 0 if diffs[i+1] <= 0 else (- q[indices[i+1]] // diffs[i+1] + indices[i+1])
if diffs[i+1] > 0 and not q[indices[i+1]] % diffs[i+1]: rightmn += 1
if leftmx + 1 < rightmn: notenough = True
i -= 1
if not passed:
res += 1
prevok = False
else:
prevok = True
else:
prevok = False
continue
if not prevok:
prevok = True
if prevok and diffs[-1] != "X" and q[indices[-1]] + diffs[-1] * (n-1 - indices[-1]) <= 0: res += 1
print(res)
```
No
| 58,374 | [
0.362060546875,
0.420166015625,
0.30517578125,
0.0191650390625,
-0.3544921875,
-0.06201171875,
-0.5478515625,
-0.056396484375,
0.154296875,
0.77490234375,
0.6435546875,
-0.375732421875,
-0.002460479736328125,
-0.8671875,
-0.6533203125,
-0.16162109375,
-0.83984375,
-0.9423828125,
... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus develops an interesting theory about the interrelation of arithmetic progressions with just everything in the world. His current idea is that the population of the capital of Berland changes over time like an arithmetic progression. Well, or like multiple arithmetic progressions.
Polycarpus believes that if he writes out the population of the capital for several consecutive years in the sequence a1, a2, ..., an, then it is convenient to consider the array as several arithmetic progressions, written one after the other. For example, sequence (8, 6, 4, 2, 1, 4, 7, 10, 2) can be considered as a sequence of three arithmetic progressions (8, 6, 4, 2), (1, 4, 7, 10) and (2), which are written one after another.
Unfortunately, Polycarpus may not have all the data for the n consecutive years (a census of the population doesn't occur every year, after all). For this reason, some values of ai may be unknown. Such values are represented by number -1.
For a given sequence a = (a1, a2, ..., an), which consists of positive integers and values -1, find the minimum number of arithmetic progressions Polycarpus needs to get a. To get a, the progressions need to be written down one after the other. Values -1 may correspond to an arbitrary positive integer and the values ai > 0 must be equal to the corresponding elements of sought consecutive record of the progressions.
Let us remind you that a finite sequence c is called an arithmetic progression if the difference ci + 1 - ci of any two consecutive elements in it is constant. By definition, any sequence of length 1 is an arithmetic progression.
Input
The first line of the input contains integer n (1 ≤ n ≤ 2·105) — the number of elements in the sequence. The second line contains integer values a1, a2, ..., an separated by a space (1 ≤ ai ≤ 109 or ai = - 1).
Output
Print the minimum number of arithmetic progressions that you need to write one after another to get sequence a. The positions marked as -1 in a can be represented by any positive integers.
Examples
Input
9
8 6 4 2 1 4 7 10 2
Output
3
Input
9
-1 6 -1 2 -1 4 7 -1 2
Output
3
Input
5
-1 -1 -1 -1 -1
Output
1
Input
7
-1 -1 4 5 1 2 3
Output
2
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
i = 0
while i < len(a) and a[i] == -1:
i += 1
j = i + 1
while j < len(a) and a[j] == -1:
j += 1
if j >= len(a):
print(1)
exit()
ans = 1
m = j + 1
if (a[j] - a[i]) % (j - i) != 0 or a[i] - (a[j] - a[i]) / (j - i) * i <= 0:
i, j = j, -1
ans += 1
for k in range(m, len(a)):
if a[k] == -1:
continue
if j == -1 and (a[k] - a[i]) % (k - i) == 0 or j != -1 and (a[k] - a[j]) * (j - i) == (a[j] - a[i]) * (k - j):
j = k
else:
i, j = k, -1
ans += 1
print(ans)
```
No
| 58,375 | [
0.362060546875,
0.420166015625,
0.30517578125,
0.0191650390625,
-0.3544921875,
-0.06201171875,
-0.5478515625,
-0.056396484375,
0.154296875,
0.77490234375,
0.6435546875,
-0.375732421875,
-0.002460479736328125,
-0.8671875,
-0.6533203125,
-0.16162109375,
-0.83984375,
-0.9423828125,
... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarpus develops an interesting theory about the interrelation of arithmetic progressions with just everything in the world. His current idea is that the population of the capital of Berland changes over time like an arithmetic progression. Well, or like multiple arithmetic progressions.
Polycarpus believes that if he writes out the population of the capital for several consecutive years in the sequence a1, a2, ..., an, then it is convenient to consider the array as several arithmetic progressions, written one after the other. For example, sequence (8, 6, 4, 2, 1, 4, 7, 10, 2) can be considered as a sequence of three arithmetic progressions (8, 6, 4, 2), (1, 4, 7, 10) and (2), which are written one after another.
Unfortunately, Polycarpus may not have all the data for the n consecutive years (a census of the population doesn't occur every year, after all). For this reason, some values of ai may be unknown. Such values are represented by number -1.
For a given sequence a = (a1, a2, ..., an), which consists of positive integers and values -1, find the minimum number of arithmetic progressions Polycarpus needs to get a. To get a, the progressions need to be written down one after the other. Values -1 may correspond to an arbitrary positive integer and the values ai > 0 must be equal to the corresponding elements of sought consecutive record of the progressions.
Let us remind you that a finite sequence c is called an arithmetic progression if the difference ci + 1 - ci of any two consecutive elements in it is constant. By definition, any sequence of length 1 is an arithmetic progression.
Input
The first line of the input contains integer n (1 ≤ n ≤ 2·105) — the number of elements in the sequence. The second line contains integer values a1, a2, ..., an separated by a space (1 ≤ ai ≤ 109 or ai = - 1).
Output
Print the minimum number of arithmetic progressions that you need to write one after another to get sequence a. The positions marked as -1 in a can be represented by any positive integers.
Examples
Input
9
8 6 4 2 1 4 7 10 2
Output
3
Input
9
-1 6 -1 2 -1 4 7 -1 2
Output
3
Input
5
-1 -1 -1 -1 -1
Output
1
Input
7
-1 -1 4 5 1 2 3
Output
2
Submitted Solution:
```
n=int(input())
A=list(map(int,input().split()))
P=[]
for i in range(n):
if(A[i]!=-1):
P.append((A[i],i))
if(len(P)==0 or len(P)==1):
print(1)
else:
p=10**10
d=10**10
z=10**10
start=0
for i in range(n):
if(A[i]==-1):
if(d==10**10):
continue
else:
A[i]=A[i-1]+d
if(A[i]<0):
A[i]=-1
d=10**10
start=i
else:
if(d==10**10):
if(p==10**10):
p=A[i]
z=i
else:
D=A[i]-p
if(D%(i-z)==0):
for k in range(i-1,z,-1):
A[k]=A[k+1]-(D//(i-z))
r=False
for k in range(z-1,start-1,-1):
if(r==False):
A[k]=A[k+1]-(D//(i-z))
if(A[k]<=0):
A[k]=1
r=True
else:
A[k]=1
d=D//(i-z)
else:
for k in range(start,i):
A[k]=p
start=i
d=10**10
p=A[i]
z=i
else:
x=A[i]-A[i-1]
if(x==d):
continue
else:
z=i
start=i
p=A[i]
d=10**10
if(A[-1]==-1):
for k in range(start,n):
A[k]=10
d=A[1]-A[0]
ans=1
i=2
while(i<n):
if(A[i]-A[i-1]==d):
i+=1
continue
else:
ans+=1
if(i==n-1):
break
i+=1
d=A[i]-A[i-1]
i+=1
print(ans)
```
No
| 58,376 | [
0.362060546875,
0.420166015625,
0.30517578125,
0.0191650390625,
-0.3544921875,
-0.06201171875,
-0.5478515625,
-0.056396484375,
0.154296875,
0.77490234375,
0.6435546875,
-0.375732421875,
-0.002460479736328125,
-0.8671875,
-0.6533203125,
-0.16162109375,
-0.83984375,
-0.9423828125,
... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp analyzes the prices of the new berPhone. At his disposal are the prices for n last days: a_1, a_2, ..., a_n, where a_i is the price of berPhone on the day i.
Polycarp considers the price on the day i to be bad if later (that is, a day with a greater number) berPhone was sold at a lower price. For example, if n=6 and a=[3, 9, 4, 6, 7, 5], then the number of days with a bad price is 3 — these are days 2 (a_2=9), 4 (a_4=6) and 5 (a_5=7).
Print the number of days with a bad price.
You have to answer t independent data sets.
Input
The first line contains an integer t (1 ≤ t ≤ 10000) — the number of sets of input data in the test. Input data sets must be processed independently, one after another.
Each input data set consists of two lines. The first line contains an integer n (1 ≤ n ≤ 150000) — the number of days. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^6), where a_i is the price on the i-th day.
It is guaranteed that the sum of n over all data sets in the test does not exceed 150000.
Output
Print t integers, the j-th of which should be equal to the number of days with a bad price in the j-th input data set.
Example
Input
5
6
3 9 4 6 7 5
1
1000000
2
2 1
10
31 41 59 26 53 58 97 93 23 84
7
3 2 1 2 3 4 5
Output
3
0
1
8
2
Tags: data structures, implementation
Correct Solution:
```
# Sourav
from sys import stdin
def solve(n,arr):
k,ctr = 9999999999,0
for j in range(n):
k = min (k,arr[n-j-1])
if(k < arr[n-j-1]):
ctr += 1
return ctr
t = int(stdin.readline().rstrip())
for i in range(t):
n = int(stdin.readline().rstrip())
arr = [int(x) for x in stdin.readline().rstrip().split()]
print(solve(n,arr))
```
| 58,914 | [
0.2337646484375,
0.276611328125,
0.0950927734375,
0.1943359375,
0.0294952392578125,
-0.41064453125,
-0.2135009765625,
0.0186920166015625,
0.437255859375,
0.84619140625,
0.76513671875,
0.1405029296875,
0.006015777587890625,
-0.74755859375,
-0.755859375,
-0.2203369140625,
-0.6333007812... | 24 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.