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.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4. | instruction | 0 | 64,022 | 17 | 128,044 |
Tags: greedy, implementation
Correct Solution:
```
xi = 0
yi = 0
ans = 1
for i in range (int(input())) :
xf,yf = map(int,input().split())
if xi == yi :
ans = ans + min (yf - yi , xf - xi)
else :
m1 = max (xi,yi)
m2 = min (xf,yf)
t = max(m2-m1+1,0)
#print("sdds",t)
ans = ans + t
xi = xf
yi = yf
print(ans)
``` | output | 1 | 64,022 | 17 | 128,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4. | instruction | 0 | 64,023 | 17 | 128,046 |
Tags: greedy, implementation
Correct Solution:
```
q = int(input())
a , b = 0,0
draws =1
for _ in range(q):
c , d = map(int, input().split())
draws+= max(0 , min(c,d)-max(a,b)+(a!=b) )
a , b = c, d
print(draws)
``` | output | 1 | 64,023 | 17 | 128,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4.
Submitted Solution:
```
from sys import stdin,stdout
input = stdin.readline
def main():
n = int(input())
preva = prevb = -1
ans = 0
for i in range(n):
a,b = map(int,input().split())
if preva != prevb:
ans += max(0,min(a,b) - max(preva,prevb) + 1)
else:
ans += max(0,min(a,b) - max(preva,prevb))
preva,prevb = a,b
print(ans)
main()
``` | instruction | 0 | 64,024 | 17 | 128,048 |
Yes | output | 1 | 64,024 | 17 | 128,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4.
Submitted Solution:
```
n = int(input())
l = []
for _ in range(n):
l += [list(map(int, input().split()))]
a = 0
b = 0
draws = 1
for score in l:
while [a, b] != score:
if a < b and a < score[0]:
a = min(b, score[0])
if a == b:
draws += 1
continue
if b < a and b < score[1]:
b = min(a, score[1])
if a == b:
draws += 1
continue
if a == score[0] and b < score[1]:
if b < a <= score[1]:
draws += 1
b = score[1]
continue
if b == score[1] and a < score[0]:
if a < b <= score[0]:
draws += 1
a = score[0]
continue
if a == b:
draws += min(score) - a
a = score[0]
b = score[1]
print(draws)
``` | instruction | 0 | 64,025 | 17 | 128,050 |
Yes | output | 1 | 64,025 | 17 | 128,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4.
Submitted Solution:
```
n=int(input())
c='s';d=1
pa,pb=0,0
for i in range(n):
a,b=map(int,input().split())
if pa==a and pb==b:
continue
if a<pb or b<pa:
pa,pb=a,b
continue
d+=a-pa+1+b-pb+1-(max(a,b)-min(pa,pb)+1)
if pa==pb:d-=1
pa,pb=a,b
#print(d)
print(d)
``` | instruction | 0 | 64,026 | 17 | 128,052 |
Yes | output | 1 | 64,026 | 17 | 128,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4.
Submitted Solution:
```
N = int(input())
draws = 1
last_score = (0, 0)
for i in range(N):
x, y = [int(x) for x in input().split()]
current_score = (x, y)
if current_score == last_score:
continue
if i == 0:
draws += min(x, y)
else:
last_min = 0
if last_score[1] < last_score[0]:
last_min = 1
last_max = (last_min+1)%2
if current_score[last_min] - last_score[last_min] >= last_score[last_max] - last_score[last_min]:
if last_score[0] != last_score[1]:
draws += 1
draws += min(current_score[0]-last_score[last_max], current_score[1]-last_score[last_max])
last_score = (x, y)
print(draws)
``` | instruction | 0 | 64,027 | 17 | 128,054 |
Yes | output | 1 | 64,027 | 17 | 128,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4.
Submitted Solution:
```
a,b,count=0,0,0
for i in range(int(input())):
af,bf=map(int,input().split())
while a<af or b<bf:
if a<=b:
a+=1
else:
b+=1
if a==b:
count+=1
print(a)
print(count+1)
``` | instruction | 0 | 64,028 | 17 | 128,056 |
No | output | 1 | 64,028 | 17 | 128,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4.
Submitted Solution:
```
a0,b0,s=0,0,0
for i in range(int(input())):
a1,b1=(int(i) for i in input().split())
if a1!=a0 and b1!=b0:
n,k=max(a0,b0),min(a1,b1)
if n<=k:
s+=k-n+1 if a1!=b1 else k-n
a0,b0=a1,b1
if a1==b1:
s+=1
print(s)
``` | instruction | 0 | 64,029 | 17 | 128,058 |
No | output | 1 | 64,029 | 17 | 128,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4.
Submitted Solution:
```
n = int(input())
a = [0]
b = [0]
for i in range(n):
x,y = map(int, input().split())
a.append(x)
b.append(y)
ans = 0
total_goals = a[n-1] + b[n-1]
for i in range(n):
if a[i+1] + b[i+1] == a[i] + b[i]:
continue
ans += min(a[i+1], b[i+1]) - max(a[i], b[i]) + 1
if i > 0 and a[i] == b[i]:
ans -= 1
if a[n] == b[n] == 0:
ans = 1
print(ans)
``` | instruction | 0 | 64,030 | 17 | 128,060 |
No | output | 1 | 64,030 | 17 | 128,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You still have partial information about the score during the historic football match. You are given a set of pairs (a_i, b_i), indicating that at some point during the match the score was "a_i: b_i". It is known that if the current score is «x:y», then after the goal it will change to "x+1:y" or "x:y+1". What is the largest number of times a draw could appear on the scoreboard?
The pairs "a_i:b_i" are given in chronological order (time increases), but you are given score only for some moments of time. The last pair corresponds to the end of the match.
Input
The first line contains a single integer n (1 ≤ n ≤ 10000) — the number of known moments in the match.
Each of the next n lines contains integers a_i and b_i (0 ≤ a_i, b_i ≤ 10^9), denoting the score of the match at that moment (that is, the number of goals by the first team and the number of goals by the second team).
All moments are given in chronological order, that is, sequences x_i and y_j are non-decreasing. The last score denotes the final result of the match.
Output
Print the maximum number of moments of time, during which the score was a draw. The starting moment of the match (with a score 0:0) is also counted.
Examples
Input
3
2 0
3 1
3 4
Output
2
Input
3
0 0
0 0
0 0
Output
1
Input
1
5 4
Output
5
Note
In the example one of the possible score sequences leading to the maximum number of draws is as follows: 0:0, 1:0, 2:0, 2:1, 3:1, 3:2, 3:3, 3:4.
Submitted Solution:
```
ii = lambda: int(input())
mi = lambda: map(int, input().split())
n = ii()
ai , bi = (0, 0)
d = 1
for i in range(n):
an, bn = mi()
if an > ai and bn > bi:
d += min(an, bn) - min(ai, bi)
ai, bi = an, bn
print(d)
``` | instruction | 0 | 64,031 | 17 | 128,062 |
No | output | 1 | 64,031 | 17 | 128,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja is a coder and he likes to take part in Codesorfes rounds. However, Uzhland doesn't have good internet connection, so Sereja sometimes skips rounds.
Codesorfes has rounds of two types: Div1 (for advanced coders) and Div2 (for beginner coders). Two rounds, Div1 and Div2, can go simultaneously, (Div1 round cannot be held without Div2) in all other cases the rounds don't overlap in time. Each round has a unique identifier — a positive integer. The rounds are sequentially (without gaps) numbered with identifiers by the starting time of the round. The identifiers of rounds that are run simultaneously are different by one, also the identifier of the Div1 round is always greater.
Sereja is a beginner coder, so he can take part only in rounds of Div2 type. At the moment he is taking part in a Div2 round, its identifier equals to x. Sereja remembers very well that he has taken part in exactly k rounds before this round. Also, he remembers all identifiers of the rounds he has taken part in and all identifiers of the rounds that went simultaneously with them. Sereja doesn't remember anything about the rounds he missed.
Sereja is wondering: what minimum and what maximum number of Div2 rounds could he have missed? Help him find these two numbers.
Input
The first line contains two integers: x (1 ≤ x ≤ 4000) — the round Sereja is taking part in today, and k (0 ≤ k < 4000) — the number of rounds he took part in.
Next k lines contain the descriptions of the rounds that Sereja took part in before. If Sereja took part in one of two simultaneous rounds, the corresponding line looks like: "1 num2 num1" (where num2 is the identifier of this Div2 round, num1 is the identifier of the Div1 round). It is guaranteed that num1 - num2 = 1. If Sereja took part in a usual Div2 round, then the corresponding line looks like: "2 num" (where num is the identifier of this Div2 round). It is guaranteed that the identifiers of all given rounds are less than x.
Output
Print in a single line two integers — the minimum and the maximum number of rounds that Sereja could have missed.
Examples
Input
3 2
2 1
2 2
Output
0 0
Input
9 3
1 2 3
2 8
1 4 5
Output
2 3
Input
10 0
Output
5 9
Note
In the second sample we have unused identifiers of rounds 1, 6, 7. The minimum number of rounds Sereja could have missed equals to 2. In this case, the round with the identifier 1 will be a usual Div2 round and the round with identifier 6 will be synchronous with the Div1 round.
The maximum number of rounds equals 3. In this case all unused identifiers belong to usual Div2 rounds. | instruction | 0 | 64,339 | 17 | 128,678 |
Tags: greedy, implementation, math
Correct Solution:
```
x, k = [int(i) for i in input().split()]
missed = [0] * x
for i in range(k):
divs = [int(i) for i in input().split()]
if divs[0] == 1:
missed[divs[1]] = 1
missed[divs[2]] = 1
else:
missed[divs[1]] = 1
max_answer = missed.count(0) - 1
good_subarrs = 0
i = 1
while i <= x-1:
if i < x-1 and missed[i] == 0 and missed[i+1] == 0:
good_subarrs += 1
i += 2
else:
i += 1
print(max_answer - good_subarrs, max_answer)
``` | output | 1 | 64,339 | 17 | 128,679 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja is a coder and he likes to take part in Codesorfes rounds. However, Uzhland doesn't have good internet connection, so Sereja sometimes skips rounds.
Codesorfes has rounds of two types: Div1 (for advanced coders) and Div2 (for beginner coders). Two rounds, Div1 and Div2, can go simultaneously, (Div1 round cannot be held without Div2) in all other cases the rounds don't overlap in time. Each round has a unique identifier — a positive integer. The rounds are sequentially (without gaps) numbered with identifiers by the starting time of the round. The identifiers of rounds that are run simultaneously are different by one, also the identifier of the Div1 round is always greater.
Sereja is a beginner coder, so he can take part only in rounds of Div2 type. At the moment he is taking part in a Div2 round, its identifier equals to x. Sereja remembers very well that he has taken part in exactly k rounds before this round. Also, he remembers all identifiers of the rounds he has taken part in and all identifiers of the rounds that went simultaneously with them. Sereja doesn't remember anything about the rounds he missed.
Sereja is wondering: what minimum and what maximum number of Div2 rounds could he have missed? Help him find these two numbers.
Input
The first line contains two integers: x (1 ≤ x ≤ 4000) — the round Sereja is taking part in today, and k (0 ≤ k < 4000) — the number of rounds he took part in.
Next k lines contain the descriptions of the rounds that Sereja took part in before. If Sereja took part in one of two simultaneous rounds, the corresponding line looks like: "1 num2 num1" (where num2 is the identifier of this Div2 round, num1 is the identifier of the Div1 round). It is guaranteed that num1 - num2 = 1. If Sereja took part in a usual Div2 round, then the corresponding line looks like: "2 num" (where num is the identifier of this Div2 round). It is guaranteed that the identifiers of all given rounds are less than x.
Output
Print in a single line two integers — the minimum and the maximum number of rounds that Sereja could have missed.
Examples
Input
3 2
2 1
2 2
Output
0 0
Input
9 3
1 2 3
2 8
1 4 5
Output
2 3
Input
10 0
Output
5 9
Note
In the second sample we have unused identifiers of rounds 1, 6, 7. The minimum number of rounds Sereja could have missed equals to 2. In this case, the round with the identifier 1 will be a usual Div2 round and the round with identifier 6 will be synchronous with the Div1 round.
The maximum number of rounds equals 3. In this case all unused identifiers belong to usual Div2 rounds. | instruction | 0 | 64,340 | 17 | 128,680 |
Tags: greedy, implementation, math
Correct Solution:
```
n,k=map(int,input().split())
rounds=[]
rounds.append(0)
rounds.append(n)
for i in range(k):
arr=[int(i) for i in input().split()]
if arr[0]==1:
rounds.append(arr[1])
rounds.append(arr[2])
else:
rounds.append(arr[1])
rounds.sort()
ansmax=0
ansmin=0
for i in range(len(rounds)-1):
if rounds[i+1]-rounds[i]-1>0:
ansmin+=((rounds[i+1]-rounds[i]-1)//2)+((rounds[i+1]-rounds[i]-1)%2)
ansmax+=rounds[i+1]-rounds[i]-1
print(ansmin,ansmax)
``` | output | 1 | 64,340 | 17 | 128,681 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja is a coder and he likes to take part in Codesorfes rounds. However, Uzhland doesn't have good internet connection, so Sereja sometimes skips rounds.
Codesorfes has rounds of two types: Div1 (for advanced coders) and Div2 (for beginner coders). Two rounds, Div1 and Div2, can go simultaneously, (Div1 round cannot be held without Div2) in all other cases the rounds don't overlap in time. Each round has a unique identifier — a positive integer. The rounds are sequentially (without gaps) numbered with identifiers by the starting time of the round. The identifiers of rounds that are run simultaneously are different by one, also the identifier of the Div1 round is always greater.
Sereja is a beginner coder, so he can take part only in rounds of Div2 type. At the moment he is taking part in a Div2 round, its identifier equals to x. Sereja remembers very well that he has taken part in exactly k rounds before this round. Also, he remembers all identifiers of the rounds he has taken part in and all identifiers of the rounds that went simultaneously with them. Sereja doesn't remember anything about the rounds he missed.
Sereja is wondering: what minimum and what maximum number of Div2 rounds could he have missed? Help him find these two numbers.
Input
The first line contains two integers: x (1 ≤ x ≤ 4000) — the round Sereja is taking part in today, and k (0 ≤ k < 4000) — the number of rounds he took part in.
Next k lines contain the descriptions of the rounds that Sereja took part in before. If Sereja took part in one of two simultaneous rounds, the corresponding line looks like: "1 num2 num1" (where num2 is the identifier of this Div2 round, num1 is the identifier of the Div1 round). It is guaranteed that num1 - num2 = 1. If Sereja took part in a usual Div2 round, then the corresponding line looks like: "2 num" (where num is the identifier of this Div2 round). It is guaranteed that the identifiers of all given rounds are less than x.
Output
Print in a single line two integers — the minimum and the maximum number of rounds that Sereja could have missed.
Examples
Input
3 2
2 1
2 2
Output
0 0
Input
9 3
1 2 3
2 8
1 4 5
Output
2 3
Input
10 0
Output
5 9
Note
In the second sample we have unused identifiers of rounds 1, 6, 7. The minimum number of rounds Sereja could have missed equals to 2. In this case, the round with the identifier 1 will be a usual Div2 round and the round with identifier 6 will be synchronous with the Div1 round.
The maximum number of rounds equals 3. In this case all unused identifiers belong to usual Div2 rounds. | instruction | 0 | 64,341 | 17 | 128,682 |
Tags: greedy, implementation, math
Correct Solution:
```
n, q = map(int, input().split())
v = [0] * (n-1)
for i in range(q):
li = [int(i) for i in input().split()]
v[li[1]-1] = 2
if li[0] == 1:
v[li[2]-1] = 1
ma = v.count(0)
mi = 0
for i in range(n-1):
if v[i] == 0:
v[i] = 2
mi += 1
if i != n-2 and v[i+1] == 0:
v[i+1] = 1
print(mi, ma)
``` | output | 1 | 64,341 | 17 | 128,683 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja is a coder and he likes to take part in Codesorfes rounds. However, Uzhland doesn't have good internet connection, so Sereja sometimes skips rounds.
Codesorfes has rounds of two types: Div1 (for advanced coders) and Div2 (for beginner coders). Two rounds, Div1 and Div2, can go simultaneously, (Div1 round cannot be held without Div2) in all other cases the rounds don't overlap in time. Each round has a unique identifier — a positive integer. The rounds are sequentially (without gaps) numbered with identifiers by the starting time of the round. The identifiers of rounds that are run simultaneously are different by one, also the identifier of the Div1 round is always greater.
Sereja is a beginner coder, so he can take part only in rounds of Div2 type. At the moment he is taking part in a Div2 round, its identifier equals to x. Sereja remembers very well that he has taken part in exactly k rounds before this round. Also, he remembers all identifiers of the rounds he has taken part in and all identifiers of the rounds that went simultaneously with them. Sereja doesn't remember anything about the rounds he missed.
Sereja is wondering: what minimum and what maximum number of Div2 rounds could he have missed? Help him find these two numbers.
Input
The first line contains two integers: x (1 ≤ x ≤ 4000) — the round Sereja is taking part in today, and k (0 ≤ k < 4000) — the number of rounds he took part in.
Next k lines contain the descriptions of the rounds that Sereja took part in before. If Sereja took part in one of two simultaneous rounds, the corresponding line looks like: "1 num2 num1" (where num2 is the identifier of this Div2 round, num1 is the identifier of the Div1 round). It is guaranteed that num1 - num2 = 1. If Sereja took part in a usual Div2 round, then the corresponding line looks like: "2 num" (where num is the identifier of this Div2 round). It is guaranteed that the identifiers of all given rounds are less than x.
Output
Print in a single line two integers — the minimum and the maximum number of rounds that Sereja could have missed.
Examples
Input
3 2
2 1
2 2
Output
0 0
Input
9 3
1 2 3
2 8
1 4 5
Output
2 3
Input
10 0
Output
5 9
Note
In the second sample we have unused identifiers of rounds 1, 6, 7. The minimum number of rounds Sereja could have missed equals to 2. In this case, the round with the identifier 1 will be a usual Div2 round and the round with identifier 6 will be synchronous with the Div1 round.
The maximum number of rounds equals 3. In this case all unused identifiers belong to usual Div2 rounds. | instruction | 0 | 64,342 | 17 | 128,684 |
Tags: greedy, implementation, math
Correct Solution:
```
#!/usr/bin/env python3
def main():
x, t = map(int, input().split())
markers = [1] * (x - 1)
for c in range(t):
r = [int(n) for n in input().split()]
markers[r[1] - 1] = 0
if r[0] == 1:
markers[r[2] - 1] = 0
c = 0
max_num = 0
min_num = 0
for i in markers:
if i:
c += 1
continue
if c:
max_num += c
min_num += ((c + 1) >> 1)
c = 0
if c:
max_num += c
min_num += ((c + 1) >> 1)
print(min_num, max_num)
if __name__ == "__main__":
main()
``` | output | 1 | 64,342 | 17 | 128,685 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja is a coder and he likes to take part in Codesorfes rounds. However, Uzhland doesn't have good internet connection, so Sereja sometimes skips rounds.
Codesorfes has rounds of two types: Div1 (for advanced coders) and Div2 (for beginner coders). Two rounds, Div1 and Div2, can go simultaneously, (Div1 round cannot be held without Div2) in all other cases the rounds don't overlap in time. Each round has a unique identifier — a positive integer. The rounds are sequentially (without gaps) numbered with identifiers by the starting time of the round. The identifiers of rounds that are run simultaneously are different by one, also the identifier of the Div1 round is always greater.
Sereja is a beginner coder, so he can take part only in rounds of Div2 type. At the moment he is taking part in a Div2 round, its identifier equals to x. Sereja remembers very well that he has taken part in exactly k rounds before this round. Also, he remembers all identifiers of the rounds he has taken part in and all identifiers of the rounds that went simultaneously with them. Sereja doesn't remember anything about the rounds he missed.
Sereja is wondering: what minimum and what maximum number of Div2 rounds could he have missed? Help him find these two numbers.
Input
The first line contains two integers: x (1 ≤ x ≤ 4000) — the round Sereja is taking part in today, and k (0 ≤ k < 4000) — the number of rounds he took part in.
Next k lines contain the descriptions of the rounds that Sereja took part in before. If Sereja took part in one of two simultaneous rounds, the corresponding line looks like: "1 num2 num1" (where num2 is the identifier of this Div2 round, num1 is the identifier of the Div1 round). It is guaranteed that num1 - num2 = 1. If Sereja took part in a usual Div2 round, then the corresponding line looks like: "2 num" (where num is the identifier of this Div2 round). It is guaranteed that the identifiers of all given rounds are less than x.
Output
Print in a single line two integers — the minimum and the maximum number of rounds that Sereja could have missed.
Examples
Input
3 2
2 1
2 2
Output
0 0
Input
9 3
1 2 3
2 8
1 4 5
Output
2 3
Input
10 0
Output
5 9
Note
In the second sample we have unused identifiers of rounds 1, 6, 7. The minimum number of rounds Sereja could have missed equals to 2. In this case, the round with the identifier 1 will be a usual Div2 round and the round with identifier 6 will be synchronous with the Div1 round.
The maximum number of rounds equals 3. In this case all unused identifiers belong to usual Div2 rounds. | instruction | 0 | 64,343 | 17 | 128,686 |
Tags: greedy, implementation, math
Correct Solution:
```
#!/usr/bin/python -SOO
x,n = map(int,input().strip().split())
s = set(range(1,x))
for _ in range(n):
xs = list(map(int,input().strip().split()))
if xs[0] == 2:
s.remove(xs[1])
else:
s.remove(xs[1])
s.remove(xs[2])
m,i= 0,0
s = sorted(s)
while i < len(s):
if i==len(s)-1:
m+=1
break
elif s[i] == s[i+1]-1:
m += 1
i += 2
else:
m += 1
i += 1
print(m,len(s))
``` | output | 1 | 64,343 | 17 | 128,687 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja is a coder and he likes to take part in Codesorfes rounds. However, Uzhland doesn't have good internet connection, so Sereja sometimes skips rounds.
Codesorfes has rounds of two types: Div1 (for advanced coders) and Div2 (for beginner coders). Two rounds, Div1 and Div2, can go simultaneously, (Div1 round cannot be held without Div2) in all other cases the rounds don't overlap in time. Each round has a unique identifier — a positive integer. The rounds are sequentially (without gaps) numbered with identifiers by the starting time of the round. The identifiers of rounds that are run simultaneously are different by one, also the identifier of the Div1 round is always greater.
Sereja is a beginner coder, so he can take part only in rounds of Div2 type. At the moment he is taking part in a Div2 round, its identifier equals to x. Sereja remembers very well that he has taken part in exactly k rounds before this round. Also, he remembers all identifiers of the rounds he has taken part in and all identifiers of the rounds that went simultaneously with them. Sereja doesn't remember anything about the rounds he missed.
Sereja is wondering: what minimum and what maximum number of Div2 rounds could he have missed? Help him find these two numbers.
Input
The first line contains two integers: x (1 ≤ x ≤ 4000) — the round Sereja is taking part in today, and k (0 ≤ k < 4000) — the number of rounds he took part in.
Next k lines contain the descriptions of the rounds that Sereja took part in before. If Sereja took part in one of two simultaneous rounds, the corresponding line looks like: "1 num2 num1" (where num2 is the identifier of this Div2 round, num1 is the identifier of the Div1 round). It is guaranteed that num1 - num2 = 1. If Sereja took part in a usual Div2 round, then the corresponding line looks like: "2 num" (where num is the identifier of this Div2 round). It is guaranteed that the identifiers of all given rounds are less than x.
Output
Print in a single line two integers — the minimum and the maximum number of rounds that Sereja could have missed.
Examples
Input
3 2
2 1
2 2
Output
0 0
Input
9 3
1 2 3
2 8
1 4 5
Output
2 3
Input
10 0
Output
5 9
Note
In the second sample we have unused identifiers of rounds 1, 6, 7. The minimum number of rounds Sereja could have missed equals to 2. In this case, the round with the identifier 1 will be a usual Div2 round and the round with identifier 6 will be synchronous with the Div1 round.
The maximum number of rounds equals 3. In this case all unused identifiers belong to usual Div2 rounds. | instruction | 0 | 64,344 | 17 | 128,688 |
Tags: greedy, implementation, math
Correct Solution:
```
x,k=map(int,input().split())
s=set()
for i in range(k):
a=list(map(int,input().split()))
if a[0]==1:
s.add(a[1])
s.add(a[2])
else:
s.add(a[1])
smax=set()
smin=set()
for i in range(1,x):
if not i in s and not i+1 in s and not i in smin:
smin.add(i+1)
if not i in s:
smax.add(i)
if not i in s and i+1 in s:
smin.add(i)
print(len(smin),len(smax))
``` | output | 1 | 64,344 | 17 | 128,689 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja is a coder and he likes to take part in Codesorfes rounds. However, Uzhland doesn't have good internet connection, so Sereja sometimes skips rounds.
Codesorfes has rounds of two types: Div1 (for advanced coders) and Div2 (for beginner coders). Two rounds, Div1 and Div2, can go simultaneously, (Div1 round cannot be held without Div2) in all other cases the rounds don't overlap in time. Each round has a unique identifier — a positive integer. The rounds are sequentially (without gaps) numbered with identifiers by the starting time of the round. The identifiers of rounds that are run simultaneously are different by one, also the identifier of the Div1 round is always greater.
Sereja is a beginner coder, so he can take part only in rounds of Div2 type. At the moment he is taking part in a Div2 round, its identifier equals to x. Sereja remembers very well that he has taken part in exactly k rounds before this round. Also, he remembers all identifiers of the rounds he has taken part in and all identifiers of the rounds that went simultaneously with them. Sereja doesn't remember anything about the rounds he missed.
Sereja is wondering: what minimum and what maximum number of Div2 rounds could he have missed? Help him find these two numbers.
Input
The first line contains two integers: x (1 ≤ x ≤ 4000) — the round Sereja is taking part in today, and k (0 ≤ k < 4000) — the number of rounds he took part in.
Next k lines contain the descriptions of the rounds that Sereja took part in before. If Sereja took part in one of two simultaneous rounds, the corresponding line looks like: "1 num2 num1" (where num2 is the identifier of this Div2 round, num1 is the identifier of the Div1 round). It is guaranteed that num1 - num2 = 1. If Sereja took part in a usual Div2 round, then the corresponding line looks like: "2 num" (where num is the identifier of this Div2 round). It is guaranteed that the identifiers of all given rounds are less than x.
Output
Print in a single line two integers — the minimum and the maximum number of rounds that Sereja could have missed.
Examples
Input
3 2
2 1
2 2
Output
0 0
Input
9 3
1 2 3
2 8
1 4 5
Output
2 3
Input
10 0
Output
5 9
Note
In the second sample we have unused identifiers of rounds 1, 6, 7. The minimum number of rounds Sereja could have missed equals to 2. In this case, the round with the identifier 1 will be a usual Div2 round and the round with identifier 6 will be synchronous with the Div1 round.
The maximum number of rounds equals 3. In this case all unused identifiers belong to usual Div2 rounds. | instruction | 0 | 64,345 | 17 | 128,690 |
Tags: greedy, implementation, math
Correct Solution:
```
x,k=map(int,input().split(" "))
hs=[0]*4001
hs[x]=1
for i in range(k):
li=list(map(int,input().split(" ")))
hs[li[1]]=1
if li[0]==1:
hs[li[2]]=1
mx=0
for i in range(1,x):
if hs[i]==0:
mx+=1
mi=mx
i=2
while i<x:
if hs[i]==0 and hs[i-1]==0:
mi-=1
i+=1
i+=1
print(mi,mx)
``` | output | 1 | 64,345 | 17 | 128,691 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja is a coder and he likes to take part in Codesorfes rounds. However, Uzhland doesn't have good internet connection, so Sereja sometimes skips rounds.
Codesorfes has rounds of two types: Div1 (for advanced coders) and Div2 (for beginner coders). Two rounds, Div1 and Div2, can go simultaneously, (Div1 round cannot be held without Div2) in all other cases the rounds don't overlap in time. Each round has a unique identifier — a positive integer. The rounds are sequentially (without gaps) numbered with identifiers by the starting time of the round. The identifiers of rounds that are run simultaneously are different by one, also the identifier of the Div1 round is always greater.
Sereja is a beginner coder, so he can take part only in rounds of Div2 type. At the moment he is taking part in a Div2 round, its identifier equals to x. Sereja remembers very well that he has taken part in exactly k rounds before this round. Also, he remembers all identifiers of the rounds he has taken part in and all identifiers of the rounds that went simultaneously with them. Sereja doesn't remember anything about the rounds he missed.
Sereja is wondering: what minimum and what maximum number of Div2 rounds could he have missed? Help him find these two numbers.
Input
The first line contains two integers: x (1 ≤ x ≤ 4000) — the round Sereja is taking part in today, and k (0 ≤ k < 4000) — the number of rounds he took part in.
Next k lines contain the descriptions of the rounds that Sereja took part in before. If Sereja took part in one of two simultaneous rounds, the corresponding line looks like: "1 num2 num1" (where num2 is the identifier of this Div2 round, num1 is the identifier of the Div1 round). It is guaranteed that num1 - num2 = 1. If Sereja took part in a usual Div2 round, then the corresponding line looks like: "2 num" (where num is the identifier of this Div2 round). It is guaranteed that the identifiers of all given rounds are less than x.
Output
Print in a single line two integers — the minimum and the maximum number of rounds that Sereja could have missed.
Examples
Input
3 2
2 1
2 2
Output
0 0
Input
9 3
1 2 3
2 8
1 4 5
Output
2 3
Input
10 0
Output
5 9
Note
In the second sample we have unused identifiers of rounds 1, 6, 7. The minimum number of rounds Sereja could have missed equals to 2. In this case, the round with the identifier 1 will be a usual Div2 round and the round with identifier 6 will be synchronous with the Div1 round.
The maximum number of rounds equals 3. In this case all unused identifiers belong to usual Div2 rounds. | instruction | 0 | 64,346 | 17 | 128,692 |
Tags: greedy, implementation, math
Correct Solution:
```
import sys
f = sys.stdin
# f = open("input.txt", "r")
x, k = map(int, f.readline().strip().split())
a = []
for i in range(k):
a += list(map(int, f.readline().strip().split()))[1:]
a.sort()
sub = list(set(range(1, x)) - set(a))
max = len(sub)
i = 0
sync = 0
while i < len(sub)-1:
if sub[i+1] - sub[i] == 1:
i += 1
sync += 1
i += 1
min = max - sync
print(min, max)
``` | output | 1 | 64,346 | 17 | 128,693 |
Provide a correct Python 3 solution for this coding contest problem.
We will host a rock-paper-scissors tournament with N people. The participants are called Person 1, Person 2, \ldots, Person N. For any two participants, the result of the match between them is determined in advance. This information is represented by positive integers A_{i,j} ( 1 \leq j < i \leq N ) as follows:
* If A_{i,j} = 0, Person j defeats Person i.
* If A_{i,j} = 1, Person i defeats Person j.
The tournament proceeds as follows:
* We will arrange the N participants in a row, in the order Person 1, Person 2, \ldots, Person N from left to right.
* We will randomly choose two consecutive persons in the row. They will play a match against each other, and we will remove the loser from the row. We will repeat this process N-1 times, and the last person remaining will be declared the champion.
Find the number of persons with the possibility of becoming the champion.
Constraints
* 1 \leq N \leq 2000
* A_{i,j} is 0 or 1.
Input
Input is given from Standard Input in the following format:
N
A_{2,1}
A_{3,1}A_{3,2}
:
A_{N,1}\ldotsA_{N,N-1}
Output
Print the number of persons with the possibility of becoming the champion.
Examples
Input
3
0
10
Output
2
Input
6
0
11
111
1111
11001
Output
3 | instruction | 0 | 64,634 | 17 | 129,268 |
"Correct Solution:
```
N = int(input())
X = [[0] * N for _ in range(N)]
for i in range(1, N):
X[i][:i] = [int(a) for a in input()]
for i in range(N):
for j in range(i+1, N):
X[i][j] = X[j][i]^1
A = [1<<i for i in range(N)]
B = [1<<i for i in range(N)]
for i in range(N):
for j in range(i):
if i and B[i-1] >> j & 1 and X[i][j]: A[i] |= A[j]
for j in range(i):
if A[i] >> j+1 & 1 and X[j][i]: B[i] |= B[j]
print(sum([(A[i] & 1) * (B[N-1]>>i & 1) for i in range(N)]))
``` | output | 1 | 64,634 | 17 | 129,269 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will host a rock-paper-scissors tournament with N people. The participants are called Person 1, Person 2, \ldots, Person N. For any two participants, the result of the match between them is determined in advance. This information is represented by positive integers A_{i,j} ( 1 \leq j < i \leq N ) as follows:
* If A_{i,j} = 0, Person j defeats Person i.
* If A_{i,j} = 1, Person i defeats Person j.
The tournament proceeds as follows:
* We will arrange the N participants in a row, in the order Person 1, Person 2, \ldots, Person N from left to right.
* We will randomly choose two consecutive persons in the row. They will play a match against each other, and we will remove the loser from the row. We will repeat this process N-1 times, and the last person remaining will be declared the champion.
Find the number of persons with the possibility of becoming the champion.
Constraints
* 1 \leq N \leq 2000
* A_{i,j} is 0 or 1.
Input
Input is given from Standard Input in the following format:
N
A_{2,1}
A_{3,1}A_{3,2}
:
A_{N,1}\ldotsA_{N,N-1}
Output
Print the number of persons with the possibility of becoming the champion.
Examples
Input
3
0
10
Output
2
Input
6
0
11
111
1111
11001
Output
3
Submitted Solution:
```
from collections import defaultdict
inpl = lambda: list(map(int,input().split()))
N = int(input())
A = [[]]
for _ in range(N-1):
A.append(list(map(int,list(input()))))
def match(i,j):
if i > j:
return bool(A[i][j])
else:
return not bool(A[j][i])
winmem = defaultdict(lambda: None)
def winnerlist(left,right):
ans = winmem[(left,right)]
if ans is not None:
return ans
elif right - left <= 1:
return set({left})
ans = set()
for i in range(left+1,right):
left_winners = winnerlist(left,i)
right_winners = winnerlist(i,right)
for l in left_winners:
for r in right_winners:
if match(l,r):
ans.add(l)
else:
ans.add(r)
winmem[(left,right)] = ans
return ans
winners = winnerlist(0,N)
print(len(winners))
``` | instruction | 0 | 64,635 | 17 | 129,270 |
No | output | 1 | 64,635 | 17 | 129,271 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will host a rock-paper-scissors tournament with N people. The participants are called Person 1, Person 2, \ldots, Person N. For any two participants, the result of the match between them is determined in advance. This information is represented by positive integers A_{i,j} ( 1 \leq j < i \leq N ) as follows:
* If A_{i,j} = 0, Person j defeats Person i.
* If A_{i,j} = 1, Person i defeats Person j.
The tournament proceeds as follows:
* We will arrange the N participants in a row, in the order Person 1, Person 2, \ldots, Person N from left to right.
* We will randomly choose two consecutive persons in the row. They will play a match against each other, and we will remove the loser from the row. We will repeat this process N-1 times, and the last person remaining will be declared the champion.
Find the number of persons with the possibility of becoming the champion.
Constraints
* 1 \leq N \leq 2000
* A_{i,j} is 0 or 1.
Input
Input is given from Standard Input in the following format:
N
A_{2,1}
A_{3,1}A_{3,2}
:
A_{N,1}\ldotsA_{N,N-1}
Output
Print the number of persons with the possibility of becoming the champion.
Examples
Input
3
0
10
Output
2
Input
6
0
11
111
1111
11001
Output
3
Submitted Solution:
```
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()
from functools import lru_cache
def main():
N = II()
A = [[0] * N for _ in range(N)]
for i in range(1, N):
s = SI()
for j, aa in enumerate(s):
aa = int(aa)
A[i][j] = aa
A[j][i] = 1 - aa
@lru_cache(maxsize=10**7)
def win(k, start, end):
ret = 0 if start != k else 1
for l in range(start, k):
if A[k][l] == 1:
if win(l, start, k):
ret = 1
break
if not ret:
return 0
ret = 0 if end - 1 != k else 1
for r in range(k + 1, end):
if A[k][r] == 1:
if win(r, k + 1, end):
ret = 1
break
return ret
ans = sum(win(k, 0, N) for k in range(N))
return ans
print(main())
``` | instruction | 0 | 64,636 | 17 | 129,272 |
No | output | 1 | 64,636 | 17 | 129,273 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will host a rock-paper-scissors tournament with N people. The participants are called Person 1, Person 2, \ldots, Person N. For any two participants, the result of the match between them is determined in advance. This information is represented by positive integers A_{i,j} ( 1 \leq j < i \leq N ) as follows:
* If A_{i,j} = 0, Person j defeats Person i.
* If A_{i,j} = 1, Person i defeats Person j.
The tournament proceeds as follows:
* We will arrange the N participants in a row, in the order Person 1, Person 2, \ldots, Person N from left to right.
* We will randomly choose two consecutive persons in the row. They will play a match against each other, and we will remove the loser from the row. We will repeat this process N-1 times, and the last person remaining will be declared the champion.
Find the number of persons with the possibility of becoming the champion.
Constraints
* 1 \leq N \leq 2000
* A_{i,j} is 0 or 1.
Input
Input is given from Standard Input in the following format:
N
A_{2,1}
A_{3,1}A_{3,2}
:
A_{N,1}\ldotsA_{N,N-1}
Output
Print the number of persons with the possibility of becoming the champion.
Examples
Input
3
0
10
Output
2
Input
6
0
11
111
1111
11001
Output
3
Submitted Solution:
```
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(1000000)
n = int(input())
people = [i for i in range(n)]
a = [[-1] * n for _ in range(n)]
for i in range(n-1):
ai = input()
for j, aij in enumerate(ai):
a[i+1][j] = int(aij)
a[j][i+1] = (int(aij) + 1) % 2
memo = {}
# startからendの範囲で優勝の可能性があるやつ
def solve(start, end):
key = (start, end)
if key in memo:
return memo[key]
if start == end:
return [start]
elif start + 1 == end:
if a[start][end] == 1:
return [start]
else:
return [end]
winable = set()
# 全勝の存在をチェック
for i in range(start, end):
if sum(a[i]) == end - start + 1 - 2:
return [i]
for i in range(start+1, end+1):
left_winable = solve(start, i-1)
if (start, i-1) not in memo:
memo[(start, i-1)] = left_winable
right_winable = solve(i, end)
if (i, end) not in memo:
memo[(i, end)] = right_winable
for l in left_winable:
for r in right_winable:
if a[l][r] == 1:
winable.add(l)
else:
winable.add(r)
return list(winable)
def main():
winable = solve(0, n-1)
print(len(winable))
if __name__ == '__main__':
main()
``` | instruction | 0 | 64,637 | 17 | 129,274 |
No | output | 1 | 64,637 | 17 | 129,275 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5 | instruction | 0 | 65,076 | 17 | 130,152 |
Tags: binary search, data structures, greedy
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = sorted(zip(map(int, input().split()), range(n)))
l, r = 0, n-1
while l < r:
m = (l+r) // 2
s0 = sum(a[i][0] for i in range(m+1))
flag = True
for i in range(m+1, n):
if a[i][0] <= s0:
s0 += a[i][0]
else:
flag = False
break
if flag:
r = m
else:
l = m+1
f = []
for i in range(l, n):
f.append(a[i][1] + 1)
print(len(f))
print(*sorted(f))
``` | output | 1 | 65,076 | 17 | 130,153 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5 | instruction | 0 | 65,077 | 17 | 130,154 |
Tags: binary search, data structures, greedy
Correct Solution:
```
for _ in range(int(input())):
input()
arr = map(int,input().split())
u = sorted((a,i) for i,a in enumerate(arr, 1))
cur = 0
res = []
for a,i in u:
if cur < a:
res.clear()
res.append(i)
cur += a
print(len(res))
print(*sorted(res))
``` | output | 1 | 65,077 | 17 | 130,155 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5 | instruction | 0 | 65,078 | 17 | 130,156 |
Tags: binary search, data structures, greedy
Correct Solution:
```
from bisect import insort_left
from collections import deque
T = int(input())
for _ in range(T):
N = int(input())
ori_nums = list(map(int, input().split()))
nums = []
for i in range(N):
nums.append((ori_nums[i], i + 1))
nums.sort()
# print(ori_nums)
# print(nums)
presum = [0]
for i in range(N):
presum.append(presum[-1] + nums[i][0])
can = set([i + 1 for i in range(N)])
idx = -1
for i in range(N - 1):
if presum[i + 1] < nums[i + 1][0]:
# can.remove(nums[i][1])
idx = i
for i in range(idx + 1):
can.remove(nums[i][1])
print(len(can))
print((" ").join(list(map(str, sorted(can)))))
``` | output | 1 | 65,078 | 17 | 130,157 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5 | instruction | 0 | 65,079 | 17 | 130,158 |
Tags: binary search, data structures, greedy
Correct Solution:
```
import sys,math,itertools
from collections import Counter,deque,defaultdict
from bisect import bisect_left,bisect_right
from heapq import heappop,heappush,heapify, nlargest
from copy import deepcopy
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_1(): return list(map(lambda x:int(x)-1, sys.stdin.readline().split()))
def inps(): return sys.stdin.readline()
def inpsl(x): tmp = sys.stdin.readline(); return tmp[:x]
def err(x): print(x); exit()
for _ in range(inp()):
n = inp()
a = inpl()
d = defaultdict(list)
for i,x in enumerate(a): d[x].append(i)
sora = sorted(a)
acc = list(itertools.accumulate(sora))
ok = []
for i in range(n)[::-1]:
if i==n-1: ok.append(sora[i])
else:
if acc[i] >= sora[i+1]:ok.append(sora[i])
else: break
res = []
for x in list(set(ok)):
for ind in d[x]:
res.append(ind+1)
print(len(res))
print(*sorted(res))
``` | output | 1 | 65,079 | 17 | 130,159 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5 | instruction | 0 | 65,080 | 17 | 130,160 |
Tags: binary search, data structures, greedy
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
A = list(map(int , input().split()))
x = [0] * n
for i in range(n):
x[i] = A[i]
A.sort(reverse = True)
l = 0
r = n -1
B = [0]*n
B[n -1] = A[n - 1]
for i in range(n - 2, -1,-1):
B[i] = B[i + 1] + A[i]
ans = []
#print(A)
#print(B)
s = 10**9
for __ in range(30):
m = (l + r)//2
z = B[m]
#print(m)
fl = 1
for i in range(m - 1, -1,-1 ):
if z >= A[i]:
z+=A[i]
fl = 1
else:
fl = 0
break
if fl == 1:
s = min(s , A[m])
l = m
else:
r = m
#print(m)
#print(x)
for i in range(n):
if x[i] >= s:
ans.append(i +1)
print(len(ans))
print(*ans)
``` | output | 1 | 65,080 | 17 | 130,161 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5 | instruction | 0 | 65,081 | 17 | 130,162 |
Tags: binary search, data structures, greedy
Correct Solution:
```
from sys import stdin
input = stdin.readline
def check_win(index):
z = b[index]
for i in range(n):
if i == index:
continue
if z >= b[i]:
z += b[i]
if z >= b[-1]:
return True
else:
return False
return True
def binary_search():
l = 0
r = n
while l < r:
m = l + ((r - l) // 2)
if check_win(m):
r = m
z = m
else:
l = m + 1
return b[z]
t = int(input())
for _ in range(t):
n = int(input())
a = [int(x) for x in input().split()]
b = sorted(a)
x = binary_search()
ans = []
for i in range(n):
if a[i] >= x:
ans.append(i+1)
print(len(ans))
print(*ans)
``` | output | 1 | 65,081 | 17 | 130,163 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5 | instruction | 0 | 65,082 | 17 | 130,164 |
Tags: binary search, data structures, greedy
Correct Solution:
```
import math
import collections
def read_list() -> list:
return [int(i) for i in input().strip().split()]
def read_num() -> int:
return int(input().strip())
t = read_num()
for i in range(t):
n = read_num()
arr = read_list()
idx_tokens = [(i + 1, j) for i, j in enumerate(arr)]
tmp = sorted(idx_tokens, key = lambda x: x[1], reverse=True)
ans = [tmp[0]]
s = sum(i[1] for i in idx_tokens)
for j in range(1, n):
s -= ans[-1][1]
if ans[-1][1] <= s or tmp[j][1] == ans[-1][1]:
ans.append(tmp[j])
else:
break
ans = sorted(ans, key=lambda x: x[0])
print(len(ans))
for i in ans:
print(i[0], end=" ")
print()
``` | output | 1 | 65,082 | 17 | 130,165 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5 | instruction | 0 | 65,083 | 17 | 130,166 |
Tags: binary search, data structures, greedy
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
arr=list(map(int,input().split()));d={}
d1={}
arr1=[]
for i in range(n):
d[arr[i]]=d.get(arr[i],0)+1
for i in d:
arr1.append([d[i],i])
arr1=sorted(arr1,key=lambda x:x[1])
summ=sum(arr)
maxx=max(arr)
# print(arr1)
d1={};ans=[]
for i in range(len(arr1)-1,-1,-1):
# print(summ,arr1[i][1]*arr1[i][0],maxx)
if summ>=maxx:
summ-=arr1[i][0]*arr1[i][1]
maxx=arr1[i][1]
d1[arr1[i][1]]=1
else:break
#print(d1)
for i in range(n):
if d1.get(arr[i],0)>0:ans.append(i+1)
print(len(ans))
print(*ans)
``` | output | 1 | 65,083 | 17 | 130,167 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5
Submitted Solution:
```
import sys
import math
input = sys.stdin.readline
mod=10**9+7
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
for _ in range(inp()):
n=inp()
l=inlt()
x=[]
for i in range(n):
x.append([l[i],i+1])
x.sort(key=lambda x:x[0])
out=[]
s=0
a=[]
y=0
for i in range(n):
s=s+x[i][0]
a.append(s)
for i in range(n-1):
if a[i]<x[i+1][0]:
y=i+1
for i in range(y,len(x)):
out.append(x[i][1])
out.sort()
print(len(out))
print(" ".join(str(i) for i in out))
``` | instruction | 0 | 65,084 | 17 | 130,168 |
Yes | output | 1 | 65,084 | 17 | 130,169 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5
Submitted Solution:
```
def take_first (elem):
return elem[0]
q = int(input())
while q > 0:
n = int(input())
a = input().split()
b = []
for i in range (n):
p = []
p.append(int(a[i]))
p.append(i)
b.append(p)
sorted_list = sorted(b, key=take_first)
sorted_list[0].append(sorted_list[0][0])
for i in range (1, n):
sorted_list[i].append(sorted_list[i-1][2]+sorted_list[i][0])
ans = []
ans.append(sorted_list[n-1][1]+1)
i = n-2
while i >= 0:
if sorted_list[i][2] < sorted_list[i+1][0]:
break
ans.append(sorted_list[i][1]+1)
i = i-1
ans.sort()
print(len(ans))
for i in ans:
print(i, end=' ')
print()
q = q-1
``` | instruction | 0 | 65,085 | 17 | 130,170 |
Yes | output | 1 | 65,085 | 17 | 130,171 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5
Submitted Solution:
```
t = int(input())
while t>0:
t-=1
n = int(input())
args = list(map(int,input().split()))
players = [(i+1, args[i]) for i in range(n)]
players.sort(key = lambda x : x[1])
s = 0
cur = 0
for i in range(n-1):
s += players[i][1]
if s < players[i+1][1]:
cur = i+1
ans = []
for i in range(cur, n):
ans.append(players[i][0])
ans.sort()
print(len(ans))
print(*ans)
``` | instruction | 0 | 65,086 | 17 | 130,172 |
Yes | output | 1 | 65,086 | 17 | 130,173 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5
Submitted Solution:
```
from collections import defaultdict
def solve(n, arr):
pos = defaultdict(list)
for (index, val) in enumerate(arr):
pos[val].append(index+1)
arr = sorted(arr)
prefix = [arr[0]]
for i in range(1, n):
prefix.append(arr[i]+prefix[i-1])
for index in range(n-2, -1, -1):
if arr[index+1] > prefix[index]:
ans = []
for item in arr[index+1:]:
ans.append(pos[item].pop())
return sorted(ans)
return list(range(1,n+1))
t = int(input())
for case in range(t):
n = int(input())
arr = list(map(int, input().split(" ")))
result = solve(n, arr)
print(len(result))
print(" ".join(list(map(str, result))))
``` | instruction | 0 | 65,087 | 17 | 130,174 |
Yes | output | 1 | 65,087 | 17 | 130,175 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
d=dict()
for i in range(n):
d[i+1]=l[i]
d={k: d[k] for k in sorted(d, key=d.get)}
ans=[]
l=list(d.values())
ind=list(d.keys())
for i in range(n-1):
if(l[i]>=l[i+1]):
ans.append(ind[i])
l[i+1]+=l[i]
ans.append(ind[-1])
print(len(ans))
print(*sorted(ans))
``` | instruction | 0 | 65,088 | 17 | 130,176 |
No | output | 1 | 65,088 | 17 | 130,177 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5
Submitted Solution:
```
t=int(input())
while t > 0 :
n = int(input())
a = [int(i) for i in input().split()]
a.sort()
dp = []
b = []
for i in range(0,n) :
if i == 0 :
dp.append(a[i])
else :
dp.append(dp[i-1]+a[i])
for i in range (0,n) :
j = i
while j + 1 < n and a[j] == a[j+1] :
j = j + 1
while i + 1 < n and a[i] == a[i+1] :
dp[i]=dp[j]
i = i + 1
e,s=[n-1,0]
b.append(n-1)
for i in range(n-2,-1,-1) :
if dp[i] >= a[i+1] :
dp[i] = dp[i+1]
b.append(i)
else :
break
b.sort()
print(len(b))
for i in range(0,len(b)) :
b[i]=str(b[i]+1)
c = ' '
print(c.join(b))
t = t - 1
``` | instruction | 0 | 65,089 | 17 | 130,178 |
No | output | 1 | 65,089 | 17 | 130,179 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
import heapq as h
import bisect
import math as mt
from types import GeneratorType
BUFSIZE = 8192
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index+1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
import sys
from math import ceil,log2
INT_MAX = sys.maxsize
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
import collections as col
import math, string
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
def minVal(x, y) :
return x if (x < y) else y;
# A utility function to get the
# middle index from corner indexes.
def getMid(s, e) :
return s + (e - s) // 2;
""" A recursive function to get the
minimum value in a given range
of array indexes. The following
are parameters for this function.
st --> Pointer to segment tree
index --> Index of current node in the
segment tree. Initially 0 is
passed as root is always at index 0
ss & se --> Starting and ending indexes
of the segment represented
by current node, i.e., st[index]
qs & qe --> Starting and ending indexes of query range """
def RMQUtil( st, ss, se, qs, qe, index) :
# If segment of this node is a part
# of given range, then return
# the min of the segment
if (qs <= ss and qe >= se) :
return st[index];
# If segment of this node
# is outside the given range
if (se < qs or ss > qe) :
return INT_MAX;
# If a part of this segment
# overlaps with the given range
mid = getMid(ss, se);
return minVal(RMQUtil(st, ss, mid, qs,
qe, 2 * index + 1),
RMQUtil(st, mid + 1, se,
qs, qe, 2 * index + 2));
# Return minimum of elements in range
# from index qs (query start) to
# qe (query end). It mainly uses RMQUtil()
def RMQ( st, n, qs, qe) :
# Check for erroneous input values
if (qs < 0 or qe > n - 1 or qs > qe) :
print("Invalid Input");
return -1;
return RMQUtil(st, 0, n - 1, qs, qe, 0);
# A recursive function that constructs
# Segment Tree for array[ss..se].
# si is index of current node in segment tree st
def constructSTUtil(arr, ss, se, st, si) :
# If there is one element in array,
# store it in current node of
# segment tree and return
if (ss == se) :
st[si] = arr[ss];
return arr[ss];
# If there are more than one elements,
# then recur for left and right subtrees
# and store the minimum of two values in this node
mid = getMid(ss, se);
st[si] = minVal(constructSTUtil(arr, ss, mid,
st, si * 2 + 1),
constructSTUtil(arr, mid + 1, se,
st, si * 2 + 2));
return st[si];
"""Function to construct segment tree
from given array. This function allocates
memory for segment tree and calls constructSTUtil()
to fill the allocated memory """
def constructST( arr, n) :
# Allocate memory for segment tree
# Height of segment tree
x = (int)(ceil(log2(n)));
# Maximum size of segment tree
max_size = 2 * (int)(2**x) - 1;
st = [0] * (max_size);
# Fill the allocated memory st
constructSTUtil(arr, 0, n - 1, st, 0);
# Return the constructed segment tree
return st;
MOD = 10**9+7
mod=10**9+7
#t=1
p=10**9+7
def ncr_util():
inv[0]=inv[1]=1
fact[0]=fact[1]=1
for i in range(2,300001):
inv[i]=(inv[i%p]*(p-p//i))%p
for i in range(1,300001):
inv[i]=(inv[i-1]*inv[i])%p
fact[i]=(fact[i-1]*i)%p
def z_array(s1):
n = len(s1)
z=[0]*(n)
l, r, k = 0, 0, 0
for i in range(1,n):
# if i>R nothing matches so we will calculate.
# Z[i] using naive way.
if i > r:
l, r = i, i
# R-L = 0 in starting, so it will start
# checking from 0'th index. For example,
# for "ababab" and i = 1, the value of R
# remains 0 and Z[i] becomes 0. For string
# "aaaaaa" and i = 1, Z[i] and R become 5
while r < n and s1[r - l] == s1[r]:
r += 1
z[i] = r - l
r -= 1
else:
# k = i-L so k corresponds to number which
# matches in [L,R] interval.
k = i - l
# if Z[k] is less than remaining interval
# then Z[i] will be equal to Z[k].
# For example, str = "ababab", i = 3, R = 5
# and L = 2
if z[k] < r - i + 1:
z[i] = z[k]
# For example str = "aaaaaa" and i = 2,
# R is 5, L is 0
else:
# else start from R and check manually
l = i
while r < n and s1[r - l] == s1[r]:
r += 1
z[i] = r - l
r -= 1
return z
'''
MAXN1=100001
spf=[0]*MAXN1
def sieve():
prime=[]
spf[1]=1
for i in range(2,MAXN1):
spf[i]=i
for i in range(4,MAXN1,2):
spf[i]=2
for i in range(3,math.ceil(math.sqrt(MAXN1))):
if spf[i]==i:
for j in range(i*i,MAXN1,i):
if spf[j]==j:
spf[j]=i
for i in range(2,MAXN1):
if spf[i]==i:
prime.append(i)
return prime
prime=sieve()
def factor(x):
d1={}
x1=x
while x!=1:
d1[spf[x]]=d1.get(spf[x],0)+1
x//=spf[x]
return d1
def primeFactors(n):
d1={}
while n % 2 == 0:
d1[2]=d1.get(2,0)+1
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
# while i divides n , print i ad divide n
while n % i== 0:
d1[i]=d1.get(i,0)+1
n = n // i
if n > 2:
d1[n]=d1.get(n,0)+1
return d1
'''
def fs(x):
if x<2:
return 0
return (x*(x-1))//2
t=int(input())
#t=1
def solve(l):
d={}
for i in range(n):
if d.get(l[i],-1)==-1:
d[l[i]]=[]
d[l[i]].append(i)
for i in d:
d[i].sort()
l.sort()
l=list(set(l))
ans=[]
cnt=0
for i in range(len(l)):
cnt+=l[i]*(len(d[l[i]]))
if l[i]<cnt:
for j in range(len(d[l[i]])):
ans.append(d[l[i]][j]+1)
ans.sort()
print(len(ans))
print(*ans[:])
for _ in range(t):
#d={}
#n,k=map(int,input().split())
n=int(input())
#b=input()
# s2=input()
l=list(map(int,input().split()))
#l.sort()
#l2=list(map(int,input().split()))
#l.sort()
#l.sort(revrese=True)
#x,y=(map(int,input().split()))
#l=str(n)
#l.sort(reverse=True)
#l2.sort(reverse=True)
#l1.sort(reverse=True)
(solve(l))
#print(solve())
``` | instruction | 0 | 65,090 | 17 | 130,180 |
No | output | 1 | 65,090 | 17 | 130,181 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A championship is held in Berland, in which n players participate. The player with the number i has a_i (a_i ≥ 1) tokens.
The championship consists of n-1 games, which are played according to the following rules:
* in each game, two random players with non-zero tokens are selected;
* the player with more tokens is considered the winner of the game (in case of a tie, the winner is chosen randomly);
* the winning player takes all of the loser's tokens;
The last player with non-zero tokens is the winner of the championship.
All random decisions that are made during the championship are made equally probable and independently.
For example, if n=4, a = [1, 2, 4, 3], then one of the options for the game (there could be other options) is:
* during the first game, the first and fourth players were selected. The fourth player has more tokens, so he takes the first player's tokens. Now a = [0, 2, 4, 4];
* during the second game, the fourth and third players were selected. They have the same number of tokens, but in a random way, the third player is the winner. Now a = [0, 2, 8, 0];
* during the third game, the second and third players were selected. The third player has more tokens, so he takes the second player's tokens. Now a = [0, 0, 10, 0];
* the third player is declared the winner of the championship.
Championship winners will receive personalized prizes. Therefore, the judges want to know in advance which players have a chance of winning, i.e have a non-zero probability of winning the championship. You have been asked to find all such players.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case consists of one positive integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of players in the championship.
The second line of each test case contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the number of tokens the players have.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print the number of players who have a nonzero probability of winning the championship. On the next line print the numbers of these players in increasing order. Players are numbered starting from one in the order in which they appear in the input.
Example
Input
2
4
1 2 4 3
5
1 1 1 1 1
Output
3
2 3 4
5
1 2 3 4 5
Submitted Solution:
```
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n, values = int(input()), list(sorted([[int(i), i] for i in input().split()]))
winner, psa, ans = [False for i in range(n - 1)] + [True], [0], [n] # largest always wins
for i in range(n):
psa.append(psa[i] + values[i][0])
for i in range(n - 2, -1, -1):
if psa[i + 1] >= values[i + 1][0] and winner[i + 1]:
winner[i] = True
ans.append(i + 1)
ans.sort()
print(len(ans))
print(*ans)
``` | instruction | 0 | 65,091 | 17 | 130,182 |
No | output | 1 | 65,091 | 17 | 130,183 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Susie, thanks to her older brother, likes to play with cars. Today she decided to set up a tournament between them. The process of a tournament is described in the next paragraph.
There are n toy cars. Each pair collides. The result of a collision can be one of the following: no car turned over, one car turned over, both cars turned over. A car is good if it turned over in no collision. The results of the collisions are determined by an n × n matrix А: there is a number on the intersection of the і-th row and j-th column that describes the result of the collision of the і-th and the j-th car:
* - 1: if this pair of cars never collided. - 1 occurs only on the main diagonal of the matrix.
* 0: if no car turned over during the collision.
* 1: if only the i-th car turned over during the collision.
* 2: if only the j-th car turned over during the collision.
* 3: if both cars turned over during the collision.
Susie wants to find all the good cars. She quickly determined which cars are good. Can you cope with the task?
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of cars.
Each of the next n lines contains n space-separated integers that determine matrix A.
It is guaranteed that on the main diagonal there are - 1, and - 1 doesn't appear anywhere else in the matrix.
It is guaranteed that the input is correct, that is, if Aij = 1, then Aji = 2, if Aij = 3, then Aji = 3, and if Aij = 0, then Aji = 0.
Output
Print the number of good cars and in the next line print their space-separated indices in the increasing order.
Examples
Input
3
-1 0 0
0 -1 1
0 2 -1
Output
2
1 3
Input
4
-1 3 3 3
3 -1 3 3
3 3 -1 3
3 3 3 -1
Output
0 | instruction | 0 | 65,190 | 17 | 130,380 |
Tags: implementation
Correct Solution:
```
#!/usr/bin/python3
import itertools as ittls
from collections import Counter
import re
def inputarray(func=int):
return map(func, input().split())
# ---------------------------------------
# --------------------------------------
N = int(input())
mask = [1]*N
for i in range(N):
A = inputarray()
for j, v in enumerate(A):
if v == 1 or v == 3:
mask[i] = 0
if v == 2 or v == 3:
mask[j] = 0
res = list(map(lambda x: str(x[0] + 1),
filter(lambda x: x[1]==1,
enumerate(mask))))
print(len(res))
print(' '.join(res))
``` | output | 1 | 65,190 | 17 | 130,381 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Susie, thanks to her older brother, likes to play with cars. Today she decided to set up a tournament between them. The process of a tournament is described in the next paragraph.
There are n toy cars. Each pair collides. The result of a collision can be one of the following: no car turned over, one car turned over, both cars turned over. A car is good if it turned over in no collision. The results of the collisions are determined by an n × n matrix А: there is a number on the intersection of the і-th row and j-th column that describes the result of the collision of the і-th and the j-th car:
* - 1: if this pair of cars never collided. - 1 occurs only on the main diagonal of the matrix.
* 0: if no car turned over during the collision.
* 1: if only the i-th car turned over during the collision.
* 2: if only the j-th car turned over during the collision.
* 3: if both cars turned over during the collision.
Susie wants to find all the good cars. She quickly determined which cars are good. Can you cope with the task?
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of cars.
Each of the next n lines contains n space-separated integers that determine matrix A.
It is guaranteed that on the main diagonal there are - 1, and - 1 doesn't appear anywhere else in the matrix.
It is guaranteed that the input is correct, that is, if Aij = 1, then Aji = 2, if Aij = 3, then Aji = 3, and if Aij = 0, then Aji = 0.
Output
Print the number of good cars and in the next line print their space-separated indices in the increasing order.
Examples
Input
3
-1 0 0
0 -1 1
0 2 -1
Output
2
1 3
Input
4
-1 3 3 3
3 -1 3 3
3 3 -1 3
3 3 3 -1
Output
0 | instruction | 0 | 65,191 | 17 | 130,382 |
Tags: implementation
Correct Solution:
```
n=int(input())
k=0; b=[]
for i in range(n):
s=input().replace("-1","4")
if s.find("3")==-1 and s.find("1")==-1:
k+=1
b.append(i+1)
print(k)
if k>0:
z=""
for x in b:
z+=str(x)+" "
print(z)
``` | output | 1 | 65,191 | 17 | 130,383 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Susie, thanks to her older brother, likes to play with cars. Today she decided to set up a tournament between them. The process of a tournament is described in the next paragraph.
There are n toy cars. Each pair collides. The result of a collision can be one of the following: no car turned over, one car turned over, both cars turned over. A car is good if it turned over in no collision. The results of the collisions are determined by an n × n matrix А: there is a number on the intersection of the і-th row and j-th column that describes the result of the collision of the і-th and the j-th car:
* - 1: if this pair of cars never collided. - 1 occurs only on the main diagonal of the matrix.
* 0: if no car turned over during the collision.
* 1: if only the i-th car turned over during the collision.
* 2: if only the j-th car turned over during the collision.
* 3: if both cars turned over during the collision.
Susie wants to find all the good cars. She quickly determined which cars are good. Can you cope with the task?
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of cars.
Each of the next n lines contains n space-separated integers that determine matrix A.
It is guaranteed that on the main diagonal there are - 1, and - 1 doesn't appear anywhere else in the matrix.
It is guaranteed that the input is correct, that is, if Aij = 1, then Aji = 2, if Aij = 3, then Aji = 3, and if Aij = 0, then Aji = 0.
Output
Print the number of good cars and in the next line print their space-separated indices in the increasing order.
Examples
Input
3
-1 0 0
0 -1 1
0 2 -1
Output
2
1 3
Input
4
-1 3 3 3
3 -1 3 3
3 3 -1 3
3 3 3 -1
Output
0 | instruction | 0 | 65,192 | 17 | 130,384 |
Tags: implementation
Correct Solution:
```
n = int(input())
L = []
for j in range(n):
T = [int(x) for x in input().split()]
for i in T:
if i == 3 or i == 1:
break
else:
L.append(j)
print(len(L))
for i in L:
print(i+1, end = ' ')
``` | output | 1 | 65,192 | 17 | 130,385 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Susie, thanks to her older brother, likes to play with cars. Today she decided to set up a tournament between them. The process of a tournament is described in the next paragraph.
There are n toy cars. Each pair collides. The result of a collision can be one of the following: no car turned over, one car turned over, both cars turned over. A car is good if it turned over in no collision. The results of the collisions are determined by an n × n matrix А: there is a number on the intersection of the і-th row and j-th column that describes the result of the collision of the і-th and the j-th car:
* - 1: if this pair of cars never collided. - 1 occurs only on the main diagonal of the matrix.
* 0: if no car turned over during the collision.
* 1: if only the i-th car turned over during the collision.
* 2: if only the j-th car turned over during the collision.
* 3: if both cars turned over during the collision.
Susie wants to find all the good cars. She quickly determined which cars are good. Can you cope with the task?
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of cars.
Each of the next n lines contains n space-separated integers that determine matrix A.
It is guaranteed that on the main diagonal there are - 1, and - 1 doesn't appear anywhere else in the matrix.
It is guaranteed that the input is correct, that is, if Aij = 1, then Aji = 2, if Aij = 3, then Aji = 3, and if Aij = 0, then Aji = 0.
Output
Print the number of good cars and in the next line print their space-separated indices in the increasing order.
Examples
Input
3
-1 0 0
0 -1 1
0 2 -1
Output
2
1 3
Input
4
-1 3 3 3
3 -1 3 3
3 3 -1 3
3 3 3 -1
Output
0 | instruction | 0 | 65,193 | 17 | 130,386 |
Tags: implementation
Correct Solution:
```
n=int(input())
l=[]
for i in range(n):
a=[int(i) for i in input().split()]
if(1 in a or 3 in a):
pass
else:
l.append(i+1)
print(len(l))
print(*l)
``` | output | 1 | 65,193 | 17 | 130,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Susie, thanks to her older brother, likes to play with cars. Today she decided to set up a tournament between them. The process of a tournament is described in the next paragraph.
There are n toy cars. Each pair collides. The result of a collision can be one of the following: no car turned over, one car turned over, both cars turned over. A car is good if it turned over in no collision. The results of the collisions are determined by an n × n matrix А: there is a number on the intersection of the і-th row and j-th column that describes the result of the collision of the і-th and the j-th car:
* - 1: if this pair of cars never collided. - 1 occurs only on the main diagonal of the matrix.
* 0: if no car turned over during the collision.
* 1: if only the i-th car turned over during the collision.
* 2: if only the j-th car turned over during the collision.
* 3: if both cars turned over during the collision.
Susie wants to find all the good cars. She quickly determined which cars are good. Can you cope with the task?
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of cars.
Each of the next n lines contains n space-separated integers that determine matrix A.
It is guaranteed that on the main diagonal there are - 1, and - 1 doesn't appear anywhere else in the matrix.
It is guaranteed that the input is correct, that is, if Aij = 1, then Aji = 2, if Aij = 3, then Aji = 3, and if Aij = 0, then Aji = 0.
Output
Print the number of good cars and in the next line print their space-separated indices in the increasing order.
Examples
Input
3
-1 0 0
0 -1 1
0 2 -1
Output
2
1 3
Input
4
-1 3 3 3
3 -1 3 3
3 3 -1 3
3 3 3 -1
Output
0 | instruction | 0 | 65,194 | 17 | 130,388 |
Tags: implementation
Correct Solution:
```
n = int(input())
matrix = [[int(i) for i in input().split()] for j in range(n)]
cars = [True] * n
for i in range(len(matrix)):
for j in range(len(matrix)):
if matrix[i][j] == 1:
cars[i] = False
if matrix[i][j] == 2:
cars[j] = False
if matrix[i][j] == 3:
cars[i], cars[j] = False, False
print(cars.count(True))
for i in range(len(cars)):
if cars[i] == True:
print(i + 1, end = ' ')
``` | output | 1 | 65,194 | 17 | 130,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Susie, thanks to her older brother, likes to play with cars. Today she decided to set up a tournament between them. The process of a tournament is described in the next paragraph.
There are n toy cars. Each pair collides. The result of a collision can be one of the following: no car turned over, one car turned over, both cars turned over. A car is good if it turned over in no collision. The results of the collisions are determined by an n × n matrix А: there is a number on the intersection of the і-th row and j-th column that describes the result of the collision of the і-th and the j-th car:
* - 1: if this pair of cars never collided. - 1 occurs only on the main diagonal of the matrix.
* 0: if no car turned over during the collision.
* 1: if only the i-th car turned over during the collision.
* 2: if only the j-th car turned over during the collision.
* 3: if both cars turned over during the collision.
Susie wants to find all the good cars. She quickly determined which cars are good. Can you cope with the task?
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of cars.
Each of the next n lines contains n space-separated integers that determine matrix A.
It is guaranteed that on the main diagonal there are - 1, and - 1 doesn't appear anywhere else in the matrix.
It is guaranteed that the input is correct, that is, if Aij = 1, then Aji = 2, if Aij = 3, then Aji = 3, and if Aij = 0, then Aji = 0.
Output
Print the number of good cars and in the next line print their space-separated indices in the increasing order.
Examples
Input
3
-1 0 0
0 -1 1
0 2 -1
Output
2
1 3
Input
4
-1 3 3 3
3 -1 3 3
3 3 -1 3
3 3 3 -1
Output
0 | instruction | 0 | 65,195 | 17 | 130,390 |
Tags: implementation
Correct Solution:
```
n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
ans = []
for i in range(n):
a[i].remove(-1)
ok = 1
for j in range(n-1):
if a[i][j] & 1:
ok = 0
if ok:
ans.append(i + 1)
print(len(ans))
print(' '.join(map(str, ans)))
``` | output | 1 | 65,195 | 17 | 130,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Susie, thanks to her older brother, likes to play with cars. Today she decided to set up a tournament between them. The process of a tournament is described in the next paragraph.
There are n toy cars. Each pair collides. The result of a collision can be one of the following: no car turned over, one car turned over, both cars turned over. A car is good if it turned over in no collision. The results of the collisions are determined by an n × n matrix А: there is a number on the intersection of the і-th row and j-th column that describes the result of the collision of the і-th and the j-th car:
* - 1: if this pair of cars never collided. - 1 occurs only on the main diagonal of the matrix.
* 0: if no car turned over during the collision.
* 1: if only the i-th car turned over during the collision.
* 2: if only the j-th car turned over during the collision.
* 3: if both cars turned over during the collision.
Susie wants to find all the good cars. She quickly determined which cars are good. Can you cope with the task?
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of cars.
Each of the next n lines contains n space-separated integers that determine matrix A.
It is guaranteed that on the main diagonal there are - 1, and - 1 doesn't appear anywhere else in the matrix.
It is guaranteed that the input is correct, that is, if Aij = 1, then Aji = 2, if Aij = 3, then Aji = 3, and if Aij = 0, then Aji = 0.
Output
Print the number of good cars and in the next line print their space-separated indices in the increasing order.
Examples
Input
3
-1 0 0
0 -1 1
0 2 -1
Output
2
1 3
Input
4
-1 3 3 3
3 -1 3 3
3 3 -1 3
3 3 3 -1
Output
0 | instruction | 0 | 65,196 | 17 | 130,392 |
Tags: implementation
Correct Solution:
```
import sys
import bisect
#input=sys.stdin.readline
#t=int(input())
t=1
for _ in range(t):
#n,m=map(int,input().split())
n=int(input())
l=[]
for i in range(n):
l.append(list(map(int,input().split())))
ans=[0]*(n+1)
for i in range(n):
for j in range(n):
if l[i][j]==1:
ans[i+1]=1
if l[i][j]==2:
ans[j+1]=1
if l[i][j]==3:
ans[i+1]=1
ans[j+1]=1
l1=[]
for i in range(1,n+1):
if ans[i]==0:
l1.append(i)
l1.sort()
#print(ans)
print(len(l1))
print(*l1)
``` | output | 1 | 65,196 | 17 | 130,393 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Susie, thanks to her older brother, likes to play with cars. Today she decided to set up a tournament between them. The process of a tournament is described in the next paragraph.
There are n toy cars. Each pair collides. The result of a collision can be one of the following: no car turned over, one car turned over, both cars turned over. A car is good if it turned over in no collision. The results of the collisions are determined by an n × n matrix А: there is a number on the intersection of the і-th row and j-th column that describes the result of the collision of the і-th and the j-th car:
* - 1: if this pair of cars never collided. - 1 occurs only on the main diagonal of the matrix.
* 0: if no car turned over during the collision.
* 1: if only the i-th car turned over during the collision.
* 2: if only the j-th car turned over during the collision.
* 3: if both cars turned over during the collision.
Susie wants to find all the good cars. She quickly determined which cars are good. Can you cope with the task?
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of cars.
Each of the next n lines contains n space-separated integers that determine matrix A.
It is guaranteed that on the main diagonal there are - 1, and - 1 doesn't appear anywhere else in the matrix.
It is guaranteed that the input is correct, that is, if Aij = 1, then Aji = 2, if Aij = 3, then Aji = 3, and if Aij = 0, then Aji = 0.
Output
Print the number of good cars and in the next line print their space-separated indices in the increasing order.
Examples
Input
3
-1 0 0
0 -1 1
0 2 -1
Output
2
1 3
Input
4
-1 3 3 3
3 -1 3 3
3 3 -1 3
3 3 3 -1
Output
0 | instruction | 0 | 65,197 | 17 | 130,394 |
Tags: implementation
Correct Solution:
```
z=[]
for i in range(1,int(input())+1):
a=list(map(int,input().split()))
if 1 not in a and 3 not in a:z+=[i]
print(len(z),"\n",*z,end=" ")
``` | output | 1 | 65,197 | 17 | 130,395 |
Provide tags and a correct Python 3 solution for this coding contest problem.
International Abbreviation Olympiad takes place annually starting from 1989. Each year the competition receives an abbreviation of form IAO'y, where y stands for some number of consequent last digits of the current year. Organizers always pick an abbreviation with non-empty string y that has never been used before. Among all such valid abbreviations they choose the shortest one and announce it to be the abbreviation of this year's competition.
For example, the first three Olympiads (years 1989, 1990 and 1991, respectively) received the abbreviations IAO'9, IAO'0 and IAO'1, while the competition in 2015 received an abbreviation IAO'15, as IAO'5 has been already used in 1995.
You are given a list of abbreviations. For each of them determine the year it stands for.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the number of abbreviations to process.
Then n lines follow, each containing a single abbreviation. It's guaranteed that each abbreviation contains at most nine digits.
Output
For each abbreviation given in the input, find the year of the corresponding Olympiad.
Examples
Input
5
IAO'15
IAO'2015
IAO'1
IAO'9
IAO'0
Output
2015
12015
1991
1989
1990
Input
4
IAO'9
IAO'99
IAO'999
IAO'9999
Output
1989
1999
2999
9999 | instruction | 0 | 65,249 | 17 | 130,498 |
Tags: constructive algorithms, greedy, implementation, math
Correct Solution:
```
from __future__ import print_function
dic = {"9":"1989","0":"1990","1":"1991","2":"1992","3":"1993","4":"1994","5":"1995","6":"1996","7":"1997","8":"1998"}
def get_year(s):
# print("came into get_year")
length=len(s)
if len(s)==1:
return dic[s]
pos=[s]
pre=1
if s[0]=="0" or len(s)<4 or (len(s)==4 and int(s)<1989):
pos=[]
# pre=1
# elif len(s)>4 or (len(s)==4 and int(s)>=1989):
# pos=[s]
# pre=1
count=0
while(count<length):
# print(count)
if int(str(pre)+s)>=1989:
pos.append(str(pre)+s)
count+=1
pre+=1
# print(s,pos)
for i in range(1,length):
# print(i)
year = get_year(s[i:])
try:
pos.remove(year)
except ValueError:
pass
# print(pos)
# print(s,pos[0])
# print(s,pos)
return pos[0]
# occupied=[]
# for abb in abbs:
# length = len(abb)
# val = int(abb)
# if(val<10**(length-1))
# print(get_year("0003566"))
# print(get_year("9999"))
# print(get_year("999"))
# print(get_year("99"))
# print(get_year("9"))
m = int(input())
for i in range(m):
x = input()
abb = x[4:]
print(int(get_year(abb)))
``` | output | 1 | 65,249 | 17 | 130,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
International Abbreviation Olympiad takes place annually starting from 1989. Each year the competition receives an abbreviation of form IAO'y, where y stands for some number of consequent last digits of the current year. Organizers always pick an abbreviation with non-empty string y that has never been used before. Among all such valid abbreviations they choose the shortest one and announce it to be the abbreviation of this year's competition.
For example, the first three Olympiads (years 1989, 1990 and 1991, respectively) received the abbreviations IAO'9, IAO'0 and IAO'1, while the competition in 2015 received an abbreviation IAO'15, as IAO'5 has been already used in 1995.
You are given a list of abbreviations. For each of them determine the year it stands for.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the number of abbreviations to process.
Then n lines follow, each containing a single abbreviation. It's guaranteed that each abbreviation contains at most nine digits.
Output
For each abbreviation given in the input, find the year of the corresponding Olympiad.
Examples
Input
5
IAO'15
IAO'2015
IAO'1
IAO'9
IAO'0
Output
2015
12015
1991
1989
1990
Input
4
IAO'9
IAO'99
IAO'999
IAO'9999
Output
1989
1999
2999
9999 | instruction | 0 | 65,250 | 17 | 130,500 |
Tags: constructive algorithms, greedy, implementation, math
Correct Solution:
```
T=int(input())
for _ in range(T):
s=input()
s=s[4:]
l=len(s)
s=int(s)
x=1988
t=1
for i in range(l):
y=s%(t*10)
z=x%(t*10)
while True:
x=x+t
z=x%(t*10)
if y==z:
break
t=t*10
print(x)
``` | output | 1 | 65,250 | 17 | 130,501 |
Provide tags and a correct Python 3 solution for this coding contest problem.
International Abbreviation Olympiad takes place annually starting from 1989. Each year the competition receives an abbreviation of form IAO'y, where y stands for some number of consequent last digits of the current year. Organizers always pick an abbreviation with non-empty string y that has never been used before. Among all such valid abbreviations they choose the shortest one and announce it to be the abbreviation of this year's competition.
For example, the first three Olympiads (years 1989, 1990 and 1991, respectively) received the abbreviations IAO'9, IAO'0 and IAO'1, while the competition in 2015 received an abbreviation IAO'15, as IAO'5 has been already used in 1995.
You are given a list of abbreviations. For each of them determine the year it stands for.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the number of abbreviations to process.
Then n lines follow, each containing a single abbreviation. It's guaranteed that each abbreviation contains at most nine digits.
Output
For each abbreviation given in the input, find the year of the corresponding Olympiad.
Examples
Input
5
IAO'15
IAO'2015
IAO'1
IAO'9
IAO'0
Output
2015
12015
1991
1989
1990
Input
4
IAO'9
IAO'99
IAO'999
IAO'9999
Output
1989
1999
2999
9999 | instruction | 0 | 65,251 | 17 | 130,502 |
Tags: constructive algorithms, greedy, implementation, math
Correct Solution:
```
def mp(): return map(int,input().split())
def lt(): return list(map(int,input().split()))
def pt(x): print(x)
def ip(): return input()
def it(): return int(input())
def sl(x): return [t for t in x]
def spl(x): return x.split()
def aj(liste, item): liste.append(item)
def bin(x): return "{0:b}".format(x)
def listring(l): return ' '.join([str(x) for x in l])
def printlist(l): print(' '.join([str(x) for x in l]))
for _ in range(it()):
string = ip()
string = string[4:]
k = 1988
for i in range(len(string)-1,-1,-1):
suffix = string[i:]
t = len(suffix)
k += 10**(t-1)
while not str(k).endswith(suffix):
k += 10**(t-1)
pt(k)
``` | output | 1 | 65,251 | 17 | 130,503 |
Provide tags and a correct Python 3 solution for this coding contest problem.
International Abbreviation Olympiad takes place annually starting from 1989. Each year the competition receives an abbreviation of form IAO'y, where y stands for some number of consequent last digits of the current year. Organizers always pick an abbreviation with non-empty string y that has never been used before. Among all such valid abbreviations they choose the shortest one and announce it to be the abbreviation of this year's competition.
For example, the first three Olympiads (years 1989, 1990 and 1991, respectively) received the abbreviations IAO'9, IAO'0 and IAO'1, while the competition in 2015 received an abbreviation IAO'15, as IAO'5 has been already used in 1995.
You are given a list of abbreviations. For each of them determine the year it stands for.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 1000) — the number of abbreviations to process.
Then n lines follow, each containing a single abbreviation. It's guaranteed that each abbreviation contains at most nine digits.
Output
For each abbreviation given in the input, find the year of the corresponding Olympiad.
Examples
Input
5
IAO'15
IAO'2015
IAO'1
IAO'9
IAO'0
Output
2015
12015
1991
1989
1990
Input
4
IAO'9
IAO'99
IAO'999
IAO'9999
Output
1989
1999
2999
9999 | instruction | 0 | 65,252 | 17 | 130,504 |
Tags: constructive algorithms, greedy, implementation, math
Correct Solution:
```
import sys
import math
import itertools as it
import operator as op
import fractions as fr
L = [1989]
d = 10
for i in range(9):
L.append(L[-1]+d)
d *= 10
n = int(sys.stdin.readline())
for _ in range(n):
s = sys.stdin.readline().strip()
d = s[s.index("'")+1:]
k = len(d)
d = int(d)
k10 = 10**k
A = L[k-1]
B = A + k10 - 1
r = 0
if d < A % k10:
r = B - (B%k10 - d)
else:
r = A + (d - A%k10)
print(r)
``` | output | 1 | 65,252 | 17 | 130,505 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.