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.
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 | 18,990 | 17 | 37,980 |
Tags: constructive algorithms, greedy, implementation, math
Correct Solution:
```
for i in range(int(input())):
t = input()[4:]
q, d = int(t), 10 ** len(t)
while q < 1988 + d // 9: q += d
print(q)
# Made By Mostafa_Khaled
``` | output | 1 | 18,990 | 17 | 37,981 |
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 | 18,991 | 17 | 37,982 |
Tags: constructive algorithms, greedy, implementation, math
Correct Solution:
```
tn=[0]*10000
ts=[0]*10000
a=1989
tn[1]=1989
ts[1]=9
for i in range(1,12):
a=a+(10**i)
tn[i+1]=a
ts[i+1]=int(str(a)[-i-1:])
noc=int(input())
for fk in range(noc):
a=input()[4:]
temp=len(a)
a=int(a)
print((a-ts[temp])%(10**temp)+tn[temp])
``` | output | 1 | 18,991 | 17 | 37,983 |
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 | 18,992 | 17 | 37,984 |
Tags: constructive algorithms, greedy, implementation, math
Correct Solution:
```
cache = [1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1989]
def solve(n):
global cache
y = cache[int(n) % 10]
for _steps in range(len(n) - 1):
mod = 10 ** (_steps + 2)
new_tail = int(n) % mod
old_tail = y % mod
if new_tail > old_tail:
# everything is fine, saving tail and head
y = y // mod * mod + new_tail
else:
y = (y // mod + 1) * mod + new_tail
return y
n = int(input())
for i in range(n):
num = input().split('\'')[1]
print(solve(num))
``` | output | 1 | 18,992 | 17 | 37,985 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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
Submitted Solution:
```
'''used={}
for i in range(1989,99999):
k=str(i)
for x in range(len(k)-1,-1,-1):
if not k[x:] in used:
used[k[x:]]=True
print(i,k[x:])
break'''
tn=[0]*10000
ts=[0]*10000
a=1989
#print(1,a,9)
tn[1]=1989
ts[1]=9
for i in range(1,11):
a=a+(10**i)
#print(i+1,a,str(a)[-i-1:])
tn[i+1]=a
ts[i+1]=int(str(a)[-i-1:])
noc=int(input())
for fk in range(noc):
a=int(input()[4:])
#print (a)
temp=len(str(a))
print((a-ts[temp])%(10**temp)+tn[temp])
``` | instruction | 0 | 18,993 | 17 | 37,986 |
No | output | 1 | 18,993 | 17 | 37,987 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
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
Submitted Solution:
```
cache = [1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1989]
def solve(n):
global cache
y = cache[n % 10]
for _steps in range(len(str(n)) - 1):
mod = 10 ** (_steps + 2)
new_tail = n % mod
old_tail = y % mod
if new_tail > old_tail:
# everything is fine, saving tail and head
y = y // mod * mod + new_tail
else:
y = (y // mod + 1) * mod + new_tail
return y
n = int(input())
for i in range(n):
num = int(input().split('\'')[1])
print(solve(num))
``` | instruction | 0 | 18,994 | 17 | 37,988 |
No | output | 1 | 18,994 | 17 | 37,989 |
Provide a correct Python 3 solution for this coding contest problem.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667 | instruction | 0 | 19,348 | 17 | 38,696 |
"Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
blocks = list(map(int, input().split()))
maxv = minv = 0
for i in range(1, n):
maxv = max(maxv, blocks[i] - blocks[i-1])
minv = max(minv, blocks[i-1] - blocks[i])
print(maxv, minv)
``` | output | 1 | 19,348 | 17 | 38,697 |
Provide a correct Python 3 solution for this coding contest problem.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667 | instruction | 0 | 19,349 | 17 | 38,698 |
"Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
li = [int(x) for x in input().split()]
a, b = 0, 0
for j in range(1, n):
a = max(a, li[j]-li[j-1])
b = min(b, li[j]-li[j-1])
print(a, -b)
``` | output | 1 | 19,349 | 17 | 38,699 |
Provide a correct Python 3 solution for this coding contest problem.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667 | instruction | 0 | 19,350 | 17 | 38,700 |
"Correct Solution:
```
for _ in range(int(input())):
_= int(input())
upv=dov=0
h= list(map(int, input().split()))
for i in range(len(h)-1):
upv= max(upv, h[i+1]-h[i])
dov= max(dov, h[i]-h[i+1])
print(upv, dov)
``` | output | 1 | 19,350 | 17 | 38,701 |
Provide a correct Python 3 solution for this coding contest problem.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667 | instruction | 0 | 19,351 | 17 | 38,702 |
"Correct Solution:
```
d = int(input())
for i in range(d):
n = int(input())
l = list(map(int, input().split()))
dis = [l[i+1] - l[i] for i in range(n - 1)]
M, m = max(dis), min(dis)
if M > 0 and m > 0:
print(M, 0)
elif M < 0 and m < 0:
print(0, abs(m))
else:
print(M, abs(m))
``` | output | 1 | 19,351 | 17 | 38,703 |
Provide a correct Python 3 solution for this coding contest problem.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667 | instruction | 0 | 19,352 | 17 | 38,704 |
"Correct Solution:
```
t=int(input())
for count in range(t):
n=int(input())
h_list=[int(i) for i in input().split(" ")]
delta_list=[]
for i in range(n-1):
delta_list.append(h_list[i+1]-h_list[i])
if max(delta_list)>0:
max_up=max(delta_list)
else:
max_up=0
if min(delta_list)<0:
max_down=min(delta_list)*(-1)
else:
max_down=0
print("%d %d" %(max_up,max_down))
``` | output | 1 | 19,352 | 17 | 38,705 |
Provide a correct Python 3 solution for this coding contest problem.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667 | instruction | 0 | 19,353 | 17 | 38,706 |
"Correct Solution:
```
n=int(input())
while n:
input()
n-=1
a=list(map(int,input().split()))
u,d=0,0
for i in range(1,len(a)):
if a[i]-a[i-1]>0:u=max(a[i]-a[i-1],u)
elif a[i]-a[i-1]<0:d=max(a[i-1]-a[i],d)
print(u,d)
``` | output | 1 | 19,353 | 17 | 38,707 |
Provide a correct Python 3 solution for this coding contest problem.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667 | instruction | 0 | 19,354 | 17 | 38,708 |
"Correct Solution:
```
n = int(input())
for j in range(n):
a = int(input())
b = list(map(int,input().split()))
hop = []
for i in range(a-1):
hop.append(b[i+1]-b[i])
hop.sort(reverse = True)
if hop[0] <= 0:
print(0,end = " ")
else:
print(hop[0],end = " ")
if hop[-1] >= 0:
print(0)
else:
print(-(hop[-1]))
``` | output | 1 | 19,354 | 17 | 38,709 |
Provide a correct Python 3 solution for this coding contest problem.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667 | instruction | 0 | 19,355 | 17 | 38,710 |
"Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
h = list(map(int, input().split()))
maxv = minv = 0
for i in range(len(h)-1):
maxv = max(maxv, h[i+1]-h[i])
minv = max(minv, h[i]-h[i+1])
print(maxv, minv)
``` | output | 1 | 19,355 | 17 | 38,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
block = list(map(int, input().split()))
diff = []
for i in range(len(block) - 1):
d = block[i+1] - block[i]
diff.append(d)
up = max(0, max(diff))
down = abs(min(0, min(diff)))
print(up, down)
``` | instruction | 0 | 19,356 | 17 | 38,712 |
Yes | output | 1 | 19,356 | 17 | 38,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667
Submitted Solution:
```
n = int(input())
for _ in range(n):
x = int(input())
lst = list(map(int, input().split()))
y, z = 0, 0
for j in range(1, x):
y = max(y, lst[j]-lst[j-1])
z = min(z, lst[j]-lst[j-1])
print(y, -z)
``` | instruction | 0 | 19,357 | 17 | 38,714 |
Yes | output | 1 | 19,357 | 17 | 38,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
blocks = list(map(int, input().split()))
ans = [0, 0]
for i in range(1, n):
ans[0] = max(ans[0], blocks[i] - blocks[i-1])
ans[1] = max(ans[1], blocks[i-1] - blocks[i])
print(*ans)
``` | instruction | 0 | 19,358 | 17 | 38,716 |
Yes | output | 1 | 19,358 | 17 | 38,717 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667
Submitted Solution:
```
# solve
def solve(n, block):
max_up = 0
max_down = 0
for i in range(n-1):
if block[i] < block[i+1]:
max_up = max(max_up, block[i+1]-block[i])
elif block[i] > block[i+1]:
max_down = max(max_down, block[i]-block[i+1])
return (max_up, max_down)
# main function
if __name__ == '__main__':
t = int(input())
for i in range(t):
n = int(input())
tmp_block = input().split()
block = []
for j in range(n):
block.append(int(tmp_block[j]))
max_up, max_down = solve(n, block)
print(max_up, max_down)
``` | instruction | 0 | 19,359 | 17 | 38,718 |
Yes | output | 1 | 19,359 | 17 | 38,719 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667
Submitted Solution:
```
#coding:UTF-8
def Calculate(rows) :
up, down = 0, 0
for x in range(0, len(rows) - 1) :
tmp = rows[x + 1] - rows[x]
if tmp < 0 :
tmp = abs(tmp)
if down < tmp :
down = tmp
elif tmp > 0 :
if up < tmp :
up = tmp
else :
pass
print("{0} {1}".format(up, down))
return(up, down)
def Main() :
fields = int(input())
up, down = [], []
for x in range(fields) :
blocks_q = int(input())
blocks = input().split(' ')
blocks = [int(x) for x in blocks]
if blocks_q != len(blocks) :
# error
pass
tmp_up, tmp_down = Calculate(blocks)
up.append(tmp_up)
down.append(tmp_down)
for x in range(len(up)) :
print("{0} {1}".format(up[x], down[x]))
if __name__ == "__main__" :
Main()
``` | instruction | 0 | 19,360 | 17 | 38,720 |
No | output | 1 | 19,360 | 17 | 38,721 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A TV program called "Saizo" is popular in a certain country. In this program, participants challenge field athletics and get a prize if they successfully capture it.
Field athletics are made by arranging blocks of different heights in a row, and how to climb up and down the steps is important for capture (Fig. 1). Your friend who will be attending this show wants you to write a program that calculates the maximum steps you have to climb and the maximum steps you have to descend given a field athletic structure. I asked you, a great programmer.
Example of athletic structure (first dataset of input example).
---
Figure 1: Example of athletic structure (first dataset of input example).
Input
The number of datasets t (0 <t ≤ 100) is given on the first line of the input. This line is followed by t datasets.
The first line of the dataset is the number of blocks that make up the field athletics n (2 ≤ n ≤ 100). In the second line, n integers indicating the height of the block from the start to the goal are given in order. The first corresponds to the start and the nth corresponds to the goal. These integers are separated by a single space character. The height h of each block satisfies 0 <h ≤ 1000.
Output
For each dataset, output the maximum step size you must climb and the maximum step size you must descend on a single line, separated by a single space character. If there is no step to climb or step to descend, the maximum corresponding step size shall be 0.
Example
Input
5
5
10 70 30 50 90
2
20 100
2
100 30
3
50 50 50
7
123 45 678 901 234 567 890
Output
60 40
80 0
0 70
0 0
633 667
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
h = list(map(int, input().split()))
maxv = 0, minv = 0
for i in range(len(h)-1):
maxv = max(maxv, h[i+1]-h[i])
minv = max(minv, h[i]-h[i+1])
print(maxv, minv)
``` | instruction | 0 | 19,361 | 17 | 38,722 |
No | output | 1 | 19,361 | 17 | 38,723 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3 | instruction | 0 | 20,130 | 17 | 40,260 |
"Correct Solution:
```
n,m=map(int,input().split())
k=[[0]*m for i in range(n)]
for i in range(n):
k[i]=list(map(int,input().split()))
ans=1000
for i in range(m-1):
ma=[0]*m
mi=-1
for j in range(n):
ma[k[j][0]-1]+=1
if ans>max(ma):
ans=max(ma)
mi=ma.index(max(ma))+1
for j in range(n):
k[j].remove(mi)
if m==1:
print(n)
else:
print(ans)
``` | output | 1 | 20,130 | 17 | 40,261 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3 | instruction | 0 | 20,131 | 17 | 40,262 |
"Correct Solution:
```
from collections import deque
from typing import Optional
class DeletableDeque:
"""Deletable Deque: a deque that supports lazy deletion of values."""
__slots__ = ["_set", "_deque"]
def __init__(self, *initial_values: int) -> None:
self._set = set()
self._deque = deque([])
if initial_values:
for v in initial_values:
self.append(v)
@property
def topleft(self) -> Optional[int]:
"""Return the leftmost value from the deque.
If the deque is empty, None is returned.
"""
while self._deque and self._deque[0] not in self._set:
self._deque.popleft()
if not self._deque:
return None
return self._deque[0]
def append(self, value: int) -> None:
"""Append value to the right side of the deque."""
if value in self._set:
return
self._set.add(value)
self._deque.append(value)
def delete(self, value: int) -> None:
"""Delete value from the deque."""
if value not in self._set:
return
self._set.discard(value)
def agc018_b():
# https://atcoder.jp/contests/agc018/tasks/agc018_b
import sys
from collections import Counter
readline = sys.stdin.buffer.readline
N, M = map(int, readline().split())
A = [DeletableDeque(*map(int, readline().split())) for _ in range(N)]
res = 301
for _ in range(M):
cnt = Counter([a.topleft for a in A])
popular_sport = max(cnt, key=cnt.get)
res = min(res, cnt[popular_sport])
for a in A:
a.delete(popular_sport)
print(res)
if __name__ == "__main__":
agc018_b()
``` | output | 1 | 20,131 | 17 | 40,263 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3 | instruction | 0 | 20,132 | 17 | 40,264 |
"Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
n, m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
cnt = [0] * (m + 1)
cur = [0] * n
done = [0] * (m + 1)
for i in range(n):
cnt[a[i][0]] += 1
cur[i] = a[i][0]
ans = max(cnt)
for _ in range(m - 1):
col = cnt.index(max(cnt))
done[col] = 1
for i in range(n):
if cur[i] == col:
j = 0
while done[a[i][j]]:
j += 1
t = a[i][j]
cur[i] = t
cnt[t] += 1
cnt[col] = 0
ans = min(ans, max(cnt))
print(ans)
``` | output | 1 | 20,132 | 17 | 40,265 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3 | instruction | 0 | 20,133 | 17 | 40,266 |
"Correct Solution:
```
from collections import deque, defaultdict
n,m = map(int, input().split())
a = [list(map(int, input().split())) for i in range(n)]
def check(x):
used = [0]*n
if x >= n:
return True
# NM
b = [deque(a[i]) for i in range(n)]
d = defaultdict(list)
ng = set()
while True:
for i in range(n):
if used[i]:
continue
while b[i] and b[i][0] in ng:
b[i].popleft()
if not b[i]:
return False
like = b[i].popleft()
d[like].append(i)
used[i] = 1
# チェック
flag = True
for key, value in d.items():
if len(value) > x:
flag = False
ng.add(key)
for v in value:
used[v] = 0
d[key] = []
if flag:
return True
left = 0
right = n+1
while right - left > 1:
mid = (left+right)//2
if check(mid):
right = mid
else:
left = mid
print(right)
``` | output | 1 | 20,133 | 17 | 40,267 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3 | instruction | 0 | 20,134 | 17 | 40,268 |
"Correct Solution:
```
# Sports Festival
from collections import Counter
N, M = map(int, input().split())
data = [list(map(int, input().split())) for i in range(N)]
ans = N
for i in range(M):
K = []
for j in range(N):
K.append(data[j][0])
index, weight = Counter(K).most_common()[0]
ans = min(ans, weight)
for k in range(N):
data[k].remove(index)
print(ans)
``` | output | 1 | 20,134 | 17 | 40,269 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3 | instruction | 0 | 20,135 | 17 | 40,270 |
"Correct Solution:
```
n,m=map(int,input().split())
#n人が参加<=300
#m個のスポーツ<=300
#最も多くの人が参加しているスポーツの最小
aa=[list(map(int, input().split())) for _ in range(n)]
a=[[-1]*m for _ in range(n)]
for y in range(n):
for x in range(m):
a[y][aa[y][x]-1]=x
def pri(x):
for item in x:
print(item)
ans=301
for _ in range(m):
score=[0]*m
#print("###########")
#pri(a)
for y in range(n):
mini=-1
miniscore=501
for x in range(m):
if miniscore>a[y][x]:
mini=x
miniscore=a[y][x]
score[mini]+=1
tmp=max(score)
ans=min(tmp,ans)
#print(score)
for x in range(m):
if score[x]==tmp:
for y in range(n):
a[y][x]=501
print(ans)
``` | output | 1 | 20,135 | 17 | 40,271 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3 | instruction | 0 | 20,136 | 17 | 40,272 |
"Correct Solution:
```
#!/usr/bin/env python3
from collections import Counter
(n, m), *d = [list(map(int, o.split())) for o in open(0)]
a = n
for _ in [0] * m:
k = []
for i in range(n):
k += d[i][0],
ind, w = Counter(k).most_common()[0]
a = min(a, w)
for j in range(n):
d[j].remove(ind)
print(a)
``` | output | 1 | 20,136 | 17 | 40,273 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3 | instruction | 0 | 20,137 | 17 | 40,274 |
"Correct Solution:
```
from collections import deque, Counter
n,m = map(int,input().split())
ls = [deque(map(int,input().split())) for i in range(n)]
seen = [0 for i in range(m+1)]
content = [0 for i in range(n)]
flg = [0 for i in range(n)]
cnt = 0
ans = 500
for i in range(n):
content[i] = ls[i][0]
c = Counter(content)
while cnt<m:
for i in range(n):
if flg[i]:
while ls[i]:
ls[i].popleft()
if seen[ls[i][0]] >= 1:
continue
else:
content[i] = ls[i][0]
break
flg[i] = 0
c = Counter(content)
x = c.most_common()[0]
ans = min(ans,x[1])
seen[x[0]] += 1
for i in range(n):
if content[i] == x[0]:
flg[i] = 1
cnt += 1
print(ans)
``` | output | 1 | 20,137 | 17 | 40,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3
Submitted Solution:
```
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,m = list(map(int, input().split()))
a = [None]*n
d = [None]*n
from collections import Counter
for i in range(n):
a[i] = list(map(lambda x: int(x)-1, input().split()))
d[i] = a[i][0]
ans = float("inf")
used = [True] * m
num = m
while True:
c = Counter(d)
# print(c, used)
mv, mk = max((v,k) for k,v in c.items())
# print(mv, mk)
ans = min(ans, mv)
used[mk] = False
num -= 1
if num==0:
break
for i in range(n):
if not used[d[i]]:
for j in range(m):
if used[a[i][j]]:
d[i] = a[i][j]
break
print(ans)
``` | instruction | 0 | 20,138 | 17 | 40,276 |
Yes | output | 1 | 20,138 | 17 | 40,277 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3
Submitted Solution:
```
from collections import deque
from typing import Optional
class DeletableDeque:
"""Deletable Deque: a deque that supports lazy deletion of values."""
__slots__ = ["_set", "_deque"]
def __init__(self, *initial_values: int) -> None:
self._set = set()
self._deque = deque([])
if initial_values:
for v in initial_values:
self.append(v)
def __contains__(self, value: int) -> bool:
return value in self._set
def __len__(self) -> int:
return len(self._set)
@property
def is_empty(self) -> bool:
"""Return whether the deque has no values or not."""
return len(self) == 0
@property
def top(self) -> Optional[int]:
"""Return the rightmost value from the deque.
If the deque is empty, None is returned.
"""
while self._deque and self._deque[-1] not in self._set:
self._deque.pop()
if not self._deque:
return None
return self._deque[-1]
@property
def topleft(self) -> Optional[int]:
"""Return the leftmost value from the deque.
If the deque is empty, None is returned.
"""
while self._deque and self._deque[0] not in self._set:
self._deque.popleft()
if not self._deque:
return None
return self._deque[0]
def pop(self) -> Optional[int]:
"""Pop and return the rightmost value from the deque.
If the deque is empty, None is returned.
"""
while self._deque and self._deque[-1] not in self._set:
self._deque.pop()
if not self._deque:
return None
res = self._deque.pop()
self._set.discard(res)
return res
def popleft(self) -> Optional[int]:
"""Pop and return the leftmost value from the deque.
If the deque is empty, None is returned.
"""
while self._deque and self._deque[0] not in self._set:
self._deque.popleft()
if not self._deque:
return None
res = self._deque.popleft()
self._set.discard(res)
return res
def append(self, value: int) -> None:
"""Append value to the right side of the deque."""
if value in self._set:
return
self._set.add(value)
self._deque.append(value)
def appendleft(self, value: int) -> None:
"""Append value to the left side of the deque."""
if value in self._set:
return
self._set.add(value)
self._deque.appendleft(value)
def delete(self, value: int) -> None:
"""Delete value from the deque."""
if value not in self._set:
return
self._set.discard(value)
def agc018_b():
# https://atcoder.jp/contests/agc018/tasks/agc018_b
import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline
N, M = map(int, readline().split())
A = [DeletableDeque(*list(map(int, readline().split()))[::-1]) for _ in range(N)]
res = 301
for _ in range(M):
cnt = defaultdict(int)
for a in A:
cnt[a.top] += 1
popular_sport = max(cnt, key=cnt.get)
res = min(res, cnt[popular_sport])
for a in A:
a.delete(popular_sport)
print(res)
if __name__ == "__main__":
agc018_b()
``` | instruction | 0 | 20,139 | 17 | 40,278 |
Yes | output | 1 | 20,139 | 17 | 40,279 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3
Submitted Solution:
```
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")
def getlist():
return list(map(int, input().split()))
#処理内容
def main():
N, M = getlist()
D = defaultdict(lambda:1)
A = []
for i in range(N):
a = list(reversed(getlist()))
A.append(a)
if M == 1:
print(N)
return
ans = INF
for i in range(M - 1):
cnt = [0] * M
for j in range(N):
cnt[A[j][-1] - 1] += 1
# print(cnt)
var = max(cnt)
ans = min(ans, var)
ind = cnt.index(var)
D[ind] = 0
for j in range(N):
while True:
if D[A[j][-1] - 1] == 0:
A[j].pop()
else:
break
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 20,140 | 17 | 40,280 |
Yes | output | 1 | 20,140 | 17 | 40,281 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3
Submitted Solution:
```
N, M = map(int, input().split())
A = [list(map(lambda x:int(x)-1, input().split())) for _ in range(N)]
def C(x):
count = [0]*M
index = [0]*N
flag = [False]*M
for i in range(N):
count[A[i][0]]+=1
m = max(count)
while m>x:
tmp = [0]*M
for i in range(N):
j = index[i]
if count[A[i][j]]>x:
flag[A[i][j]] = True
for i in range(N):
j = index[i]
while flag[A[i][j]]:
index[i]+=1
j+=1
if j == M:
return False
tmp[A[i][j]]+=1
count = [t for t in tmp]
m = max(count)
return True
ng = 0
ok = N
while ok-ng>1:
mid = (ok+ng)//2
if C(mid):ok = mid
else:ng = mid
print(ok)
``` | instruction | 0 | 20,141 | 17 | 40,282 |
Yes | output | 1 | 20,141 | 17 | 40,283 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3
Submitted Solution:
```
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
N,M = LI()
A = [LI() for _ in range(N)]
ctr = [0] * N
sp = [0] * (M+1)
for i in range(N):
sp[A[i][ctr[i]]] += 1
ans = max(sp)
for _ in range(N-1):
m = 0
mi = -1
for i in range(1,M+1):
if sp[i] > m:
m = sp[i]
mi = i
sp[mi] = -1
for i in range(N):
if A[i][ctr[i]] == mi:
while sp[A[i][ctr[i]]] < 0:
ctr[i] += 1
sp[A[i][ctr[i]]] += 1
ans = min(ans,max(sp))
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 20,142 | 17 | 40,284 |
No | output | 1 | 20,142 | 17 | 40,285 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3
Submitted Solution:
```
n,m = map(int,input().split())
a = [list(map(int,input().split())) for i in range(n)]
count = [0]*(m+1)
for i in a:
count[i[0]] += 1
l = [0]*n
ans = max(count)
s = set()
for i in range(n-1):
M = max(count)
ind = count.index(M)
s.add(ind)
for j in range(n):
if a[j][l[j]] == ind:
count[ind] -= 1
while a[j][l[j]] in s:
l[j] += 1
count[a[j][l[j]]] += 1
ans = min(ans,max(count))
print(ans)
``` | instruction | 0 | 20,143 | 17 | 40,286 |
No | output | 1 | 20,143 | 17 | 40,287 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3
Submitted Solution:
```
from collections import Counter
def update_rank_lis(rank_lis, drop_sport):
return [
[sport for sport in ranks if sport != drop_sport]
for ranks in rank_lis
]
def count_first(rank_lis):
first_cnt = Counter([ranks[0] for ranks in rank_lis])
return sorted([(cnt, sport) for sport, cnt in first_cnt.items()])[-1]
def solve(N, M, rank_lis):
min_value = M
for _ in range(M):
most_pop_cnt, most_pop_sport = count_first(rank_lis)
min_value = min(most_pop_cnt, min_value)
rank_lis = update_rank_lis(rank_lis, most_pop_sport)
print(min_value)
N, M = map(int, input().split())
rank_lis = [list(map(int, input().split())) for _ in range(N)]
solve(N, M, rank_lis)
``` | instruction | 0 | 20,144 | 17 | 40,288 |
No | output | 1 | 20,144 | 17 | 40,289 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is hosting an sports meet. There are N people who will participate. These people are conveniently numbered 1 through N. Also, there are M options of sports for this event. These sports are numbered 1 through M. Among these options, Takahashi will select one or more sports (possibly all) to be played in the event.
Takahashi knows that Person i's j-th favorite sport is Sport A_{ij}. Each person will only participate in his/her most favorite sport among the ones that are actually played in the event, and will not participate in the other sports.
Takahashi is worried that one of the sports will attract too many people. Therefore, he would like to carefully select sports to be played so that the number of the participants in the sport with the largest number of participants is minimized. Find the minimum possible number of the participants in the sport with the largest number of participants.
Constraints
* 1 \leq N \leq 300
* 1 \leq M \leq 300
* A_{i1} , A_{i2} , ... , A_{iM} is a permutation of the integers from 1 to M.
Input
Input is given from Standard Input in the following format:
N M
A_{11} A_{12} ... A_{1M}
A_{21} A_{22} ... A_{2M}
:
A_{N1} A_{N2} ... A_{NM}
Output
Print the minimum possible number of the participants in the sport with the largest number of participants.
Examples
Input
4 5
5 1 3 4 2
2 5 3 1 4
2 3 1 4 5
2 5 4 3 1
Output
2
Input
3 3
2 1 3
2 1 3
2 1 3
Output
3
Submitted Solution:
```
import collections
N, M = map(int, input().split())
A = [list(map(int, input().split())) for i in range(N)]
ans = N # １種類だけ開催
d = dict()
D = collections.defaultdict(list)
for i in range(1, M+1):
d[i] = 0
for i in range(N):
for j in range(M):
d[A[i][j]] += j
D[A[i][j]].append(j)
d = list(d.items())
d.sort(key=lambda x: x[1], reverse=True)
idx = [M]*N
arr = [0]*M
for i in range(M):
x = d[i][0]
for j in range(N):
#print(idx[j], D[x])
if idx[j] > D[x][j]:
arr[x-1] += 1
if i > 0:
arr[A[j][idx[j]]-1] -= 1
idx[j] = D[x][j]
ans = min(ans, max(arr))
print(ans)
``` | instruction | 0 | 20,145 | 17 | 40,290 |
No | output | 1 | 20,145 | 17 | 40,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum. | instruction | 0 | 20,302 | 17 | 40,604 |
Tags: greedy, sortings
Correct Solution:
```
n,m=map(int,input().split())
s={}
for i in range(0,n):
a,b=map(int,input().split())
if(s.get(a,-1)==-1): s[a]=[b]
else: s[a].append(b)
p=[0]*(n+1)
for i in s:
zc=0
s[i].sort(reverse=True)
for j in range(0,len(s[i])):
zc+=s[i][j]
if(zc>0):
p[j]+=zc
zd=0
for i in range(0,n+1):
zd=max(zd,p[i])
print(zd)
``` | output | 1 | 20,302 | 17 | 40,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum. | instruction | 0 | 20,303 | 17 | 40,606 |
Tags: greedy, sortings
Correct Solution:
```
from collections import defaultdict
n,m=[int(i) for i in input().split()]
d=defaultdict(lambda:[])
for _ in range(n):
a,b=[int(i) for i in input().split()]
d[a].append(b)
class node:
def __init__(self,sub):
self.sub=sub
spe=[]
presum=[]
size=1
final=[]
maxsize=0
l=0
for k,v in d.items():
o=node(k)
v.sort(reverse=True)
o.spe=v
o.presum=[]
o.presum.append(v[0])
for e in v[1:]:
o.presum.append(o.presum[-1]+e)
o.size+=1
final.append(o)
l+=1
maxsize=max(maxsize,o.size)
ans=0
start=0
final.sort(key=lambda o:o.size)
for size in range(maxsize):
count=0
for i in range(l-1,start-1,-1):
o=final[i]
count+=max(0,o.presum[size])
if o.size>size+1:
start=i
ans=max(ans,count)
print(max(0,ans))
``` | output | 1 | 20,303 | 17 | 40,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum. | instruction | 0 | 20,304 | 17 | 40,608 |
Tags: greedy, sortings
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
def main():
n,m=map(int,input().split())
a=[[] for _ in range(m+1)]
for i in range(n):
x,y=map(int,input().split())
a[x].append(y)
b=[0]*(n+1)
for i in range(1,m+1):
z=a[i]
z.sort(reverse=True)
su=0
for j in range(len(z)):
su+=z[j]
if su<0:
break
b[j+1]+=su
print(max(b))
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 20,304 | 17 | 40,609 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum. | instruction | 0 | 20,305 | 17 | 40,610 |
Tags: greedy, sortings
Correct Solution:
```
import math
#------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now----------------------------------------------------
n,m=map(int,input().split())
d=dict()
for i in range(n):
a,b=map(int,input().split())
if a in d:
d[a].append(b)
else:
d.update({a:[b]})
for j in d:
d[j].sort(reverse=True)
#print(d)
ans=[0]*n
for j in d:
su=0
for k in range(len(d[j])):
su+=d[j][k]
#print(d[j][k])
if su>0:
ans[k]+=su
#print(ans)
print(max(ans))
``` | output | 1 | 20,305 | 17 | 40,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum. | instruction | 0 | 20,306 | 17 | 40,612 |
Tags: greedy, sortings
Correct Solution:
```
from sys import stdin
n,m=map(int,input().split())
d=[[] for i in range(m+1)]
for i in range(n):
a,b=(int(x) for x in stdin.readline().split())
d[a]+=[b]
for i in range(1,m+1):
d[i].sort(reverse=True)
for i in range(1,m+1):
for j in range(1,len(d[i])):
d[i][j]+=d[i][j-1]
l=[0]*100001
for i in range(1,m+1):
for j in range(len(d[i])):
if l[j]+d[i][j]<l[j]:
break
l[j]=l[j]+d[i][j]
print(max(l))
``` | output | 1 | 20,306 | 17 | 40,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum. | instruction | 0 | 20,307 | 17 | 40,614 |
Tags: greedy, sortings
Correct Solution:
```
from sys import stdin
n,m=map(int,stdin.readline().strip().split())
adj=[[0,0] for i in range(max(m,n)+1)]
dp=[0 for i in range(max(m,n)+1)]
s=[]
for i in range(n):
a,b=map(int,stdin.readline().strip().split())
s.append([b,a])
s.sort(reverse=True)
ans=0
for i in range(n):
a,b=s[i][1],s[i][0]
adj[a][0]+=1
adj[a][1]+=b
dp[adj[a][0]]=max(dp[adj[a][0]]+adj[a][1],dp[adj[a][0]])
print(max(dp))
``` | output | 1 | 20,307 | 17 | 40,615 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum. | instruction | 0 | 20,308 | 17 | 40,616 |
Tags: greedy, sortings
Correct Solution:
```
n, m = [int(_) for _ in input().split()]
d = [[] for k in range(m + 1)]
for _ in range(n):
s, r = [int(_) for _ in input().split()]
d[s].append(r)
max_num = 0
for v in d:
max_num = max(max_num, len(v))
sums = [0] * max_num
for i, v in enumerate(d):
v.sort(reverse=True)
s = 0
for k, j in enumerate(v):
s += j
if s > 0:
sums[k] += s
else:
break
print(max(sums))
``` | output | 1 | 20,308 | 17 | 40,617 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum. | instruction | 0 | 20,309 | 17 | 40,618 |
Tags: greedy, sortings
Correct Solution:
```
def inint():
return int(input())
def inlist():
return list(map(int,input().split()))
def main():
n,m=inlist()
a=[[] for i in range(m+1)]
ch=[0]*(n+1)
for _ in range(n):
i,j=inlist()
a[i].append(j)
for i in range(1,m+1):
a[i].sort(reverse=True)
ch1=0
for j in range(len(a[i])):
ch1+=a[i][j]
if ch1>0:ch[j+1]+=ch1
print(max(ch))
if __name__ == "__main__":
#import profile
#profile.run("main()")
main()
``` | output | 1 | 20,309 | 17 | 40,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum.
Submitted Solution:
```
[n, m] = [int(x) for x in input().split()]
# get candidates
# put into sorted lists by subject/skill level
# create the running sum of those lists
# put those sorted lists into a sorted of (len, running_sum_list)
# for each number of candidates -> (0 to sorted_running_sum_lists[0][0])
# find the the sum of skills for valid lists
# for every number of candidate
# for every running skill list
# break if not enough candidates
# if running skill levels > 0 add
raw_skill_levels = [[] for x in range(m + 10)]
for i in range(n):
[s, r] = [int(x) for x in input().split()]
raw_skill_levels[s].append(r)
p_skills = []
for i in range(0, m+1):
if not raw_skill_levels[i]:
continue
sorted_skill_levels = reversed(sorted(raw_skill_levels[i]))
running_skill = 0
running_sums = []
for skill in sorted_skill_levels:
running_skill += skill
running_sums.append(running_skill)
p_skills.append((len(running_sums), running_sums))
p_skills = sorted(p_skills)
p_skills.reverse()
max_score = 0
for i in range(0, p_skills[0][0]):
score = 0
for j in range(0, len(p_skills)):
if p_skills[j][0] <= i:
break
# print(p_skills[j], i)
if p_skills[j][1][i] > 0:
score += p_skills[j][1][i]
max_score = max(max_score, score)
print(max_score)
``` | instruction | 0 | 20,310 | 17 | 40,620 |
Yes | output | 1 | 20,310 | 17 | 40,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum.
Submitted Solution:
```
''' Thruth can only be found at one place - THE CODE '''
''' Copyright 2018, SATYAM KUMAR'''
from sys import stdin, stdout
import cProfile, math
from collections import Counter
from bisect import bisect_left,bisect,bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
sys.setrecursionlimit(10**6) # max depth of recursion
threading.stack_size(2**27) # new thread will get stack of such size
printHeap = str()
memory_constrained = False
P = 10**9+7
import sys
sys.setrecursionlimit(10000000)
class Operation:
def __init__(self, name, function, function_on_equal, neutral_value=0):
self.name = name
self.f = function
self.f_on_equal = function_on_equal
def add_multiple(x, count):
return x * count
def min_multiple(x, count):
return x
def max_multiple(x, count):
return x
sum_operation = Operation("sum", sum, add_multiple, 0)
min_operation = Operation("min", min, min_multiple, 1e9)
max_operation = Operation("max", max, max_multiple, -1e9)
class SegmentTree:
def __init__(self,
array,
operations=[sum_operation, min_operation, max_operation]):
self.array = array
if type(operations) != list:
raise TypeError("operations must be a list")
self.operations = {}
for op in operations:
self.operations[op.name] = op
self.root = SegmentTreeNode(0, len(array) - 1, self)
def query(self, start, end, operation_name):
if self.operations.get(operation_name) == None:
raise Exception("This operation is not available")
return self.root._query(start, end, self.operations[operation_name])
def summary(self):
return self.root.values
def update(self, position, value):
self.root._update(position, value)
def update_range(self, start, end, value):
self.root._update_range(start, end, value)
def __repr__(self):
return self.root.__repr__()
class SegmentTreeNode:
def __init__(self, start, end, segment_tree):
self.range = (start, end)
self.parent_tree = segment_tree
self.range_value = None
self.values = {}
self.left = None
self.right = None
if start == end:
self._sync()
return
self.left = SegmentTreeNode(start, start + (end - start) // 2,
segment_tree)
self.right = SegmentTreeNode(start + (end - start) // 2 + 1, end,
segment_tree)
self._sync()
def _query(self, start, end, operation):
if end < self.range[0] or start > self.range[1]:
return None
if start <= self.range[0] and self.range[1] <= end:
return self.values[operation.name]
self._push()
left_res = self.left._query(start, end,
operation) if self.left else None
right_res = self.right._query(start, end,
operation) if self.right else None
if left_res is None:
return right_res
if right_res is None:
return left_res
return operation.f([left_res, right_res])
def _update(self, position, value):
if position < self.range[0] or position > self.range[1]:
return
if position == self.range[0] and self.range[1] == position:
self.parent_tree.array[position] = value
self._sync()
return
self._push()
self.left._update(position, value)
self.right._update(position, value)
self._sync()
def _update_range(self, start, end, value):
if end < self.range[0] or start > self.range[1]:
return
if start <= self.range[0] and self.range[1] <= end:
self.range_value = value
self._sync()
return
self._push()
self.left._update_range(start, end, value)
self.right._update_range(start, end, value)
self._sync()
def _sync(self):
if self.range[0] == self.range[1]:
for op in self.parent_tree.operations.values():
current_value = self.parent_tree.array[self.range[0]]
if self.range_value is not None:
current_value = self.range_value
self.values[op.name] = op.f([current_value])
else:
for op in self.parent_tree.operations.values():
result = op.f(
[self.left.values[op.name], self.right.values[op.name]])
if self.range_value is not None:
bound_length = self.range[1] - self.range[0] + 1
result = op.f_on_equal(self.range_value, bound_length)
self.values[op.name] = result
def _push(self):
if self.range_value is None:
return
if self.left:
self.left.range_value = self.range_value
self.right.range_value = self.range_value
self.left._sync()
self.right._sync()
self.range_value = None
def __repr__(self):
ans = "({}, {}): {}\n".format(self.range[0], self.range[1],
self.values)
if self.left:
ans += self.left.__repr__()
if self.right:
ans += self.right.__repr__()
return ans
def display(string_to_print):
stdout.write(str(string_to_print) + "\n")
def primeFactors(n): #n**0.5 complex
factors = dict()
for i in range(2,math.ceil(math.sqrt(n))+1):
while n % i== 0:
if i in factors:
factors[i]+=1
else: factors[i]=1
n = n // i
if n>2:
factors[n]=1
return (factors)
def isprime(n):
"""Returns True if n is prime."""
if n < 4:
return True
if n % 2 == 0:
return False
if n % 3 == 0:
return False
i = 5
w = 2
while i * i <= n:
if n % i == 0:
return False
i += w
w = 6 - w
return True
def test_print(*args):
if testingMode:
print(args)
def display_list(list1, sep=" "):
stdout.write(sep.join(map(str, list1)) + "\n")
def get_int():
return int(stdin.readline().strip())
def get_tuple():
return map(int, stdin.readline().split())
def get_list():
return list(map(int, stdin.readline().split()))
memory = dict()
def clear_cache():
global memory
memory = dict()
def cached_fn(fn, *args):
global memory
if args in memory:
return memory[args]
else:
result = fn(*args)
memory[args] = result
return result
# -------------------------------------------------------------- MAIN PROGRAM
TestCases = False
testingMode = False
optimiseForReccursion = False #Can not be used clubbed with TestCases
def comp(li):
return len(li)
def main():
n, m = get_tuple()
li = [[] for _ in range(m)]
res = 0
for _ in range(n):
s, r = get_tuple()
li[s-1].append(r)
for x in li:
x.sort(reverse = True)
li.sort(key = comp,reverse=True)
# print(li)
for x in li:
sm = 0
for j,el in enumerate(x):
x[j]+=sm
sm=x[j]
#print(li)
for i in range(1,len(li[0])+1):
# i mtlb kitne lene h ek baar me
ans = 0
for j in li:
if len(j)<i: break
ans += j[i-1] if j[i-1]>0 else 0
#print ("ANS",ans)
res = max(res,ans)
print(res) if res>0 else print(0)
# --------------------------------------------------------------------- END
if TestCases:
for _ in range(get_int()):
cProfile.run('main()') if testingMode else main()
else: (cProfile.run('main()') if testingMode else main()) if not optimiseForReccursion else threading.Thread(target=main).start()
``` | instruction | 0 | 20,311 | 17 | 40,622 |
Yes | output | 1 | 20,311 | 17 | 40,623 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum.
Submitted Solution:
```
n, m = map(int, input().split())
a = [[] for i in range(m)]
for _ in range(n):
t, s = map(int, input().split())
a[t - 1].append(s)
pre = [0] * n;
for i in range(m):
a[i].sort(reverse = True)
sum = 0
k = len(a[i])
for j in range(k):
sum += a[i][j]
if sum < 0:
break
pre[j] = pre[j] + sum
print(max(max(pre), 0))
``` | instruction | 0 | 20,312 | 17 | 40,624 |
Yes | output | 1 | 20,312 | 17 | 40,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum.
Submitted Solution:
```
n,m=map(int,input().split())
s=[[] for i in range(m)]
for _ in range(n):
si,ri=map(int,input().split())
s[si-1].append(ri)
pre=[0]*n
for i in range(m):
s[i].sort(reverse=True)
prefix=0
k=len(s[i])
for j in range(k):
prefix+=s[i][j]
if prefix<0:
break
pre[j]+=prefix
print(max(max(pre),0))
``` | instruction | 0 | 20,313 | 17 | 40,626 |
Yes | output | 1 | 20,313 | 17 | 40,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum.
Submitted Solution:
```
import sys
r = lambda: sys.stdin.readline()
n, m = map(int,r().split())
mx = [[] for row in range(m)]
mxlen = [0]*m
for i in range(n):
s1 , s2 = map(int,r().split())
if s2 > 0:
mx[s1-1] += [s2]
mxlen[s1-1]+=1
answer=0
maxnum = max(mxlen)
for i in range(1, maxnum+1):
answer_ = 0
for j in mx:
if len(j)>=i:
answer_+=sum(j[:i])
if answer < answer_:
answer = answer_
print(answer)
``` | instruction | 0 | 20,314 | 17 | 40,628 |
No | output | 1 | 20,314 | 17 | 40,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum.
Submitted Solution:
```
def inint():
return int(input())
def inlist():
return list(map(int,input().split()))
def main():
n,m=inlist()
a={i:[0,[]] for i in range(1,m+1)}
for _ in range(n):
i,j=inlist()
if a[i][0]+j<0:continue
a[i][0]+=j
a[i][1].append(j)
#print(a)
for i in list(a):
if a[i][0]<0 or len(a[i][1])==0:a.__delitem__(i)
if len(a)==0:print(0);return
b=[]
for i in a:
b.append((a[i][0],sorted(a[i][1])))
b.sort(key=lambda x:x[0]/len(x[1]))
#print(b)
sol=0
for i in range(2):
l=len(b[-i-1][1]);sm=0
for j in b:
if len(j[1])>=l:
for k in range(1,l+1):
sm+=j[1][-k]
sol=max(sm,sol)
#print(sm,l,b[-i-1])
if len(b)==1:break
print(sol)
if __name__ == "__main__":
#import profile
#profile.run("main()")
main()
``` | instruction | 0 | 20,315 | 17 | 40,630 |
No | output | 1 | 20,315 | 17 | 40,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A multi-subject competition is coming! The competition has m different subjects participants can choose from. That's why Alex (the coach) should form a competition delegation among his students.
He has n candidates. For the i-th person he knows subject s_i the candidate specializes in and r_i — a skill level in his specialization (this level can be negative!).
The rules of the competition require each delegation to choose some subset of subjects they will participate in. The only restriction is that the number of students from the team participating in each of the chosen subjects should be the same.
Alex decided that each candidate would participate only in the subject he specializes in. Now Alex wonders whom he has to choose to maximize the total sum of skill levels of all delegates, or just skip the competition this year if every valid non-empty delegation has negative sum.
(Of course, Alex doesn't have any spare money so each delegate he chooses must participate in the competition).
Input
The first line contains two integers n and m (1 ≤ n ≤ 10^5, 1 ≤ m ≤ 10^5) — the number of candidates and the number of subjects.
The next n lines contains two integers per line: s_i and r_i (1 ≤ s_i ≤ m, -10^4 ≤ r_i ≤ 10^4) — the subject of specialization and the skill level of the i-th candidate.
Output
Print the single integer — the maximum total sum of skills of delegates who form a valid delegation (according to rules above) or 0 if every valid non-empty delegation has negative sum.
Examples
Input
6 3
2 6
3 6
2 5
3 5
1 9
3 1
Output
22
Input
5 3
2 6
3 6
2 5
3 5
1 11
Output
23
Input
5 2
1 -1
1 -5
2 -1
2 -1
1 -10
Output
0
Note
In the first example it's optimal to choose candidates 1, 2, 3, 4, so two of them specialize in the 2-nd subject and other two in the 3-rd. The total sum is 6 + 6 + 5 + 5 = 22.
In the second example it's optimal to choose candidates 1, 2 and 5. One person in each subject and the total sum is 6 + 6 + 11 = 23.
In the third example it's impossible to obtain a non-negative sum.
Submitted Solution:
```
n,m=map(int,input().split())
ls=[[] for i in range(m)]
incl=[-1]*m
for i in range(n):
s,r=map(int,input().split())
s-=1
ls[s].append(r)
for i in range(m):
ls[i].sort(reverse=True)
tot=0
for x in ls[i]:
if tot+x>=0:incl[i]+=1
else: break
longest=max([len(x) for x in ls])
ans,tot=0,0
for idx in range(longest):
for i in range(m):
if idx==incl[i]+1:tot-=sum([ls[i][j] for j in range(idx)])
elif idx<=incl[i]:tot+=ls[i][idx]
ans=max(ans,tot)
print(ans)
``` | instruction | 0 | 20,316 | 17 | 40,632 |
No | output | 1 | 20,316 | 17 | 40,633 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.