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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are 3N participants in AtCoder Group Contest. The strength of the i-th participant is represented by an integer a_i. They will form N teams, each consisting of three participants. No participant may belong to multiple teams.
The strength of a team is defined as the second largest strength among its members. For example, a team of participants of strength 1, 5, 2 has a strength 2, and a team of three participants of strength 3, 2, 3 has a strength 3.
Find the maximum possible sum of the strengths of N teams.
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ a_i ≤ 10^{9}
* a_i are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_{3N}
Output
Print the answer.
Examples
Input
2
5 2 8 5 1 5
Output
10
Input
10
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
10000000000
Submitted Solution:
```
N, X, Y = map( int, input().split() )
C = []
W = []
for i in range( N ):
c, w = map( int, input().split() )
C.append( c - 1 )
W.append( w )
c2w = [ [] for i in range( N ) ]
for i in range( N ):
c2w[ C[ i ] ].append( W[ i ] )
for i in range( N ):
c2w[ C[ i ] ].sort()
minw, _minwp = 2e9, -1
for i in range( N ):
if minw > c2w[ i ][ 0 ]:
minw = c2w[ i ][ 0 ]
_minwp = i
minw2 = 2e9
for i in range( N ):
if i == _minwp: continue
if minw2 > c2w[ i ][ 0 ]:
minw2 = c2w[ i ][ 0 ]
merged = [ False for i in range( N ) ]
hi = [ 1 for i in range( N ) ]
for i in range( N ):
if len( c2w[ i ] ) == 0: continue
lb, ub = 2, len( c2w[ i ] )
while lb <= ub:
mid = lb + ub >> 1
if c2w[ i ][ 0 ] + c2w[ i ][ mid - 1 ] <= X:
hi[ i ] = max( hi[ i ], mid )
lb = mid + 1
else:
ub = mid - 1
lb, ub = 1, len( c2w[ i ] )
www = minw2 if minw != minw2 and c2w[ i ][ 0 ] == minw else minw
while lb <= ub:
mid = lb + ub >> 1
if www + c2w[ i ][ mid - 1 ] <= Y:
hi[ i ] = max( hi[ i ], mid )
merged[ i ] = True
lb = mid + 1
else:
ub = mid - 1
MOD = int( 1e9 + 7 )
fact = [ 1 ]
inv_fact = [ 1 ]
for i in range( 1, N + 1, 1 ):
fact.append( fact[ i - 1 ] * i % MOD )
inv_fact.append( pow( fact[ i ], MOD - 2, MOD ) )
ans = fact[ sum( merged[ i ] * hi[ i ] for i in range( N ) ) ]
for i in range( N ):
if not merged[ i ]: continue
ans = ans * inv_fact[ hi[ i ] ] % MOD
print( ans )
``` | instruction | 0 | 2,348 | 17 | 4,696 |
No | output | 1 | 2,348 | 17 | 4,697 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are 3N participants in AtCoder Group Contest. The strength of the i-th participant is represented by an integer a_i. They will form N teams, each consisting of three participants. No participant may belong to multiple teams.
The strength of a team is defined as the second largest strength among its members. For example, a team of participants of strength 1, 5, 2 has a strength 2, and a team of three participants of strength 3, 2, 3 has a strength 3.
Find the maximum possible sum of the strengths of N teams.
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ a_i ≤ 10^{9}
* a_i are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_{3N}
Output
Print the answer.
Examples
Input
2
5 2 8 5 1 5
Output
10
Input
10
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
10000000000
Submitted Solution:
```
def slove():
import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
a = list(map(int, input().rstrip('\n').split()))
a.sort(reverse=True)
print(a)
print(a[1:2*n+1:2])
print(sum(a[1:2*n+1:2]))
if __name__ == '__main__':
slove()
``` | instruction | 0 | 2,349 | 17 | 4,698 |
No | output | 1 | 2,349 | 17 | 4,699 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are 3N participants in AtCoder Group Contest. The strength of the i-th participant is represented by an integer a_i. They will form N teams, each consisting of three participants. No participant may belong to multiple teams.
The strength of a team is defined as the second largest strength among its members. For example, a team of participants of strength 1, 5, 2 has a strength 2, and a team of three participants of strength 3, 2, 3 has a strength 3.
Find the maximum possible sum of the strengths of N teams.
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ a_i ≤ 10^{9}
* a_i are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_{3N}
Output
Print the answer.
Examples
Input
2
5 2 8 5 1 5
Output
10
Input
10
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
10000000000
Submitted Solution:
```
# -*- coding: utf-8 -*-
n = int(input())
nums = [int(s) for s in input().split()]
nums.sort()
ans = 0
for i in range(n, 2*n):
ans += nums[i]
print(ans)
``` | instruction | 0 | 2,350 | 17 | 4,700 |
No | output | 1 | 2,350 | 17 | 4,701 |
Provide a correct Python 3 solution for this coding contest problem.
There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n ≤ 1000) on the first line, reception number pi (1 ≤ pi ≤ n) of the i-th subject on the following n lines, height hi in centimeters (1 ≤ hi ≤ 200), Given a kilogram of body weight wi (1 ≤ wi ≤ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2 | instruction | 0 | 2,374 | 17 | 4,748 |
"Correct Solution:
```
while True:
n = int(input())
if n == 0: break
ans = minv = 1<<10
for _ in range(n):
p, h, w = map(int, input().split())
BMI = w / ((h*0.01)**2)
tmp = 22 - BMI if 22 > BMI else BMI - 22
if tmp < minv:
ans, minv = p, tmp
print(ans)
``` | output | 1 | 2,374 | 17 | 4,749 |
Provide a correct Python 3 solution for this coding contest problem.
There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n ≤ 1000) on the first line, reception number pi (1 ≤ pi ≤ n) of the i-th subject on the following n lines, height hi in centimeters (1 ≤ hi ≤ 200), Given a kilogram of body weight wi (1 ≤ wi ≤ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2 | instruction | 0 | 2,375 | 17 | 4,750 |
"Correct Solution:
```
while True:
n = int(input())
if n == 0:
break
ans = 0
min_bmi = 100000.0
for l in range(n):
p,hh,ww = [int(i) for i in input().split()]
h = float(hh)
w = float(ww)
h = h * 0.01
bmi = abs(w / (h*h) - 22.0)
if bmi < min_bmi:
min_bmi = bmi
ans = p
print(ans)
``` | output | 1 | 2,375 | 17 | 4,751 |
Provide a correct Python 3 solution for this coding contest problem.
There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n ≤ 1000) on the first line, reception number pi (1 ≤ pi ≤ n) of the i-th subject on the following n lines, height hi in centimeters (1 ≤ hi ≤ 200), Given a kilogram of body weight wi (1 ≤ wi ≤ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2 | instruction | 0 | 2,376 | 17 | 4,752 |
"Correct Solution:
```
while True:
n = int(input())
if n == 0:
break
pairs = []
for _ in range(n):
p, h, w = map(int, input().split())
bmi = w / (h / 100) ** 2
pairs.append((p, bmi))
pairs.sort()
print(min(pairs, key=lambda x:abs(x[1] - 22))[0])
``` | output | 1 | 2,376 | 17 | 4,753 |
Provide a correct Python 3 solution for this coding contest problem.
There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n ≤ 1000) on the first line, reception number pi (1 ≤ pi ≤ n) of the i-th subject on the following n lines, height hi in centimeters (1 ≤ hi ≤ 200), Given a kilogram of body weight wi (1 ≤ wi ≤ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2 | instruction | 0 | 2,377 | 17 | 4,754 |
"Correct Solution:
```
# from sys import exit
while(True):
N = int(input())
if N == 0:
break
L = []
for i in range(N):
p, h, w = [int(n) for n in input().split()]
L.append((p, abs(22- w/((h/100)**2))))
# print(abs(22- w/((h/100)**2)))
L = sorted(L, key=lambda x: x[1])
print(L[0][0])
``` | output | 1 | 2,377 | 17 | 4,755 |
Provide a correct Python 3 solution for this coding contest problem.
There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n ≤ 1000) on the first line, reception number pi (1 ≤ pi ≤ n) of the i-th subject on the following n lines, height hi in centimeters (1 ≤ hi ≤ 200), Given a kilogram of body weight wi (1 ≤ wi ≤ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2 | instruction | 0 | 2,378 | 17 | 4,756 |
"Correct Solution:
```
while 1:
n = int(input())
if n == 0:
break
best = 10**9
for _ in range(n):
p, h, w = map(int, input().split())
bmi = w / (h / 100)**2
diff = abs(bmi - 22)
if diff < best:
ans = p
best = diff
elif diff == best:
if ans > p:
ans = p
print(ans)
``` | output | 1 | 2,378 | 17 | 4,757 |
Provide a correct Python 3 solution for this coding contest problem.
There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n ≤ 1000) on the first line, reception number pi (1 ≤ pi ≤ n) of the i-th subject on the following n lines, height hi in centimeters (1 ≤ hi ≤ 200), Given a kilogram of body weight wi (1 ≤ wi ≤ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2 | instruction | 0 | 2,379 | 17 | 4,758 |
"Correct Solution:
```
while True:
n = int(input())
if n == 0:
break
L =[]
for _ in range(n):
id, h, w = [int(x) for x in input().split()]
bmi = abs(w * 10000 / h**2 -22.0)
L.append([bmi,id])
L.sort()
print(L[0][1])
``` | output | 1 | 2,379 | 17 | 4,759 |
Provide a correct Python 3 solution for this coding contest problem.
There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n ≤ 1000) on the first line, reception number pi (1 ≤ pi ≤ n) of the i-th subject on the following n lines, height hi in centimeters (1 ≤ hi ≤ 200), Given a kilogram of body weight wi (1 ≤ wi ≤ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2 | instruction | 0 | 2,380 | 17 | 4,760 |
"Correct Solution:
```
while True:
def BMI(h,w):
X=w/(h/100)**2
return X
n =int(input())
if n==0:
break
tbl=[[0 for j in range(2)] for i in range(n)]
for i in range(n):
p,h,w=list(map(int, input().split()))
# print(BMI(h,w))
id=abs(22-BMI(h,w))
tbl[i][0]=p
tbl[i][1]=id
#print(tbl)
id_min=10**9
ans=0
for i in range(n):
if tbl[i][1]<id_min:
ans=tbl[i][0]
id_min=tbl[i][1]
print(ans)
``` | output | 1 | 2,380 | 17 | 4,761 |
Provide a correct Python 3 solution for this coding contest problem.
There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n ≤ 1000) on the first line, reception number pi (1 ≤ pi ≤ n) of the i-th subject on the following n lines, height hi in centimeters (1 ≤ hi ≤ 200), Given a kilogram of body weight wi (1 ≤ wi ≤ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2 | instruction | 0 | 2,381 | 17 | 4,762 |
"Correct Solution:
```
# AOJ 0159 The Best Body
# Python3 2018.6.18 bal4u
GOAL = 22.0
EPS = 1e-5
while True:
n = int(input())
if n == 0: break
id, vmin = 0, 1000000000.0;
for i in range(n):
p, h, w = list(map(int, input().split()))
bmi = w/(h/100)**2
diff = abs(bmi-GOAL)
if abs(diff-vmin) < EPS: # diff == vmin
if p < id: id = p
elif diff < vmin:
id, vmin = p, diff
print(id)
``` | output | 1 | 2,381 | 17 | 4,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n ≤ 1000) on the first line, reception number pi (1 ≤ pi ≤ n) of the i-th subject on the following n lines, height hi in centimeters (1 ≤ hi ≤ 200), Given a kilogram of body weight wi (1 ≤ wi ≤ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2
Submitted Solution:
```
def BMI(height, weight):
return weight / (height / 100) ** 2
STANDARD_VALUE = 22
while True:
input_count = int(input())
if input_count == 0:
break
input_data = [map(int, input().split(" ")) for _ in range(input_count)]
data = [(number, BMI(height, weight)) for number, height, weight in input_data]
data = [(number, abs(bmi - STANDARD_VALUE)) for number, bmi in data]
data.sort(key=lambda item: (item[1], item[0]))
print(data[0][0])
``` | instruction | 0 | 2,383 | 17 | 4,766 |
Yes | output | 1 | 2,383 | 17 | 4,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n ≤ 1000) on the first line, reception number pi (1 ≤ pi ≤ n) of the i-th subject on the following n lines, height hi in centimeters (1 ≤ hi ≤ 200), Given a kilogram of body weight wi (1 ≤ wi ≤ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0159
"""
import sys
from sys import stdin
input = stdin.readline
from collections import namedtuple
bmi = namedtuple('bmi', ['d', 'p'])
def calc_BMI(h, w):
return w / ((h / 100)**2)
def main(args):
while True:
n = int(input())
if n == 0:
break
scores = []
for _ in range(n):
p, h, w = map(int, input().split())
scores.append(bmi(abs(calc_BMI(h, w) - 22), p))
scores.sort()
print(scores[0].p)
if __name__ == '__main__':
main(sys.argv[1:])
``` | instruction | 0 | 2,384 | 17 | 4,768 |
Yes | output | 1 | 2,384 | 17 | 4,769 |
Provide a correct Python 3 solution for this coding contest problem.
Akira, the student council president of A High School, decided to investigate which club activities the A High School students belong to. A High School has N students numbered 1 to N and M types of club activities numbered 1 to M. There is no limit to the number of people in each club activity, and there can be 0 club activities. However, according to the school rules of A High School, students can only belong to one club activity. All students follow this school rule.
Akira asked student members to investigate and obtained records for line K, such as each line being one of the following:
* Student a and student b belong to the same club activities.
* Student c belongs to club activity x.
However, there may be a contradiction in this record that would cause someone to violate school rules. Akira decided to look at the first line in order and look for the first line that could be judged to be inconsistent.
Create a program that finds the number of the first line that can be determined to be inconsistent given a record of K lines.
Input
The input is given in the following format.
NMK
record1
record2
::
recordK
The first line gives the number of students N (1 ≤ N ≤ 100000), the number of club activity types M (1 ≤ M ≤ 100000), and the number of recorded lines K (1 ≤ K ≤ 200000). Each line of record, recordi, is given in the following K lines in one of the following formats:
1 a b
Or
2 c x
When the first digit is "1", it indicates that student a (1 ≤ a ≤ N) and student b (1 ≤ b ≤ N) belong to the same club activity. However, a ≠ b.
When the first digit is "2", it indicates that student c (1 ≤ c ≤ N) belongs to club activity x (1 ≤ x ≤ M).
Output
Output the number of the first line that can be determined to be inconsistent on one line. If not found, output 0 on one line.
Examples
Input
3 2 5
1 1 2
1 2 3
2 1 1
2 3 2
2 2 1
Output
4
Input
3 2 4
1 1 2
2 1 1
2 3 2
2 2 1
Output
0
Input
3 2 2
1 1 2
2 1 1
Output
0 | instruction | 0 | 2,385 | 17 | 4,770 |
"Correct Solution:
```
n, m, k = map(int, input().split())
*parent, = range(n+m)
def root(x):
if x == parent[x]:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
px = root(x); py = root(y)
if px < py:
parent[py] = px
else:
parent[px] = py
for i in range(k):
a, b, c = map(int, input().split())
b -= 1; c -= 1
if a == 1:
pb = root(m+b); pc = root(m+c)
if pb < m and pc < m and pb != pc:
print(i+1)
break
unite(pb, pc)
else:
pb = root(m+b)
if pb < m and pb != c:
print(i+1)
break
unite(c, pb)
else:
print(0)
``` | output | 1 | 2,385 | 17 | 4,771 |
Provide a correct Python 3 solution for this coding contest problem.
Akira, the student council president of A High School, decided to investigate which club activities the A High School students belong to. A High School has N students numbered 1 to N and M types of club activities numbered 1 to M. There is no limit to the number of people in each club activity, and there can be 0 club activities. However, according to the school rules of A High School, students can only belong to one club activity. All students follow this school rule.
Akira asked student members to investigate and obtained records for line K, such as each line being one of the following:
* Student a and student b belong to the same club activities.
* Student c belongs to club activity x.
However, there may be a contradiction in this record that would cause someone to violate school rules. Akira decided to look at the first line in order and look for the first line that could be judged to be inconsistent.
Create a program that finds the number of the first line that can be determined to be inconsistent given a record of K lines.
Input
The input is given in the following format.
NMK
record1
record2
::
recordK
The first line gives the number of students N (1 ≤ N ≤ 100000), the number of club activity types M (1 ≤ M ≤ 100000), and the number of recorded lines K (1 ≤ K ≤ 200000). Each line of record, recordi, is given in the following K lines in one of the following formats:
1 a b
Or
2 c x
When the first digit is "1", it indicates that student a (1 ≤ a ≤ N) and student b (1 ≤ b ≤ N) belong to the same club activity. However, a ≠ b.
When the first digit is "2", it indicates that student c (1 ≤ c ≤ N) belongs to club activity x (1 ≤ x ≤ M).
Output
Output the number of the first line that can be determined to be inconsistent on one line. If not found, output 0 on one line.
Examples
Input
3 2 5
1 1 2
1 2 3
2 1 1
2 3 2
2 2 1
Output
4
Input
3 2 4
1 1 2
2 1 1
2 3 2
2 2 1
Output
0
Input
3 2 2
1 1 2
2 1 1
Output
0 | instruction | 0 | 2,386 | 17 | 4,772 |
"Correct Solution:
```
n, m, k = map(int, input().split())
parent = [i for i in range(n)]
club = [-1 for _ in range(n)]
def find(x):
if x == parent[x]:
return x
ret = find(parent[x])
parent[x] = ret
return ret
for count in range(1, k + 1):
t, a, b = map(int, input().split())
a -= 1
b -= 1
if t == 1:
p_a = find(a)
p_b = find(b)
c_a = club[p_a]
c_b = club[p_b]
if c_a >= 0 and c_b >= 0 and c_a != c_b:
print(count)
break
if c_a < 0 and c_b >= 0:
club[p_a] = c_b
parent[p_b] = p_a
else:
p_a = find(a)
if club[p_a] < 0:
club[p_a] = b
if club[p_a] >= 0 and club[p_a] != b:
print(count)
break
else:
print(0)
``` | output | 1 | 2,386 | 17 | 4,773 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Akira, the student council president of A High School, decided to investigate which club activities the A High School students belong to. A High School has N students numbered 1 to N and M types of club activities numbered 1 to M. There is no limit to the number of people in each club activity, and there can be 0 club activities. However, according to the school rules of A High School, students can only belong to one club activity. All students follow this school rule.
Akira asked student members to investigate and obtained records for line K, such as each line being one of the following:
* Student a and student b belong to the same club activities.
* Student c belongs to club activity x.
However, there may be a contradiction in this record that would cause someone to violate school rules. Akira decided to look at the first line in order and look for the first line that could be judged to be inconsistent.
Create a program that finds the number of the first line that can be determined to be inconsistent given a record of K lines.
Input
The input is given in the following format.
NMK
record1
record2
::
recordK
The first line gives the number of students N (1 ≤ N ≤ 100000), the number of club activity types M (1 ≤ M ≤ 100000), and the number of recorded lines K (1 ≤ K ≤ 200000). Each line of record, recordi, is given in the following K lines in one of the following formats:
1 a b
Or
2 c x
When the first digit is "1", it indicates that student a (1 ≤ a ≤ N) and student b (1 ≤ b ≤ N) belong to the same club activity. However, a ≠ b.
When the first digit is "2", it indicates that student c (1 ≤ c ≤ N) belongs to club activity x (1 ≤ x ≤ M).
Output
Output the number of the first line that can be determined to be inconsistent on one line. If not found, output 0 on one line.
Examples
Input
3 2 5
1 1 2
1 2 3
2 1 1
2 3 2
2 2 1
Output
4
Input
3 2 4
1 1 2
2 1 1
2 3 2
2 2 1
Output
0
Input
3 2 2
1 1 2
2 1 1
Output
0
Submitted Solution:
```
# coding=utf-8
class ClubConflictException(Exception):
pass
class Student:
def __init__(self, number):
self.name = number
self.club = -1
self.in_same_club = []
def set_club(self, clb, order_from=None):
if not self.is_belong():
self.club = clb
if not order_from is None:
try:
self.in_same_club.remove(order_from)
except ValueError:
pass
self.synchronize_club()
elif self.club == clb:
if not order_from is None:
try:
self.in_same_club.remove(order_from)
except ValueError:
pass
else:
raise ClubConflictException
def is_belong(self):
if self.club == -1:
return False
return True
def synchronize_club(self):
if not self.in_same_club:
pass
else:
to_synchro = self.in_same_club[:]
for std in to_synchro:
std.set_club(self.club, self)
self.in_same_club.remove(std)
class Club:
def __init__(self, number):
self.name = number
class Commission:
def __init__(self):
self.student_list = []
self.club_list = []
def set_same_club(self, std1, std2):
student1 = self.check_std(std1)
student2 = self.check_std(std2)
if student1.is_belong():
student2.set_club(student1.club)
elif student2.is_belong():
student1.set_club(student2.club)
else:
student1.in_same_club.append(student2)
student2.in_same_club.append(student1)
def link_std_and_club(self, std, club):
student = self.check_std(std)
clb = self.check_club(club)
student.set_club(clb)
def check_std(self, std):
if self.is_made_std(std):
return self.search_list(std, self.student_list)
return self.make_std(std)
def check_club(self, club):
if self.is_made_club(club):
return self.search_list(club, self.club_list)
return self.make_club(club)
def search_list(self, element, org_list):
list_to_dict = {elm.name: elm for elm in org_list}
return list_to_dict[element]
def is_made_std(self, std):
std_n_list = [student.name for student in self.student_list]
if std in std_n_list:
return True
return False
def make_std(self, std):
student = Student(std)
self.student_list.append(student)
return student
def is_made_club(self, clb):
club_n_list = [club.name for club in self.club_list]
if clb in club_n_list:
return True
return False
def make_club(self, club):
clb = Club(club)
self.club_list.append(clb)
return clb
if __name__ == '__main__':
N, M, K = map(int, input().split())
akira = Commission()
for i in range(1, K+1):
rtype, x1, x2 = map(int, input().split())
if rtype == 1:
try:
akira.set_same_club(x1, x2)
except ClubConflictException:
print(i)
break
elif rtype == 2:
try:
akira.link_std_and_club(x1, x2)
except ClubConflictException:
print(i)
break
else:
print(0)
``` | instruction | 0 | 2,387 | 17 | 4,774 |
No | output | 1 | 2,387 | 17 | 4,775 |
Provide a correct Python 3 solution for this coding contest problem.
There are $ n $ acitivities with start times $ \\ {s_i \\} $ and finish times $ \\ {t_i \\} $. Assuming that a person can only work on a single activity at a time, find the maximum number of activities that can be performed by a single person.
Constraints
* $ 1 \ le n \ le 10 ^ 5 $
* $ 1 \ le s_i \ lt t_i \ le 10 ^ 9 (1 \ le i \ le n) $
Input
$ n $
$ s_1 $ $ t_1 $
$ s_2 $ $ t_2 $
::
$ s_n $ $ t_n $
The first line consists of the integer $ n $. In the following $ n $ lines, the start time $ s_i $ and the finish time $ t_i $ of the activity $ i $ are given.
output
Print the maximum number of activities in a line.
Examples
Input
5
1 2
3 9
3 5
5 9
6 8
Output
3
Input
3
1 5
3 4
2 5
Output
1
Input
3
1 2
2 3
3 4
Output
2 | instruction | 0 | 2,436 | 17 | 4,872 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Greedy algorithms - Activity Selection Problem
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_15_C&lang=jp
"""
n = int(input())
activities = sorted([[int(i) for i in input().split()] for _ in range(n)], key=lambda x: x[1], reverse=True)
ans, ct = 0, 0
while activities:
s, t = activities.pop()
if s > ct:
ct = t
ans += 1
print(ans)
``` | output | 1 | 2,436 | 17 | 4,873 |
Provide a correct Python 3 solution for this coding contest problem.
There are $ n $ acitivities with start times $ \\ {s_i \\} $ and finish times $ \\ {t_i \\} $. Assuming that a person can only work on a single activity at a time, find the maximum number of activities that can be performed by a single person.
Constraints
* $ 1 \ le n \ le 10 ^ 5 $
* $ 1 \ le s_i \ lt t_i \ le 10 ^ 9 (1 \ le i \ le n) $
Input
$ n $
$ s_1 $ $ t_1 $
$ s_2 $ $ t_2 $
::
$ s_n $ $ t_n $
The first line consists of the integer $ n $. In the following $ n $ lines, the start time $ s_i $ and the finish time $ t_i $ of the activity $ i $ are given.
output
Print the maximum number of activities in a line.
Examples
Input
5
1 2
3 9
3 5
5 9
6 8
Output
3
Input
3
1 5
3 4
2 5
Output
1
Input
3
1 2
2 3
3 4
Output
2 | instruction | 0 | 2,438 | 17 | 4,876 |
"Correct Solution:
```
def main():
n = int(input())
sch = []
for _ in range(n):
sch.append(list(map(int,input().split())))
sch.sort(key=lambda a: a[1])
res,t = 0,-1
for i in range(n):
if t<sch[i][0]:
t = sch[i][1]
res+=1
print (res)
if __name__ == '__main__':
main()
``` | output | 1 | 2,438 | 17 | 4,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1 | instruction | 0 | 2,718 | 17 | 5,436 |
Tags: data structures, implementation, math
Correct Solution:
```
n, m = map(int, input().split())
a = [str((m+1)//2 + (1 - 2*((m+i%m-1)%2))*(((i%m)+1)//2)) for i in range(n)]
print("\n".join(a))
``` | output | 1 | 2,718 | 17 | 5,437 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1 | instruction | 0 | 2,719 | 17 | 5,438 |
Tags: data structures, implementation, math
Correct Solution:
```
def task(n,m):
if m%2==0:
c=0
else:
c=1
mid=m//2+c
l=mid-1
hi=mid+1
print(mid)
n-=1
if m%2!=0:
while n:
if l>0:
print(l)
l-=1
n-=1
if hi<=m and n:
print(hi)
hi+=1
n-=1
if hi>m and l<=0:
hi=mid+1
l=mid-1
if n:
print(mid)
n-=1
return ""
else:
while n:
if hi<=m and n:
print(hi)
hi+=1
n-=1
if l>0 and n:
print(l)
l-=1
n-=1
if hi>m and l<=0:
hi=mid+1
l=mid-1
if n:
print(mid)
n-=1
return ""
a,b=map(int,input().strip().split())
print(task(a,b))
``` | output | 1 | 2,719 | 17 | 5,439 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1 | instruction | 0 | 2,720 | 17 | 5,440 |
Tags: data structures, implementation, math
Correct Solution:
```
n,m=list(map(int,input().split()))
l=[0]*(n+1)
b=[0]*(m+1)
m1=(m+1)//2
if m%2==1:
for i in range(1,n+1):
if i<=m:
if i%2==1:
l[i]=m1+i//2
else:
l[i]=m1-i//2
else:
l[i]=l[i-m]
if m%2==0:
for i in range(1,n+1):
if i<=m:
if i%2==1:
l[i]=m1-i//2
else:
l[i]=m1+i//2
else:
l[i]=l[i-m]
for i in range(1,n+1):
print(l[i])
``` | output | 1 | 2,720 | 17 | 5,441 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1 | instruction | 0 | 2,721 | 17 | 5,442 |
Tags: data structures, implementation, math
Correct Solution:
```
from sys import *
input = stdin.readline
n, m = map(int, input().split())
rishabh = (m + 1) // 2
ans = []
smh = rishabh
for kk in range(n):
ans.append(smh)
if smh == rishabh and m%2 == 1:
smh -= 1
elif smh <= rishabh:
smh = m - smh + 1
else:
smh = m - smh
if smh == 0:
smh = rishabh
for kkk in ans:
print(kkk)
``` | output | 1 | 2,721 | 17 | 5,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1 | instruction | 0 | 2,722 | 17 | 5,444 |
Tags: data structures, implementation, math
Correct Solution:
```
n,m=map(int,input().split())
#baskets=[int(i) for i in input().split()]
if m%2==0:
ans=[]
for i in range(m//2,0,-1):
ans.append(i)
ans.append(m-i+1)
z=n//m
k=ans*z
k=k+ans[0:n%m]
else:
ans=[m//2+1]
for i in range(m//2,0,-1):
ans.append(i)
ans.append(m-i+1)
z=n//m
k=ans*z
k=k+ans[0:n%m]
for i in k:
print(i)
``` | output | 1 | 2,722 | 17 | 5,445 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1 | instruction | 0 | 2,723 | 17 | 5,446 |
Tags: data structures, implementation, math
Correct Solution:
```
def func(i):
return abs((m+1)/2-i)
a = input()
[n, m] = a.split(' ')
[n, m] = [int(n), int(m)];
a = [i for i in range(1, m+1)]
a.sort(key=func)
i = 0;
while(i<n):
print(a[i%m])
i+=1;
# print(a)
``` | output | 1 | 2,723 | 17 | 5,447 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1 | instruction | 0 | 2,724 | 17 | 5,448 |
Tags: data structures, implementation, math
Correct Solution:
```
n,m = input().split()
n,m = int(n),int(m)
for i in range(n):
j = i % m;
if m % 2 == 1:
if j % 2 == 0:
print(int(m/2 + j/2) + 1)
else:
print(int(m/2 - (j+1)/2) + 1)
else:
if j % 2 == 0:
print(int(m/2 - j/2))
else:
print(int(m/2 + (j+1)/2))
``` | output | 1 | 2,724 | 17 | 5,449 |
Provide tags and a correct Python 3 solution for this coding contest problem.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1 | instruction | 0 | 2,725 | 17 | 5,450 |
Tags: data structures, implementation, math
Correct Solution:
```
n, m = map(int, input().split())
center = (m+1)//2
pos = center
for i in range(n):
print(pos)
if pos == center and m%2 == 1:
pos -= 1
elif pos <= center:
pos = m-pos+1
else:
pos = m-pos
if pos == 0:
pos = center
``` | output | 1 | 2,725 | 17 | 5,451 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
n,m = map(int,input().split())
lst = [0]*m
if m%2:
i = 1
x = (m+1)//2
lst[0] = x
for j in range(x-1,0,-1):
lst[i] = j
i += 2
i = 2
for j in range(x+1,m+1):
lst[i] = j
i += 2
else:
i = 0
x = (m+1)//2
for j in range(x,0,-1):
lst[i] = j
i += 2
i = 1
for j in range(x+1,m+1):
lst[i] = j
i += 2
t = n//m
if t==0:
print(*lst[:n%m])
else:
lst *= t
lst += lst[:n%m]
print(*lst)
``` | instruction | 0 | 2,726 | 17 | 5,452 |
Yes | output | 1 | 2,726 | 17 | 5,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
from sys import stdin, stdout, setrecursionlimit
from collections import deque
# tail-recursion optimization
# In case of tail-recusion optimized code, have to use python compiler.
# Otherwise, memory limit may exceed.
# declare the class Tail_Recursion_Optimization
class Tail_Recursion_Optimization:
def __init__(self, RECURSION_LIMIT, STACK_SIZE):
setrecursionlimit(RECURSION_LIMIT)
threading.stack_size(STACK_SIZE)
return None
class SOLVE:
def solve(self):
R = stdin.readline
#f = open('input.txt');R = f.readline
W = stdout.write
ans = []
n, m = [int(x) for x in R().split()]
a = (m+1) // 2
b = a + (-1 if m%2 else 1)
boxes = deque()
while 1 <= a <= m and 1 <= b <= m:
boxes.append(str(a))
boxes.append(str(b))
a += ( 1 if m%2 else -1)
b += (-1 if m%2 else 1)
if m%2:
boxes.append(str(m))
for i in range(1, n+1):
current_box = boxes.popleft()
ans.append(current_box)
boxes.append(current_box)
W('\n'.join(ans))
return 0
def main():
s = SOLVE()
s.solve()
#Tail_Recursion_Optimization(10**7, 100*1024**2) # recursion-call size, stack-size in byte (MB*1024**2)
#threading.Thread(target=main).start()
main()
``` | instruction | 0 | 2,727 | 17 | 5,454 |
Yes | output | 1 | 2,727 | 17 | 5,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
n, m = map(int, input().split())
p = [0] * (n + 1)
t = [0] + [[j + i for i in range(0, n - j + 1, m)] for j in range(m - 1, m % 2, - 2)] + [[j + i for i in range(0, n - j + 1, m)] for j in range(2 - m % 2, m + 1, 2)]
for j in range(1, m + 1):
for i in t[j]:
p[i] = str(j)
print('\n'.join(p[1: ]))
``` | instruction | 0 | 2,728 | 17 | 5,456 |
Yes | output | 1 | 2,728 | 17 | 5,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
n,m=map(int,input().split(' '))
arr=[]
mid=int((m+1)/2)
if(m%2==0):
if(m==2):
arr.append(mid)
arr.append(mid+1)
else:
arr.append(mid)
for i in range(1,mid):
arr.append(mid+i)
arr.append(mid-i)
arr.append(m)
else:
arr.append(mid)
for i in range(1,mid):
arr.append(mid-i)
arr.append(mid+i)
for i in range(n//m):
for j in range(m):
print(arr[j])
for i in range(n%m):
print(arr[i])
``` | instruction | 0 | 2,729 | 17 | 5,458 |
Yes | output | 1 | 2,729 | 17 | 5,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
n,m=map(int,input().split())
a=[]
if m%2==0:
t1=m//2
t2=m//2+1
while t1>0 or t2<m:
a.append(t1)
a.append(t2)
t1-=1
t2+=1
else:
t1=m//2
t2=t1-1
t3=t1+1
a.append(t1+1)
while t2>=0 and t3<m:
a.append(t2+1)
a.append(t3+1)
t2-=1
t3+=1
if (n//m)==0:
for i in range(n):
print(a[i])
print("ok")
else:
t1=n//m
while t1!=0:
for i in range(m):
print(a[i])
t1-=1
t2=n%m
for i in range(m):
if i<t2:
print(a[i])
else:
break
``` | instruction | 0 | 2,730 | 17 | 5,460 |
No | output | 1 | 2,730 | 17 | 5,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
n,m = map(int,input().split())
d = {i+1:0 for i in range(n)}
i = 0
t = int(m/2)
t1 = t + 1
r = 0
if m%2 == 0:
while i!= n:
d[i+1] = t
i = i + 1
if i < n:
d[i+1] = t1
i = i + 1
r = r + 1
if r == t:
r == 0
t = t - r
t1 = t1 + r
if m%2 == 1:
r = 1
while i != n:
d[i+1] = t1
i = i + 1
if i < n:
if r == t1:
r = 0
d[i+1] = t1-r
i = i + 1
if i < n:
if r == t1:
r = 0
d[i+1] = t1+r
i = i + 1
r = r + 1
for i in d:
print(d[i])
``` | instruction | 0 | 2,731 | 17 | 5,462 |
No | output | 1 | 2,731 | 17 | 5,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
from sys import stdin ,stdout
from os import path
rd = lambda:stdin.readline().strip()
wr = stdout.write
if(path.exists('input.txt')):
stdin = open("input.txt","r")
import time
#------------------------------------
x,y = map(int,rd().split())
out =""
temp =0
if y % 2== 0 :
temp =y//2
out+=str(temp)
else:
temp =(y+1)//2
out+=str(temp)
for i in range(1,y+1):
if i != temp :
out+=str(i)
count = x//y
if count == 0 :
out=out[:x%y]
else:
out = (out*count)+out[:x%y]
for i in out :
print(i)
``` | instruction | 0 | 2,732 | 17 | 5,464 |
No | output | 1 | 2,732 | 17 | 5,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After a team finished their training session on Euro football championship, Valeric was commissioned to gather the balls and sort them into baskets. Overall the stadium has n balls and m baskets. The baskets are positioned in a row from left to right and they are numbered with numbers from 1 to m, correspondingly. The balls are numbered with numbers from 1 to n.
Valeric decided to sort the balls in the order of increasing of their numbers by the following scheme. He will put each new ball in the basket with the least number of balls. And if he's got several variants, he chooses the basket which stands closer to the middle. That means that he chooses the basket for which <image> is minimum, where i is the number of the basket. If in this case Valeric still has multiple variants, he chooses the basket with the minimum number.
For every ball print the number of the basket where it will go according to Valeric's scheme.
Note that the balls are sorted into baskets in the order of increasing numbers, that is, the first ball goes first, then goes the second ball and so on.
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of balls and baskets, correspondingly.
Output
Print n numbers, one per line. The i-th line must contain the number of the basket for the i-th ball.
Examples
Input
4 3
Output
2
1
3
2
Input
3 1
Output
1
1
1
Submitted Solution:
```
from sys import stdin,stdout
ii1 = lambda: int(stdin.readline().strip())
is1 = lambda: stdin.readline().strip()
iia = lambda: list(map(int, stdin.readline().strip().split()))
isa = lambda: stdin.readline().strip().split()
mod = 1000000007
n, m = iia()
if m % 2 == 0:
mid = m // 2 + 1
else:
mid = m // 2
l = r = mid
l1 = r1 = True
while n != 0:
if l1 and r1:
print(mid)
n -= 1
l = r = mid
l1 = r1 = False
if l > 1 and n:
print(l-1)
l -= 1
n -= 1
if l == 1:
l1 = True
if r < m and n:
print(r+1)
r += 1
n -= 1
if r == m:
r1 = True
``` | instruction | 0 | 2,733 | 17 | 5,466 |
No | output | 1 | 2,733 | 17 | 5,467 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people. | instruction | 0 | 2,844 | 17 | 5,688 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
def f(k):
return k*(k-1)//2
n,m=map(int,input().split())
print(f(n//m+1)*(n%m)+f(n//m)*(m-n%m),f(n-m+1))
``` | output | 1 | 2,844 | 17 | 5,689 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people. | instruction | 0 | 2,845 | 17 | 5,690 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
n, m = tuple(map(int, input().split()))
n1 = int(n / m)
mod = n % m
print((n1 + 1) * n1 // 2 * mod + n1 * (n1 - 1) // 2 * (m - mod), (n - m + 1) * (n - m) // 2)
``` | output | 1 | 2,845 | 17 | 5,691 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people. | instruction | 0 | 2,846 | 17 | 5,692 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
# coding: utf-8
n, m = [int(i) for i in input().split()]
if n%m==0:
kmin = (n//m)*(n//m-1)//2*m
kmax = (n-m+1)*(n-m)//2
else:
t = n//m
kmin = t*(t+1)//2*(n%m)+t*(t-1)//2*(m-n%m)
kmax = (n-m+1)*(n-m)//2
print(kmin,kmax)
``` | output | 1 | 2,846 | 17 | 5,693 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people. | instruction | 0 | 2,847 | 17 | 5,694 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
w=input().split(" ")
n=int(w[0])
m=int(w[1])
formax=n-m
maxx=int((formax)*(formax+1)//2)
a=n//m
b=n%m
minn=int((b*(a*(a+1)/2))+((m-b)*(a*(a-1)/2)))
print(str(minn)+" "+str(maxx))
``` | output | 1 | 2,847 | 17 | 5,695 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people. | instruction | 0 | 2,848 | 17 | 5,696 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
n, m = map(int, input().split())
print(((n // m) * (n // m - 1)) // 2 * (m - n % m) + (n % m) * ((n // m + 1) * (n // m)) // 2,
(n - m + 1) * (n - m) // 2)
``` | output | 1 | 2,848 | 17 | 5,697 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people. | instruction | 0 | 2,849 | 17 | 5,698 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
n, m = map(int, input().split())
#pentru doua gramezi este optim sa muti dintr-una in cealalta pentru a maximiza C(a,2)+C(b,2)
#a+b == n. graficul apare ca al unei functii de gradul 2 cu fundul in jos
#cum treci la 3/4.. variabile?
def P(x):
return x*(x-1)//2
print(P(n//m)*(m - n%m) + P(n//m+1)*(n%m), end = ' ')
print(P(n-m+1))
``` | output | 1 | 2,849 | 17 | 5,699 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people. | instruction | 0 | 2,850 | 17 | 5,700 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
n, m = (int(s) for s in input().split(" "))
res2 = (n-m+1) * (n-m) // 2
res1 = (n//m - 1) * (n//m) * (m - n%m) //2 + (n//m ) * (n//m + 1) * (n%m)//2
print(res1, res2)
``` | output | 1 | 2,850 | 17 | 5,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people. | instruction | 0 | 2,851 | 17 | 5,702 |
Tags: combinatorics, constructive algorithms, greedy, math
Correct Solution:
```
n,k=map(int,input().split())
x=n-(k-1)
kmax = (x*(x-1))//2
t = n//k
y = n%k
kmin = (k-y)*((t*(t-1))//2) + y*(((t+1)*t)//2)
print(kmin,kmax)
``` | output | 1 | 2,851 | 17 | 5,703 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people.
Submitted Solution:
```
n,m=map(int,input().split())
mxc=n%m
mnc=m-mxc
mn=n//m
mx=mn+1
print(mxc*mx*(mx-1)//2 + mnc*mn*(mn-1)//2, (n-m)*(n-m+1)//2)
``` | instruction | 0 | 2,852 | 17 | 5,704 |
Yes | output | 1 | 2,852 | 17 | 5,705 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people.
Submitted Solution:
```
n,m=map(int,input().split())
av=n//m
mi=av*(av-1)//2
mi*=m
mi+=av*(n%m)
ma=(n-m)*(n-m+1)//2
print(mi,ma)
``` | instruction | 0 | 2,853 | 17 | 5,706 |
Yes | output | 1 | 2,853 | 17 | 5,707 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people.
Submitted Solution:
```
def friends_in_team(amount):
if amount <= 1:
return 0
return (amount * (amount - 1)) // 2
n, m = (int(x) for x in input().split())
a = friends_in_team(n // m) * (m - n % m)
a += friends_in_team(n // m + 1) * (n % m)
b = friends_in_team(n - m + 1)
print('{} {}'.format(min(a, b), max(a, b)))
``` | instruction | 0 | 2,854 | 17 | 5,708 |
Yes | output | 1 | 2,854 | 17 | 5,709 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people.
Submitted Solution:
```
n, m = (int(x) for x in input().split())
q, r = n // m, n % m
kmin = r * (q + 1) * q // 2 + (m - r) * q * (q - 1) // 2
kmax = (n - m + 1) * (n - m) // 2
print(kmin, kmax)
``` | instruction | 0 | 2,855 | 17 | 5,710 |
Yes | output | 1 | 2,855 | 17 | 5,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people.
Submitted Solution:
```
n, m = map(int, input().split())
div = n//m
mod = n%m
mini = ((div-1) * (m-mod) + (div + 1) * (mod))*div/2
maxi = (n-(m+1)) * (n-m) / 2
print(int(mini), int(maxi))
``` | instruction | 0 | 2,856 | 17 | 5,712 |
No | output | 1 | 2,856 | 17 | 5,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people.
Submitted Solution:
```
w=input().split(" ")
n=int(w[0])
m=int(w[1])
formax=n-m
maxx=int((formax)*(formax+1)/2)
a=n//m
b=n%m
minn=int((b*(a*(a+1)/2))+((m-b)*(a*(a-1)/2)))
print(str(minn)+" "+str(maxx))
``` | instruction | 0 | 2,857 | 17 | 5,714 |
No | output | 1 | 2,857 | 17 | 5,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people.
Submitted Solution:
```
def comb(p): return ((p/2)*(p-1)) if (p%2==0) else (((p-1)/2)*p)
def max_pair(n,m): print(int(comb(n-m+1)),end="");
def min_pair(n,m):
val,mod,sm=n//m,n%m,0
for i in range(m):
if mod:
sm+=comb(val+1)
mod-=1
else: sm+=comb(val)
print(int(sm),end=" ")
n,m=input().split(" ")
n,m=int(n),int(m)
if n==m:
print("0 0")
else:
min_pair(n,m)
max_pair(n,m)
``` | instruction | 0 | 2,858 | 17 | 5,716 |
No | output | 1 | 2,858 | 17 | 5,717 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
n participants of the competition were split into m teams in some manner so that each team has at least one participant. After the competition each pair of participants from the same team became friends.
Your task is to write a program that will find the minimum and the maximum number of pairs of friends that could have formed by the end of the competition.
Input
The only line of input contains two integers n and m, separated by a single space (1 ≤ m ≤ n ≤ 109) — the number of participants and the number of teams respectively.
Output
The only line of the output should contain two integers kmin and kmax — the minimum possible number of pairs of friends and the maximum possible number of pairs of friends respectively.
Examples
Input
5 1
Output
10 10
Input
3 2
Output
1 1
Input
6 3
Output
3 6
Note
In the first sample all the participants get into one team, so there will be exactly ten pairs of friends.
In the second sample at any possible arrangement one team will always have two participants and the other team will always have one participant. Thus, the number of pairs of friends will always be equal to one.
In the third sample minimum number of newly formed friendships can be achieved if participants were split on teams consisting of 2 people, maximum number can be achieved if participants were split on teams of 1, 1 and 4 people.
Submitted Solution:
```
import math
def combine(x,y):
if x==y:
return 1
elif y>x:
return 0
else:
ans = math.factorial(x)/(math.factorial(x-y)*math.factorial(y))
return ans
n,m=map(int,input().split())
#min
group=[]
check=n
later=m
a=n%m
while a!=0:
check-=a
later-=1
group.append(a)
a=check%later
group.append(a)
k=check//later
v=combine(k,2)
ans=0
ans+=(v*later)
for t in group:
v=combine(t,2)
ans+=(v)
print (int(ans),end=' ')
#max
x=n-(m-1)
v=combine(x,2)
print (int(v))
``` | instruction | 0 | 2,859 | 17 | 5,718 |
No | output | 1 | 2,859 | 17 | 5,719 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.