message stringlengths 2 20.1k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 1.95k 109k | cluster float64 17 17 | __index_level_0__ int64 3.91k 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Two semifinals have just been in the running tournament. Each semifinal had n participants. There are n participants advancing to the finals, they are chosen as follows: from each semifinal, we choose k people (0 ≤ 2k ≤ n) who showed the best result in their semifinals and all other places in the finals go to the people who haven't ranked in the top k in their semifinal but got to the n - 2k of the best among the others.
The tournament organizers hasn't yet determined the k value, so the participants want to know who else has any chance to get to the finals and who can go home.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of participants in each semifinal.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109) — the results of the i-th participant (the number of milliseconds he needs to cover the semifinals distance) of the first and second semifinals, correspondingly. All results are distinct. Sequences a1, a2, ..., an and b1, b2, ..., bn are sorted in ascending order, i.e. in the order the participants finished in the corresponding semifinal.
Output
Print two strings consisting of n characters, each equals either "0" or "1". The first line should correspond to the participants of the first semifinal, the second line should correspond to the participants of the second semifinal. The i-th character in the j-th line should equal "1" if the i-th participant of the j-th semifinal has any chances to advance to the finals, otherwise it should equal a "0".
Examples
Input
4
9840 9920
9860 9980
9930 10020
10040 10090
Output
1110
1100
Input
4
9900 9850
9940 9930
10000 10020
10060 10110
Output
1100
1100
Note
Consider the first sample. Each semifinal has 4 participants. The results of the first semifinal are 9840, 9860, 9930, 10040. The results of the second semifinal are 9920, 9980, 10020, 10090.
* If k = 0, the finalists are determined by the time only, so players 9840, 9860, 9920 and 9930 advance to the finals.
* If k = 1, the winners from both semifinals move to the finals (with results 9840 and 9920), and the other places are determined by the time (these places go to the sportsmen who run the distance in 9860 and 9930 milliseconds).
* If k = 2, then first and second places advance from each seminfial, these are participants with results 9840, 9860, 9920 and 9980 milliseconds. | instruction | 0 | 89,625 | 17 | 179,250 |
Tags: implementation, sortings
Correct Solution:
```
n = int(input())
sem1 = []
sem2 = []
l = [0,0]
for cont in range(0,n):
l = list(map(int, input().split()))
sem1.append(l[0])
sem2.append(l[1])
kmax = int(n/2)
max1 = 0
max2 = 0
for cont in range(0,n):
if sem1[max1] < sem2[max2]:
max1 += 1
else:
max2 += 1
ris1 = ['1']*(max([max1,kmax]))
ris2 = ['1']*max([max2,kmax])
ris1 = ris1 + ['0']*(n-len(ris1))
ris2 = ris2 + ['0']*(n-len(ris2))
print(''.join(ris1))
print(''.join(ris2))
``` | output | 1 | 89,625 | 17 | 179,251 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two semifinals have just been in the running tournament. Each semifinal had n participants. There are n participants advancing to the finals, they are chosen as follows: from each semifinal, we choose k people (0 ≤ 2k ≤ n) who showed the best result in their semifinals and all other places in the finals go to the people who haven't ranked in the top k in their semifinal but got to the n - 2k of the best among the others.
The tournament organizers hasn't yet determined the k value, so the participants want to know who else has any chance to get to the finals and who can go home.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of participants in each semifinal.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109) — the results of the i-th participant (the number of milliseconds he needs to cover the semifinals distance) of the first and second semifinals, correspondingly. All results are distinct. Sequences a1, a2, ..., an and b1, b2, ..., bn are sorted in ascending order, i.e. in the order the participants finished in the corresponding semifinal.
Output
Print two strings consisting of n characters, each equals either "0" or "1". The first line should correspond to the participants of the first semifinal, the second line should correspond to the participants of the second semifinal. The i-th character in the j-th line should equal "1" if the i-th participant of the j-th semifinal has any chances to advance to the finals, otherwise it should equal a "0".
Examples
Input
4
9840 9920
9860 9980
9930 10020
10040 10090
Output
1110
1100
Input
4
9900 9850
9940 9930
10000 10020
10060 10110
Output
1100
1100
Note
Consider the first sample. Each semifinal has 4 participants. The results of the first semifinal are 9840, 9860, 9930, 10040. The results of the second semifinal are 9920, 9980, 10020, 10090.
* If k = 0, the finalists are determined by the time only, so players 9840, 9860, 9920 and 9930 advance to the finals.
* If k = 1, the winners from both semifinals move to the finals (with results 9840 and 9920), and the other places are determined by the time (these places go to the sportsmen who run the distance in 9860 and 9930 milliseconds).
* If k = 2, then first and second places advance from each seminfial, these are participants with results 9840, 9860, 9920 and 9980 milliseconds. | instruction | 0 | 89,626 | 17 | 179,252 |
Tags: implementation, sortings
Correct Solution:
```
n = int(input())
a, b = zip(*(map(int, input().split()) for _ in range(n)))
i = j = 0
while i < n and j < n and i + j < n:
if a[i] < b[j]:
i += 1
else:
j += 1
p = lambda x: ("1" * max(n // 2, x)).ljust(n, "0")
print(p(i))
print(p(j))
``` | output | 1 | 89,626 | 17 | 179,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two semifinals have just been in the running tournament. Each semifinal had n participants. There are n participants advancing to the finals, they are chosen as follows: from each semifinal, we choose k people (0 ≤ 2k ≤ n) who showed the best result in their semifinals and all other places in the finals go to the people who haven't ranked in the top k in their semifinal but got to the n - 2k of the best among the others.
The tournament organizers hasn't yet determined the k value, so the participants want to know who else has any chance to get to the finals and who can go home.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of participants in each semifinal.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109) — the results of the i-th participant (the number of milliseconds he needs to cover the semifinals distance) of the first and second semifinals, correspondingly. All results are distinct. Sequences a1, a2, ..., an and b1, b2, ..., bn are sorted in ascending order, i.e. in the order the participants finished in the corresponding semifinal.
Output
Print two strings consisting of n characters, each equals either "0" or "1". The first line should correspond to the participants of the first semifinal, the second line should correspond to the participants of the second semifinal. The i-th character in the j-th line should equal "1" if the i-th participant of the j-th semifinal has any chances to advance to the finals, otherwise it should equal a "0".
Examples
Input
4
9840 9920
9860 9980
9930 10020
10040 10090
Output
1110
1100
Input
4
9900 9850
9940 9930
10000 10020
10060 10110
Output
1100
1100
Note
Consider the first sample. Each semifinal has 4 participants. The results of the first semifinal are 9840, 9860, 9930, 10040. The results of the second semifinal are 9920, 9980, 10020, 10090.
* If k = 0, the finalists are determined by the time only, so players 9840, 9860, 9920 and 9930 advance to the finals.
* If k = 1, the winners from both semifinals move to the finals (with results 9840 and 9920), and the other places are determined by the time (these places go to the sportsmen who run the distance in 9860 and 9930 milliseconds).
* If k = 2, then first and second places advance from each seminfial, these are participants with results 9840, 9860, 9920 and 9980 milliseconds.
Submitted Solution:
```
# -*- coding: utf-8 -*-
n = int(input())
a, b = [], []
for i in range(n):
x, y = map(int, input().split())
a.append(x)
b.append(y)
p = q = 0
c = 0
while c < n:
if a[p] < b[q]:
#print('{}<{}'.format(a[p], a[q]))
p += 1
else:
#print('{}>{}'.format(a[p], a[q]))
q += 1
c += 1
p0 = max(p, n//2)
print('1'*p0 + '0'*(n-p0))
q0 = max(q, n//2)
print('1'*q0 + '0'*(n-q0))
``` | instruction | 0 | 89,627 | 17 | 179,254 |
Yes | output | 1 | 89,627 | 17 | 179,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two semifinals have just been in the running tournament. Each semifinal had n participants. There are n participants advancing to the finals, they are chosen as follows: from each semifinal, we choose k people (0 ≤ 2k ≤ n) who showed the best result in their semifinals and all other places in the finals go to the people who haven't ranked in the top k in their semifinal but got to the n - 2k of the best among the others.
The tournament organizers hasn't yet determined the k value, so the participants want to know who else has any chance to get to the finals and who can go home.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of participants in each semifinal.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109) — the results of the i-th participant (the number of milliseconds he needs to cover the semifinals distance) of the first and second semifinals, correspondingly. All results are distinct. Sequences a1, a2, ..., an and b1, b2, ..., bn are sorted in ascending order, i.e. in the order the participants finished in the corresponding semifinal.
Output
Print two strings consisting of n characters, each equals either "0" or "1". The first line should correspond to the participants of the first semifinal, the second line should correspond to the participants of the second semifinal. The i-th character in the j-th line should equal "1" if the i-th participant of the j-th semifinal has any chances to advance to the finals, otherwise it should equal a "0".
Examples
Input
4
9840 9920
9860 9980
9930 10020
10040 10090
Output
1110
1100
Input
4
9900 9850
9940 9930
10000 10020
10060 10110
Output
1100
1100
Note
Consider the first sample. Each semifinal has 4 participants. The results of the first semifinal are 9840, 9860, 9930, 10040. The results of the second semifinal are 9920, 9980, 10020, 10090.
* If k = 0, the finalists are determined by the time only, so players 9840, 9860, 9920 and 9930 advance to the finals.
* If k = 1, the winners from both semifinals move to the finals (with results 9840 and 9920), and the other places are determined by the time (these places go to the sportsmen who run the distance in 9860 and 9930 milliseconds).
* If k = 2, then first and second places advance from each seminfial, these are participants with results 9840, 9860, 9920 and 9980 milliseconds.
Submitted Solution:
```
n = int(input())
a = []
b = []
for i in range(n):
x, y = map(int,input().split())
a.append(x)
b.append(y)
x = [0] * n
y = [0] * n
i = 0
j = 0
cnt = 0
while(i < n and j < n):
if a[i] > b[j]:
y[j] = 1
j += 1
cnt += 1
elif a[i] <= b[j]:
x[i] = 1
i += 1
cnt += 1
if cnt == n:
break
for i in range(n // 2):
x[i] = 1
for j in range(n//2):
y[j] = 1
for i in range(n):
print(x[i], end = '')
print()
for j in range(n):
print(y[j], end = '')
``` | instruction | 0 | 89,628 | 17 | 179,256 |
Yes | output | 1 | 89,628 | 17 | 179,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two semifinals have just been in the running tournament. Each semifinal had n participants. There are n participants advancing to the finals, they are chosen as follows: from each semifinal, we choose k people (0 ≤ 2k ≤ n) who showed the best result in their semifinals and all other places in the finals go to the people who haven't ranked in the top k in their semifinal but got to the n - 2k of the best among the others.
The tournament organizers hasn't yet determined the k value, so the participants want to know who else has any chance to get to the finals and who can go home.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of participants in each semifinal.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109) — the results of the i-th participant (the number of milliseconds he needs to cover the semifinals distance) of the first and second semifinals, correspondingly. All results are distinct. Sequences a1, a2, ..., an and b1, b2, ..., bn are sorted in ascending order, i.e. in the order the participants finished in the corresponding semifinal.
Output
Print two strings consisting of n characters, each equals either "0" or "1". The first line should correspond to the participants of the first semifinal, the second line should correspond to the participants of the second semifinal. The i-th character in the j-th line should equal "1" if the i-th participant of the j-th semifinal has any chances to advance to the finals, otherwise it should equal a "0".
Examples
Input
4
9840 9920
9860 9980
9930 10020
10040 10090
Output
1110
1100
Input
4
9900 9850
9940 9930
10000 10020
10060 10110
Output
1100
1100
Note
Consider the first sample. Each semifinal has 4 participants. The results of the first semifinal are 9840, 9860, 9930, 10040. The results of the second semifinal are 9920, 9980, 10020, 10090.
* If k = 0, the finalists are determined by the time only, so players 9840, 9860, 9920 and 9930 advance to the finals.
* If k = 1, the winners from both semifinals move to the finals (with results 9840 and 9920), and the other places are determined by the time (these places go to the sportsmen who run the distance in 9860 and 9930 milliseconds).
* If k = 2, then first and second places advance from each seminfial, these are participants with results 9840, 9860, 9920 and 9980 milliseconds.
Submitted Solution:
```
n = int(input())
team1 = [0 for i in range(n+1)]
team2 = [0 for i in range(n+1)]
for i in range(1, n+1):
line = input().split()
team1[i] = int(line[0])
team2[i] = int(line[1])
for i in range(1, n+1):
if i <= n // 2 or team1[i] < team2[n-i+1]:
print(1, end = '')
else:
print(0, end = '')
print()
for i in range(1, n+1):
if i <= n // 2 or team2[i] < team1[n-i+1]:
print(1, end = '')
else:
print(0, end = '')
print()
``` | instruction | 0 | 89,629 | 17 | 179,258 |
Yes | output | 1 | 89,629 | 17 | 179,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two semifinals have just been in the running tournament. Each semifinal had n participants. There are n participants advancing to the finals, they are chosen as follows: from each semifinal, we choose k people (0 ≤ 2k ≤ n) who showed the best result in their semifinals and all other places in the finals go to the people who haven't ranked in the top k in their semifinal but got to the n - 2k of the best among the others.
The tournament organizers hasn't yet determined the k value, so the participants want to know who else has any chance to get to the finals and who can go home.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of participants in each semifinal.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109) — the results of the i-th participant (the number of milliseconds he needs to cover the semifinals distance) of the first and second semifinals, correspondingly. All results are distinct. Sequences a1, a2, ..., an and b1, b2, ..., bn are sorted in ascending order, i.e. in the order the participants finished in the corresponding semifinal.
Output
Print two strings consisting of n characters, each equals either "0" or "1". The first line should correspond to the participants of the first semifinal, the second line should correspond to the participants of the second semifinal. The i-th character in the j-th line should equal "1" if the i-th participant of the j-th semifinal has any chances to advance to the finals, otherwise it should equal a "0".
Examples
Input
4
9840 9920
9860 9980
9930 10020
10040 10090
Output
1110
1100
Input
4
9900 9850
9940 9930
10000 10020
10060 10110
Output
1100
1100
Note
Consider the first sample. Each semifinal has 4 participants. The results of the first semifinal are 9840, 9860, 9930, 10040. The results of the second semifinal are 9920, 9980, 10020, 10090.
* If k = 0, the finalists are determined by the time only, so players 9840, 9860, 9920 and 9930 advance to the finals.
* If k = 1, the winners from both semifinals move to the finals (with results 9840 and 9920), and the other places are determined by the time (these places go to the sportsmen who run the distance in 9860 and 9930 milliseconds).
* If k = 2, then first and second places advance from each seminfial, these are participants with results 9840, 9860, 9920 and 9980 milliseconds.
Submitted Solution:
```
Narray = int(input())
Aarray = []
Barray = []
k = int(Narray/2)
a,b,p,q = 0,0,0,0;
for i in range(Narray):
Carray = input().split()
if q+p <= Narray:
Aarray.append(int(Carray[0]))
Barray.append(int(Carray[1]))
if Aarray[0] < Barray[0]:
Aarray.pop(0)
p +=1; q +=0;
else:
Barray.pop(0)
p +=0; q +=1;
if q + p == Narray:
a,b = p,q;
else:
continue
if a < b:
print('1'*(k)+'0'*(Narray-k))
print('1'*(Narray-a)+'0'*a)
elif (a == b):
print('1'*(k)+'0'*(Narray-k))
print('1'*(k)+'0'*(Narray-k))
else:
print('1'*(Narray-b)+'0'*b)
print('1'*(k)+'0'*(Narray-k))
``` | instruction | 0 | 89,630 | 17 | 179,260 |
Yes | output | 1 | 89,630 | 17 | 179,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two semifinals have just been in the running tournament. Each semifinal had n participants. There are n participants advancing to the finals, they are chosen as follows: from each semifinal, we choose k people (0 ≤ 2k ≤ n) who showed the best result in their semifinals and all other places in the finals go to the people who haven't ranked in the top k in their semifinal but got to the n - 2k of the best among the others.
The tournament organizers hasn't yet determined the k value, so the participants want to know who else has any chance to get to the finals and who can go home.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of participants in each semifinal.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109) — the results of the i-th participant (the number of milliseconds he needs to cover the semifinals distance) of the first and second semifinals, correspondingly. All results are distinct. Sequences a1, a2, ..., an and b1, b2, ..., bn are sorted in ascending order, i.e. in the order the participants finished in the corresponding semifinal.
Output
Print two strings consisting of n characters, each equals either "0" or "1". The first line should correspond to the participants of the first semifinal, the second line should correspond to the participants of the second semifinal. The i-th character in the j-th line should equal "1" if the i-th participant of the j-th semifinal has any chances to advance to the finals, otherwise it should equal a "0".
Examples
Input
4
9840 9920
9860 9980
9930 10020
10040 10090
Output
1110
1100
Input
4
9900 9850
9940 9930
10000 10020
10060 10110
Output
1100
1100
Note
Consider the first sample. Each semifinal has 4 participants. The results of the first semifinal are 9840, 9860, 9930, 10040. The results of the second semifinal are 9920, 9980, 10020, 10090.
* If k = 0, the finalists are determined by the time only, so players 9840, 9860, 9920 and 9930 advance to the finals.
* If k = 1, the winners from both semifinals move to the finals (with results 9840 and 9920), and the other places are determined by the time (these places go to the sportsmen who run the distance in 9860 and 9930 milliseconds).
* If k = 2, then first and second places advance from each seminfial, these are participants with results 9840, 9860, 9920 and 9980 milliseconds.
Submitted Solution:
```
Narray = int(input())
Aarray = []
Barray = []
for i in range(Narray):
Carray = input().split()
Aarray.append(int(Carray[0]))
Barray.append(int(Carray[1]))
k = int(Narray/2)
A1array, B1array = Aarray[k:], Barray[k:]
Aarray, Barray = Aarray[:k], Barray[:k]
if Narray == 1:
print(str(1))
print(str(1))
else:
if Aarray[0] < Barray[0]:
dem = 0;
for x in A1array:
if x < B1array[0]:
dem += 1
else:
dem += 0
Earray = A1array[dem:]
Earray = [str(0) for i in Earray]
Aarray = Aarray + A1array[:dem]
Aarray = [str(1) for j in Aarray]
Aarray = Aarray + Earray
B1array = [str(0) for i in B1array]
Barray = [str(1) for j in Barray]
Barray = Barray +B1array
s = str("")
print(s.join(Aarray))
print(s.join(Barray))
else:
dem1 = 0;
for x in B1array:
if x < A1array[0]:
dem1 += 1
else:
dem1 += 0
Earray = B1array[dem1:]
Earray = [str(0) for i in Earray]
Barray = Barray + B1array[:dem1]
Barray = [str(1) for j in Barray]
Barray = Barray + Earray
A1array = [str(0) for i in A1array]
Aarray = [str(1) for j in Aarray]
Aarray = Aarray +A1array
s = str("")
print(s.join(Aarray))
print(s.join(Barray))
``` | instruction | 0 | 89,631 | 17 | 179,262 |
No | output | 1 | 89,631 | 17 | 179,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two semifinals have just been in the running tournament. Each semifinal had n participants. There are n participants advancing to the finals, they are chosen as follows: from each semifinal, we choose k people (0 ≤ 2k ≤ n) who showed the best result in their semifinals and all other places in the finals go to the people who haven't ranked in the top k in their semifinal but got to the n - 2k of the best among the others.
The tournament organizers hasn't yet determined the k value, so the participants want to know who else has any chance to get to the finals and who can go home.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of participants in each semifinal.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109) — the results of the i-th participant (the number of milliseconds he needs to cover the semifinals distance) of the first and second semifinals, correspondingly. All results are distinct. Sequences a1, a2, ..., an and b1, b2, ..., bn are sorted in ascending order, i.e. in the order the participants finished in the corresponding semifinal.
Output
Print two strings consisting of n characters, each equals either "0" or "1". The first line should correspond to the participants of the first semifinal, the second line should correspond to the participants of the second semifinal. The i-th character in the j-th line should equal "1" if the i-th participant of the j-th semifinal has any chances to advance to the finals, otherwise it should equal a "0".
Examples
Input
4
9840 9920
9860 9980
9930 10020
10040 10090
Output
1110
1100
Input
4
9900 9850
9940 9930
10000 10020
10060 10110
Output
1100
1100
Note
Consider the first sample. Each semifinal has 4 participants. The results of the first semifinal are 9840, 9860, 9930, 10040. The results of the second semifinal are 9920, 9980, 10020, 10090.
* If k = 0, the finalists are determined by the time only, so players 9840, 9860, 9920 and 9930 advance to the finals.
* If k = 1, the winners from both semifinals move to the finals (with results 9840 and 9920), and the other places are determined by the time (these places go to the sportsmen who run the distance in 9860 and 9930 milliseconds).
* If k = 2, then first and second places advance from each seminfial, these are participants with results 9840, 9860, 9920 and 9980 milliseconds.
Submitted Solution:
```
def calc_chances_matrix(_n, _a, _b):
chances_matrix = [[0 for i in range(n)] for j in range(2)]
for k in range(0, n // 2 + 1):
if k >= 1:
chances_matrix[0][k - 1] = 1
chances_matrix[1][k - 1] = 1
last_a = k - 1
last_b = k - 1
for i in range(n - (2 * k)):
if last_b >= n - 1 or _a[last_a + 1] < _b[last_b + 1]:
last_a += 1
chances_matrix[0][last_a] = 1
else:
last_b += 1
chances_matrix[1][last_b] = 1
return chances_matrix
n = int(input())
a, b = [], []
for i in range(n):
ai, bi = map(int, input().split())
a.append(ai)
b.append(bi)
print(*calc_chances_matrix(n, a, b)[0], sep=' ')
print(*calc_chances_matrix(n, a, b)[1], sep=' ')
``` | instruction | 0 | 89,632 | 17 | 179,264 |
No | output | 1 | 89,632 | 17 | 179,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two semifinals have just been in the running tournament. Each semifinal had n participants. There are n participants advancing to the finals, they are chosen as follows: from each semifinal, we choose k people (0 ≤ 2k ≤ n) who showed the best result in their semifinals and all other places in the finals go to the people who haven't ranked in the top k in their semifinal but got to the n - 2k of the best among the others.
The tournament organizers hasn't yet determined the k value, so the participants want to know who else has any chance to get to the finals and who can go home.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of participants in each semifinal.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109) — the results of the i-th participant (the number of milliseconds he needs to cover the semifinals distance) of the first and second semifinals, correspondingly. All results are distinct. Sequences a1, a2, ..., an and b1, b2, ..., bn are sorted in ascending order, i.e. in the order the participants finished in the corresponding semifinal.
Output
Print two strings consisting of n characters, each equals either "0" or "1". The first line should correspond to the participants of the first semifinal, the second line should correspond to the participants of the second semifinal. The i-th character in the j-th line should equal "1" if the i-th participant of the j-th semifinal has any chances to advance to the finals, otherwise it should equal a "0".
Examples
Input
4
9840 9920
9860 9980
9930 10020
10040 10090
Output
1110
1100
Input
4
9900 9850
9940 9930
10000 10020
10060 10110
Output
1100
1100
Note
Consider the first sample. Each semifinal has 4 participants. The results of the first semifinal are 9840, 9860, 9930, 10040. The results of the second semifinal are 9920, 9980, 10020, 10090.
* If k = 0, the finalists are determined by the time only, so players 9840, 9860, 9920 and 9930 advance to the finals.
* If k = 1, the winners from both semifinals move to the finals (with results 9840 and 9920), and the other places are determined by the time (these places go to the sportsmen who run the distance in 9860 and 9930 milliseconds).
* If k = 2, then first and second places advance from each seminfial, these are participants with results 9840, 9860, 9920 and 9980 milliseconds.
Submitted Solution:
```
n = int(input())
A = B = []
p = q = 0
k = n//2
for i in range(n):
a, b = map(int, input().split())
A.append(a)
B.append(b)
for i in range(n):
if A[p] < B[q]:
p += 1
else:
q += 1
for i in range(n):
print(1 if i < q or i < k else 0, end='')
print()
for i in range(n):
print(1 if i < p or i < k else 0, end='')
``` | instruction | 0 | 89,633 | 17 | 179,266 |
No | output | 1 | 89,633 | 17 | 179,267 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two semifinals have just been in the running tournament. Each semifinal had n participants. There are n participants advancing to the finals, they are chosen as follows: from each semifinal, we choose k people (0 ≤ 2k ≤ n) who showed the best result in their semifinals and all other places in the finals go to the people who haven't ranked in the top k in their semifinal but got to the n - 2k of the best among the others.
The tournament organizers hasn't yet determined the k value, so the participants want to know who else has any chance to get to the finals and who can go home.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of participants in each semifinal.
Each of the next n lines contains two integers ai and bi (1 ≤ ai, bi ≤ 109) — the results of the i-th participant (the number of milliseconds he needs to cover the semifinals distance) of the first and second semifinals, correspondingly. All results are distinct. Sequences a1, a2, ..., an and b1, b2, ..., bn are sorted in ascending order, i.e. in the order the participants finished in the corresponding semifinal.
Output
Print two strings consisting of n characters, each equals either "0" or "1". The first line should correspond to the participants of the first semifinal, the second line should correspond to the participants of the second semifinal. The i-th character in the j-th line should equal "1" if the i-th participant of the j-th semifinal has any chances to advance to the finals, otherwise it should equal a "0".
Examples
Input
4
9840 9920
9860 9980
9930 10020
10040 10090
Output
1110
1100
Input
4
9900 9850
9940 9930
10000 10020
10060 10110
Output
1100
1100
Note
Consider the first sample. Each semifinal has 4 participants. The results of the first semifinal are 9840, 9860, 9930, 10040. The results of the second semifinal are 9920, 9980, 10020, 10090.
* If k = 0, the finalists are determined by the time only, so players 9840, 9860, 9920 and 9930 advance to the finals.
* If k = 1, the winners from both semifinals move to the finals (with results 9840 and 9920), and the other places are determined by the time (these places go to the sportsmen who run the distance in 9860 and 9930 milliseconds).
* If k = 2, then first and second places advance from each seminfial, these are participants with results 9840, 9860, 9920 and 9980 milliseconds.
Submitted Solution:
```
def calc_chances_matrix(_n, _a, _b):
chances_matrix = [[0 for i in range(n)] for j in range(2)]
for k in range(0, n // 2 + 1):
if k >= 1:
chances_matrix[0][k - 1] = 1
chances_matrix[1][k - 1] = 1
last_a = k - 1
last_b = k - 1
for i in range(n - (2 * k)):
if last_b >= n - 1 or _a[last_a + 1] < _b[last_b + 1]:
last_a += 1
chances_matrix[0][last_a] = 1
else:
last_b += 1
chances_matrix[1][last_b] = 1
return chances_matrix
n = int(input())
a, b = [], []
for i in range(n):
ai, bi = map(int, input().split())
a.append(ai)
b.append(bi)
print(calc_chances_matrix(n, a, b))
``` | instruction | 0 | 89,634 | 17 | 179,268 |
No | output | 1 | 89,634 | 17 | 179,269 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes. | instruction | 0 | 89,864 | 17 | 179,728 |
Tags: implementation, math
Correct Solution:
```
n, m, a, b = map(int, input().split())
print(min((-n) % m * a, n % m * b))
``` | output | 1 | 89,864 | 17 | 179,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes. | instruction | 0 | 89,865 | 17 | 179,730 |
Tags: implementation, math
Correct Solution:
```
n, m, a, b = map(int, input().strip().split())
if n == m:
print(0)
elif n < m:
if (m-n)*a < n*b:
print((m-n)*a)
else:
print(n*b)
elif n > m:
x = (n % m) * b
y = (m - (n % m)) * a
print(min(x,y))
``` | output | 1 | 89,865 | 17 | 179,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes. | instruction | 0 | 89,866 | 17 | 179,732 |
Tags: implementation, math
Correct Solution:
```
n, m, a, b = map(int, input().split())
q = n % m
p = n // m
print(min(((p + 1) * m - n) * a, q * b))
``` | output | 1 | 89,866 | 17 | 179,733 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes. | instruction | 0 | 89,867 | 17 | 179,734 |
Tags: implementation, math
Correct Solution:
```
n, m, a, b = map(int, input().split())
r = n % m
print(min(r * b, (m - r) * a))
``` | output | 1 | 89,867 | 17 | 179,735 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes. | instruction | 0 | 89,868 | 17 | 179,736 |
Tags: implementation, math
Correct Solution:
```
n, m, a, b = map(int, input().split())
n %= m
print(min(n * b, (m - n) * a))
``` | output | 1 | 89,868 | 17 | 179,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes. | instruction | 0 | 89,869 | 17 | 179,738 |
Tags: implementation, math
Correct Solution:
```
n,m,a,b=map(int,input().split())
print([0,min((n%m)*b,abs(m-n%m)*a)][n%m!=0])
``` | output | 1 | 89,869 | 17 | 179,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes. | instruction | 0 | 89,870 | 17 | 179,740 |
Tags: implementation, math
Correct Solution:
```
n,m,a,b=map(int,input().split())
if n%m==0:
print(0)
else:
x=a*(m*(n//m+1)-n)
y=b*(n-m*(n//m))
print(min(x,y))
``` | output | 1 | 89,870 | 17 | 179,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes. | instruction | 0 | 89,871 | 17 | 179,742 |
Tags: implementation, math
Correct Solution:
```
n,m,a,b=list(map(int,input().strip().split()))
if(n%m==0):
print(0)
else:
temp=n//m
demo=n-temp*m
demo=demo*b
temp=temp+1
bui=temp*m-n
bui=bui*a
if(bui>=demo):
print(demo)
else:
print(bui)
``` | output | 1 | 89,871 | 17 | 179,743 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n, m, a, b = map(int, input().split())
ans = 0
if n%m==0:
pass
elif n<m:
ans = min(b*n, a*(m-n))
else:
ans = min(b*(n%m), a*(m-(n%m)))
print(ans)
``` | instruction | 0 | 89,872 | 17 | 179,744 |
Yes | output | 1 | 89,872 | 17 | 179,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n, m, a, b = map(int, input().split())
d = n % m
print(min(d * b, (m - d) * a))
``` | instruction | 0 | 89,873 | 17 | 179,746 |
Yes | output | 1 | 89,873 | 17 | 179,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n, m, a, b = map(int, input().split())
if n % m == 0:
print(0)
else:
res1 = (n % m) * b
res2 = (m - n % m) * a
print(min(res1, res2))
``` | instruction | 0 | 89,874 | 17 | 179,748 |
Yes | output | 1 | 89,874 | 17 | 179,749 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n,m,a,b = input().split(" ")
n = int(n)
m = int(m)
a = int(a)
b = int(b)
if n%m==0:
print(0)
else:
ba = int(n/m)
bb = ba
ba = ba + 1
ba = ba * m - n
ba = ba * a
bb = n-bb*m
bb = bb*b
if bb>ba:
print(ba)
else:
print(bb)
``` | instruction | 0 | 89,875 | 17 | 179,750 |
Yes | output | 1 | 89,875 | 17 | 179,751 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n,m,a,b=list(map(int,input().split()))
l=[]
todestroy=(n%m)*b
tocreate=((n+m)//m*m-n)*a
print(tocreate)
l.append(todestroy)
l.append(tocreate)
print(min(l))
``` | instruction | 0 | 89,876 | 17 | 179,752 |
No | output | 1 | 89,876 | 17 | 179,753 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n,m,a,b = input().split()
n = int(n)
m = int(m)
a = int(a)
b = int(b)
if(m%m==0):
print("0")
else:
if(n<m):
cost_of_const = (m-n)*a
cost_of_dest = n*b
print(min(cost_of_const , cost_dest))
else:
s = n//m
cost_of_dest = (n-s)*b
cost_of_const = (n+1-s)*a
print(min(cost_of_const , cost_dest))
``` | instruction | 0 | 89,877 | 17 | 179,754 |
No | output | 1 | 89,877 | 17 | 179,755 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n,m,a,b=[int(x) for x in input().split()]
k=n
t=m
while n%t!=0:
t-=1
while k%m!=0:
k+=1
print(min((k-n)*a,(m-t)*b))
``` | instruction | 0 | 89,878 | 17 | 179,756 |
No | output | 1 | 89,878 | 17 | 179,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
a,b,c,d=[int(i) for i in input().split()]
if(a%b==0):
print(0)
else:
a1=b-(a%b)
a2=a-(a//b)
print(min(a1*c,a2*d))
``` | instruction | 0 | 89,879 | 17 | 179,758 |
No | output | 1 | 89,879 | 17 | 179,759 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2 | instruction | 0 | 90,039 | 17 | 180,078 |
"Correct Solution:
```
def main():
number_of_team = int(input())
#チーム数
result_matrix = [list(map(int, input().split())) for l in range(int(number_of_team*(number_of_team-1)/2))]
#入力される試合の結果
points_of_team = [0 for l in range(number_of_team)]
#勝ち点を保存するリスト
#勝ち点の計算
for low in result_matrix:
if low[2] == low[3]:
points_of_team[int(low[0])-1] += 1
points_of_team[int(low[1])-1] += 1
elif low[2] > low[3]:
points_of_team[int(low[0])-1] += 3
else:
points_of_team[int(low[1])-1] += 3
sort_list = sorted(points_of_team,reverse=True)
result_list = [0 for i in range(number_of_team)]#出力用のリスト
rank = 1
pred = sort_list[0]
for i in range(number_of_team):
max_index = points_of_team.index(sort_list[i])
if pred != sort_list[i]:
pred = sort_list[i]
rank = i+1
result_list[max_index] = rank
points_of_team[max_index] = -1
for i in range(number_of_team):
print(result_list[i])
if __name__ == '__main__':
main()
``` | output | 1 | 90,039 | 17 | 180,079 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2 | instruction | 0 | 90,040 | 17 | 180,080 |
"Correct Solution:
```
def f():
from heapq import heappop, heappush
N=int(input())
r=[0]*N
for _ in[0]*(N*~-N//2):
a,b,c,d=map(int,input().split())
r[a-1]+=3*(c>d)+(c==d)
r[b-1]+=3*(d>c)+(d==c)
b=[[]for _ in[0]*N*3]
for i in range(N):b[r[i]]+=[i]
pq = []
for i, s in enumerate(r):heappush(pq,[-s,i])
rank=1
display_rank=1
prev_score=float('inf')
while pq:
s,i=heappop(pq)
if s!=prev_score:rank=display_rank
r[i]=rank
display_rank+=1
prev_score=s
print(*r,sep='\n')
f()
########################################################################################################################
##################################################v
################################################################################
##########v####################v##############################v##########v
``` | output | 1 | 90,040 | 17 | 180,081 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2 | instruction | 0 | 90,041 | 17 | 180,082 |
"Correct Solution:
```
n = int(input())
score = [list(map(lambda x: int(x) - 1 , input().split())) for _ in range(int(n*(n-1)/2))]
points = [0 for _ in range(n)]
for a,b,c,d in score:
if c > d:
points[a] += 3
elif c < d:
points[b] += 3
else:
points[a] += 1
points[b] += 1
rank = sorted(points, reverse=True)
for p in points:
print(rank.index(p) + 1)
``` | output | 1 | 90,041 | 17 | 180,083 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2 | instruction | 0 | 90,042 | 17 | 180,084 |
"Correct Solution:
```
n=int(input());s=[list(map(int,input().split())) for _ in range(int(n*(n-1)/2))];p=[0]*n
for a,b,c,d in s:
if c>d:p[a-1]+=3
elif c<d:p[b-1]+=3
else:p[a-1]+=1;p[b-1]+=1
r=sorted(p,reverse=True)
for q in p:print(r.index(q)+1)
``` | output | 1 | 90,042 | 17 | 180,085 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2 | instruction | 0 | 90,043 | 17 | 180,086 |
"Correct Solution:
```
# AOJ 0566: Soccer
# Python3 2018.6.30 bal4u
n = int(input())
m = n*(n-1)>>1
team = [[0 for j in range(3)] for i in range(n)] #[id,win,lost]
for i in range(n): team[i][0] = i
for i in range(m):
a, b, c, d = map(int, input().split())
a, b = a-1, b-1
if c > d: team[a][1] += 3
elif c < d: team[b][1] += 3
else:
team[a][1] += 1
team[b][1] += 1
team.sort(key=lambda x:(-x[1],x[0]))
team[0][2] = 1
for i in range(1, n):
if team[i][1] == team[i-1][1]: team[i][2] = team[i-1][2]
else: team[i][2] = i+1
team.sort()
for i in range(n): print(team[i][2])
``` | output | 1 | 90,043 | 17 | 180,087 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2 | instruction | 0 | 90,044 | 17 | 180,088 |
"Correct Solution:
```
n = int(input())
R = {}
for i in range(n): R[i] = 0
for _ in range(n*(n-1)//2):
a, b, c, d = map(int, input().split())
if c>d:
R[a-1] += 3
elif c==d:
R[a-1] += 1
R[b-1] += 1
else:
R[b-1] += 3
rank, temp = 1, -1
ranks = []
R = sorted(R.items(), key=lambda x:-x[1])
#print(R)
for i in range(len(R)):
if temp!=R[i][1]:
rank = i+1
ranks.append([R[i][0], i+1])
else:
ranks.append([R[i][0], rank])
temp = R[i][1]
ranks = sorted(ranks)
for i in ranks:
print(i[1])
``` | output | 1 | 90,044 | 17 | 180,089 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2 | instruction | 0 | 90,045 | 17 | 180,090 |
"Correct Solution:
```
t = int(input())
point_l = [0 for i in range(t)]
for i in range(int(t*(t-1)/2)):
tmp = [int(x) for x in input().split()]
if tmp[2] > tmp[3]:
point_l[tmp[0]-1] += 3
elif tmp[3] > tmp[2]:
point_l[tmp[1]-1] += 3
elif tmp[2] == tmp[3]:
point_l[tmp[0]-1] += 1
point_l[tmp[1]-1] += 1
rank_l = [0 for i in range(t)]
rank = 1
for l in sorted(point_l, reverse=True):
dup = point_l.count(l)
for j in range(dup):
rank_l[point_l.index(l)] += rank
point_l[point_l.index(l)] = -1
rank += dup
for l in rank_l:
print(l)
``` | output | 1 | 90,045 | 17 | 180,091 |
Provide a correct Python 3 solution for this coding contest problem.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2 | instruction | 0 | 90,046 | 17 | 180,092 |
"Correct Solution:
```
n=int(input());p=[0]*n
for i in range(n*(n-1)//2):
a,b,c,d=map(int,input().split())
if c>d:p[a-1]+=3
elif c<d:p[b-1]+=3
else:p[a-1]+=1;p[b-1]+=1
r=sorted(p,reverse=True)
for q in p:print(r.index(q)+1)
``` | output | 1 | 90,046 | 17 | 180,093 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0566
"""
import sys
from sys import stdin
from heapq import heappop, heappush
input = stdin.readline
def main(args):
N = int(input())
scores = [0] * (N+1)
scores[0] = -1
results = [-1] * (N+1)
for _ in range(N*(N-1)//2):
a, b, c, d = [int(x) for x in input().split()]
if c > d:
scores[a] += 3
elif c < d:
scores[b] += 3
else:
scores[a] += 1
scores[b] += 1
pq = []
for i, s in enumerate(scores[1:], start=1):
heappush(pq, [-s, i])
rank = 1
display_rank = 1
prev_score = float('inf')
while pq:
s, i = heappop(pq)
if s == prev_score:
results[i] = rank
else:
rank = display_rank
results[i] = rank
display_rank += 1
prev_score = s
for r in results[1:]:
print(r)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 90,047 | 17 | 180,094 |
Yes | output | 1 | 90,047 | 17 | 180,095 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2
Submitted Solution:
```
n = int(input())
point = [0] * n
for i in range(n * (n - 1) // 2):
A, B, X, Y = map(int, input().split())
if X > Y:
point[A - 1] += 3
elif Y > X:
point[B - 1] += 3
else:
point[A - 1] += 1
point[B - 1] += 1
point_sorted = sorted(point, reverse=True)
for i in range(n):
print(point_sorted.index(point[i]) + 1)
``` | instruction | 0 | 90,048 | 17 | 180,096 |
Yes | output | 1 | 90,048 | 17 | 180,097 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2
Submitted Solution:
```
def f():
from heapq import heappop, heappush
N=int(input())
r=[0]*N
for _ in[0]*(N*~-N//2):
a,b,c,d=map(int,input().split())
r[a-1]+=3*(c>d)+(c==d)
r[b-1]+=3*(d>c)+(d==c)
b=[[]for _ in[0]*N*3]
for i in range(N):b[r[i]]+=[i]
pq = []
for i, s in enumerate(r):heappush(pq,[-s,i])
rank=1
display_rank=1
prev_score=float('inf')
while pq:
s,i=heappop(pq)
if s!=prev_score:rank=display_rank
r[i]=rank
display_rank+=1
prev_score=s
print(*r,sep='\n')
f()
``` | instruction | 0 | 90,049 | 17 | 180,098 |
Yes | output | 1 | 90,049 | 17 | 180,099 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2
Submitted Solution:
```
#B
N = int(input())
ABCD = [list(map(int,input().split())) for i in range(N*(N-1)//2)]
point = [[0,i] for i in range(N)]
for abcd in ABCD:
a,b,c,d = abcd
if c > d:
point[a-1][0]+=3
elif c < d:
point[b-1][0]+=3
else:
point[a-1][0]+=1
point[b-1][0]+=1
rank = [0]*N
point.sort(reverse=True)
mae = 0
now = 0
for i in range(N):
p = point[i][0]
ind = point[i][1]
if p != mae:
mae = p
now = i
rank[ind] = now+1
else:
rank[ind] = now+1
for r in rank:
print(r)
``` | instruction | 0 | 90,050 | 17 | 180,100 |
Yes | output | 1 | 90,050 | 17 | 180,101 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2
Submitted Solution:
```
def f():
N=int(input())
s=[0]*N
for _ in[0]*(N*~-N//2):
a,b,c,d=map(int,input().split())
s[a-1]+=3*(c>d)+(c==d)
s[b-1]+=3*(d>c)+(d==c)
b=[[]for _ in[0]*N*3]
for i in range(N):b[s[i]]+=[i]
r=1
for x in b[::-1]:
for y in x:s[y]=r;r+=1
print(*s,sep='\n')
f()
``` | instruction | 0 | 90,051 | 17 | 180,102 |
No | output | 1 | 90,051 | 17 | 180,103 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2
Submitted Solution:
```
t = int(input())
point_l = [0 for i in range(t)]
for i in range((t*(t-1))/2):
input_line = input()
tmp = [int(x) for x in input_line.rstrip().split(' ')]
if tmp[2] > tmp[3]:
point_l[tmp[0]-1] += 3
elif tmp[3] > tmp[2]:
point_l[tmp[1]-1] += 3
elif tmp[2] == tmp[3]:
point_l[tmp[0]-1] += 1
point_l[tmp[1]-1] += 1
rank_l = [0 for i in range(t)]
rank = 1
for l in sorted(point_l, reverse=True):
dup = point_l.count(l)
for j in range(dup):
rank_l[point_l.index(l)] += rank
point_l[point_l.index(l)] = -1
rank += dup
for l in rank_l:
print(l)
``` | instruction | 0 | 90,052 | 17 | 180,104 |
No | output | 1 | 90,052 | 17 | 180,105 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel is organizing a football tournament. He has come up with the following tournament format:
1. In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even.
2. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be <image> games), and the tournament ends.
For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games.
Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers.
Input
The first line contains a single integer n (1 ≤ n ≤ 1018), the number of games that should be played.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1.
Examples
Input
3
Output
3
4
Input
25
Output
20
Input
2
Output
-1 | instruction | 0 | 92,066 | 17 | 184,132 |
Tags: binary search, math
Correct Solution:
```
n = int(input()) + 1
b, p = 1, []
while b < n + 1:
d = (2 * b - 1) ** 2 + 8 * (n - b)
s = int(d ** 0.5)
s += int((d // s - s) // 2)
if s * s == d:
a = s - (2 * b - 1)
if a % 4 == 0: p.append(b * (a // 2 + 1))
b *= 2
print('\n'.join(map(str, p)) if p else '-1')
``` | output | 1 | 92,066 | 17 | 184,133 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel is organizing a football tournament. He has come up with the following tournament format:
1. In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even.
2. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be <image> games), and the tournament ends.
For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games.
Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers.
Input
The first line contains a single integer n (1 ≤ n ≤ 1018), the number of games that should be played.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1.
Examples
Input
3
Output
3
4
Input
25
Output
20
Input
2
Output
-1 | instruction | 0 | 92,067 | 17 | 184,134 |
Tags: binary search, math
Correct Solution:
```
f=n=int(input())
N=1
while N<=n*2:
l,h=0,n
while h>=l:
m=(l+h)//2
r=(m*2+1)*(m+N-1)
if r>n:h=m-1
elif r<n:l=m+1
else:
print(m*2*N+N)
f=0
break
N*=2
if f:print(-1)
# Made By Mostafa_Khaled
``` | output | 1 | 92,067 | 17 | 184,135 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel is organizing a football tournament. He has come up with the following tournament format:
1. In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even.
2. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be <image> games), and the tournament ends.
For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games.
Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers.
Input
The first line contains a single integer n (1 ≤ n ≤ 1018), the number of games that should be played.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1.
Examples
Input
3
Output
3
4
Input
25
Output
20
Input
2
Output
-1 | instruction | 0 | 92,068 | 17 | 184,136 |
Tags: binary search, math
Correct Solution:
```
from decimal import *
def is_int(d):
return d == int(d)
getcontext().prec=40
n=Decimal(input())
l=[]
p2=Decimal(1)
for i in range(70):
d=9+8*n+4*(p2**2)-12*p2
x=(3-2*p2+d.sqrt())/2
if(is_int(x)):
if(x%2==1):
l.append(p2*x)#l.append((p2+(x+1)/2)*x)
p2=p2*2
l.sort()
if len(l)==0:
print(-1)
else:
for i in l:
print(int(i))
``` | output | 1 | 92,068 | 17 | 184,137 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel is organizing a football tournament. He has come up with the following tournament format:
1. In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even.
2. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be <image> games), and the tournament ends.
For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games.
Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers.
Input
The first line contains a single integer n (1 ≤ n ≤ 1018), the number of games that should be played.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1.
Examples
Input
3
Output
3
4
Input
25
Output
20
Input
2
Output
-1 | instruction | 0 | 92,069 | 17 | 184,138 |
Tags: binary search, math
Correct Solution:
```
from math import sqrt
n = int(input())
resp = set()
for y in range(1, 65):
delta = 2**(2*y) - (2**(y+1))*3 + 9 + 8*n
raiz = -1
l, r = 0, int(sqrt(delta))+10
while l <= r :
m = (l+r)//2
if m*m == delta:
raiz = m
break
elif m*m < delta:
l = m+1
else:
r = m-1
if raiz == -1:
continue
x1 = (3-2**y+raiz)//2
x2 = (3-2**y-raiz)//2
if x1 % 2 == 1:
x1 = x1 * (2**(y-1))
if x1 >= 1:
resp.add(x1)
if x2 % 2 == 1:
x2 = x2 * (2**(y-1))
if x2 >= 1:
resp.add(x2)
if len(resp) == 0:
print("-1")
else:
for e in sorted(resp):
print(e)
``` | output | 1 | 92,069 | 17 | 184,139 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel is organizing a football tournament. He has come up with the following tournament format:
1. In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even.
2. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be <image> games), and the tournament ends.
For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games.
Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers.
Input
The first line contains a single integer n (1 ≤ n ≤ 1018), the number of games that should be played.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1.
Examples
Input
3
Output
3
4
Input
25
Output
20
Input
2
Output
-1 | instruction | 0 | 92,070 | 17 | 184,140 |
Tags: binary search, math
Correct Solution:
```
#!/usr/bin/python3
y=int(input())
s=set()
e=1
for k in range(0,70):
b=2*e-3
c=-2*y
d=b*b-4*c
if d>=0:
L=0
R=d
while True:
M=(L+R+1)//2
if L==R:
break
MM=M*M
if MM>d:
R=M-1
else:
L=M
if M*M==d:
x=-b+M
if x>0 and x%2==0:
x//=2
if x%2==1:
s.add(x*e)
x=-b-M
if x>0 and x%2==0:
x//=2
if x%2==1:
s.add(x*e)
e<<=1
y=True
for x in sorted(s):
print(x)
y=False
if y:
print(-1)
``` | output | 1 | 92,070 | 17 | 184,141 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel is organizing a football tournament. He has come up with the following tournament format:
1. In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even.
2. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be <image> games), and the tournament ends.
For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games.
Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers.
Input
The first line contains a single integer n (1 ≤ n ≤ 1018), the number of games that should be played.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1.
Examples
Input
3
Output
3
4
Input
25
Output
20
Input
2
Output
-1 | instruction | 0 | 92,071 | 17 | 184,142 |
Tags: binary search, math
Correct Solution:
```
n = int(input())
f = 0
for p in range(63):
N = 1 << (p+1)
l = 0
h = n
while h >= l:
m = (l+h)//2
x = m*2+1
res = x*(x+N-3)
if res == n*2:
print(x*(1 << p))
f = 1
break
elif res > n*2:
h = m-1
else:
l = m+1
if f==0:
print(-1)
``` | output | 1 | 92,071 | 17 | 184,143 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel is organizing a football tournament. He has come up with the following tournament format:
1. In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even.
2. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be <image> games), and the tournament ends.
For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games.
Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers.
Input
The first line contains a single integer n (1 ≤ n ≤ 1018), the number of games that should be played.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1.
Examples
Input
3
Output
3
4
Input
25
Output
20
Input
2
Output
-1 | instruction | 0 | 92,072 | 17 | 184,144 |
Tags: binary search, math
Correct Solution:
```
n = int(input())
succ = False;
for ii in range(0, 100):
i = 2 ** ii
l = 1
r = 2 ** 100
while l < r:
mid = (l+r)//2
x = 2 * mid - 1
v = x*((x-1)//2+i-1)
if v == n:
succ = True
print(x*i)
break
elif v < n:
l = mid + 1
else:
r = mid
if not succ:
print("-1")
``` | output | 1 | 92,072 | 17 | 184,145 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Daniel is organizing a football tournament. He has come up with the following tournament format:
1. In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even.
2. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be <image> games), and the tournament ends.
For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games.
Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers.
Input
The first line contains a single integer n (1 ≤ n ≤ 1018), the number of games that should be played.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1.
Examples
Input
3
Output
3
4
Input
25
Output
20
Input
2
Output
-1 | instruction | 0 | 92,073 | 17 | 184,146 |
Tags: binary search, math
Correct Solution:
```
n = int(input())
x=1
res=[]
for i in range(64):
lo, hi =0, int(1e15)
f=0
ans=0
while lo+1<hi:
mid=(lo+hi)//2
v = (x-1)*mid+ (mid*mid-mid)//2
if(v==n):
f=1;
ans=mid
break;
if(v>n):
hi=mid
else:
lo=mid
if(f and ans%2==1):
res.append(ans*x)
x=x*2
if(len(res)==0):
print(-1);
exit(0)
for x in res:
print(int(x))
``` | output | 1 | 92,073 | 17 | 184,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Daniel is organizing a football tournament. He has come up with the following tournament format:
1. In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even.
2. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be <image> games), and the tournament ends.
For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games.
Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers.
Input
The first line contains a single integer n (1 ≤ n ≤ 1018), the number of games that should be played.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1.
Examples
Input
3
Output
3
4
Input
25
Output
20
Input
2
Output
-1
Submitted Solution:
```
import sys
def isqrt(n):
l = -1
h = n
while l + 1 < h:
m = (l + h) // 2
if m * m <= n:
l = m
else:
h = m
return l
with sys.stdin as fin, sys.stdout as fout:
n = int(next(fin))
ans = []
for i in range(64 + 1):
a = 2 ** i - 1
q = 1 - 4 * a + 4 * a ** 2 + 8 * n
rt = isqrt(q)
if rt ** 2 != q:
continue
res = 1 - 2 * a + rt
if res % 2 != 0 or res % 4 == 0:
continue
ans.append(res // 2 * 2 ** i)
if not ans:
print(-1, file=fout)
else:
for i in ans:
print(i, file=fout)
``` | instruction | 0 | 92,074 | 17 | 184,148 |
Yes | output | 1 | 92,074 | 17 | 184,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Daniel is organizing a football tournament. He has come up with the following tournament format:
1. In the first several (possibly zero) stages, while the number of teams is even, they split in pairs and play one game for each pair. At each stage the loser of each pair is eliminated (there are no draws). Such stages are held while the number of teams is even.
2. Eventually there will be an odd number of teams remaining. If there is one team remaining, it will be declared the winner, and the tournament ends. Otherwise each of the remaining teams will play with each other remaining team once in round robin tournament (if there are x teams, there will be <image> games), and the tournament ends.
For example, if there were 20 teams initially, they would begin by playing 10 games. So, 10 teams would be eliminated, and the remaining 10 would play 5 games. Then the remaining 5 teams would play 10 games in a round robin tournament. In total there would be 10+5+10=25 games.
Daniel has already booked the stadium for n games. Help him to determine how many teams he should invite so that the tournament needs exactly n games. You should print all possible numbers of teams that will yield exactly n games in ascending order, or -1 if there are no such numbers.
Input
The first line contains a single integer n (1 ≤ n ≤ 1018), the number of games that should be played.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print all possible numbers of invited teams in ascending order, one per line. If exactly n games cannot be played, output one number: -1.
Examples
Input
3
Output
3
4
Input
25
Output
20
Input
2
Output
-1
Submitted Solution:
```
ans=[]
n=1
def f(r,k):
a=2**k
a-=1
a*=r
b=r*(r-1)//2
return a+b
def ff(r,k):
a=2**k
return a*r
def tr(k):
if(f(1,k)>n):
return
l=1
r=2**60
while(r-l>1):
mid=(l+r)//2
if(f(mid,k)<n):l=mid+1
else:r=mid
while(f(l,k)<n):l+=1
if(f(l,k)==n and l&1):ans.append(ff(l,k))
n=eval(input())
for i in range(60,-1,-1):
tr(i)
ans.sort()
if len(ans)==0:
print(-1)
import sys
sys.exit(0)
for i in ans:
print(i,end=' ')
``` | instruction | 0 | 92,075 | 17 | 184,150 |
Yes | output | 1 | 92,075 | 17 | 184,151 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.