message stringlengths 2 39.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 219 108k | cluster float64 11 11 | __index_level_0__ int64 438 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
from collections import defaultdict
from heapq import heapify, heappop, heappush
def solve():
n, s, y = map(int, input().split())
a = input().split()
d = defaultdict(list)
for i, x in enumerate(a):
d[x].append(i)
for i in range(1, n + 2):
e = str(i)
if e not in d:
break
q = [(-len(d[x]), x) for x in d.keys()]
heapify(q)
ans = [0] * n
for i in range(s):
l, x = heappop(q)
ans[d[x].pop()] = x
l += 1
if l:
heappush(q, (l, x))
p = []
while q:
l, x = heappop(q)
p.extend(d[x])
if p:
h = (n - s) // 2
y = n - y
q = p[h:] + p[:h]
for x, z in zip(p, q):
if a[x] == a[z]:
if y:ans[x] = e;y -= 1
else:print("NO");return
else:ans[x] = a[z]
for i in range(n - s):
if y and ans[p[i]] != e:ans[p[i]] = e;y -= 1
print("YES");print(' '.join(ans))
for t in range(int(input())):solve()
``` | instruction | 0 | 70,907 | 11 | 141,814 |
Yes | output | 1 | 70,907 | 11 | 141,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
from collections import defaultdict
from heapq import heapify, heappop, heappush
def solve():
n, s, y = map(int, input().split())
a = input().split()
d = defaultdict(list)
for i, x in enumerate(a):
d[x].append(i)
for i in range(1, n + 2):
e = str(i)
if e not in d:break
q = [(-len(d[x]), x) for x in d.keys()]
heapify(q)
ans,p = [0] * n,[]
for i in range(s):
l, x = heappop(q);ans[d[x].pop()] = x;l += 1
if l:heappush(q, (l, x))
while q:l, x = heappop(q);p.extend(d[x])
if p:
h = (n - s) // 2;y = n - y;q = p[h:] + p[:h]
for x, z in zip(p, q):
if a[x] == a[z]:
if y:ans[x] = e;y -= 1
else:print("NO");return
else:ans[x] = a[z]
for i in range(n - s):
if y and ans[p[i]] != e:ans[p[i]] = e;y -= 1
print("YES");print(' '.join(ans))
for t in range(int(input())):solve()
``` | instruction | 0 | 70,908 | 11 | 141,816 |
Yes | output | 1 | 70,908 | 11 | 141,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
import collections
t = int(input())
for _ in range(t):
# print('time', _)
n, x, y = map(int, input().split())
b = [int(i) for i in input().split()]
if t == 1000 and _ != 39:
continue
if t == 1000:
print(n, x, y)
print(b)
if x == n:
print("YES")
for i in b:
print(b, end = '')
print()
continue
setB = set(b)
noin = 1
while noin in setB:
noin += 1
cnt = collections.deque([i, j] for i, j in collections.Counter(b).most_common())
cnt2 = collections.deque()
pos = [set() for _ in range(n + 2)]
for i in range(len(b)):
pos[b[i]].add(i)
res=[-1] * n
l = x
while l > 0:
i = cnt.popleft()
i[1] -= 1
if i[1] != 0:
cnt2.appendleft(i)
while not cnt or cnt2 and cnt2[0][1] >= cnt[0][1]:
cnt.appendleft(cnt2.popleft())
p = pos[i[0]].pop()
res[p] = i[0]
l -= 1
ml = cnt[0][1]
remain = []
while cnt:
i, j = cnt.popleft()
remain += [i] * j
while cnt2:
i, j =cnt2.popleft()
remain += [i] * j
if y - x > (len(remain) - ml) * 2 :
print('No')
continue
i = 0
match = [0] * len(remain)
for i in range(ml, ml + y - x):
match[i % len(remain)] = remain[(i + ml) % len(remain)]
for i in range(ml + y - x, ml + len(remain)):
match[i % len(remain)] = noin
# print(match, remain)
for i in range(len(match)):
p = pos[remain[i]].pop()
res[p] = match[i]
if l == 0:
print("YES")
for i in res:
print(i, end=' ')
print()
else:
print("No")
``` | instruction | 0 | 70,909 | 11 | 141,818 |
No | output | 1 | 70,909 | 11 | 141,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
import collections
t = int(input())
for _ in range(t):
# print('time', _)
n, x, y = map(int, input().split())
b = [int(i) for i in input().split()]
if x == n:
print("YES")
for i in b:
print(i, end = '')
print()
continue
setB = set(b)
noin = 1
while noin in setB:
noin += 1
cnt = collections.deque([i, j] for i, j in collections.Counter(b).most_common())
cnt2 = collections.deque()
pos = [set() for _ in range(n + 2)]
for i in range(len(b)):
pos[b[i]].add(i)
res=[-1] * n
l = x
while l > 0:
i = cnt.popleft()
i[1] -= 1
if i[1] != 0:
cnt2.appendleft(i)
while not cnt or cnt2 and cnt2[0][1] >= cnt[0][1]:
cnt.appendleft(cnt2.popleft())
p = pos[i[0]].pop()
res[p] = i[0]
l -= 1
ml = cnt[0][1]
remain = []
while cnt:
i, j = cnt.popleft()
remain += [i] * j
while cnt2:
i, j =cnt2.popleft()
remain += [i] * j
if y - x > (len(remain) - ml) * 2 :
print('No')
continue
i = 0
match = [0] * len(remain)
for i in range(ml, ml + y - x):
match[i % len(remain)] = remain[(i + ml) % len(remain)]
for i in range(ml + y - x, ml + len(remain)):
match[i % len(remain)] = noin
# print(match, remain)
for i in range(len(match)):
p = pos[remain[i]].pop()
res[p] = match[i]
if l == 0:
print("YES")
for i in res:
print(i, end=' ')
print()
else:
print("No")
``` | instruction | 0 | 70,910 | 11 | 141,820 |
No | output | 1 | 70,910 | 11 | 141,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
import collections
t = int(input())
for _ in range(t):
# print('time', _)
n, x, y = map(int, input().split())
b = [int(i) for i in input().split()]
if x == n:
print("YES")
for i in b:
print(b, end = '')
print()
continue
setB = set(b)
noin = 1
while noin in setB:
noin += 1
cnt = collections.deque([i, j] for i, j in collections.Counter(b).most_common())
cnt2 = collections.deque()
pos = [set() for _ in range(n + 2)]
for i in range(len(b)):
pos[b[i]].add(i)
res=[-1] * n
l = x
while l > 0:
i = cnt.popleft()
i[1] -= 1
if i[1] != 0:
cnt2.appendleft(i)
while not cnt or cnt2 and cnt2[0][1] >= cnt[0][1]:
cnt.appendleft(cnt2.popleft())
p = pos[i[0]].pop()
res[p] = i[0]
l -= 1
ml = cnt[0][1]
remain = []
while cnt:
i, j = cnt.popleft()
remain += [i] * j
while cnt2:
i, j =cnt2.popleft()
remain += [i] * j
if y - x > (len(remain) - ml) * 2:
print('No')
continue
i = 0
match = [0] * len(remain)
for i in range(ml, ml + y - x):
match[i % len(remain)] = remain[(i + ml) % len(remain)]
for i in range(ml + y - x, ml + len(remain)):
match[i % len(remain)] = noin
# print(match, remain)
for i in range(len(match)):
p = pos[remain[i]].pop()
res[p] = match[i]
if l == 0:
print("YES")
for i in res:
print(i, end=' ')
print()
else:
print("No")
``` | instruction | 0 | 70,911 | 11 | 141,822 |
No | output | 1 | 70,911 | 11 | 141,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.
When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.
The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.
For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.
<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines.
You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.
The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).
If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.
If there are multiple solutions, output any.
Example
Input
7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1
Output
YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1
Note
The first test case is described in the statement.
In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.
In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.
In the fourth test case, it can be proved that no solution exists.
Submitted Solution:
```
from collections import defaultdict
import heapq
T = int(input())
for _ in range(T):
N, X, Y = [int(x) for x in input().split(' ')]
b = [(i, int(x)) for i, x in enumerate(input().split(' '))]
freq = defaultdict(int)
for _, x in b:
freq[x] += 1
b.sort(key=lambda x: (x[1], x[0]))
heap = [(-y, x) for x, y in freq.items()]
heapq.heapify(heap)
c = []
for _ in range(X):
x, y = heapq.heappop(heap)
c.append(y)
if x != 0:
heapq.heappush(heap, (x+1, y))
d = []
for x, y in heap:
for _ in range(-x):
d.append(y)
d.sort()
freq = defaultdict(int)
for x in d:
freq[x] += 1
rot = max(freq.values())
c += d[-rot:] + d[:-rot]
unused = list(set(range(1, N+2)) - set(c))[0]
for i in range(X, N-Y+X):
c[i] = unused
#print(b)
#print(c)
#print()
bad = False
for i in range(N-Y+X, N):
if c[i] == b[i][1]:
print('NO')
bad = True
break
if not bad:
print('YES')
a = [0 for _ in range(N)]
for i, x in enumerate(c):
a[b[i][0]] = x
print(' '.join(str(x) for x in a))
``` | instruction | 0 | 70,912 | 11 | 141,824 |
No | output | 1 | 70,912 | 11 | 141,825 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha | instruction | 0 | 71,151 | 11 | 142,302 |
Tags: implementation
Correct Solution:
```
a, b, c, d = map(int, input().split())
m = max(3 * a // 10, a - a // 250 * c)
v = max(3 * b // 10, b - b // 250 * d)
print("Tie" if m == v else "Misha" if m > v else "Vasya")
``` | output | 1 | 71,151 | 11 | 142,303 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha | instruction | 0 | 71,152 | 11 | 142,304 |
Tags: implementation
Correct Solution:
```
a,b,c,d=map(int,input().split())
if max((3*a)/10,a-(a//250)*c)>max((3*b)/10,b-(b//250)*d):
print("Misha")
elif max((3*a)/10,a-(a//250)*c)<max((3*b)/10,b-(b//250)*d):
print("Vasya")
else:
print("Tie")
``` | output | 1 | 71,152 | 11 | 142,305 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha | instruction | 0 | 71,153 | 11 | 142,306 |
Tags: implementation
Correct Solution:
```
arr = list(map(int, input().split()))
misha = max(3*arr[0]/10, arr[0] - arr[0]*arr[2]/250)
vasya = max(3*arr[1]/10, arr[1] - arr[1]*arr[3]/250)
if misha == vasya:
print("Tie")
elif misha < vasya:
print("Vasya")
else:
print("Misha")
``` | output | 1 | 71,153 | 11 | 142,307 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha | instruction | 0 | 71,154 | 11 | 142,308 |
Tags: implementation
Correct Solution:
```
m,v,tm,tv = map(int,input().split())
bm = max(3*m/10,m - m/250*tm)
bv = max(3*v/10,v - v/250*tv)
if bm == bv:
print("Tie")
elif bm >= bv:
print("Misha")
else:
print("Vasya")
``` | output | 1 | 71,154 | 11 | 142,309 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha | instruction | 0 | 71,155 | 11 | 142,310 |
Tags: implementation
Correct Solution:
```
z=list(map(int,input().split()))
vanya=0
misha=0
misha=max((3*z[0]/10),(z[0]-(z[0]/250)*z[2]))
vanya=max((3*z[1]/10),(z[1]-(z[1]/250)*z[3]))
if misha==vanya :
print("Tie")
elif misha < vanya :
print("Vasya")
else :
print("Misha")
``` | output | 1 | 71,155 | 11 | 142,311 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha | instruction | 0 | 71,156 | 11 | 142,312 |
Tags: implementation
Correct Solution:
```
a,b,c,d=map(int,input().split())
m=max(((a//10)*3),(a-(a*c)//250))
v=max(((b//10)*3),(b-(b*d)//250))
if m>v:
print('Misha')
elif m<v:
print('Vasya')
else:
print('Tie')
``` | output | 1 | 71,156 | 11 | 142,313 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha | instruction | 0 | 71,157 | 11 | 142,314 |
Tags: implementation
Correct Solution:
```
a, b, c, d = map(int,input().split())
m = max((3 * a)/10, a-(a/250) * c)
v = max((3 * b)/10, b-(b/250) * d)
if m > v:
print("Misha")
elif m < v:
print("Vasya")
else:
print("Tie")
``` | output | 1 | 71,157 | 11 | 142,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha | instruction | 0 | 71,158 | 11 | 142,316 |
Tags: implementation
Correct Solution:
```
def point(p,t):
return max(3*p/10,p-p/250*t)
a,b,c,d = map(int,input().split())
mi = point(a,c)
va = point(b,d)
if mi > va:
print("Misha")
elif va > mi:
print("Vasya")
else:
print("Tie")
``` | output | 1 | 71,158 | 11 | 142,317 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
# Author : code_marshal
# cmp is not available in python 3.x
a,b,c,d=map(int,raw_input().split())
ch=cmp(max(a*3//10,a-a*c//250),max(b*3//10,b-b*d//250))
if not ch:print "Tie"
elif ch==1:print "Misha"
else:print "Vasya"
``` | instruction | 0 | 71,159 | 11 | 142,318 |
Yes | output | 1 | 71,159 | 11 | 142,319 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a,b,c,d=map(int,input().split())
f=lambda p,t:max(3*p/10,p-p/250*t)
df=f(a,c)-f(b,d)
print('Vasya' if df<0 else ['Tie', 'Misha'][df>0])
``` | instruction | 0 | 71,160 | 11 | 142,320 |
Yes | output | 1 | 71,160 | 11 | 142,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a,b,c,d=list(map(int,input().split()))
t=max((3*a)//10,a-(a//250)*c)
p=max((3*b)//10,b-(b//250)*d)
if t>p:
print("Misha")
elif t==p:
print("Tie")
else:
print("Vasya")
``` | instruction | 0 | 71,161 | 11 | 142,322 |
Yes | output | 1 | 71,161 | 11 | 142,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
import sys
import math
a, b, c, d = [int(x) for x in (sys.stdin.readline()).split()]
vmax1 = max(3 * a / 10, a - a / 250 * c)
vmax2 = max(3 * b / 10, b - b / 250 * d)
if(vmax1 > vmax2):
print("Misha")
elif(vmax1 < vmax2):
print("Vasya")
else:
print("Tie")
``` | instruction | 0 | 71,162 | 11 | 142,324 |
Yes | output | 1 | 71,162 | 11 | 142,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a, b, c, d = map(int, input().split())
m = max(3 * a // 10, a - c * a // 250)
v = max(3 * b // 10, b - d * b // 250)
if m > v:
print('Misha')
elif v > m:
print('Vasya')
else:
print('Tie')
``` | instruction | 0 | 71,163 | 11 | 142,326 |
Yes | output | 1 | 71,163 | 11 | 142,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a,b,c,d = [int(item) for item in input().split()]
x = max(3*a/10 , (a-(a*c/250)))
y = max(3*b/10 , (b-(b*c/250)))
if x>y:
print("Misha")
elif x<y:
print("Vasya")
else:
print("Tie")
``` | instruction | 0 | 71,164 | 11 | 142,328 |
No | output | 1 | 71,164 | 11 | 142,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a, b, c, d = map(int, input().split())
x = max(a / 10, a - (a / 250) * c)
y = max(b / 10, b - (b / 250) * d)
if x < y:
print('Misha')
elif y < x:
print('Vasya')
else: print('Tie')
``` | instruction | 0 | 71,165 | 11 | 142,330 |
No | output | 1 | 71,165 | 11 | 142,331 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a,b,c,d=list(map(int,input().split()))
if(a==b and c==d):
print("Tie")
elif(a==b and c>d):
print("Misha")
else:
if((a-b)%250==0 and a>b):
print("Misha")
else:
print("Vasya")
``` | instruction | 0 | 71,166 | 11 | 142,332 |
No | output | 1 | 71,166 | 11 | 142,333 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Misha and Vasya participated in a Codeforces contest. Unfortunately, each of them solved only one problem, though successfully submitted it at the first attempt. Misha solved the problem that costs a points and Vasya solved the problem that costs b points. Besides, Misha submitted the problem c minutes after the contest started and Vasya submitted the problem d minutes after the contest started. As you know, on Codeforces the cost of a problem reduces as a round continues. That is, if you submit a problem that costs p points t minutes after the contest started, you get <image> points.
Misha and Vasya are having an argument trying to find out who got more points. Help them to find out the truth.
Input
The first line contains four integers a, b, c, d (250 ≤ a, b ≤ 3500, 0 ≤ c, d ≤ 180).
It is guaranteed that numbers a and b are divisible by 250 (just like on any real Codeforces round).
Output
Output on a single line:
"Misha" (without the quotes), if Misha got more points than Vasya.
"Vasya" (without the quotes), if Vasya got more points than Misha.
"Tie" (without the quotes), if both of them got the same number of points.
Examples
Input
500 1000 20 30
Output
Vasya
Input
1000 1000 1 1
Output
Tie
Input
1500 1000 176 177
Output
Misha
Submitted Solution:
```
a,b,c,d=map(int,input().split())
p1=max(3*a/10,a*c/250)
p2=max(3*b/10,b*d/250)
if p1>p2:
print("Misha")
elif p1<p2:
print("Vasya")
else:
print("Tie")
``` | instruction | 0 | 71,167 | 11 | 142,334 |
No | output | 1 | 71,167 | 11 | 142,335 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
Alice and Bob are competing in the 50m dash.
However, in this world, the higher the AOJ rate is, the better, so the higher the AOJ rate wins.
If there is no AOJ rate on either side, there is no comparison, so there is no choice but to compete in the 50m sprint time. In this case, the one with the shorter time wins.
If the AOJ rates are the same, it is a draw, and if you have to compete in the 50m time, it is a draw if the times are the same.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq T_1, T_2 \ lt 100 $
* $ -1 \ leq R_1, R_2 \ lt 2850 $
* All inputs are integers
Input
The input is given in the following format.
$ T_1 $ $ T_2 $ $ R_1 $ $ R_2 $
Each element is given separated by blanks.
$ T_1 and T_2 $ represent the time of Alice and Bob's 50m run, respectively, and $ R_1 and R_2 $ represent the rates of Alice and Bob's AOJ, respectively.
However, $ R_1 = -1 $ indicates that there is no Alice rate, and $ R_2 = -1 $ indicates that there is no Bob rate.
Output
Print "Alice" if Alice wins, "Bob" if Bob wins, and "Draw" if it's a draw on the $ 1 $ line.
Examples
Input
9 8 1000 999
Output
Alice
Input
9 8 1000 1000
Output
Draw
Input
9 8 2849 -1
Output
Bob | instruction | 0 | 71,594 | 11 | 143,188 |
"Correct Solution:
```
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
T1, T2, R1, R2 = LI()
if (R1 == -1 or R2 == -1) :
if (T1 < T2):
print("Alice")
elif (T2 < T1) :
print("Bob")
else :
print("Draw")
else :
if (R1 > R2):
print("Alice")
elif (R2 > R1) :
print("Bob")
else :
print("Draw")
return
if __name__ == "__main__":
solve()
``` | output | 1 | 71,594 | 11 | 143,189 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced. | instruction | 0 | 71,640 | 11 | 143,280 |
Tags: implementation
Correct Solution:
```
input()
print('EASY' if set(input().split())=={'0'} else 'HARD')
``` | output | 1 | 71,640 | 11 | 143,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced. | instruction | 0 | 71,641 | 11 | 143,282 |
Tags: implementation
Correct Solution:
```
n = int(input())
s = input()
if s.count('1') == 0:
print('EASY')
else:
print('HARD')
``` | output | 1 | 71,641 | 11 | 143,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced. | instruction | 0 | 71,642 | 11 | 143,284 |
Tags: implementation
Correct Solution:
```
a=input()
a=input().split()
b=False
i=0
while i<len(a):
if a[i]=='1':
print ('Hard')
b=True
break
i+=1
if not b:
print ('Easy')
``` | output | 1 | 71,642 | 11 | 143,285 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced. | instruction | 0 | 71,643 | 11 | 143,286 |
Tags: implementation
Correct Solution:
```
b=int(input())
x=input()
m=x.split(' ')
n=[ ]
hard=0
for i in m:
n.append(int(i))
for i in n:
if i==1:
hard+=1
if hard>0:
print("HARD")
else:
print("EASY")
``` | output | 1 | 71,643 | 11 | 143,287 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced. | instruction | 0 | 71,644 | 11 | 143,288 |
Tags: implementation
Correct Solution:
```
blah = int(input(''))
bloo = input('').strip()
if '1' in bloo:
print('HARD')
else:
print('EASY')
``` | output | 1 | 71,644 | 11 | 143,289 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced. | instruction | 0 | 71,645 | 11 | 143,290 |
Tags: implementation
Correct Solution:
```
n = int(input())
S=[0]*n
sum = 0
S=map(int, input().split())
S=list(S)
for i in range(0, n):
sum+=S[i]
if sum == 0:
print("EASY")
else:
print("HARD")
``` | output | 1 | 71,645 | 11 | 143,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced. | instruction | 0 | 71,646 | 11 | 143,292 |
Tags: implementation
Correct Solution:
```
n = int(input())
A = list(map(int,input().split()))
flag = 0
for i in range(len(A)):
if A[i] == 1:
print('HARD')
flag += 1
break
if flag == 0:
print('EASY')
``` | output | 1 | 71,646 | 11 | 143,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced. | instruction | 0 | 71,647 | 11 | 143,294 |
Tags: implementation
Correct Solution:
```
n = int(input())
x = input()
x = x.split(" ")
k = 0
for i in x:
if i == "1":
k += 1
if k >= 1:
print("HARD")
else:
print("EASY")
``` | output | 1 | 71,647 | 11 | 143,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
a=int(input())
x=[int(num) for num in input().split()]
r=sum(x)
if r>0:
print('HARD')
else:
print('EASY')
``` | instruction | 0 | 71,648 | 11 | 143,296 |
Yes | output | 1 | 71,648 | 11 | 143,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
if(sum(l)>0):
print('HARD')
else:
print('EASY')
``` | instruction | 0 | 71,649 | 11 | 143,298 |
Yes | output | 1 | 71,649 | 11 | 143,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n = int(input())
lis = map(int, input().split(" "))
lis = list(filter(lambda x: x,lis))
if len(lis) > 0:
print("HARD")
else:
print("EASY")
``` | instruction | 0 | 71,650 | 11 | 143,300 |
Yes | output | 1 | 71,650 | 11 | 143,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n = int(input())
k = [int(i) for i in input().split()]
if 1 in k:
print('HARD')
else:
print('EASY')
``` | instruction | 0 | 71,651 | 11 | 143,302 |
Yes | output | 1 | 71,651 | 11 | 143,303 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n=4
arr=[0,1,0,]
if(max(arr)==0):
print("easy")
else:
print("hard")
``` | instruction | 0 | 71,652 | 11 | 143,304 |
No | output | 1 | 71,652 | 11 | 143,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n = int(input())
lis = [int(i) for i in input().split()]
count = 0
for i in range(n):
if(lis[i] == 1):
count = count + 1
if(count == 1):
print("HARD");
else:
print("EASY");
``` | instruction | 0 | 71,653 | 11 | 143,306 |
No | output | 1 | 71,653 | 11 | 143,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
n=int(input())
lt=list(map(int,input().split()))
if 1 in lt:
print("HARD")
``` | instruction | 0 | 71,654 | 11 | 143,308 |
No | output | 1 | 71,654 | 11 | 143,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
When preparing a tournament, Codeforces coordinators try treir best to make the first problem as easy as possible. This time the coordinator had chosen some problem and asked n people about their opinions. Each person answered whether this problem is easy or hard.
If at least one of these n people has answered that the problem is hard, the coordinator decides to change the problem. For the given responses, check if the problem is easy enough.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — the number of people who were asked to give their opinions.
The second line contains n integers, each integer is either 0 or 1. If i-th integer is 0, then i-th person thinks that the problem is easy; if it is 1, then i-th person thinks that the problem is hard.
Output
Print one word: "EASY" if the problem is easy according to all responses, or "HARD" if there is at least one person who thinks the problem is hard.
You may print every letter in any register: "EASY", "easy", "EaSY" and "eAsY" all will be processed correctly.
Examples
Input
3
0 0 1
Output
HARD
Input
1
0
Output
EASY
Note
In the first example the third person says it's a hard problem, so it should be replaced.
In the second example the problem easy for the only person, so it doesn't have to be replaced.
Submitted Solution:
```
persone = input()
verdetto_persone = input().split(" ")
print(verdetto_persone)
for persona in verdetto_persone:
if persona == "1":
print("HARD")
break
``` | instruction | 0 | 71,655 | 11 | 143,310 |
No | output | 1 | 71,655 | 11 | 143,311 |
Provide tags and a correct Python 3 solution for this coding contest problem.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3 | instruction | 0 | 71,776 | 11 | 143,552 |
Tags: binary search, math, meet-in-the-middle, number theory
Correct Solution:
```
# https://codeforces.com/contest/1263/problem/C
t = int(input())
for i in range(t):
ans = 0
n = int(input())
s = set([0])
ans = [0]
i = n
while i > 0:
tmp = n // i
if tmp not in s:
s.add(tmp)
ans.append(tmp)
i = min(n//(tmp+1), i-1)
print(len(ans))
print(*ans)
``` | output | 1 | 71,776 | 11 | 143,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
ret = {0}
d = 1
while d * d <= n:
ret.update((n // d, d))
d += 1
print('%d\n%s' % (len(ret), ' '.join(map(str, sorted(ret)))))
``` | instruction | 0 | 71,778 | 11 | 143,556 |
Yes | output | 1 | 71,778 | 11 | 143,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
import math
t = int(input())
for _ in range(t):
n = int(input())
s = set()
s.add(0)
limit = math.ceil(math.sqrt(n))
for i in range(1,limit+10):
tmp = len(s)
s.add(n // i)
if len(s) > tmp:
s.add(i)
s = sorted(list(s))
print(len(s))
print(*s)
``` | instruction | 0 | 71,779 | 11 | 143,558 |
Yes | output | 1 | 71,779 | 11 | 143,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
x=set()
for i in range(1,int(n**0.5)+1):
x.add(n//i)
x.add(i)
x.add(0)
print(len(x))
print(" ".join(map(str,sorted(x))))
``` | instruction | 0 | 71,780 | 11 | 143,560 |
Yes | output | 1 | 71,780 | 11 | 143,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
di = {}
for _ in range(int(input())):
n = int(input())
if n in di:
print(di[n][0])
print(di[n][1])
continue
s1 = set()
s1.add(1)
s1.add(n)
s1.add(0)
min = n
i = 2
while i <= min:
next = n//i
min = next
s1.add(next)
if n//next == i:
s1.add(i)
i += 1
s = ""
ans = " ".join(str(k) for k in sorted(list(s1)))
print(len(s1))
print(ans)
di[n] = [len(s1), ans]
``` | instruction | 0 | 71,781 | 11 | 143,562 |
Yes | output | 1 | 71,781 | 11 | 143,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
import math
t = int(input())
while(t!=0):
n = int(input())
k = n + 1
a = [0]
b = []
for i in range(1, (int)(n**0.5 )+1 ) :
a.append(i)
if(i != n//i):
b.append(n//i)
a = a + b
print(len(a))
print(*a)
t -= 1
``` | instruction | 0 | 71,782 | 11 | 143,564 |
No | output | 1 | 71,782 | 11 | 143,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
T = int(input())
for t in range(T):
N = int(input())
V = {0}
def look(l, u, f = 0, i = 0):
#print(' ' * i, l, u, f)
m = (l + u) // 2
if u != l:
t = N // m
if t in V:
if f: look(l, m, 0, i+1)
else: look(m+1, u, 1, i+1)
else:
V.add(t)
look(l, m, 0, i + 1)
look(m+1, u, 1, i + 1)
look(1, N+1)
print(len(V))
print(*sorted(V))
``` | instruction | 0 | 71,783 | 11 | 143,566 |
No | output | 1 | 71,783 | 11 | 143,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
from math import floor
T=int(input())
for _ in range(T):
n=int(input())
i=1;s=set();s.add(0);d={};s.add(1)
while True:
k=n//i
if d.get(k,0)>0:break
s.add(k);d[k]=1
i+=1
for j in range(n//2,i,-2):
s.add(n//j)
ans=list(s)
print(len(ans))
print(*sorted(ans))
``` | instruction | 0 | 71,784 | 11 | 143,568 |
No | output | 1 | 71,784 | 11 | 143,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On the well-known testing system MathForces, a draw of n rating units is arranged. The rating will be distributed according to the following algorithm: if k participants take part in this event, then the n rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.
For example, if n = 5 and k = 3, then each participant will recieve an 1 rating unit, and also 2 rating units will remain unused. If n = 5, and k = 6, then none of the participants will increase their rating.
Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.
For example, if n=5, then the answer is equal to the sequence 0, 1, 2, 5. Each of the sequence values (and only them) can be obtained as ⌊ n/k ⌋ for some positive integer k (where ⌊ x ⌋ is the value of x rounded down): 0 = ⌊ 5/7 ⌋, 1 = ⌊ 5/5 ⌋, 2 = ⌊ 5/2 ⌋, 5 = ⌊ 5/1 ⌋.
Write a program that, for a given n, finds a sequence of all possible rating increments.
Input
The first line contains integer number t (1 ≤ t ≤ 10) — the number of test cases in the input. Then t test cases follow.
Each line contains an integer n (1 ≤ n ≤ 10^9) — the total number of the rating units being drawn.
Output
Output the answers for each of t test cases. Each answer should be contained in two lines.
In the first line print a single integer m — the number of different rating increment values that Vasya can get.
In the following line print m integers in ascending order — the values of possible rating increments.
Example
Input
4
5
11
1
3
Output
4
0 1 2 5
6
0 1 2 3 5 11
2
0 1
3
0 1 3
Submitted Solution:
```
import os
import sys
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")
##########################################################
# from collections import Counter
for i in range(int(input())):
n=int(input())
#ans=[0,1,n]
#if n//2>1:
#ans.append(2)
'''l=1
r=n
while l<=r:
mid=(l+r)//2
if n//mid>1:
l=mid+1
else:
r=mid-1
val=l'''
ans=set()
for i in range(1,n+1):
if n//i<=1:
break
ans.add(n//i)
ans.add(0)
ans.add(n)
print(len(ans))
print(*sorted(ans))
``` | instruction | 0 | 71,785 | 11 | 143,570 |
No | output | 1 | 71,785 | 11 | 143,571 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A boy Valera registered on site Codeforces as Valera, and wrote his first Codeforces Round #300. He boasted to a friend Arkady about winning as much as x points for his first contest. But Arkady did not believe his friend's words and decided to check whether Valera could have shown such a result.
He knows that the contest number 300 was unusual because there were only two problems. The contest lasted for t minutes, the minutes are numbered starting from zero. The first problem had the initial cost of a points, and every minute its cost reduced by da points. The second problem had the initial cost of b points, and every minute this cost reduced by db points. Thus, as soon as the zero minute of the contest is over, the first problem will cost a - da points, and the second problem will cost b - db points. It is guaranteed that at any moment of the contest each problem has a non-negative cost.
Arkady asks you to find out whether Valera could have got exactly x points for this contest. You should assume that Valera could have solved any number of the offered problems. You should also assume that for each problem Valera made no more than one attempt, besides, he could have submitted both problems at the same minute of the contest, starting with minute 0 and ending with minute number t - 1. Please note that Valera can't submit a solution exactly t minutes after the start of the contest or later.
Input
The single line of the input contains six integers x, t, a, b, da, db (0 ≤ x ≤ 600; 1 ≤ t, a, b, da, db ≤ 300) — Valera's result, the contest's duration, the initial cost of the first problem, the initial cost of the second problem, the number of points that the first and the second problem lose per minute, correspondingly.
It is guaranteed that at each minute of the contest each problem has a non-negative cost, that is, a - i·da ≥ 0 and b - i·db ≥ 0 for all 0 ≤ i ≤ t - 1.
Output
If Valera could have earned exactly x points at a contest, print "YES", otherwise print "NO" (without the quotes).
Examples
Input
30 5 20 20 3 5
Output
YES
Input
10 4 100 5 5 1
Output
NO
Note
In the first sample Valera could have acted like this: he could have submitted the first problem at minute 0 and the second problem — at minute 2. Then the first problem brings him 20 points and the second problem brings him 10 points, that in total gives the required 30 points. | instruction | 0 | 71,935 | 11 | 143,870 |
Tags: brute force, implementation
Correct Solution:
```
x, t, a, b, da, db = map(int, input().split())
A, B = [0] + [a - da * i for i in range(t)], set([0] + [b - db * i for i in range(t)])
print('YES' if any(x - i in B for i in A) else 'NO')
``` | output | 1 | 71,935 | 11 | 143,871 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.