message stringlengths 2 20.2k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 757 108k | cluster float64 4 4 | __index_level_0__ int64 1.51k 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment 0 and turn power off at moment M. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp.
The lamp allows only good programs. Good program can be represented as a non-empty array a, where 0 < a_1 < a_2 < ... < a_{|a|} < M. All a_i must be integers. Of course, preinstalled program is a good program.
The lamp follows program a in next manner: at moment 0 turns power and light on. Then at moment a_i the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment 1 and then do nothing, the total time when the lamp is lit will be 1. Finally, at moment M the lamp is turning its power off regardless of its state.
Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program a, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of a, or even at the begining or at the end of a.
Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from x till moment y, then its lit for y - x units of time. Segments of time when the lamp is lit are summed up.
Input
First line contains two space separated integers n and M (1 ≤ n ≤ 10^5, 2 ≤ M ≤ 10^9) — the length of program a and the moment when power turns off.
Second line contains n space separated integers a_1, a_2, ..., a_n (0 < a_1 < a_2 < ... < a_n < M) — initially installed program a.
Output
Print the only integer — maximum possible total time when the lamp is lit.
Examples
Input
3 10
4 6 7
Output
8
Input
2 12
1 10
Output
9
Input
2 7
3 4
Output
6
Note
In the first example, one of possible optimal solutions is to insert value x = 3 before a_1, so program will be [3, 4, 6, 7] and time of lamp being lit equals (3 - 0) + (6 - 4) + (10 - 7) = 8. Other possible solution is to insert x = 5 in appropriate place.
In the second example, there is only one optimal solution: to insert x = 2 between a_1 and a_2. Program will become [1, 2, 10], and answer will be (1 - 0) + (10 - 2) = 9.
In the third example, optimal answer is to leave program untouched, so answer will be (3 - 0) + (7 - 4) = 6. | instruction | 0 | 42,902 | 4 | 85,804 |
Tags: greedy
Correct Solution:
```
n,m=map(int,input().split())
a=[int(x) for x in input().split()];b=[]
a.insert(0,0)
if n%2==0:
a.insert(n+1,m)
k=sum((-1)**(i+1)*a[i] for i in range(n+2))
else:
k=sum((-1)**(i+1)*a[i] for i in range(n+1))
l=m-k+a[1]-1
b+=[k,l]
for i in range(1,(n+1)//2):
l+=a[2*i-1]+a[2*i+1]-2*a[2*i]
b+=[l]
print(int(max(b)))
``` | output | 1 | 42,902 | 4 | 85,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment 0 and turn power off at moment M. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp.
The lamp allows only good programs. Good program can be represented as a non-empty array a, where 0 < a_1 < a_2 < ... < a_{|a|} < M. All a_i must be integers. Of course, preinstalled program is a good program.
The lamp follows program a in next manner: at moment 0 turns power and light on. Then at moment a_i the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment 1 and then do nothing, the total time when the lamp is lit will be 1. Finally, at moment M the lamp is turning its power off regardless of its state.
Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program a, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of a, or even at the begining or at the end of a.
Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from x till moment y, then its lit for y - x units of time. Segments of time when the lamp is lit are summed up.
Input
First line contains two space separated integers n and M (1 ≤ n ≤ 10^5, 2 ≤ M ≤ 10^9) — the length of program a and the moment when power turns off.
Second line contains n space separated integers a_1, a_2, ..., a_n (0 < a_1 < a_2 < ... < a_n < M) — initially installed program a.
Output
Print the only integer — maximum possible total time when the lamp is lit.
Examples
Input
3 10
4 6 7
Output
8
Input
2 12
1 10
Output
9
Input
2 7
3 4
Output
6
Note
In the first example, one of possible optimal solutions is to insert value x = 3 before a_1, so program will be [3, 4, 6, 7] and time of lamp being lit equals (3 - 0) + (6 - 4) + (10 - 7) = 8. Other possible solution is to insert x = 5 in appropriate place.
In the second example, there is only one optimal solution: to insert x = 2 between a_1 and a_2. Program will become [1, 2, 10], and answer will be (1 - 0) + (10 - 2) = 9.
In the third example, optimal answer is to leave program untouched, so answer will be (3 - 0) + (7 - 4) = 6. | instruction | 0 | 42,903 | 4 | 85,806 |
Tags: greedy
Correct Solution:
```
f=lambda:map(int,input().split())
n,m=f()
a=list(f())
a=[0]+a+[m]
time_int,light,dark=[],0,0
for i in range(len(a)-1):
t=a[i+1]-a[i]
time_int.append(t)
if i % 2==0:
light+=t
else:
dark+=t
left_light=0
for i in range(len(time_int)):
if i % 2 != 0:
dark-=time_int[i]
if left_light+dark+time_int[i]-1 > light:
light=left_light+dark+time_int[i]-1
if i%2==0:
left_light+=time_int[i]
print(light)
``` | output | 1 | 42,903 | 4 | 85,807 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment 0 and turn power off at moment M. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp.
The lamp allows only good programs. Good program can be represented as a non-empty array a, where 0 < a_1 < a_2 < ... < a_{|a|} < M. All a_i must be integers. Of course, preinstalled program is a good program.
The lamp follows program a in next manner: at moment 0 turns power and light on. Then at moment a_i the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment 1 and then do nothing, the total time when the lamp is lit will be 1. Finally, at moment M the lamp is turning its power off regardless of its state.
Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program a, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of a, or even at the begining or at the end of a.
Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from x till moment y, then its lit for y - x units of time. Segments of time when the lamp is lit are summed up.
Input
First line contains two space separated integers n and M (1 ≤ n ≤ 10^5, 2 ≤ M ≤ 10^9) — the length of program a and the moment when power turns off.
Second line contains n space separated integers a_1, a_2, ..., a_n (0 < a_1 < a_2 < ... < a_n < M) — initially installed program a.
Output
Print the only integer — maximum possible total time when the lamp is lit.
Examples
Input
3 10
4 6 7
Output
8
Input
2 12
1 10
Output
9
Input
2 7
3 4
Output
6
Note
In the first example, one of possible optimal solutions is to insert value x = 3 before a_1, so program will be [3, 4, 6, 7] and time of lamp being lit equals (3 - 0) + (6 - 4) + (10 - 7) = 8. Other possible solution is to insert x = 5 in appropriate place.
In the second example, there is only one optimal solution: to insert x = 2 between a_1 and a_2. Program will become [1, 2, 10], and answer will be (1 - 0) + (10 - 2) = 9.
In the third example, optimal answer is to leave program untouched, so answer will be (3 - 0) + (7 - 4) = 6.
Submitted Solution:
```
n, m = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
l.append(m)
l.insert(0, 0)
n = n+2
cum_on = [0]*n
for i in range(n-2, -1, -1):
cum_on[i] = l[i+1]-l[i]
if i != n-2:
cum_on[i] = cum_on[i+2]+cum_on[i]
state = 1
ans = cum_on[0]
temp_ans = 0
for i in range(1, n):
if l[i] - l[i-1] < 2:
if state == 1:
temp_ans += l[i] - l[i-1]
state ^= 1
continue
if state == 1:
ans = max(ans, temp_ans + cum_on[i] + l[i]-l[i-1]-1)
temp_ans += l[i]-l[i-1]
else:
temp = temp_ans + l[i]-l[i-1]-1
if i+1 < n:
temp += cum_on[i+1]
ans = max(ans, temp)
state ^= 1
print(ans)
``` | instruction | 0 | 42,904 | 4 | 85,808 |
Yes | output | 1 | 42,904 | 4 | 85,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment 0 and turn power off at moment M. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp.
The lamp allows only good programs. Good program can be represented as a non-empty array a, where 0 < a_1 < a_2 < ... < a_{|a|} < M. All a_i must be integers. Of course, preinstalled program is a good program.
The lamp follows program a in next manner: at moment 0 turns power and light on. Then at moment a_i the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment 1 and then do nothing, the total time when the lamp is lit will be 1. Finally, at moment M the lamp is turning its power off regardless of its state.
Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program a, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of a, or even at the begining or at the end of a.
Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from x till moment y, then its lit for y - x units of time. Segments of time when the lamp is lit are summed up.
Input
First line contains two space separated integers n and M (1 ≤ n ≤ 10^5, 2 ≤ M ≤ 10^9) — the length of program a and the moment when power turns off.
Second line contains n space separated integers a_1, a_2, ..., a_n (0 < a_1 < a_2 < ... < a_n < M) — initially installed program a.
Output
Print the only integer — maximum possible total time when the lamp is lit.
Examples
Input
3 10
4 6 7
Output
8
Input
2 12
1 10
Output
9
Input
2 7
3 4
Output
6
Note
In the first example, one of possible optimal solutions is to insert value x = 3 before a_1, so program will be [3, 4, 6, 7] and time of lamp being lit equals (3 - 0) + (6 - 4) + (10 - 7) = 8. Other possible solution is to insert x = 5 in appropriate place.
In the second example, there is only one optimal solution: to insert x = 2 between a_1 and a_2. Program will become [1, 2, 10], and answer will be (1 - 0) + (10 - 2) = 9.
In the third example, optimal answer is to leave program untouched, so answer will be (3 - 0) + (7 - 4) = 6.
Submitted Solution:
```
length, endTime = map(int, input().split())
array = [0] + list(map(int, input().split())) + [endTime]
x = [(array[i + 1] - array[i]) * ((-1) ** i) for i in range(len(array) - 1)]
preSum = [x[0]]
for i in range(1, len(x)):
if x[i] > 0:
preSum.append(preSum[-1] + x[i])
else:
preSum.append(preSum[-1])
appSum = [0]
for i in range(len(x) - 1, -1, -1):
if x[i] < 0:
appSum.append(-x[i] + appSum[-1])
else:
appSum.append(appSum[-1])
appSum = list(reversed(appSum))
res = sum([i for i in x if i > 0])
for i in range(len(x) - 1, -1, -1):
if x[i] < -1:
res = max(res, preSum[i - 1] - x[i] - 1 + appSum[i+1])
print(res)
``` | instruction | 0 | 42,905 | 4 | 85,810 |
Yes | output | 1 | 42,905 | 4 | 85,811 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment 0 and turn power off at moment M. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp.
The lamp allows only good programs. Good program can be represented as a non-empty array a, where 0 < a_1 < a_2 < ... < a_{|a|} < M. All a_i must be integers. Of course, preinstalled program is a good program.
The lamp follows program a in next manner: at moment 0 turns power and light on. Then at moment a_i the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment 1 and then do nothing, the total time when the lamp is lit will be 1. Finally, at moment M the lamp is turning its power off regardless of its state.
Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program a, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of a, or even at the begining or at the end of a.
Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from x till moment y, then its lit for y - x units of time. Segments of time when the lamp is lit are summed up.
Input
First line contains two space separated integers n and M (1 ≤ n ≤ 10^5, 2 ≤ M ≤ 10^9) — the length of program a and the moment when power turns off.
Second line contains n space separated integers a_1, a_2, ..., a_n (0 < a_1 < a_2 < ... < a_n < M) — initially installed program a.
Output
Print the only integer — maximum possible total time when the lamp is lit.
Examples
Input
3 10
4 6 7
Output
8
Input
2 12
1 10
Output
9
Input
2 7
3 4
Output
6
Note
In the first example, one of possible optimal solutions is to insert value x = 3 before a_1, so program will be [3, 4, 6, 7] and time of lamp being lit equals (3 - 0) + (6 - 4) + (10 - 7) = 8. Other possible solution is to insert x = 5 in appropriate place.
In the second example, there is only one optimal solution: to insert x = 2 between a_1 and a_2. Program will become [1, 2, 10], and answer will be (1 - 0) + (10 - 2) = 9.
In the third example, optimal answer is to leave program untouched, so answer will be (3 - 0) + (7 - 4) = 6.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Wed Nov 4 19:22:19 2020
@author: Morris
"""
f = 1
n, M = map(int, input().split())
a = [0] + [int(x) for x in input().split()] + [M]
b = [0]*(n+2)
for i in range(1,n+1):
b[i] = b[i-1] + f*(a[i]-a[i-1])
f ^= 1
b[n+1] = b[n] + f*(M-a[n])
ans = b[n+1]
for i in range(1,n+2):
if (a[i]-a[i-1]>1):
if i&1:
ans = max(ans, b[i]+M-a[i]-(b[n+1]-b[i])-1)
else:
ans = max(ans, b[i]+a[i]-a[i-1]-1+M-a[i]-(b[n+1]-b[i]))
print(ans)
``` | instruction | 0 | 42,906 | 4 | 85,812 |
Yes | output | 1 | 42,906 | 4 | 85,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment 0 and turn power off at moment M. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp.
The lamp allows only good programs. Good program can be represented as a non-empty array a, where 0 < a_1 < a_2 < ... < a_{|a|} < M. All a_i must be integers. Of course, preinstalled program is a good program.
The lamp follows program a in next manner: at moment 0 turns power and light on. Then at moment a_i the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment 1 and then do nothing, the total time when the lamp is lit will be 1. Finally, at moment M the lamp is turning its power off regardless of its state.
Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program a, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of a, or even at the begining or at the end of a.
Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from x till moment y, then its lit for y - x units of time. Segments of time when the lamp is lit are summed up.
Input
First line contains two space separated integers n and M (1 ≤ n ≤ 10^5, 2 ≤ M ≤ 10^9) — the length of program a and the moment when power turns off.
Second line contains n space separated integers a_1, a_2, ..., a_n (0 < a_1 < a_2 < ... < a_n < M) — initially installed program a.
Output
Print the only integer — maximum possible total time when the lamp is lit.
Examples
Input
3 10
4 6 7
Output
8
Input
2 12
1 10
Output
9
Input
2 7
3 4
Output
6
Note
In the first example, one of possible optimal solutions is to insert value x = 3 before a_1, so program will be [3, 4, 6, 7] and time of lamp being lit equals (3 - 0) + (6 - 4) + (10 - 7) = 8. Other possible solution is to insert x = 5 in appropriate place.
In the second example, there is only one optimal solution: to insert x = 2 between a_1 and a_2. Program will become [1, 2, 10], and answer will be (1 - 0) + (10 - 2) = 9.
In the third example, optimal answer is to leave program untouched, so answer will be (3 - 0) + (7 - 4) = 6.
Submitted Solution:
```
_, M = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
if a[0] != 0:
a.insert(0, 0)
if a[-1] != M:
a.append(M)
light = []
dark = []
for i in range(len(a) // 2):
light.append(a[2*i+1] - a[2*i])
if 2*i+2 < len(a):
dark.append(a[2*i+2] - a[2*i+1])
total_light = sum(light)
total_dark = sum(dark)
pre_sum = 0
post_sum = total_light
for i in range(len(light)):
v = light[i]
light[i] = (pre_sum, v, post_sum - light[i])
pre_sum += v
post_sum -= v
pre_sum = 0
post_sum = total_dark
for i in range(len(dark)):
v = dark[i]
dark[i] = (pre_sum, v, post_sum - dark[i])
pre_sum += v
post_sum -= v
max = max(total_light, total_dark)
for i in range(len(light)):
pre, v, post = light[i]
if i < len(dark):
sum = pre + v - 1 + dark[i][2]
if sum > max:
max = sum
for i in range(len(dark)):
pre, v, _ = light[i]
pre = pre + v
_, v, post = dark[i]
sum = pre + v - 1 + post
if sum > max:
max = sum
print(max)
# 0 2 4 6 8 10 12 14 16 18 21 22 24 26 28
# 13 = (0, 2, 11) (2, 2, 9) (2, 7) (2, 5) (2, 3) (1, 2) (2, 0) -> 16 = 2 2 2 2 2 2 2 2
# 15 = (0, 2, 13) (2, 2, 11) (2, 9) (2, 7) (3, 4) (2, 2) (2, 0) 12 = 2 2 2 2 2 1 1
# 17
# if sum(light) > sum(dark):
# print(sum(light))
#
#
# print(str(int(total / 2)))
``` | instruction | 0 | 42,907 | 4 | 85,814 |
Yes | output | 1 | 42,907 | 4 | 85,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment 0 and turn power off at moment M. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp.
The lamp allows only good programs. Good program can be represented as a non-empty array a, where 0 < a_1 < a_2 < ... < a_{|a|} < M. All a_i must be integers. Of course, preinstalled program is a good program.
The lamp follows program a in next manner: at moment 0 turns power and light on. Then at moment a_i the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment 1 and then do nothing, the total time when the lamp is lit will be 1. Finally, at moment M the lamp is turning its power off regardless of its state.
Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program a, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of a, or even at the begining or at the end of a.
Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from x till moment y, then its lit for y - x units of time. Segments of time when the lamp is lit are summed up.
Input
First line contains two space separated integers n and M (1 ≤ n ≤ 10^5, 2 ≤ M ≤ 10^9) — the length of program a and the moment when power turns off.
Second line contains n space separated integers a_1, a_2, ..., a_n (0 < a_1 < a_2 < ... < a_n < M) — initially installed program a.
Output
Print the only integer — maximum possible total time when the lamp is lit.
Examples
Input
3 10
4 6 7
Output
8
Input
2 12
1 10
Output
9
Input
2 7
3 4
Output
6
Note
In the first example, one of possible optimal solutions is to insert value x = 3 before a_1, so program will be [3, 4, 6, 7] and time of lamp being lit equals (3 - 0) + (6 - 4) + (10 - 7) = 8. Other possible solution is to insert x = 5 in appropriate place.
In the second example, there is only one optimal solution: to insert x = 2 between a_1 and a_2. Program will become [1, 2, 10], and answer will be (1 - 0) + (10 - 2) = 9.
In the third example, optimal answer is to leave program untouched, so answer will be (3 - 0) + (7 - 4) = 6.
Submitted Solution:
```
n,M=map(int,input().split())
s=[0]+list(map(int,input().split()))+[M]
alist=[s[i]-s[i-1] for i in range(1,n+2)]
litall=alist[::2]
unlitall=alist[1::2]
ans=sum(litall)
lit = 0
unlit = sum(unlitall)
for i in range(1,n,2):
m=i//2
lit+=litall[m]
unlit-=unlitall[m]
t=max(alist[i],alist[i+1])
r=lit+unlit+t-1
if r>ans:
ans=r
print(ans)
``` | instruction | 0 | 42,908 | 4 | 85,816 |
No | output | 1 | 42,908 | 4 | 85,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment 0 and turn power off at moment M. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp.
The lamp allows only good programs. Good program can be represented as a non-empty array a, where 0 < a_1 < a_2 < ... < a_{|a|} < M. All a_i must be integers. Of course, preinstalled program is a good program.
The lamp follows program a in next manner: at moment 0 turns power and light on. Then at moment a_i the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment 1 and then do nothing, the total time when the lamp is lit will be 1. Finally, at moment M the lamp is turning its power off regardless of its state.
Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program a, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of a, or even at the begining or at the end of a.
Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from x till moment y, then its lit for y - x units of time. Segments of time when the lamp is lit are summed up.
Input
First line contains two space separated integers n and M (1 ≤ n ≤ 10^5, 2 ≤ M ≤ 10^9) — the length of program a and the moment when power turns off.
Second line contains n space separated integers a_1, a_2, ..., a_n (0 < a_1 < a_2 < ... < a_n < M) — initially installed program a.
Output
Print the only integer — maximum possible total time when the lamp is lit.
Examples
Input
3 10
4 6 7
Output
8
Input
2 12
1 10
Output
9
Input
2 7
3 4
Output
6
Note
In the first example, one of possible optimal solutions is to insert value x = 3 before a_1, so program will be [3, 4, 6, 7] and time of lamp being lit equals (3 - 0) + (6 - 4) + (10 - 7) = 8. Other possible solution is to insert x = 5 in appropriate place.
In the second example, there is only one optimal solution: to insert x = 2 between a_1 and a_2. Program will become [1, 2, 10], and answer will be (1 - 0) + (10 - 2) = 9.
In the third example, optimal answer is to leave program untouched, so answer will be (3 - 0) + (7 - 4) = 6.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sat Nov 7 19:55:28 2020
@author: 86177
"""
"""
n,m=[int(x) for x in input().split()]
w=[]
for i in range(n):
c=[int(x) for x in input().split()]
for x in c[1:]:
w.append(x)
a=len(set(w))
if a == m:
print("YES")
else:
print('NO')
"""
"""
M>=2
"""
n,m=[int(s) for s in input().split()]
w=[0,m]
c=[int(i) for i in input().split()]
l=len(c)
for i in c:
w.append(i)
w.sort()#对所有的已知节点排序
o=[]#奇数段逐次求和
e=[]#偶数段逐次求和
s=0#奇数段起始
ss=0#偶数段起始
al=[]#奇数段，偶数段，奇数段....
for i in range(l+1):#计算出总节点数
if i%2==0:
s=abs(w[i]-w[i+1])#求奇数段
o.append(s)#并入奇数段列表
al.append(s)#并入总列表
if i%2!=0:
ss=abs(w[i]-w[i+1])#求偶数段
e.append(ss)#并入偶数段列表
al.append(ss)#并入列表
print(al)
print(o)
print(e)
d=0
f=0
el=[]
ol=[0]
if l%2==0:
for i in range(l-1):
d+=e[-1+i]#偶数段列表逐个求和（倒序）
el.append(d)
f+=o[i]#奇数段列表逐个求和（正序）
ol.append(f)
else:
for i in range(l-1):
d+=e[-1+i]
el.append(d)
for i in range(l-1):
f+=o[i]
ol.append(f)
el.reverse()
print(el)
print(ol)
ll=len(al)#总列表长度
sss=0#求各种插入情况和
r=[]#各种插入情况亮灯时间列表
if ll <=3:
for i in range(ll):
if i==0 or i%2==0:
sss=al[i]-1++ol[i//2]++el[i//2]
r.append(sss)
else:
sss=al[i] ++el[(i+1)//2] ++ol[(i+1)//2] -1
r.append(sss)
else:
for i in range(ll-2):
if i==0 or i%2==0:
sss=al[i]-1++ol[i//2]++el[i//2]
r.append(sss)
else:
sss=al[i] ++el[(i+1)//2] ++ol[(i+1)//2] -1
r.append(sss)
print(r)
"""
print(max(r))
"""
``` | instruction | 0 | 42,909 | 4 | 85,818 |
No | output | 1 | 42,909 | 4 | 85,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment 0 and turn power off at moment M. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp.
The lamp allows only good programs. Good program can be represented as a non-empty array a, where 0 < a_1 < a_2 < ... < a_{|a|} < M. All a_i must be integers. Of course, preinstalled program is a good program.
The lamp follows program a in next manner: at moment 0 turns power and light on. Then at moment a_i the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment 1 and then do nothing, the total time when the lamp is lit will be 1. Finally, at moment M the lamp is turning its power off regardless of its state.
Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program a, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of a, or even at the begining or at the end of a.
Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from x till moment y, then its lit for y - x units of time. Segments of time when the lamp is lit are summed up.
Input
First line contains two space separated integers n and M (1 ≤ n ≤ 10^5, 2 ≤ M ≤ 10^9) — the length of program a and the moment when power turns off.
Second line contains n space separated integers a_1, a_2, ..., a_n (0 < a_1 < a_2 < ... < a_n < M) — initially installed program a.
Output
Print the only integer — maximum possible total time when the lamp is lit.
Examples
Input
3 10
4 6 7
Output
8
Input
2 12
1 10
Output
9
Input
2 7
3 4
Output
6
Note
In the first example, one of possible optimal solutions is to insert value x = 3 before a_1, so program will be [3, 4, 6, 7] and time of lamp being lit equals (3 - 0) + (6 - 4) + (10 - 7) = 8. Other possible solution is to insert x = 5 in appropriate place.
In the second example, there is only one optimal solution: to insert x = 2 between a_1 and a_2. Program will become [1, 2, 10], and answer will be (1 - 0) + (10 - 2) = 9.
In the third example, optimal answer is to leave program untouched, so answer will be (3 - 0) + (7 - 4) = 6.
Submitted Solution:
```
n,m=[int(x) for x in input().split()]
a=[0]
a.extend([int(x) for x in input().split()])
a.append(m)
b=a.copy()
def f(x):
i=0
k=0
while k+1<=len(x)-1:
i+=x[k+1]-x[k]
k+=2
return(i)
y=f(a)
c=0
for z in range(n-1):
if a[z+1]-a[z]<a[z+3]-a[z+2]:
c=z
if c!=0:
a.insert(c+3,a[c+2]+1)
print(y)
``` | instruction | 0 | 42,910 | 4 | 85,820 |
No | output | 1 | 42,910 | 4 | 85,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently, you bought a brand new smart lamp with programming features. At first, you set up a schedule to the lamp. Every day it will turn power on at moment 0 and turn power off at moment M. Moreover, the lamp allows you to set a program of switching its state (states are "lights on" and "lights off"). Unfortunately, some program is already installed into the lamp.
The lamp allows only good programs. Good program can be represented as a non-empty array a, where 0 < a_1 < a_2 < ... < a_{|a|} < M. All a_i must be integers. Of course, preinstalled program is a good program.
The lamp follows program a in next manner: at moment 0 turns power and light on. Then at moment a_i the lamp flips its state to opposite (if it was lit, it turns off, and vice versa). The state of the lamp flips instantly: for example, if you turn the light off at moment 1 and then do nothing, the total time when the lamp is lit will be 1. Finally, at moment M the lamp is turning its power off regardless of its state.
Since you are not among those people who read instructions, and you don't understand the language it's written in, you realize (after some testing) the only possible way to alter the preinstalled program. You can insert at most one element into the program a, so it still should be a good program after alteration. Insertion can be done between any pair of consecutive elements of a, or even at the begining or at the end of a.
Find such a way to alter the program that the total time when the lamp is lit is maximum possible. Maybe you should leave program untouched. If the lamp is lit from x till moment y, then its lit for y - x units of time. Segments of time when the lamp is lit are summed up.
Input
First line contains two space separated integers n and M (1 ≤ n ≤ 10^5, 2 ≤ M ≤ 10^9) — the length of program a and the moment when power turns off.
Second line contains n space separated integers a_1, a_2, ..., a_n (0 < a_1 < a_2 < ... < a_n < M) — initially installed program a.
Output
Print the only integer — maximum possible total time when the lamp is lit.
Examples
Input
3 10
4 6 7
Output
8
Input
2 12
1 10
Output
9
Input
2 7
3 4
Output
6
Note
In the first example, one of possible optimal solutions is to insert value x = 3 before a_1, so program will be [3, 4, 6, 7] and time of lamp being lit equals (3 - 0) + (6 - 4) + (10 - 7) = 8. Other possible solution is to insert x = 5 in appropriate place.
In the second example, there is only one optimal solution: to insert x = 2 between a_1 and a_2. Program will become [1, 2, 10], and answer will be (1 - 0) + (10 - 2) = 9.
In the third example, optimal answer is to leave program untouched, so answer will be (3 - 0) + (7 - 4) = 6.
Submitted Solution:
```
n,m=[int(x) for x in input().split()]
a=list(map(int,input().split()))
a.append(m)
b=[]
l=[]
for i in a:
b.append(i)
l.append(i)
pre=c=0
sm=0
for i in a:
if c%2==0:
sm+=i-pre
c+=1
pre=i
c=pre=maxa=0
for i in a:
if c%2:
dif=i-pre
if dif>=maxa:
maxa=dif
idx=pre+1
c+=1
pre=i
a.append(idx)
a.sort()
sm1=0
pre=c=0
for i in a:
if c%2==0:
sm1+=i-pre
c+=1
pre=i
c=pre=maxa=0
for i in b:
if c%2==0:
dif=i-pre
if dif>=maxa:
maxa=dif
idx=i-1
c+=1
pre=i
b.append(idx)
b.sort()
pre=c=sm2=0
for i in b:
if c%2==0:
sm2+=i-pre
c+=1
pre=i
l.append(m-1)
pre=c=sm3=0
for i in l:
if c%2==0:
sm3+=i-pre
c+=1
pre=i
print(max(sm,sm1,sm2,sm3))
``` | instruction | 0 | 42,911 | 4 | 85,822 |
No | output | 1 | 42,911 | 4 | 85,823 |
Provide a correct Python 3 solution for this coding contest problem.
problem
A mysterious $ X $ [cm] plant grows in one place. This plant has the following mysterious properties.
* Say "nobiro" to this plant and it will grow $ A $ [cm].
* Say "tidime" to this plant and it will grow $ B $ [cm].
* If you say "karero" to this plant, it will be $ 0 $ [cm].
However, this plant does not have a negative length. Specifically, when it grows from the state of $ C $ [cm] to $ D $ [cm] $ (C + D \ lt 0) $, it is a plant. Stops growing when it reaches $ 0 $ [cm].
Say one of "nobiro", "tidime", "karero" to this plant only once a day for $ N $ days. Find the length [cm] of the plant after $ N $ days.
output
Print the length of the plant after $ N $ days. Also print a newline at the end.
Example
Input
10 30 10
3
nobiro
nobiro
tidime
Output
80 | instruction | 0 | 43,775 | 4 | 87,550 |
"Correct Solution:
```
#!/usr/bin/env python3
x, a, b = map(int, input().split())
n = int(input())
for _ in range(n):
s = input()
if s == 'nobiro':
x = max(0, x + a)
elif s == 'tidime':
x = max(0, x + b)
else:
x = 0
print(x)
``` | output | 1 | 43,775 | 4 | 87,551 |
Provide a correct Python 3 solution for this coding contest problem.
problem
A mysterious $ X $ [cm] plant grows in one place. This plant has the following mysterious properties.
* Say "nobiro" to this plant and it will grow $ A $ [cm].
* Say "tidime" to this plant and it will grow $ B $ [cm].
* If you say "karero" to this plant, it will be $ 0 $ [cm].
However, this plant does not have a negative length. Specifically, when it grows from the state of $ C $ [cm] to $ D $ [cm] $ (C + D \ lt 0) $, it is a plant. Stops growing when it reaches $ 0 $ [cm].
Say one of "nobiro", "tidime", "karero" to this plant only once a day for $ N $ days. Find the length [cm] of the plant after $ N $ days.
output
Print the length of the plant after $ N $ days. Also print a newline at the end.
Example
Input
10 30 10
3
nobiro
nobiro
tidime
Output
80 | instruction | 0 | 43,778 | 4 | 87,556 |
"Correct Solution:
```
x, a, b = (int(y) for y in input().split())
n = int(input())
for i in range(n):
s = input()
if s[0] == "n" :
x = max(0,x + a)
elif s[0] == "t" :
x = max(0,x + b)
else:
x = 0
print(x)
``` | output | 1 | 43,778 | 4 | 87,557 |
Provide a correct Python 3 solution for this coding contest problem.
The goddess of programming is reviewing a thick logbook, which is a yearly record of visitors to her holy altar of programming. The logbook also records her visits at the altar.
The altar attracts programmers from all over the world because one visitor is chosen every year and endowed with a gift of miracle programming power by the goddess. The endowed programmer is chosen from those programmers who spent the longest time at the altar during the goddess's presence. There have been enthusiastic visitors who spent very long time at the altar but failed to receive the gift because the goddess was absent during their visits.
Now, your mission is to write a program that finds how long the programmer to be endowed stayed at the altar during the goddess's presence.
Input
The input is a sequence of datasets. The number of datasets is less than 100. Each dataset is formatted as follows.
n
M1/D1 h1:m1e1 p1
M2/D2 h2:m2e2 p2
.
.
.
Mn/Dn hn:mnen pn
The first line of a dataset contains a positive even integer, n ≤ 1000, which denotes the number of lines of the logbook. This line is followed by n lines of space-separated data, where Mi/Di identifies the month and the day of the visit, hi:mi represents the time of either the entrance to or exit from the altar, ei is either I for entrance, or O for exit, and pi identifies the visitor.
All the lines in the logbook are formatted in a fixed-column format. Both the month and the day in the month are represented by two digits. Therefore April 1 is represented by 04/01 and not by 4/1. The time is described in the 24-hour system, taking two digits for the hour, followed by a colon and two digits for minutes, 09:13 for instance and not like 9:13. A programmer is identified by an ID, a unique number using three digits. The same format is used to indicate entrance and exit of the goddess, whose ID is 000.
All the lines in the logbook are sorted in ascending order with respect to date and time. Because the altar is closed at midnight, the altar is emptied at 00:00. You may assume that each time in the input is between 00:01 and 23:59, inclusive.
A programmer may leave the altar just after entering it. In this case, the entrance and exit time are the same and the length of such a visit is considered 0 minute. You may assume for such entrance and exit records, the line that corresponds to the entrance appears earlier in the input than the line that corresponds to the exit. You may assume that at least one programmer appears in the logbook.
The end of the input is indicated by a line containing a single zero.
Output
For each dataset, output the total sum of the blessed time of the endowed programmer. The blessed time of a programmer is the length of his/her stay at the altar during the presence of the goddess. The endowed programmer is the one whose total blessed time is the longest among all the programmers. The output should be represented in minutes. Note that the goddess of programming is not a programmer.
Example
Input
14
04/21 09:00 I 000
04/21 09:00 I 001
04/21 09:15 I 002
04/21 09:30 O 001
04/21 09:45 O 000
04/21 10:00 O 002
04/28 09:00 I 003
04/28 09:15 I 000
04/28 09:30 I 004
04/28 09:45 O 004
04/28 10:00 O 000
04/28 10:15 O 003
04/29 20:00 I 002
04/29 21:30 O 002
20
06/01 09:00 I 001
06/01 09:15 I 002
06/01 09:15 I 003
06/01 09:30 O 002
06/01 10:00 I 000
06/01 10:15 O 001
06/01 10:30 I 002
06/01 10:45 O 002
06/01 11:00 I 001
06/01 11:15 O 000
06/01 11:30 I 002
06/01 11:45 O 001
06/01 12:00 O 002
06/01 12:15 I 000
06/01 12:30 I 002
06/01 12:45 O 000
06/01 13:00 I 000
06/01 13:15 O 000
06/01 13:30 O 002
06/01 13:45 O 003
0
Output
45
120 | instruction | 0 | 44,608 | 4 | 89,216 |
"Correct Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
while True:
n = I()
if n == 0:
break
a = [LS() for _ in range(n)]
d = {}
e = collections.defaultdict(int)
b = []
for day,ts,f,i in a:
i = int(i)
ta = ts.split(':')
t = int(ta[0]) * 60 + int(ta[1])
if i == 0:
if f == 'I':
for k in list(d.keys()):
e[k] -= t - d[k]
d[i] = t
else:
del d[i]
for k in list(d.keys()):
e[k] += t - d[k]
else:
if f == 'I':
d[i] = t
else:
if 0 in d:
e[i] += t - d[i]
del d[i]
if len(e) == 0:
rr.append(0)
else:
rr.append(max(e.values()))
return '\n'.join(map(str,rr))
print(main())
``` | output | 1 | 44,608 | 4 | 89,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Eugeny loves listening to music. He has n songs in his play list. We know that song number i has the duration of ti minutes. Eugeny listens to each song, perhaps more than once. He listens to song number i ci times. Eugeny's play list is organized as follows: first song number 1 plays c1 times, then song number 2 plays c2 times, ..., in the end the song number n plays cn times.
Eugeny took a piece of paper and wrote out m moments of time when he liked a song. Now for each such moment he wants to know the number of the song that played at that moment. The moment x means that Eugeny wants to know which song was playing during the x-th minute of his listening to the play list.
Help Eugeny and calculate the required numbers of songs.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 105). The next n lines contain pairs of integers. The i-th line contains integers ci, ti (1 ≤ ci, ti ≤ 109) — the description of the play list. It is guaranteed that the play list's total duration doesn't exceed 109 <image>.
The next line contains m positive integers v1, v2, ..., vm, that describe the moments Eugeny has written out. It is guaranteed that there isn't such moment of time vi, when the music doesn't play any longer. It is guaranteed that vi < vi + 1 (i < m).
The moment of time vi means that Eugeny wants to know which song was playing during the vi-th munite from the start of listening to the playlist.
Output
Print m integers — the i-th number must equal the number of the song that was playing during the vi-th minute after Eugeny started listening to the play list.
Examples
Input
1 2
2 8
1 16
Output
1
1
Input
4 9
1 2
2 1
1 1
2 2
1 2 3 4 5 6 7 8 9
Output
1
1
2
2
3
4
4
4
4
Submitted Solution:
```
import bisect
n, m = map(int, input().split())
T = [0] * n
for i in range(n):
t, c = map(int, input().split())
T[i] = t * c
m = list(map(int, input().split()))
for i in range(1, n):
T[i] += T[i - 1]
for i in range(len(m)):
i = bisect.bisect_left(T, m[i], 0, n)
print(i + 1)
``` | instruction | 0 | 44,887 | 4 | 89,774 |
Yes | output | 1 | 44,887 | 4 | 89,775 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Eugeny loves listening to music. He has n songs in his play list. We know that song number i has the duration of ti minutes. Eugeny listens to each song, perhaps more than once. He listens to song number i ci times. Eugeny's play list is organized as follows: first song number 1 plays c1 times, then song number 2 plays c2 times, ..., in the end the song number n plays cn times.
Eugeny took a piece of paper and wrote out m moments of time when he liked a song. Now for each such moment he wants to know the number of the song that played at that moment. The moment x means that Eugeny wants to know which song was playing during the x-th minute of his listening to the play list.
Help Eugeny and calculate the required numbers of songs.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 105). The next n lines contain pairs of integers. The i-th line contains integers ci, ti (1 ≤ ci, ti ≤ 109) — the description of the play list. It is guaranteed that the play list's total duration doesn't exceed 109 <image>.
The next line contains m positive integers v1, v2, ..., vm, that describe the moments Eugeny has written out. It is guaranteed that there isn't such moment of time vi, when the music doesn't play any longer. It is guaranteed that vi < vi + 1 (i < m).
The moment of time vi means that Eugeny wants to know which song was playing during the vi-th munite from the start of listening to the playlist.
Output
Print m integers — the i-th number must equal the number of the song that was playing during the vi-th minute after Eugeny started listening to the play list.
Examples
Input
1 2
2 8
1 16
Output
1
1
Input
4 9
1 2
2 1
1 1
2 2
1 2 3 4 5 6 7 8 9
Output
1
1
2
2
3
4
4
4
4
Submitted Solution:
```
import math
import itertools
import collections
def getdict(n):
d = {}
if type(n) is list:
for i in n:
if i in d:
d[i] += 1
else:
d[i] = 1
else:
for i in range(n):
t = ii()
if t in d:
d[t] += 1
else:
d[t] = 1
return d
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a*b) // math.gcd(a, b)
def wr(arr): return ' '.join(map(str, arr))
def prime(n):
if n == 2:
return True
if n % 2 == 0 or n <= 1:
return False
sqr = int(math.sqrt(n)) + 1
for d in range(3, sqr, 2):
if n % d == 0:
return False
return True
def revn(n):
m = 0
while n > 0:
m = m * 10 + n % 10
n = n // 10
return m
n, m = mi()
c, t = mi()
pl = [0]*n
pl[0] = c * t
for i in range(1, n):
c, t = mi()
pl[i] += pl[i - 1] + c * t
v = li()
j = 0
for i in range(m):
while v[i] > pl[j]:
j += 1
print(j + 1)
``` | instruction | 0 | 44,888 | 4 | 89,776 |
Yes | output | 1 | 44,888 | 4 | 89,777 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Eugeny loves listening to music. He has n songs in his play list. We know that song number i has the duration of ti minutes. Eugeny listens to each song, perhaps more than once. He listens to song number i ci times. Eugeny's play list is organized as follows: first song number 1 plays c1 times, then song number 2 plays c2 times, ..., in the end the song number n plays cn times.
Eugeny took a piece of paper and wrote out m moments of time when he liked a song. Now for each such moment he wants to know the number of the song that played at that moment. The moment x means that Eugeny wants to know which song was playing during the x-th minute of his listening to the play list.
Help Eugeny and calculate the required numbers of songs.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 105). The next n lines contain pairs of integers. The i-th line contains integers ci, ti (1 ≤ ci, ti ≤ 109) — the description of the play list. It is guaranteed that the play list's total duration doesn't exceed 109 <image>.
The next line contains m positive integers v1, v2, ..., vm, that describe the moments Eugeny has written out. It is guaranteed that there isn't such moment of time vi, when the music doesn't play any longer. It is guaranteed that vi < vi + 1 (i < m).
The moment of time vi means that Eugeny wants to know which song was playing during the vi-th munite from the start of listening to the playlist.
Output
Print m integers — the i-th number must equal the number of the song that was playing during the vi-th minute after Eugeny started listening to the play list.
Examples
Input
1 2
2 8
1 16
Output
1
1
Input
4 9
1 2
2 1
1 1
2 2
1 2 3 4 5 6 7 8 9
Output
1
1
2
2
3
4
4
4
4
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase
from fractions import *
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def value():
return tuple(map(int,input().split()))
def array():
return [int(i) for i in input().split()]
def Int():
return int(input())
def Str():
return input()
def arrayS():
return [i for i in input().split()]
#-------------------------code---------------------------#
#vsInput()
n,m=value()
time=[0]
for i in range(n):
c,t=value()
time.append(c*t+time[-1])
a=array()
for i in a:
ind=bisect_left(time,i)
print(ind)
``` | instruction | 0 | 44,889 | 4 | 89,778 |
Yes | output | 1 | 44,889 | 4 | 89,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Eugeny loves listening to music. He has n songs in his play list. We know that song number i has the duration of ti minutes. Eugeny listens to each song, perhaps more than once. He listens to song number i ci times. Eugeny's play list is organized as follows: first song number 1 plays c1 times, then song number 2 plays c2 times, ..., in the end the song number n plays cn times.
Eugeny took a piece of paper and wrote out m moments of time when he liked a song. Now for each such moment he wants to know the number of the song that played at that moment. The moment x means that Eugeny wants to know which song was playing during the x-th minute of his listening to the play list.
Help Eugeny and calculate the required numbers of songs.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 105). The next n lines contain pairs of integers. The i-th line contains integers ci, ti (1 ≤ ci, ti ≤ 109) — the description of the play list. It is guaranteed that the play list's total duration doesn't exceed 109 <image>.
The next line contains m positive integers v1, v2, ..., vm, that describe the moments Eugeny has written out. It is guaranteed that there isn't such moment of time vi, when the music doesn't play any longer. It is guaranteed that vi < vi + 1 (i < m).
The moment of time vi means that Eugeny wants to know which song was playing during the vi-th munite from the start of listening to the playlist.
Output
Print m integers — the i-th number must equal the number of the song that was playing during the vi-th minute after Eugeny started listening to the play list.
Examples
Input
1 2
2 8
1 16
Output
1
1
Input
4 9
1 2
2 1
1 1
2 2
1 2 3 4 5 6 7 8 9
Output
1
1
2
2
3
4
4
4
4
Submitted Solution:
```
# Getting input
song = list()
n,m=map(int,input().split())
song.append(0)
for i in range(n):
note, times = map(int,input().split())
total_time = song[i] +note*times
song.append(total_time)
eugeny_moments = list(map(int, input().split()))
# computing result
counter = 0
for i in range(m):
while(True):
check = eugeny_moments[i] - song[counter]
if check > 0:
counter += 1
else:
break
print(counter)
``` | instruction | 0 | 44,890 | 4 | 89,780 |
Yes | output | 1 | 44,890 | 4 | 89,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Eugeny loves listening to music. He has n songs in his play list. We know that song number i has the duration of ti minutes. Eugeny listens to each song, perhaps more than once. He listens to song number i ci times. Eugeny's play list is organized as follows: first song number 1 plays c1 times, then song number 2 plays c2 times, ..., in the end the song number n plays cn times.
Eugeny took a piece of paper and wrote out m moments of time when he liked a song. Now for each such moment he wants to know the number of the song that played at that moment. The moment x means that Eugeny wants to know which song was playing during the x-th minute of his listening to the play list.
Help Eugeny and calculate the required numbers of songs.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 105). The next n lines contain pairs of integers. The i-th line contains integers ci, ti (1 ≤ ci, ti ≤ 109) — the description of the play list. It is guaranteed that the play list's total duration doesn't exceed 109 <image>.
The next line contains m positive integers v1, v2, ..., vm, that describe the moments Eugeny has written out. It is guaranteed that there isn't such moment of time vi, when the music doesn't play any longer. It is guaranteed that vi < vi + 1 (i < m).
The moment of time vi means that Eugeny wants to know which song was playing during the vi-th munite from the start of listening to the playlist.
Output
Print m integers — the i-th number must equal the number of the song that was playing during the vi-th minute after Eugeny started listening to the play list.
Examples
Input
1 2
2 8
1 16
Output
1
1
Input
4 9
1 2
2 1
1 1
2 2
1 2 3 4 5 6 7 8 9
Output
1
1
2
2
3
4
4
4
4
Submitted Solution:
```
#CF302B
r = input().split(' ')
n = int( r[ 0 ] )
m = int( r[ 1 ] )
s = []
print( n , m )
for i in range( 0 , n ):
r = input().split(' ')
s.append( int( r[ 0 ] ) * int( r[ 1 ] ) )
if i > 0:
s[ i ] += s[ i - 1 ]
r = input().split(' ')
ct = 0
for i in range( 0 , m ):
v = int( r[ i ] )
while s[ ct ] < v :
ct += 1
print( ct + 1 )
``` | instruction | 0 | 44,891 | 4 | 89,782 |
No | output | 1 | 44,891 | 4 | 89,783 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Eugeny loves listening to music. He has n songs in his play list. We know that song number i has the duration of ti minutes. Eugeny listens to each song, perhaps more than once. He listens to song number i ci times. Eugeny's play list is organized as follows: first song number 1 plays c1 times, then song number 2 plays c2 times, ..., in the end the song number n plays cn times.
Eugeny took a piece of paper and wrote out m moments of time when he liked a song. Now for each such moment he wants to know the number of the song that played at that moment. The moment x means that Eugeny wants to know which song was playing during the x-th minute of his listening to the play list.
Help Eugeny and calculate the required numbers of songs.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 105). The next n lines contain pairs of integers. The i-th line contains integers ci, ti (1 ≤ ci, ti ≤ 109) — the description of the play list. It is guaranteed that the play list's total duration doesn't exceed 109 <image>.
The next line contains m positive integers v1, v2, ..., vm, that describe the moments Eugeny has written out. It is guaranteed that there isn't such moment of time vi, when the music doesn't play any longer. It is guaranteed that vi < vi + 1 (i < m).
The moment of time vi means that Eugeny wants to know which song was playing during the vi-th munite from the start of listening to the playlist.
Output
Print m integers — the i-th number must equal the number of the song that was playing during the vi-th minute after Eugeny started listening to the play list.
Examples
Input
1 2
2 8
1 16
Output
1
1
Input
4 9
1 2
2 1
1 1
2 2
1 2 3 4 5 6 7 8 9
Output
1
1
2
2
3
4
4
4
4
Submitted Solution:
```
# Getting input
song = list()
n,m=map(int,input().split())
song.append(0)
for i in range(n):
note, times = map(int,input().split())
total_time = note*times
song.append(total_time)
print(song)
eugeny_moments = list(map(int, input().split()))
# computing result
counter = 0
for i in range(m):
while(True):
check = eugeny_moments[i] - song[counter]
if check > 0:
counter += 1
else:
break
print(counter)
``` | instruction | 0 | 44,892 | 4 | 89,784 |
No | output | 1 | 44,892 | 4 | 89,785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Eugeny loves listening to music. He has n songs in his play list. We know that song number i has the duration of ti minutes. Eugeny listens to each song, perhaps more than once. He listens to song number i ci times. Eugeny's play list is organized as follows: first song number 1 plays c1 times, then song number 2 plays c2 times, ..., in the end the song number n plays cn times.
Eugeny took a piece of paper and wrote out m moments of time when he liked a song. Now for each such moment he wants to know the number of the song that played at that moment. The moment x means that Eugeny wants to know which song was playing during the x-th minute of his listening to the play list.
Help Eugeny and calculate the required numbers of songs.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 105). The next n lines contain pairs of integers. The i-th line contains integers ci, ti (1 ≤ ci, ti ≤ 109) — the description of the play list. It is guaranteed that the play list's total duration doesn't exceed 109 <image>.
The next line contains m positive integers v1, v2, ..., vm, that describe the moments Eugeny has written out. It is guaranteed that there isn't such moment of time vi, when the music doesn't play any longer. It is guaranteed that vi < vi + 1 (i < m).
The moment of time vi means that Eugeny wants to know which song was playing during the vi-th munite from the start of listening to the playlist.
Output
Print m integers — the i-th number must equal the number of the song that was playing during the vi-th minute after Eugeny started listening to the play list.
Examples
Input
1 2
2 8
1 16
Output
1
1
Input
4 9
1 2
2 1
1 1
2 2
1 2 3 4 5 6 7 8 9
Output
1
1
2
2
3
4
4
4
4
Submitted Solution:
```
n,m=map(int,input().split())
l=[]
x=0
for i in range(n):
c,t=map(int,input().split())
x+=c*t
l.append(x)
l1=list(map(int,input().split()))
ans=[]
for i in range(m):
beg=0
end=n-1
while beg<=end:
mid=(end+beg)//2
j=mid-1
if l1[i]<=l[mid] and l1[i]>l[j]:
ans.append(mid+1)
break
elif mid==0:
ans.append(mid+1)
break
elif l1[i]<l[mid]:
end=mid-1
else:
beg=mid+1
for i in range(m):
print(ans[i])
``` | instruction | 0 | 44,893 | 4 | 89,786 |
No | output | 1 | 44,893 | 4 | 89,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Eugeny loves listening to music. He has n songs in his play list. We know that song number i has the duration of ti minutes. Eugeny listens to each song, perhaps more than once. He listens to song number i ci times. Eugeny's play list is organized as follows: first song number 1 plays c1 times, then song number 2 plays c2 times, ..., in the end the song number n plays cn times.
Eugeny took a piece of paper and wrote out m moments of time when he liked a song. Now for each such moment he wants to know the number of the song that played at that moment. The moment x means that Eugeny wants to know which song was playing during the x-th minute of his listening to the play list.
Help Eugeny and calculate the required numbers of songs.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 105). The next n lines contain pairs of integers. The i-th line contains integers ci, ti (1 ≤ ci, ti ≤ 109) — the description of the play list. It is guaranteed that the play list's total duration doesn't exceed 109 <image>.
The next line contains m positive integers v1, v2, ..., vm, that describe the moments Eugeny has written out. It is guaranteed that there isn't such moment of time vi, when the music doesn't play any longer. It is guaranteed that vi < vi + 1 (i < m).
The moment of time vi means that Eugeny wants to know which song was playing during the vi-th munite from the start of listening to the playlist.
Output
Print m integers — the i-th number must equal the number of the song that was playing during the vi-th minute after Eugeny started listening to the play list.
Examples
Input
1 2
2 8
1 16
Output
1
1
Input
4 9
1 2
2 1
1 1
2 2
1 2 3 4 5 6 7 8 9
Output
1
1
2
2
3
4
4
4
4
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Tue Nov 3 20:30:05 2015
@author: kevin
"""
tableautaille=input().split(" ");
n=int(tableautaille[0])
m=int(tableautaille[1])
tabfinal=[]
for i in range(n):
tab=input().split(" ")
c=int(tab[0])
t=int(tab[1])
tabfinal+=[i+1]*(c*t)
print(tabfinal)
tableau=input().split(" ");
for i in range(m):
print(tabfinal[int(tableau[i])-1])
``` | instruction | 0 | 44,894 | 4 | 89,788 |
No | output | 1 | 44,894 | 4 | 89,789 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total. | instruction | 0 | 44,961 | 4 | 89,922 |
Tags: implementation
Correct Solution:
```
def main():
number, of, quantifier = input().split()
number = int(number)
months = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
weeks = {
'mon': 1,
'tue': 2,
'wed': 3,
'thu': 4,
'fri': 5,
'sat': 6,
'sun': 7
}
if quantifier == 'month':
total = sum(1 for month in months if number <= month)
elif quantifier == 'week':
total = 53 if number == weeks['fri'] or number == weeks['sat'] else 52
print(total)
if __name__ == '__main__':
main()
``` | output | 1 | 44,961 | 4 | 89,923 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total. | instruction | 0 | 44,962 | 4 | 89,924 |
Tags: implementation
Correct Solution:
```
# import sys
# sys.stdin = open("test.in","r")
# sys.stdout = open("test.out","w")
# a=list(map(int,input().split()))
a = input().split()
a[0] = int(a[0])
if a[2]=='week':
if a[0]<5 or a[0]==7:
print('52')
else:
print('53')
else:
if a[0]<30:
print('12')
elif a[0]<31:
print('11')
else:
print('7')
``` | output | 1 | 44,962 | 4 | 89,925 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total. | instruction | 0 | 44,963 | 4 | 89,926 |
Tags: implementation
Correct Solution:
```
x = input().split()
day = int(x[0])
wom = x[2]
if wom == "week":
if day == 5 or day ==6:
print(53)
else:
print(52)
else:
if day <30:
print(12)
elif day < 31:
print(11)
else:
print(7)
``` | output | 1 | 44,963 | 4 | 89,927 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total. | instruction | 0 | 44,964 | 4 | 89,928 |
Tags: implementation
Correct Solution:
```
n, s, s1 = input().split()
if s1 == "week":
a = [4, 5, 6, 7, 1, 2, 3]
x = a[int(n) - 1]
ans = 0
while x <= 366:
ans += 1
x += 7
else:
a = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
ans = 0
for i in a:
if int(n) <= i:
ans += 1
print(ans)
``` | output | 1 | 44,964 | 4 | 89,929 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total. | instruction | 0 | 44,965 | 4 | 89,930 |
Tags: implementation
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 28 07:25:01 2019
@author: avina
"""
s = input().split()
a = int(s[0])
if s[-1] == 'week':
if a == 6 or a == 5:
print(53)
else:
print(52)
else:
if a > 29:
if a == 31:
print(7)
else:
print(11)
else:
print(12)
``` | output | 1 | 44,965 | 4 | 89,931 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total. | instruction | 0 | 44,966 | 4 | 89,932 |
Tags: implementation
Correct Solution:
```
s = input()
if s[5:] == 'week':
if s[0] == '6' or s[0] == '5':
print(53)
else:
print(52)
else:
if int(s[:2]) == 30:
print(11)
elif int(s[:2]) == 31:
print(7)
else:
print(12)
``` | output | 1 | 44,966 | 4 | 89,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total. | instruction | 0 | 44,967 | 4 | 89,934 |
Tags: implementation
Correct Solution:
```
days_in_month = map(int, "31 29 31 30 31 30 31 31 30 31 30 31".split())
s = input().split()
n = int(s[0])
if s[2] == "month":
ans = 0
for el in days_in_month:
if n <= el:
ans += 1
print(ans)
else:
if n in [5, 6]:
print(53)
else:
print(52)
``` | output | 1 | 44,967 | 4 | 89,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total. | instruction | 0 | 44,968 | 4 | 89,936 |
Tags: implementation
Correct Solution:
```
import os
import sys
debug = True
if debug and os.path.exists("input.in"):
input = open("input.in", "r").readline
else:
debug = False
input = sys.stdin.readline
def inp():
return (int(input()))
def inlt():
return (list(map(int, input().split())))
def insr():
s = input()
return s[:len(s) - 1] # Remove line char from end
def invr():
return (map(int, input().split()))
test_count = 1
if debug:
test_count = inp()
for t in range(test_count):
if debug:
print("Test Case #", t + 1)
# Start code here
tokens = input().split()
day = int(tokens[0])
t_type = tokens[2]
if t_type == "week":
if day in (5, 6):
print(53)
else:
print(52)
else:
if day <= 29:
print(12)
elif day == 30:
print(11)
else:
print(7)
``` | output | 1 | 44,968 | 4 | 89,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total.
Submitted Solution:
```
s = input().split()
if s[2] == 'week':
if 4 < int(s[0]) < 7:
print(53)
else:
print(52)
else:
print(7 if s[0] == "31" else 11 if s[0] == "30" else 12)
``` | instruction | 0 | 44,969 | 4 | 89,938 |
Yes | output | 1 | 44,969 | 4 | 89,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total.
Submitted Solution:
```
k = input().split(" of ")
if k[1]=='week':
print([52,53][k[0]=='5' or k[0]=='6'])
elif int(k[0])<31:
print([11,12][int(k[0])<=29])
else:
print(7)
``` | instruction | 0 | 44,970 | 4 | 89,940 |
Yes | output | 1 | 44,970 | 4 | 89,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total.
Submitted Solution:
```
a = list(input().split())
if a[2] == 'month':
if a[0] == '31':
print(7)
elif a[0] == '30':
print(11)
else:
print(12)
else:
if a[0] == '5' or a[0] == '6':
print(53)
else:
print(52)
``` | instruction | 0 | 44,971 | 4 | 89,942 |
Yes | output | 1 | 44,971 | 4 | 89,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total.
Submitted Solution:
```
x = input().split()
if x[2] == "week":
if x[0] == "5" or x[0] == "6":
print("53")
else:
print("52")
else:
if x[0] == "31":
print(7)
elif x[0] == "30":
print(11)
else:
print(12)
``` | instruction | 0 | 44,972 | 4 | 89,944 |
Yes | output | 1 | 44,972 | 4 | 89,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total.
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
t = LS()
if t[-1] == 'week':
if t[0] < '5':
return 52
return 51
if t[0] < '30':
return 12
if t[0] == '30':
return 11
return 7
print(main())
``` | instruction | 0 | 44,973 | 4 | 89,946 |
No | output | 1 | 44,973 | 4 | 89,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total.
Submitted Solution:
```
a,b,c = input().split()
a = int (a)
if c[0]=='m':
if a>=1 and a<=29:
print ('12')
elif a>=30:
print ('11')
else:
if a==5 or a==6:
print ('53')
else:
print ('52')
``` | instruction | 0 | 44,974 | 4 | 89,948 |
No | output | 1 | 44,974 | 4 | 89,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total.
Submitted Solution:
```
#!/usr/bin/env python3
import sys
S = input()
if S == "1 of week":
print(52)
if S == "2 of week":
print(52)
if S == "3 of week":
print(52)
if S == "4 of week":
print(52)
if S == "5 of week":
print(53)
if S == "6 of week":
print(53)
if S == "7 of week":
print(52)
for i in range(1, 29):
if S == str(i) + " of month":
print(12)
if S == "29 of month":
print(11)
if S == "30 of month":
print(11)
if S == "31 of month":
print(7)
``` | instruction | 0 | 44,975 | 4 | 89,950 |
No | output | 1 | 44,975 | 4 | 89,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Today is Wednesday, the third day of the week. What's more interesting is that tomorrow is the last day of the year 2015.
Limak is a little polar bear. He enjoyed this year a lot. Now, he is so eager to the coming year 2016.
Limak wants to prove how responsible a bear he is. He is going to regularly save candies for the entire year 2016! He considers various saving plans. He can save one candy either on some fixed day of the week or on some fixed day of the month.
Limak chose one particular plan. He isn't sure how many candies he will save in the 2016 with his plan. Please, calculate it and tell him.
Input
The only line of the input is in one of the following two formats:
* "x of week" where x (1 ≤ x ≤ 7) denotes the day of the week. The 1-st day is Monday and the 7-th one is Sunday.
* "x of month" where x (1 ≤ x ≤ 31) denotes the day of the month.
Output
Print one integer — the number of candies Limak will save in the year 2016.
Examples
Input
4 of week
Output
52
Input
30 of month
Output
11
Note
Polar bears use the Gregorian calendar. It is the most common calendar and you likely use it too. You can read about it on Wikipedia if you want to – <https://en.wikipedia.org/wiki/Gregorian_calendar>. The week starts with Monday.
In the first sample Limak wants to save one candy on each Thursday (the 4-th day of the week). There are 52 Thursdays in the 2016. Thus, he will save 52 candies in total.
In the second sample Limak wants to save one candy on the 30-th day of each month. There is the 30-th day in exactly 11 months in the 2016 — all months but February. It means that Limak will save 11 candies in total.
Submitted Solution:
```
n, a, b = [str(i) for i in input().split()]
n = int(n)
def calc(n):
if(n == 5):
if(365/7 > int("{0:.0f}".format((365/7)))):
print("{0:.0f}".format((365/7)+1))
else:
print(365/7)
elif(n == 6):
if(364/7 != int("{0:.0f}".format((364/7)))):
print("{0:.0f}".format((364/7)+1))
else:
print(364/7)
elif(n == 7):
if(363/7 != int("{0:.0f}".format((363/7)))):
print("{0:.0f}".format((363/7)+1))
else:
print(363/7)
elif(n == 1):
if(362/7 != int("{0:.0f}".format((362/7)))):
print("{0:.0f}".format((362/7)+1))
else:
print(362/7)
elif(n == 2):
if(361/7 != int("{0:.0f}".format((361/7)))):
print("{0:.0f}".format((361/7)+1))
else:
print(361/7)
elif(n == 3):
if(360/7 != int("{0:.0f}".format((360/7)))):
print("{0:.0f}".format((360/7)+1))
else:
print(360/7)
elif(n == 4):
if(359/7 != int("{0:.0f}".format((359/7)))):
print("{0:.0f}".format((359/7)+1))
else:
print(359/7)
if (b == "month"):
if(n < 29):
print(12)
elif(n == 30 or n == 29):
print(11)
else:
print(7)
else:
calc(n)
``` | instruction | 0 | 44,976 | 4 | 89,952 |
No | output | 1 | 44,976 | 4 | 89,953 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got a list of program warning logs. Each record of a log stream is a string in this format:
"2012-MM-DD HH:MM:SS:MESSAGE" (without the quotes).
String "MESSAGE" consists of spaces, uppercase and lowercase English letters and characters "!", ".", ",", "?". String "2012-MM-DD" determines a correct date in the year of 2012. String "HH:MM:SS" determines a correct time in the 24 hour format.
The described record of a log stream means that at a certain time the record has got some program warning (string "MESSAGE" contains the warning's description).
Your task is to print the first moment of time, when the number of warnings for the last n seconds was not less than m.
Input
The first line of the input contains two space-separated integers n and m (1 ≤ n, m ≤ 10000).
The second and the remaining lines of the input represent the log stream. The second line of the input contains the first record of the log stream, the third line contains the second record and so on. Each record of the log stream has the above described format. All records are given in the chronological order, that is, the warning records are given in the order, in which the warnings appeared in the program.
It is guaranteed that the log has at least one record. It is guaranteed that the total length of all lines of the log stream doesn't exceed 5·106 (in particular, this means that the length of some line does not exceed 5·106 characters). It is guaranteed that all given dates and times are correct, and the string 'MESSAGE" in all records is non-empty.
Output
If there is no sought moment of time, print -1. Otherwise print a string in the format "2012-MM-DD HH:MM:SS" (without the quotes) — the first moment of time when the number of warnings for the last n seconds got no less than m.
Examples
Input
60 3
2012-03-16 16:15:25: Disk size is
2012-03-16 16:15:25: Network failute
2012-03-16 16:16:29: Cant write varlog
2012-03-16 16:16:42: Unable to start process
2012-03-16 16:16:43: Disk size is too small
2012-03-16 16:16:53: Timeout detected
Output
2012-03-16 16:16:43
Input
1 2
2012-03-16 23:59:59:Disk size
2012-03-17 00:00:00: Network
2012-03-17 00:00:01:Cant write varlog
Output
-1
Input
2 2
2012-03-16 23:59:59:Disk size is too sm
2012-03-17 00:00:00:Network failute dete
2012-03-17 00:00:01:Cant write varlogmysq
Output
2012-03-17 00:00:00 | instruction | 0 | 45,668 | 4 | 91,336 |
Tags: binary search, brute force, implementation, strings
Correct Solution:
```
# import atexit
# import io
# import sys
#
# _INPUT_LINES = sys.stdin.read().splitlines()
# input = iter(_INPUT_LINES).__next__
# _OUTPUT_BUFFER = io.StringIO()
# sys.stdout = _OUTPUT_BUFFER
#
#
# @atexit.register
# def write():
# sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
import bisect
from datetime import datetime
def main():
n, m = map(int, input().split())
n -= 1
timestamps = []
raw = []
while True:
s = ""
try:
s = input()
except:
print(-1)
exit(0)
d = datetime.strptime(s[0:19], "%Y-%m-%d %H:%M:%S")
timestamps.append(int(d.timestamp()))
raw.append(s[0:19])
idx = bisect.bisect_left(timestamps, timestamps[-1] - n)
if len(timestamps) - idx == m:
print(raw[-1])
exit(0)
if __name__ == "__main__":
main()
``` | output | 1 | 45,668 | 4 | 91,337 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got a list of program warning logs. Each record of a log stream is a string in this format:
"2012-MM-DD HH:MM:SS:MESSAGE" (without the quotes).
String "MESSAGE" consists of spaces, uppercase and lowercase English letters and characters "!", ".", ",", "?". String "2012-MM-DD" determines a correct date in the year of 2012. String "HH:MM:SS" determines a correct time in the 24 hour format.
The described record of a log stream means that at a certain time the record has got some program warning (string "MESSAGE" contains the warning's description).
Your task is to print the first moment of time, when the number of warnings for the last n seconds was not less than m.
Input
The first line of the input contains two space-separated integers n and m (1 ≤ n, m ≤ 10000).
The second and the remaining lines of the input represent the log stream. The second line of the input contains the first record of the log stream, the third line contains the second record and so on. Each record of the log stream has the above described format. All records are given in the chronological order, that is, the warning records are given in the order, in which the warnings appeared in the program.
It is guaranteed that the log has at least one record. It is guaranteed that the total length of all lines of the log stream doesn't exceed 5·106 (in particular, this means that the length of some line does not exceed 5·106 characters). It is guaranteed that all given dates and times are correct, and the string 'MESSAGE" in all records is non-empty.
Output
If there is no sought moment of time, print -1. Otherwise print a string in the format "2012-MM-DD HH:MM:SS" (without the quotes) — the first moment of time when the number of warnings for the last n seconds got no less than m.
Examples
Input
60 3
2012-03-16 16:15:25: Disk size is
2012-03-16 16:15:25: Network failute
2012-03-16 16:16:29: Cant write varlog
2012-03-16 16:16:42: Unable to start process
2012-03-16 16:16:43: Disk size is too small
2012-03-16 16:16:53: Timeout detected
Output
2012-03-16 16:16:43
Input
1 2
2012-03-16 23:59:59:Disk size
2012-03-17 00:00:00: Network
2012-03-17 00:00:01:Cant write varlog
Output
-1
Input
2 2
2012-03-16 23:59:59:Disk size is too sm
2012-03-17 00:00:00:Network failute dete
2012-03-17 00:00:01:Cant write varlogmysq
Output
2012-03-17 00:00:00 | instruction | 0 | 45,669 | 4 | 91,338 |
Tags: binary search, brute force, implementation, strings
Correct Solution:
```
n, m = map(int, input().split(" "))
messages = []
months = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
while True:
try:
s = input()
messages.append(s)
except:
break
# print(messages)
length = len(messages)
pref = [0]
for i in range(1, 13):
pref.append(pref[i - 1] + months[i])
# print(pref)
got = False
now = 0
prev = 0
store = []
for message in messages:
date = int(message[8:10]) + pref[int(message[5:7]) - 1]
time = date * 24 * 60 * 60 + int(message[11:13]) * 60 * 60 + int(message[14:16]) * 60 + int(message[17:19])
store.append(time)
if now < m - 1:
now += 1
continue
else:
prev = now - (m - 1)
if (store[now] - store[prev]) < n:
print(message[:19])
got = True
break
now += 1
if not got:
print(-1)
``` | output | 1 | 45,669 | 4 | 91,339 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got a list of program warning logs. Each record of a log stream is a string in this format:
"2012-MM-DD HH:MM:SS:MESSAGE" (without the quotes).
String "MESSAGE" consists of spaces, uppercase and lowercase English letters and characters "!", ".", ",", "?". String "2012-MM-DD" determines a correct date in the year of 2012. String "HH:MM:SS" determines a correct time in the 24 hour format.
The described record of a log stream means that at a certain time the record has got some program warning (string "MESSAGE" contains the warning's description).
Your task is to print the first moment of time, when the number of warnings for the last n seconds was not less than m.
Input
The first line of the input contains two space-separated integers n and m (1 ≤ n, m ≤ 10000).
The second and the remaining lines of the input represent the log stream. The second line of the input contains the first record of the log stream, the third line contains the second record and so on. Each record of the log stream has the above described format. All records are given in the chronological order, that is, the warning records are given in the order, in which the warnings appeared in the program.
It is guaranteed that the log has at least one record. It is guaranteed that the total length of all lines of the log stream doesn't exceed 5·106 (in particular, this means that the length of some line does not exceed 5·106 characters). It is guaranteed that all given dates and times are correct, and the string 'MESSAGE" in all records is non-empty.
Output
If there is no sought moment of time, print -1. Otherwise print a string in the format "2012-MM-DD HH:MM:SS" (without the quotes) — the first moment of time when the number of warnings for the last n seconds got no less than m.
Examples
Input
60 3
2012-03-16 16:15:25: Disk size is
2012-03-16 16:15:25: Network failute
2012-03-16 16:16:29: Cant write varlog
2012-03-16 16:16:42: Unable to start process
2012-03-16 16:16:43: Disk size is too small
2012-03-16 16:16:53: Timeout detected
Output
2012-03-16 16:16:43
Input
1 2
2012-03-16 23:59:59:Disk size
2012-03-17 00:00:00: Network
2012-03-17 00:00:01:Cant write varlog
Output
-1
Input
2 2
2012-03-16 23:59:59:Disk size is too sm
2012-03-17 00:00:00:Network failute dete
2012-03-17 00:00:01:Cant write varlogmysq
Output
2012-03-17 00:00:00 | instruction | 0 | 45,670 | 4 | 91,340 |
Tags: binary search, brute force, implementation, strings
Correct Solution:
```
import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
import bisect
from datetime import datetime
def main():
n, m = map(int, input().split())
n -= 1
timestamps = []
while True:
s = ""
try:
s = input()
except:
print(-1)
exit(0)
d = datetime.strptime(s[0:19], "%Y-%m-%d %H:%M:%S")
timestamps.append(int(d.timestamp()))
idx = bisect.bisect_left(timestamps, timestamps[-1] - n)
if len(timestamps) - idx == m:
print(s[0:19])
exit(0)
if __name__ == "__main__":
main()
``` | output | 1 | 45,670 | 4 | 91,341 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You've got a list of program warning logs. Each record of a log stream is a string in this format:
"2012-MM-DD HH:MM:SS:MESSAGE" (without the quotes).
String "MESSAGE" consists of spaces, uppercase and lowercase English letters and characters "!", ".", ",", "?". String "2012-MM-DD" determines a correct date in the year of 2012. String "HH:MM:SS" determines a correct time in the 24 hour format.
The described record of a log stream means that at a certain time the record has got some program warning (string "MESSAGE" contains the warning's description).
Your task is to print the first moment of time, when the number of warnings for the last n seconds was not less than m.
Input
The first line of the input contains two space-separated integers n and m (1 ≤ n, m ≤ 10000).
The second and the remaining lines of the input represent the log stream. The second line of the input contains the first record of the log stream, the third line contains the second record and so on. Each record of the log stream has the above described format. All records are given in the chronological order, that is, the warning records are given in the order, in which the warnings appeared in the program.
It is guaranteed that the log has at least one record. It is guaranteed that the total length of all lines of the log stream doesn't exceed 5·106 (in particular, this means that the length of some line does not exceed 5·106 characters). It is guaranteed that all given dates and times are correct, and the string 'MESSAGE" in all records is non-empty.
Output
If there is no sought moment of time, print -1. Otherwise print a string in the format "2012-MM-DD HH:MM:SS" (without the quotes) — the first moment of time when the number of warnings for the last n seconds got no less than m.
Examples
Input
60 3
2012-03-16 16:15:25: Disk size is
2012-03-16 16:15:25: Network failute
2012-03-16 16:16:29: Cant write varlog
2012-03-16 16:16:42: Unable to start process
2012-03-16 16:16:43: Disk size is too small
2012-03-16 16:16:53: Timeout detected
Output
2012-03-16 16:16:43
Input
1 2
2012-03-16 23:59:59:Disk size
2012-03-17 00:00:00: Network
2012-03-17 00:00:01:Cant write varlog
Output
-1
Input
2 2
2012-03-16 23:59:59:Disk size is too sm
2012-03-17 00:00:00:Network failute dete
2012-03-17 00:00:01:Cant write varlogmysq
Output
2012-03-17 00:00:00 | instruction | 0 | 45,671 | 4 | 91,342 |
Tags: binary search, brute force, implementation, strings
Correct Solution:
```
import atexit
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER
@atexit.register
def write():
sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
import bisect
from datetime import datetime
def main():
n, m = map(int, input().split())
n -= 1
timestamps = []
raw = []
while True:
s = ""
try:
s = input()
except:
print(-1)
exit(0)
d = datetime.strptime(s[0:19], "%Y-%m-%d %H:%M:%S")
timestamps.append(int(d.timestamp()))
raw.append(s[0:19])
idx = bisect.bisect_left(timestamps, timestamps[-1] - n)
if len(timestamps) - idx == m:
print(raw[-1])
exit(0)
if __name__ == "__main__":
main()
``` | output | 1 | 45,671 | 4 | 91,343 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got a list of program warning logs. Each record of a log stream is a string in this format:
"2012-MM-DD HH:MM:SS:MESSAGE" (without the quotes).
String "MESSAGE" consists of spaces, uppercase and lowercase English letters and characters "!", ".", ",", "?". String "2012-MM-DD" determines a correct date in the year of 2012. String "HH:MM:SS" determines a correct time in the 24 hour format.
The described record of a log stream means that at a certain time the record has got some program warning (string "MESSAGE" contains the warning's description).
Your task is to print the first moment of time, when the number of warnings for the last n seconds was not less than m.
Input
The first line of the input contains two space-separated integers n and m (1 ≤ n, m ≤ 10000).
The second and the remaining lines of the input represent the log stream. The second line of the input contains the first record of the log stream, the third line contains the second record and so on. Each record of the log stream has the above described format. All records are given in the chronological order, that is, the warning records are given in the order, in which the warnings appeared in the program.
It is guaranteed that the log has at least one record. It is guaranteed that the total length of all lines of the log stream doesn't exceed 5·106 (in particular, this means that the length of some line does not exceed 5·106 characters). It is guaranteed that all given dates and times are correct, and the string 'MESSAGE" in all records is non-empty.
Output
If there is no sought moment of time, print -1. Otherwise print a string in the format "2012-MM-DD HH:MM:SS" (without the quotes) — the first moment of time when the number of warnings for the last n seconds got no less than m.
Examples
Input
60 3
2012-03-16 16:15:25: Disk size is
2012-03-16 16:15:25: Network failute
2012-03-16 16:16:29: Cant write varlog
2012-03-16 16:16:42: Unable to start process
2012-03-16 16:16:43: Disk size is too small
2012-03-16 16:16:53: Timeout detected
Output
2012-03-16 16:16:43
Input
1 2
2012-03-16 23:59:59:Disk size
2012-03-17 00:00:00: Network
2012-03-17 00:00:01:Cant write varlog
Output
-1
Input
2 2
2012-03-16 23:59:59:Disk size is too sm
2012-03-17 00:00:00:Network failute dete
2012-03-17 00:00:01:Cant write varlogmysq
Output
2012-03-17 00:00:00
Submitted Solution:
```
print (-1)
``` | instruction | 0 | 45,672 | 4 | 91,344 |
No | output | 1 | 45,672 | 4 | 91,345 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You've got a list of program warning logs. Each record of a log stream is a string in this format:
"2012-MM-DD HH:MM:SS:MESSAGE" (without the quotes).
String "MESSAGE" consists of spaces, uppercase and lowercase English letters and characters "!", ".", ",", "?". String "2012-MM-DD" determines a correct date in the year of 2012. String "HH:MM:SS" determines a correct time in the 24 hour format.
The described record of a log stream means that at a certain time the record has got some program warning (string "MESSAGE" contains the warning's description).
Your task is to print the first moment of time, when the number of warnings for the last n seconds was not less than m.
Input
The first line of the input contains two space-separated integers n and m (1 ≤ n, m ≤ 10000).
The second and the remaining lines of the input represent the log stream. The second line of the input contains the first record of the log stream, the third line contains the second record and so on. Each record of the log stream has the above described format. All records are given in the chronological order, that is, the warning records are given in the order, in which the warnings appeared in the program.
It is guaranteed that the log has at least one record. It is guaranteed that the total length of all lines of the log stream doesn't exceed 5·106 (in particular, this means that the length of some line does not exceed 5·106 characters). It is guaranteed that all given dates and times are correct, and the string 'MESSAGE" in all records is non-empty.
Output
If there is no sought moment of time, print -1. Otherwise print a string in the format "2012-MM-DD HH:MM:SS" (without the quotes) — the first moment of time when the number of warnings for the last n seconds got no less than m.
Examples
Input
60 3
2012-03-16 16:15:25: Disk size is
2012-03-16 16:15:25: Network failute
2012-03-16 16:16:29: Cant write varlog
2012-03-16 16:16:42: Unable to start process
2012-03-16 16:16:43: Disk size is too small
2012-03-16 16:16:53: Timeout detected
Output
2012-03-16 16:16:43
Input
1 2
2012-03-16 23:59:59:Disk size
2012-03-17 00:00:00: Network
2012-03-17 00:00:01:Cant write varlog
Output
-1
Input
2 2
2012-03-16 23:59:59:Disk size is too sm
2012-03-17 00:00:00:Network failute dete
2012-03-17 00:00:01:Cant write varlogmysq
Output
2012-03-17 00:00:00
Submitted Solution:
```
n, m = map(int, input().split(" "))
messages = []
months = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
while True:
try:
s = input()
messages.append(s)
except:
break
# print(messages)
length = len(messages)
pref = [0]
for i in range(1, 13):
pref.append(pref[i - 1] + months[i])
print(pref)
got = False
now = 0
prev = 0
store = []
for message in messages:
date = int(message[8:10]) + pref[int(message[5:7]) - 1]
time = date * 24 * 60 * 60 + int(message[11:13]) * 60 * 60 + int(message[14:16]) * 60 + int(message[17:19])
store.append(time)
if now < m - 1:
now += 1
continue
else:
prev = now - (m - 1)
if (store[now] - store[prev]) < n:
print(message[:19])
got = True
break
now += 1
if not got:
print(-1)
``` | instruction | 0 | 45,673 | 4 | 91,346 |
No | output | 1 | 45,673 | 4 | 91,347 |
Provide a correct Python 3 solution for this coding contest problem.
The volume of access to a web service varies from time to time in a day. Also, the hours with the highest volume of access varies from service to service. For example, a service popular in the United States may receive more access in the daytime in the United States, while another service popular in Japan may receive more access in the daytime in Japan. When you develop a web service, you have to design the system so it can handle all requests made during the busiest hours.
You are a lead engineer in charge of a web service in the 30th century. It’s the era of Galaxy Wide Web (GWW), thanks to the invention of faster-than-light communication. The service can be accessed from all over the galaxy. Thus many intelligent creatures, not limited to human beings, can use the service. Since the volume of access to your service is increasing these days, you have decided to reinforce the server system. You want to design a new system that handles requests well even during the hours with the highest volume of access. However, this is not a trivial task. Residents in each planet have their specific length of a day, say, a cycle of life. The length of a day is not always 24 hours. Therefore, a cycle of the volume of access are different by planets of users.
You have obtained hourly data of the volume of access for all planets where you provide the service. Assuming the volume of access follows a daily cycle for each planet, you want to know the highest volume of access in one hour. It should be a quite easy task for you, a famous talented engineer in the galaxy.
Input
The input consists of multiple datasets. Each dataset has the following format:
N
d1 t1 q1,0 ... q1,d1-1
...
dN tN qN,0 ... qN,dN-1
N is the number of planets. di (1 ≤ i ≤ N) is the length of a day in the planet i. ti (0 ≤ ti ≤ di - 1) is the current time of the planet i. qi, j is the volume of access on the planet i during from the j-th hour to the (j+1)-th hour.
You may assume that N ≤ 100, di ≤ 24, qi, j ≤ 1000000 (1 ≤ i ≤ N, 0 ≤ j ≤ di - 1).
The last dataset is followed by a line containing one zero. This line is not a part of any dataset and should not be processed.
Output
For each dataset, output the maximum volume of access in one hour in a line.
Example
Input
2
4 0 1 2 3 4
2 0 2 1
0
Output
5 | instruction | 0 | 46,128 | 4 | 92,256 |
"Correct Solution:
```
from itertools import cycle
while True:
n = int(input())
if not n:
break
qs = {}
for i in range(n):
d, t, *q = (int(s) for s in input().split())
q = q[t:] + q[:t]
if d not in qs:
qs[d] = q
else:
qs[d] = [a + b for a, b in zip(qs[d], q)]
L = 16 * 9 * 5 * 7 * 11
ps = [13, 17, 19, 23, 1]
psum = sum(max(qs.pop(i, [0])) for i in ps)
qmax = max(sum(j) for i, j in zip(range(L-1),
zip(*[cycle(q) for q in qs.values()])
)
)
print(psum + qmax)
``` | output | 1 | 46,128 | 4 | 92,257 |
Provide a correct Python 3 solution for this coding contest problem.
The volume of access to a web service varies from time to time in a day. Also, the hours with the highest volume of access varies from service to service. For example, a service popular in the United States may receive more access in the daytime in the United States, while another service popular in Japan may receive more access in the daytime in Japan. When you develop a web service, you have to design the system so it can handle all requests made during the busiest hours.
You are a lead engineer in charge of a web service in the 30th century. It’s the era of Galaxy Wide Web (GWW), thanks to the invention of faster-than-light communication. The service can be accessed from all over the galaxy. Thus many intelligent creatures, not limited to human beings, can use the service. Since the volume of access to your service is increasing these days, you have decided to reinforce the server system. You want to design a new system that handles requests well even during the hours with the highest volume of access. However, this is not a trivial task. Residents in each planet have their specific length of a day, say, a cycle of life. The length of a day is not always 24 hours. Therefore, a cycle of the volume of access are different by planets of users.
You have obtained hourly data of the volume of access for all planets where you provide the service. Assuming the volume of access follows a daily cycle for each planet, you want to know the highest volume of access in one hour. It should be a quite easy task for you, a famous talented engineer in the galaxy.
Input
The input consists of multiple datasets. Each dataset has the following format:
N
d1 t1 q1,0 ... q1,d1-1
...
dN tN qN,0 ... qN,dN-1
N is the number of planets. di (1 ≤ i ≤ N) is the length of a day in the planet i. ti (0 ≤ ti ≤ di - 1) is the current time of the planet i. qi, j is the volume of access on the planet i during from the j-th hour to the (j+1)-th hour.
You may assume that N ≤ 100, di ≤ 24, qi, j ≤ 1000000 (1 ≤ i ≤ N, 0 ≤ j ≤ di - 1).
The last dataset is followed by a line containing one zero. This line is not a part of any dataset and should not be processed.
Output
For each dataset, output the maximum volume of access in one hour in a line.
Example
Input
2
4 0 1 2 3 4
2 0 2 1
0
Output
5 | instruction | 0 | 46,129 | 4 | 92,258 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def gcd(m, n):
while n:
m, n = n, m % n
return m
def lcm(m, n):
return m // gcd(m, n) * n
def solve():
N = int(readline())
if N == 0:
return False
pp = [13, 17, 19, 23]
E = [[0]*i for i in range(25)]
Q = []
for i in range(N):
d, t, *qs = map(int, readline().split())
qs = qs[t:] + qs[:t]
Ed = E[d]
for i in range(d):
Ed[i] += qs[i]
L = 13860
V = [0]*L
for i in range(1, 25):
if i in pp:
continue
if i <= 12:
Ei = E[i]; Ej = E[2*i]
for j in range(2*i):
Ej[j] += Ei[j % i]
else:
Ei = E[i]
if i == 16:
for j in range(8):
Ei[j] = max(Ei[j+8], Ei[j])
Ej = E[24]
for j in range(24):
Ej[j] += Ei[j % 8]
elif i == 24:
for j in range(12):
Ei[j] = max(Ei[j+12], Ei[j])
for j in range(L):
V[j] += Ei[j % 12]
else:
for j in range(L):
V[j] += Ei[j % i]
ans = max(V)
for i in pp:
ans += max(E[i])
write("%d\n" % ans)
return True
while solve():
...
``` | output | 1 | 46,129 | 4 | 92,259 |
Provide a correct Python 3 solution for this coding contest problem.
Welcome to PC Koshien, players. Physical condition management is important to participate in the event. It is said that at the turn of the season when the temperature fluctuates greatly, it puts a strain on the body and it is easy to catch a cold. The day you should be careful about is the day when the difference between the maximum temperature and the minimum temperature is the largest. When the maximum and minimum temperatures of a day are given for 7 days, create a program that outputs the value obtained by subtracting the minimum temperature from the maximum temperature for each day.
input
Input data is given in the following format.
a1 b1
a2 b2
::
a7 b7
The input consists of 7 lines, and line i is given an integer representing the maximum temperature ai (-40 ≤ ai ≤ 40) and the minimum temperature bi (-40 ≤ bi ≤ 40) on day i. On all days, the maximum temperature ai is always above the minimum temperature bi.
output
Output the temperature difference for 7 days in 7 lines.
Example
Input
30 19
39 20
19 18
25 20
22 21
23 10
10 -10
Output
11
19
1
5
1
13
20 | instruction | 0 | 46,971 | 4 | 93,942 |
"Correct Solution:
```
for x in range(7):
a,b=list(map(int,input().split()))
print(a-b)
``` | output | 1 | 46,971 | 4 | 93,943 |
Provide a correct Python 3 solution for this coding contest problem.
Welcome to PC Koshien, players. Physical condition management is important to participate in the event. It is said that at the turn of the season when the temperature fluctuates greatly, it puts a strain on the body and it is easy to catch a cold. The day you should be careful about is the day when the difference between the maximum temperature and the minimum temperature is the largest. When the maximum and minimum temperatures of a day are given for 7 days, create a program that outputs the value obtained by subtracting the minimum temperature from the maximum temperature for each day.
input
Input data is given in the following format.
a1 b1
a2 b2
::
a7 b7
The input consists of 7 lines, and line i is given an integer representing the maximum temperature ai (-40 ≤ ai ≤ 40) and the minimum temperature bi (-40 ≤ bi ≤ 40) on day i. On all days, the maximum temperature ai is always above the minimum temperature bi.
output
Output the temperature difference for 7 days in 7 lines.
Example
Input
30 19
39 20
19 18
25 20
22 21
23 10
10 -10
Output
11
19
1
5
1
13
20 | instruction | 0 | 46,972 | 4 | 93,944 |
"Correct Solution:
```
# coding: utf-8
# Your code here!
for i in range(7):
a,b=map(int,input().split())
K = a-b
print(K)
``` | output | 1 | 46,972 | 4 | 93,945 |
Provide a correct Python 3 solution for this coding contest problem.
Welcome to PC Koshien, players. Physical condition management is important to participate in the event. It is said that at the turn of the season when the temperature fluctuates greatly, it puts a strain on the body and it is easy to catch a cold. The day you should be careful about is the day when the difference between the maximum temperature and the minimum temperature is the largest. When the maximum and minimum temperatures of a day are given for 7 days, create a program that outputs the value obtained by subtracting the minimum temperature from the maximum temperature for each day.
input
Input data is given in the following format.
a1 b1
a2 b2
::
a7 b7
The input consists of 7 lines, and line i is given an integer representing the maximum temperature ai (-40 ≤ ai ≤ 40) and the minimum temperature bi (-40 ≤ bi ≤ 40) on day i. On all days, the maximum temperature ai is always above the minimum temperature bi.
output
Output the temperature difference for 7 days in 7 lines.
Example
Input
30 19
39 20
19 18
25 20
22 21
23 10
10 -10
Output
11
19
1
5
1
13
20 | instruction | 0 | 46,973 | 4 | 93,946 |
"Correct Solution:
```
list=[]
for i in range(7):
a,b=map(int,input().split())
list.append((a,b))
print(a-b)
``` | output | 1 | 46,973 | 4 | 93,947 |
Provide a correct Python 3 solution for this coding contest problem.
Welcome to PC Koshien, players. Physical condition management is important to participate in the event. It is said that at the turn of the season when the temperature fluctuates greatly, it puts a strain on the body and it is easy to catch a cold. The day you should be careful about is the day when the difference between the maximum temperature and the minimum temperature is the largest. When the maximum and minimum temperatures of a day are given for 7 days, create a program that outputs the value obtained by subtracting the minimum temperature from the maximum temperature for each day.
input
Input data is given in the following format.
a1 b1
a2 b2
::
a7 b7
The input consists of 7 lines, and line i is given an integer representing the maximum temperature ai (-40 ≤ ai ≤ 40) and the minimum temperature bi (-40 ≤ bi ≤ 40) on day i. On all days, the maximum temperature ai is always above the minimum temperature bi.
output
Output the temperature difference for 7 days in 7 lines.
Example
Input
30 19
39 20
19 18
25 20
22 21
23 10
10 -10
Output
11
19
1
5
1
13
20 | instruction | 0 | 46,974 | 4 | 93,948 |
"Correct Solution:
```
xy = [map(int, input().split()) for _ in range(7)]
x, y = [list(i) for i in zip(*xy)]
for i in range(7):
print(abs(x[i] - y[i]))
``` | output | 1 | 46,974 | 4 | 93,949 |
Provide a correct Python 3 solution for this coding contest problem.
Welcome to PC Koshien, players. Physical condition management is important to participate in the event. It is said that at the turn of the season when the temperature fluctuates greatly, it puts a strain on the body and it is easy to catch a cold. The day you should be careful about is the day when the difference between the maximum temperature and the minimum temperature is the largest. When the maximum and minimum temperatures of a day are given for 7 days, create a program that outputs the value obtained by subtracting the minimum temperature from the maximum temperature for each day.
input
Input data is given in the following format.
a1 b1
a2 b2
::
a7 b7
The input consists of 7 lines, and line i is given an integer representing the maximum temperature ai (-40 ≤ ai ≤ 40) and the minimum temperature bi (-40 ≤ bi ≤ 40) on day i. On all days, the maximum temperature ai is always above the minimum temperature bi.
output
Output the temperature difference for 7 days in 7 lines.
Example
Input
30 19
39 20
19 18
25 20
22 21
23 10
10 -10
Output
11
19
1
5
1
13
20 | instruction | 0 | 46,975 | 4 | 93,950 |
"Correct Solution:
```
for i in range(1,8):
a,b=map(int,input().split())
print(a-b)
``` | output | 1 | 46,975 | 4 | 93,951 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.