message stringlengths 2 45.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 254 108k | cluster float64 3 3 | __index_level_0__ int64 508 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Surely you have seen insane videos by South Korean rapper PSY, such as "Gangnam Style", "Gentleman" and "Daddy". You might also hear that PSY has been recording video "Oppa Funcan Style" two years ago (unfortunately we couldn't find it on the internet). We will remind you what this hit looked like (you can find original description [here](http://acm.timus.ru/problem.aspx?space=1&num=2107&locale=en)):
On the ground there are n platforms, which are numbered with integers from 1 to n, on i-th platform there is a dancer with number i. Further, every second all the dancers standing on the platform with number i jump to the platform with the number f(i). The moving rule f is selected in advance and is not changed throughout the clip.
The duration of the clip was k seconds and the rule f was chosen in such a way that after k seconds all dancers were in their initial positions (i.e. the i-th dancer stood on the platform with the number i). That allowed to loop the clip and collect even more likes.
PSY knows that enhanced versions of old artworks become more and more popular every day. So he decided to release a remastered-version of his video.
In his case "enhanced version" means even more insanity, so the number of platforms can be up to 10^{18}! But the video director said that if some dancer stays on the same platform all the time, then the viewer will get bored and will turn off the video immediately. Therefore, for all x from 1 to n f(x) ≠ x must hold.
Big part of classic video's success was in that looping, so in the remastered version all dancers should return to their initial positions in the end of the clip as well.
PSY hasn't decided on the exact number of platforms and video duration yet, so he asks you to check if there is a good rule f for different options.
Input
In the first line of input there is one integer t (1 ≤ t ≤ 10^{4}) — the number of options for n and k to check.
In the next t lines the options are given: each option is described with two integers n and k (1 ≤ n ≤ 10^{18}, 1 ≤ k ≤ 10^{15}) — the number of dancers and the duration in seconds.
It is guaranteed that the number of different values of k in one test is not greater than 50.
Output
Print t lines. If the i-th option of the video is feasible, print "YES" (without quotes) in i-th line, otherwise print "NO" (without quotes).
Example
Input
3
7 7
3 8
5 6
Output
YES
NO
YES
Submitted Solution:
```
cases = int(input())
for case in range(cases):
a, b = input().split()
n = int(a)
k = int(b)
if((n%2==0) and (k%2==0)):
print('YES')
elif(n/k==1):
print('YES')
elif((n%2==1) and (k%2==0) and (k%3==0)):
print('YES')
elif(n%k==0):
print('YES')
else:
print('NO')
``` | instruction | 0 | 25,318 | 3 | 50,636 |
No | output | 1 | 25,318 | 3 | 50,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Surely you have seen insane videos by South Korean rapper PSY, such as "Gangnam Style", "Gentleman" and "Daddy". You might also hear that PSY has been recording video "Oppa Funcan Style" two years ago (unfortunately we couldn't find it on the internet). We will remind you what this hit looked like (you can find original description [here](http://acm.timus.ru/problem.aspx?space=1&num=2107&locale=en)):
On the ground there are n platforms, which are numbered with integers from 1 to n, on i-th platform there is a dancer with number i. Further, every second all the dancers standing on the platform with number i jump to the platform with the number f(i). The moving rule f is selected in advance and is not changed throughout the clip.
The duration of the clip was k seconds and the rule f was chosen in such a way that after k seconds all dancers were in their initial positions (i.e. the i-th dancer stood on the platform with the number i). That allowed to loop the clip and collect even more likes.
PSY knows that enhanced versions of old artworks become more and more popular every day. So he decided to release a remastered-version of his video.
In his case "enhanced version" means even more insanity, so the number of platforms can be up to 10^{18}! But the video director said that if some dancer stays on the same platform all the time, then the viewer will get bored and will turn off the video immediately. Therefore, for all x from 1 to n f(x) ≠ x must hold.
Big part of classic video's success was in that looping, so in the remastered version all dancers should return to their initial positions in the end of the clip as well.
PSY hasn't decided on the exact number of platforms and video duration yet, so he asks you to check if there is a good rule f for different options.
Input
In the first line of input there is one integer t (1 ≤ t ≤ 10^{4}) — the number of options for n and k to check.
In the next t lines the options are given: each option is described with two integers n and k (1 ≤ n ≤ 10^{18}, 1 ≤ k ≤ 10^{15}) — the number of dancers and the duration in seconds.
It is guaranteed that the number of different values of k in one test is not greater than 50.
Output
Print t lines. If the i-th option of the video is feasible, print "YES" (without quotes) in i-th line, otherwise print "NO" (without quotes).
Example
Input
3
7 7
3 8
5 6
Output
YES
NO
YES
Submitted Solution:
```
cases = int(input())
for case in range(cases):
a, b = input().split()
n = int(a)
k = int(b)
if((n%2==0) and (k%2==0)):
print('YES')
elif(n/k==1):
print('YES')
elif((n%2==1) and (k%2==0) and (k%3==0)):
print('YES')
elif(k%n==0):
print('YES')
elif(n%k==0):
print('YES')
else:
print('NO')
``` | instruction | 0 | 25,319 | 3 | 50,638 |
No | output | 1 | 25,319 | 3 | 50,639 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Surely you have seen insane videos by South Korean rapper PSY, such as "Gangnam Style", "Gentleman" and "Daddy". You might also hear that PSY has been recording video "Oppa Funcan Style" two years ago (unfortunately we couldn't find it on the internet). We will remind you what this hit looked like (you can find original description [here](http://acm.timus.ru/problem.aspx?space=1&num=2107&locale=en)):
On the ground there are n platforms, which are numbered with integers from 1 to n, on i-th platform there is a dancer with number i. Further, every second all the dancers standing on the platform with number i jump to the platform with the number f(i). The moving rule f is selected in advance and is not changed throughout the clip.
The duration of the clip was k seconds and the rule f was chosen in such a way that after k seconds all dancers were in their initial positions (i.e. the i-th dancer stood on the platform with the number i). That allowed to loop the clip and collect even more likes.
PSY knows that enhanced versions of old artworks become more and more popular every day. So he decided to release a remastered-version of his video.
In his case "enhanced version" means even more insanity, so the number of platforms can be up to 10^{18}! But the video director said that if some dancer stays on the same platform all the time, then the viewer will get bored and will turn off the video immediately. Therefore, for all x from 1 to n f(x) ≠ x must hold.
Big part of classic video's success was in that looping, so in the remastered version all dancers should return to their initial positions in the end of the clip as well.
PSY hasn't decided on the exact number of platforms and video duration yet, so he asks you to check if there is a good rule f for different options.
Input
In the first line of input there is one integer t (1 ≤ t ≤ 10^{4}) — the number of options for n and k to check.
In the next t lines the options are given: each option is described with two integers n and k (1 ≤ n ≤ 10^{18}, 1 ≤ k ≤ 10^{15}) — the number of dancers and the duration in seconds.
It is guaranteed that the number of different values of k in one test is not greater than 50.
Output
Print t lines. If the i-th option of the video is feasible, print "YES" (without quotes) in i-th line, otherwise print "NO" (without quotes).
Example
Input
3
7 7
3 8
5 6
Output
YES
NO
YES
Submitted Solution:
```
cases = int(input())
for case in range(cases):
a, b = input().split()
n = int(a)
k = int(b)
if((n%2==0) and (k%2==0)):
print('YES')
elif(n/k==1):
print('YES')
elif((n%2==1) and (k%2==0) and (k%3==0)):
print('YES')
else:
print('NO')
``` | instruction | 0 | 25,320 | 3 | 50,640 |
No | output | 1 | 25,320 | 3 | 50,641 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113 | instruction | 0 | 25,353 | 3 | 50,706 |
"Correct Solution:
```
t1, t2 = list(map(int, input().split()))
a1, a2 = list(map(int, input().split()))
b1, b2 = list(map(int, input().split()))
fin_gap = t1 * (a1 - b1) + t2 * (a2 - b2)
mid_gap = t1 * (a1 - b1)
if fin_gap == 0:
print("infinity")
else:
if mid_gap * fin_gap > 0:
print(0)
else:
mod = abs(mid_gap) % abs(fin_gap)
q = abs(mid_gap) // abs(fin_gap)
if mod == 0:
ans = q * 2
else:
ans = q * 2 + 1
print(ans)
``` | output | 1 | 25,353 | 3 | 50,707 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113 | instruction | 0 | 25,354 | 3 | 50,708 |
"Correct Solution:
```
import math
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
if A1 > B1:
F1, F2 = A1, A2
S1, S2 = B1, B2
else:
F1, F2 = B1, B2
S1, S2 = A1, A2
oi = F1 * T1 - S1 * T1
nuki = S2 * T2 - F2 * T2 - oi
if nuki == 0:
print("infinity")
elif nuki > 0:
enc = oi // nuki * 2
if oi % nuki != 0:
enc = enc + 1
print(enc)
else:
print(0)
``` | output | 1 | 25,354 | 3 | 50,709 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113 | instruction | 0 | 25,355 | 3 | 50,710 |
"Correct Solution:
```
import math
t1, t2, a1, a2, b1, b2 = [int(_) for _ in open(0).read().split()]
c1 = (b1 - a1) * t1
c2 = c1 + (b2 - a2) * t2
if c1 * c2 > 0:
print(0)
exit()
if c2 == 0:
print('infinity')
exit()
if c1 < 0:
c1 *= -1
c2 *= -1
ans = 2 * (c1 // (-c2)) + (c1 % c2 != 0)
print(ans)
``` | output | 1 | 25,355 | 3 | 50,711 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113 | instruction | 0 | 25,356 | 3 | 50,712 |
"Correct Solution:
```
t1,t2 = [int(i) for i in input().split()]
a1,a2 = [int(i) for i in input().split()]
b1,b2 = [int(i) for i in input().split()]
c1,c2 = (a1-b1)*t1,(a2-b2)*t2
if c1 < 0:
c1 *= -1
c2 *= -1
if c1 + c2 == 0:
print('infinity')
elif c1 + c2 > 0:
print(0)
else:
num = -c1 // (c1 + c2)
print(num * 2 if -c1 % (c1 + c2) == 0 else num * 2 + 1)
``` | output | 1 | 25,356 | 3 | 50,713 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113 | instruction | 0 | 25,357 | 3 | 50,714 |
"Correct Solution:
```
T1,T2 = map(int, input().split())
A1,A2 = map(int, input().split())
B1,B2 = map(int, input().split())
d1,d2 = (A1-B1)*T1,(A2-B2)*T2
if d1 < 0: d1,d2 = -d1,-d2
if d1+d2 == 0: print("infinity")
elif d1+d2>0: print(0)
elif d1 % (-(d1+d2)) == 0: print(d1//(-(d1+d2))*2)
else: print(d1//(-(d1+d2))*2+1)
``` | output | 1 | 25,357 | 3 | 50,715 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113 | instruction | 0 | 25,358 | 3 | 50,716 |
"Correct Solution:
```
def sumitb2019_f():
t1, t2 = map(int, input().split())
a1, a2 = map(int, input().split())
b1, b2 = map(int, input().split())
p = (a1 - b1) * t1
q = (a2 - b2) * t2
if p > 0:
p *= -1
q *= -1
if p + q < 0:
ans = 0
elif p + q == 0:
ans = 'infinity'
else:
s, t = divmod(-p, p + q)
if t == 0: ans = s * 2
else: ans = s * 2 + 1
print(ans)
if __name__ == '__main__':
sumitb2019_f()
``` | output | 1 | 25,358 | 3 | 50,717 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113 | instruction | 0 | 25,359 | 3 | 50,718 |
"Correct Solution:
```
import math
t1,t2 = map(int,input().split())
a1,a2 = map(int,input().split())
b1,b2 = map(int,input().split())
if a1*t1+a2*t2 == b1*t1+b2*t2:
print('infinity')
exit(0)
if (a1*t1 < b1*t1 and a1*t1+a2*t2 < b1*t1+b2*t2) or (a1*t1 > b1*t1 and a1*t1+a2*t2 > b1*t1+b2*t2):
print(0)
exit(0)
m = abs(a1*t1-b1*t1)
s = abs(a1*t1+a2*t2-b1*t1-b2*t2)
if m%s == 0:
print((m//s)*2)
else:
print((m//s)*2+1)
``` | output | 1 | 25,359 | 3 | 50,719 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113 | instruction | 0 | 25,360 | 3 | 50,720 |
"Correct Solution:
```
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
d1 = T1*(A1-B1)
d2 = T2*(A2-B2)
if d1>d2:
d1 *= -1
d2 *= -1
if (d1>0 and d1+d2>0) or (d1<0 and d1+d2<0):
print(0)
elif d1+d2==0:
print("infinity")
else:
v = (abs(d1)//(d1+d2))
ans = v*2
pos = d1+v*(d1+d2)
if pos<0 and pos+d2>=0:
ans += 1
print(ans)
``` | output | 1 | 25,360 | 3 | 50,721 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113
Submitted Solution:
```
t1, t2 = map(int, input().split())
a1,a2 = map(int, input().split())
b1, b2 = map(int, input().split())
#t1で生まれる差
P = (a1 - b1) * t1
#t2で生まれる差
Q = (a2 - b2) * t2
#P < 0 のことを仮定する
if P > 0:
P *= -1
Q *= -1
if P + Q < 0:
print(0)
elif P + Q == 0:
print("infinity")
else:
#つぎのPを足したときに、負にいくかどうか？
i = P * (-1)
if i % (P + Q) == 0:
print(2 * (i // (P + Q)))
else:
print(2 * (i // (P + Q)) + 1)
``` | instruction | 0 | 25,361 | 3 | 50,722 |
Yes | output | 1 | 25,361 | 3 | 50,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113
Submitted Solution:
```
T1, T2 = map(int, input().split())
A1, A2 = map(int, input().split())
B1, B2 = map(int, input().split())
taka = T1 * A1 + T2 * A2
aoki = T1 * B1 + T2 * B2
if taka == aoki:
print("infinity")
quit()
if taka > aoki:
taka, aoki = aoki, taka
A1, B1 = B1, A1
A2, B2 = B2, A2
if A1 < B1:
print(0)
quit()
if A1 == B2:
print(1)
quit()
first_diff = A1 * T1 - B1 * T1
diff = aoki - taka
print(first_diff // diff * 2 + (first_diff % diff != 0))
``` | instruction | 0 | 25,362 | 3 | 50,724 |
Yes | output | 1 | 25,362 | 3 | 50,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113
Submitted Solution:
```
t1,t2 = map(int,input().split())
a1,a2 = map(int,input().split())
b1,b2 = map(int,input().split())
a1 -= b1
a2 -= b2
if a1 < 0:
a1 *= -1
a2 *= -1
d = a1 * t1 + a2 * t2
if d > 0:
print(0)
elif d == 0:
print('infinity')
else:
d *= -1
l = a1 * t1
if l % d != 0:
print(l//d*2+1)
else:
print(l//d*2)
#print(a1,a2)
#print(d,l)
``` | instruction | 0 | 25,363 | 3 | 50,726 |
Yes | output | 1 | 25,363 | 3 | 50,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113
Submitted Solution:
```
import math
T1, T2 = map(int,input().split())
A1, A2 = map(int,input().split())
B1, B2 = map(int,input().split())
if A1*T1+A2*T2 == B1*T1+B2*T2:
print('infinity')
elif (A1-B1)*T1/((A1-B1)*T1+(A2-B2)*T2) > 0:
print(0)
else:
n = abs((A1-B1)*T1/((A1-B1)*T1+(A2-B2)*T2))
meet = math.ceil(n) + int(n)
print(meet)
``` | instruction | 0 | 25,364 | 3 | 50,728 |
Yes | output | 1 | 25,364 | 3 | 50,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113
Submitted Solution:
```
t1,t2 = map(int, input().split()))
a1,a2 = map(int, input().split()))
b1,b2 = map(int, input().split()))
x,y=(a1-b1)*t1 + (a2-b2)*t2, (a1-b1)*t1
if x == 0:
print("infinity")
elif x*y > 0:
print(0)
else:
s,t = divmod(abs(y), abs(x))
print(s*2+1 if t else 0)
``` | instruction | 0 | 25,365 | 3 | 50,730 |
No | output | 1 | 25,365 | 3 | 50,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113
Submitted Solution:
```
T1, T2 = list(map(int, input().split()))
A1, A2 = list(map(int, input().split()))
B1, B2 = list(map(int, input().split()))
L1 = T1 * (A1- B1)
L2 = L1 + T2 * (A2- B2)
if L1 * L2 > 0:
print(0)
elif L2 == 0:
print("infinity")
else:
M = (-L1) / L2
ans = 2 * M + 1
if float(int(M)) == M:
ans -= 1
print(ans)
``` | instruction | 0 | 25,366 | 3 | 50,732 |
No | output | 1 | 25,366 | 3 | 50,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113
Submitted Solution:
```
import math
t = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = [t[0]*a[0],t[1]*a[1]]
d = [t[0]*b[0],t[1]*b[1]]
if sum(c)==sum(d):
print('infinity')
exit()
elif c[0]==d[0]:
print('infinity')
exit()
if sum(d)>sum(c) and d[0]>c[0]:
print(0)
exit()
elif sum(c)>sum(d) and c[0]>d[0]:
print(0)
exit()
if sum(d)>sum(c):
if d[0]>c[0]:
print(0)
exit()
elif d[0]<c[0]:
n = (c[0]-d[0])/(sum(d)-sum(c))
if n==int(n):
print(2*n)
else:
print(2*math.ceil(n)-1)
elif sum(c)>sum(d):
if c[0]>d[0]:
print(0)
exit()
elif c[0]<d[0]:
n = (c[0]-d[0])/(sum(d)-sum(c))
if n==int(n):
print(2*n)
else:
print(2*math.ceil(n)-1)
``` | instruction | 0 | 25,367 | 3 | 50,734 |
No | output | 1 | 25,367 | 3 | 50,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki are training for long-distance races in an infinitely long straight course running from west to east.
They start simultaneously at the same point and moves as follows towards the east:
* Takahashi runs A_1 meters per minute for the first T_1 minutes, then runs at A_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
* Aoki runs B_1 meters per minute for the first T_1 minutes, then runs at B_2 meters per minute for the subsequent T_2 minutes, and alternates between these two modes forever.
How many times will Takahashi and Aoki meet each other, that is, come to the same point? We do not count the start of the run. If they meet infinitely many times, report that fact.
Constraints
* 1 \leq T_i \leq 100000
* 1 \leq A_i \leq 10^{10}
* 1 \leq B_i \leq 10^{10}
* A_1 \neq B_1
* A_2 \neq B_2
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
T_1 T_2
A_1 A_2
B_1 B_2
Output
Print the number of times Takahashi and Aoki will meet each other.
If they meet infinitely many times, print `infinity` instead.
Examples
Input
1 2
10 10
12 4
Output
1
Input
100 1
101 101
102 1
Output
infinity
Input
12000 15700
3390000000 3810000000
5550000000 2130000000
Output
113
Submitted Solution:
```
import sys
sys.setrecursionlimit(10 ** 9)
stdin = sys.stdin
ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip() # ignore trailing spaces
T1, T2 = rl()
A1, A2 = rl()
B1, B2 = rl()
if T1 * A1 + T2 * A2 == T1 * B1 + T2 * B2:
print('infinity')
exit()
if (A1 > B1 and A1 + A2 > B1 + B2) or (A1 < B1 and A1 + A2 < B1 + B2):
print(0)
exit()
diff = abs(A1-B1) * T1
diff2 = abs(T1 * A1 + T2 * A2 - (T1 * B1 + T2 * B2))
x, y = divmod(diff, diff2)
print(x * 2 if y == 0 else x * 2 + 1)
``` | instruction | 0 | 25,368 | 3 | 50,736 |
No | output | 1 | 25,368 | 3 | 50,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000
Submitted Solution:
```
x = int(input())
p = int(input())
print("%.016f\n" % ((((x+(x%2))/2)*100/p)))
``` | instruction | 0 | 25,463 | 3 | 50,926 |
Yes | output | 1 | 25,463 | 3 | 50,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000
Submitted Solution:
```
x = int(input())
p = int(input())
l = p / 100
def f(d):
return (d / 2) * 100 / p
if x % 2 == 0:
res = f(x)
else:
res = 1 + l * f(x - 1) + (1 - l) * f(x + 1)
print(res)
``` | instruction | 0 | 25,464 | 3 | 50,928 |
Yes | output | 1 | 25,464 | 3 | 50,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000
Submitted Solution:
```
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x;
double p;
cin >> x >> p;
if (x % 2) {
cout << setprecision(20) << (((double)x + 1) / 2) / p * 100 << endl;
} else {
cout << setprecision(20) << (((double)x) / 2) / p * 100 << endl;
}
}
``` | instruction | 0 | 25,466 | 3 | 50,932 |
No | output | 1 | 25,466 | 3 | 50,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000
Submitted Solution:
```
import sys
X = int(sys.stdin.readline())
P = int(sys.stdin.readline())
print((X+1)//2)
``` | instruction | 0 | 25,467 | 3 | 50,934 |
No | output | 1 | 25,467 | 3 | 50,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Aoki is in search of Takahashi, who is missing in a one-dimentional world. Initially, the coordinate of Aoki is 0, and the coordinate of Takahashi is known to be x, but his coordinate afterwards cannot be known to Aoki.
Time is divided into turns. In each turn, Aoki and Takahashi take the following actions simultaneously:
* Let the current coordinate of Aoki be a, then Aoki moves to a coordinate he selects from a-1, a and a+1.
* Let the current coordinate of Takahashi be b, then Takahashi moves to the coordinate b-1 with probability of p percent, and moves to the coordinate b+1 with probability of 100-p percent.
When the coordinates of Aoki and Takahashi coincide, Aoki can find Takahashi. When they pass by each other, Aoki cannot find Takahashi.
Aoki wants to minimize the expected number of turns taken until he finds Takahashi. Find the minimum possible expected number of turns.
Constraints
* 1 ≦ x ≦ 1,000,000,000
* 1 ≦ p ≦ 100
* x and p are integers.
Input
The input is given from Standard Input in the following format:
x
p
Output
Print the minimum possible expected number of turns. The output is considered correct if the absolute or relative error is at most 10^{-6}.
Examples
Input
3
100
Output
2.0000000
Input
6
40
Output
7.5000000
Input
101
80
Output
63.7500000
Submitted Solution:
```
sx = input()
sp = input()
x = int(sx)
p = int(sp)
ret = 0
e = 0
cnt = x % 2
if p == 100:
ret = int(x / 2) + cnt
print(ret)
``` | instruction | 0 | 25,468 | 3 | 50,936 |
No | output | 1 | 25,468 | 3 | 50,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Furik and Rubik love playing computer games. Furik has recently found a new game that greatly interested Rubik. The game consists of n parts and to complete each part a player may probably need to complete some other ones. We know that the game can be fully completed, that is, its parts do not form cyclic dependencies.
Rubik has 3 computers, on which he can play this game. All computers are located in different houses. Besides, it has turned out that each part of the game can be completed only on one of these computers. Let's number the computers with integers from 1 to 3. Rubik can perform the following actions:
* Complete some part of the game on some computer. Rubik spends exactly 1 hour on completing any part on any computer.
* Move from the 1-st computer to the 2-nd one. Rubik spends exactly 1 hour on that.
* Move from the 1-st computer to the 3-rd one. Rubik spends exactly 2 hours on that.
* Move from the 2-nd computer to the 1-st one. Rubik spends exactly 2 hours on that.
* Move from the 2-nd computer to the 3-rd one. Rubik spends exactly 1 hour on that.
* Move from the 3-rd computer to the 1-st one. Rubik spends exactly 1 hour on that.
* Move from the 3-rd computer to the 2-nd one. Rubik spends exactly 2 hours on that.
Help Rubik to find the minimum number of hours he will need to complete all parts of the game. Initially Rubik can be located at the computer he considers necessary.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of game parts. The next line contains n integers, the i-th integer — ci (1 ≤ ci ≤ 3) represents the number of the computer, on which you can complete the game part number i.
Next n lines contain descriptions of game parts. The i-th line first contains integer ki (0 ≤ ki ≤ n - 1), then ki distinct integers ai, j (1 ≤ ai, j ≤ n; ai, j ≠ i) — the numbers of parts to complete before part i.
Numbers on all lines are separated by single spaces. You can assume that the parts of the game are numbered from 1 to n in some way. It is guaranteed that there are no cyclic dependencies between the parts of the game.
Output
On a single line print the answer to the problem.
Examples
Input
1
1
0
Output
1
Input
5
2 2 1 1 3
1 5
2 5 1
2 5 4
1 5
0
Output
7
Note
Note to the second sample: before the beginning of the game the best strategy is to stand by the third computer. First we complete part 5. Then we go to the 1-st computer and complete parts 3 and 4. Then we go to the 2-nd computer and complete parts 1 and 2. In total we get 1+1+2+1+2, which equals 7 hours.
Submitted Solution:
```
problem = int(input())
count = 0
for problemset in range(0,problem):
solution = input()
if(solution.count('1') >= 2):
count = count + 1
print(count)
``` | instruction | 0 | 25,894 | 3 | 51,788 |
No | output | 1 | 25,894 | 3 | 51,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Furik and Rubik love playing computer games. Furik has recently found a new game that greatly interested Rubik. The game consists of n parts and to complete each part a player may probably need to complete some other ones. We know that the game can be fully completed, that is, its parts do not form cyclic dependencies.
Rubik has 3 computers, on which he can play this game. All computers are located in different houses. Besides, it has turned out that each part of the game can be completed only on one of these computers. Let's number the computers with integers from 1 to 3. Rubik can perform the following actions:
* Complete some part of the game on some computer. Rubik spends exactly 1 hour on completing any part on any computer.
* Move from the 1-st computer to the 2-nd one. Rubik spends exactly 1 hour on that.
* Move from the 1-st computer to the 3-rd one. Rubik spends exactly 2 hours on that.
* Move from the 2-nd computer to the 1-st one. Rubik spends exactly 2 hours on that.
* Move from the 2-nd computer to the 3-rd one. Rubik spends exactly 1 hour on that.
* Move from the 3-rd computer to the 1-st one. Rubik spends exactly 1 hour on that.
* Move from the 3-rd computer to the 2-nd one. Rubik spends exactly 2 hours on that.
Help Rubik to find the minimum number of hours he will need to complete all parts of the game. Initially Rubik can be located at the computer he considers necessary.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of game parts. The next line contains n integers, the i-th integer — ci (1 ≤ ci ≤ 3) represents the number of the computer, on which you can complete the game part number i.
Next n lines contain descriptions of game parts. The i-th line first contains integer ki (0 ≤ ki ≤ n - 1), then ki distinct integers ai, j (1 ≤ ai, j ≤ n; ai, j ≠ i) — the numbers of parts to complete before part i.
Numbers on all lines are separated by single spaces. You can assume that the parts of the game are numbered from 1 to n in some way. It is guaranteed that there are no cyclic dependencies between the parts of the game.
Output
On a single line print the answer to the problem.
Examples
Input
1
1
0
Output
1
Input
5
2 2 1 1 3
1 5
2 5 1
2 5 4
1 5
0
Output
7
Note
Note to the second sample: before the beginning of the game the best strategy is to stand by the third computer. First we complete part 5. Then we go to the 1-st computer and complete parts 3 and 4. Then we go to the 2-nd computer and complete parts 1 and 2. In total we get 1+1+2+1+2, which equals 7 hours.
Submitted Solution:
```
n=int(input())
ans=0
while(n>0):
c=0
a=list(map(int,input().strip().split()))[:3]
if(a.count(1)>=2):
ans+=1
n-=1
print(ans)
``` | instruction | 0 | 25,895 | 3 | 51,790 |
No | output | 1 | 25,895 | 3 | 51,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Furik and Rubik love playing computer games. Furik has recently found a new game that greatly interested Rubik. The game consists of n parts and to complete each part a player may probably need to complete some other ones. We know that the game can be fully completed, that is, its parts do not form cyclic dependencies.
Rubik has 3 computers, on which he can play this game. All computers are located in different houses. Besides, it has turned out that each part of the game can be completed only on one of these computers. Let's number the computers with integers from 1 to 3. Rubik can perform the following actions:
* Complete some part of the game on some computer. Rubik spends exactly 1 hour on completing any part on any computer.
* Move from the 1-st computer to the 2-nd one. Rubik spends exactly 1 hour on that.
* Move from the 1-st computer to the 3-rd one. Rubik spends exactly 2 hours on that.
* Move from the 2-nd computer to the 1-st one. Rubik spends exactly 2 hours on that.
* Move from the 2-nd computer to the 3-rd one. Rubik spends exactly 1 hour on that.
* Move from the 3-rd computer to the 1-st one. Rubik spends exactly 1 hour on that.
* Move from the 3-rd computer to the 2-nd one. Rubik spends exactly 2 hours on that.
Help Rubik to find the minimum number of hours he will need to complete all parts of the game. Initially Rubik can be located at the computer he considers necessary.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of game parts. The next line contains n integers, the i-th integer — ci (1 ≤ ci ≤ 3) represents the number of the computer, on which you can complete the game part number i.
Next n lines contain descriptions of game parts. The i-th line first contains integer ki (0 ≤ ki ≤ n - 1), then ki distinct integers ai, j (1 ≤ ai, j ≤ n; ai, j ≠ i) — the numbers of parts to complete before part i.
Numbers on all lines are separated by single spaces. You can assume that the parts of the game are numbered from 1 to n in some way. It is guaranteed that there are no cyclic dependencies between the parts of the game.
Output
On a single line print the answer to the problem.
Examples
Input
1
1
0
Output
1
Input
5
2 2 1 1 3
1 5
2 5 1
2 5 4
1 5
0
Output
7
Note
Note to the second sample: before the beginning of the game the best strategy is to stand by the third computer. First we complete part 5. Then we go to the 1-st computer and complete parts 3 and 4. Then we go to the 2-nd computer and complete parts 1 and 2. In total we get 1+1+2+1+2, which equals 7 hours.
Submitted Solution:
```
n=int(input())
count=0
for i in range(0,n):
x=input()
if x.count('1') >=2:
count+=1
print(count)
``` | instruction | 0 | 25,896 | 3 | 51,792 |
No | output | 1 | 25,896 | 3 | 51,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Furik and Rubik love playing computer games. Furik has recently found a new game that greatly interested Rubik. The game consists of n parts and to complete each part a player may probably need to complete some other ones. We know that the game can be fully completed, that is, its parts do not form cyclic dependencies.
Rubik has 3 computers, on which he can play this game. All computers are located in different houses. Besides, it has turned out that each part of the game can be completed only on one of these computers. Let's number the computers with integers from 1 to 3. Rubik can perform the following actions:
* Complete some part of the game on some computer. Rubik spends exactly 1 hour on completing any part on any computer.
* Move from the 1-st computer to the 2-nd one. Rubik spends exactly 1 hour on that.
* Move from the 1-st computer to the 3-rd one. Rubik spends exactly 2 hours on that.
* Move from the 2-nd computer to the 1-st one. Rubik spends exactly 2 hours on that.
* Move from the 2-nd computer to the 3-rd one. Rubik spends exactly 1 hour on that.
* Move from the 3-rd computer to the 1-st one. Rubik spends exactly 1 hour on that.
* Move from the 3-rd computer to the 2-nd one. Rubik spends exactly 2 hours on that.
Help Rubik to find the minimum number of hours he will need to complete all parts of the game. Initially Rubik can be located at the computer he considers necessary.
Input
The first line contains integer n (1 ≤ n ≤ 200) — the number of game parts. The next line contains n integers, the i-th integer — ci (1 ≤ ci ≤ 3) represents the number of the computer, on which you can complete the game part number i.
Next n lines contain descriptions of game parts. The i-th line first contains integer ki (0 ≤ ki ≤ n - 1), then ki distinct integers ai, j (1 ≤ ai, j ≤ n; ai, j ≠ i) — the numbers of parts to complete before part i.
Numbers on all lines are separated by single spaces. You can assume that the parts of the game are numbered from 1 to n in some way. It is guaranteed that there are no cyclic dependencies between the parts of the game.
Output
On a single line print the answer to the problem.
Examples
Input
1
1
0
Output
1
Input
5
2 2 1 1 3
1 5
2 5 1
2 5 4
1 5
0
Output
7
Note
Note to the second sample: before the beginning of the game the best strategy is to stand by the third computer. First we complete part 5. Then we go to the 1-st computer and complete parts 3 and 4. Then we go to the 2-nd computer and complete parts 1 and 2. In total we get 1+1+2+1+2, which equals 7 hours.
Submitted Solution:
```
num = result= 0
for x in range(int(input())):
if input().count('1') > 1:
num += 1
print(num)
``` | instruction | 0 | 25,897 | 3 | 51,794 |
No | output | 1 | 25,897 | 3 | 51,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ralph is going to collect mushrooms in the Mushroom Forest.
There are m directed paths connecting n trees in the Mushroom Forest. On each path grow some mushrooms. When Ralph passes a path, he collects all the mushrooms on the path. The Mushroom Forest has a magical fertile ground where mushrooms grow at a fantastic speed. New mushrooms regrow as soon as Ralph finishes mushroom collection on a path. More specifically, after Ralph passes a path the i-th time, there regrow i mushrooms less than there was before this pass. That is, if there is initially x mushrooms on a path, then Ralph will collect x mushrooms for the first time, x - 1 mushrooms the second time, x - 1 - 2 mushrooms the third time, and so on. However, the number of mushrooms can never be less than 0.
For example, let there be 9 mushrooms on a path initially. The number of mushrooms that can be collected from the path is 9, 8, 6 and 3 when Ralph passes by from first to fourth time. From the fifth time and later Ralph can't collect any mushrooms from the path (but still can pass it).
Ralph decided to start from the tree s. How many mushrooms can he collect using only described paths?
Input
The first line contains two integers n and m (1 ≤ n ≤ 106, 0 ≤ m ≤ 106), representing the number of trees and the number of directed paths in the Mushroom Forest, respectively.
Each of the following m lines contains three integers x, y and w (1 ≤ x, y ≤ n, 0 ≤ w ≤ 108), denoting a path that leads from tree x to tree y with w mushrooms initially. There can be paths that lead from a tree to itself, and multiple paths between the same pair of trees.
The last line contains a single integer s (1 ≤ s ≤ n) — the starting position of Ralph.
Output
Print an integer denoting the maximum number of the mushrooms Ralph can collect during his route.
Examples
Input
2 2
1 2 4
2 1 4
1
Output
16
Input
3 3
1 2 4
2 3 3
1 3 8
1
Output
8
Note
In the first sample Ralph can pass three times on the circle and collect 4 + 4 + 3 + 3 + 1 + 1 = 16 mushrooms. After that there will be no mushrooms for Ralph to collect.
In the second sample, Ralph can go to tree 3 and collect 8 mushrooms on the path from tree 1 to tree 3.
Submitted Solution:
```
m = list(map(int, input().split()))[1]
a = list()
b = 0
i = 0
for i in range(m): a.append(list(map(int, input().split()))[2])
input()
while (sum(a) > 0):
i += 1
b += sum(a)
for j in range(len(a)): a[j] -= i
for j in a:
if (j < 1): a.remove(j)
print(b)
``` | instruction | 0 | 26,186 | 3 | 52,372 |
No | output | 1 | 26,186 | 3 | 52,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima has a hamsters farm. Soon N hamsters will grow up on it and Dima will sell them in a city nearby.
Hamsters should be transported in boxes. If some box is not completely full, the hamsters in it are bored, that's why each box should be completely full with hamsters.
Dima can buy boxes at a factory. The factory produces boxes of K kinds, boxes of the i-th kind can contain in themselves ai hamsters. Dima can buy any amount of boxes, but he should buy boxes of only one kind to get a wholesale discount.
Of course, Dima would buy boxes in such a way that each box can be completely filled with hamsters and transported to the city. If there is no place for some hamsters, Dima will leave them on the farm.
Find out how many boxes and of which type should Dima buy to transport maximum number of hamsters.
Input
The first line contains two integers N and K (0 ≤ N ≤ 1018, 1 ≤ K ≤ 105) — the number of hamsters that will grow up on Dima's farm and the number of types of boxes that the factory produces.
The second line contains K integers a1, a2, ..., aK (1 ≤ ai ≤ 1018 for all i) — the capacities of boxes.
Output
Output two integers: the type of boxes that Dima should buy and the number of boxes of that type Dima should buy. Types of boxes are numbered from 1 to K in the order they are given in input.
If there are many correct answers, output any of them.
Examples
Input
19 3
5 4 10
Output
2 4
Input
28 3
5 6 30
Output
1 5
Submitted Solution:
```
n,k=map(int,input().split())
l=list(map(int,input().split()))
temp=n+1
for i in l:
if(n%i<temp):
temp=n%i
ind=l.index(i)
ans=n//i
print(ind+1, ans)
``` | instruction | 0 | 26,211 | 3 | 52,422 |
Yes | output | 1 | 26,211 | 3 | 52,423 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima has a hamsters farm. Soon N hamsters will grow up on it and Dima will sell them in a city nearby.
Hamsters should be transported in boxes. If some box is not completely full, the hamsters in it are bored, that's why each box should be completely full with hamsters.
Dima can buy boxes at a factory. The factory produces boxes of K kinds, boxes of the i-th kind can contain in themselves ai hamsters. Dima can buy any amount of boxes, but he should buy boxes of only one kind to get a wholesale discount.
Of course, Dima would buy boxes in such a way that each box can be completely filled with hamsters and transported to the city. If there is no place for some hamsters, Dima will leave them on the farm.
Find out how many boxes and of which type should Dima buy to transport maximum number of hamsters.
Input
The first line contains two integers N and K (0 ≤ N ≤ 1018, 1 ≤ K ≤ 105) — the number of hamsters that will grow up on Dima's farm and the number of types of boxes that the factory produces.
The second line contains K integers a1, a2, ..., aK (1 ≤ ai ≤ 1018 for all i) — the capacities of boxes.
Output
Output two integers: the type of boxes that Dima should buy and the number of boxes of that type Dima should buy. Types of boxes are numbered from 1 to K in the order they are given in input.
If there are many correct answers, output any of them.
Examples
Input
19 3
5 4 10
Output
2 4
Input
28 3
5 6 30
Output
1 5
Submitted Solution:
```
n, k = list(map(int, input().split()))
b = list(map(int, input().split()))
c = [n % x for x in b]
c = c.index(min(c)) + 1
print(c, n // b[c - 1])
``` | instruction | 0 | 26,213 | 3 | 52,426 |
Yes | output | 1 | 26,213 | 3 | 52,427 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima has a hamsters farm. Soon N hamsters will grow up on it and Dima will sell them in a city nearby.
Hamsters should be transported in boxes. If some box is not completely full, the hamsters in it are bored, that's why each box should be completely full with hamsters.
Dima can buy boxes at a factory. The factory produces boxes of K kinds, boxes of the i-th kind can contain in themselves ai hamsters. Dima can buy any amount of boxes, but he should buy boxes of only one kind to get a wholesale discount.
Of course, Dima would buy boxes in such a way that each box can be completely filled with hamsters and transported to the city. If there is no place for some hamsters, Dima will leave them on the farm.
Find out how many boxes and of which type should Dima buy to transport maximum number of hamsters.
Input
The first line contains two integers N and K (0 ≤ N ≤ 1018, 1 ≤ K ≤ 105) — the number of hamsters that will grow up on Dima's farm and the number of types of boxes that the factory produces.
The second line contains K integers a1, a2, ..., aK (1 ≤ ai ≤ 1018 for all i) — the capacities of boxes.
Output
Output two integers: the type of boxes that Dima should buy and the number of boxes of that type Dima should buy. Types of boxes are numbered from 1 to K in the order they are given in input.
If there are many correct answers, output any of them.
Examples
Input
19 3
5 4 10
Output
2 4
Input
28 3
5 6 30
Output
1 5
Submitted Solution:
```
n , k = map ( int , input (). split ())
l = list ( map ( int , input (). split ()))
m = []
if(n==0):
print(1,0)
else:
for i in l :
m . append ( n % i )
a = min ( m )
b = m . index ( a )
print ( b + 1 , l [ b ])
``` | instruction | 0 | 26,215 | 3 | 52,430 |
No | output | 1 | 26,215 | 3 | 52,431 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima has a hamsters farm. Soon N hamsters will grow up on it and Dima will sell them in a city nearby.
Hamsters should be transported in boxes. If some box is not completely full, the hamsters in it are bored, that's why each box should be completely full with hamsters.
Dima can buy boxes at a factory. The factory produces boxes of K kinds, boxes of the i-th kind can contain in themselves ai hamsters. Dima can buy any amount of boxes, but he should buy boxes of only one kind to get a wholesale discount.
Of course, Dima would buy boxes in such a way that each box can be completely filled with hamsters and transported to the city. If there is no place for some hamsters, Dima will leave them on the farm.
Find out how many boxes and of which type should Dima buy to transport maximum number of hamsters.
Input
The first line contains two integers N and K (0 ≤ N ≤ 1018, 1 ≤ K ≤ 105) — the number of hamsters that will grow up on Dima's farm and the number of types of boxes that the factory produces.
The second line contains K integers a1, a2, ..., aK (1 ≤ ai ≤ 1018 for all i) — the capacities of boxes.
Output
Output two integers: the type of boxes that Dima should buy and the number of boxes of that type Dima should buy. Types of boxes are numbered from 1 to K in the order they are given in input.
If there are many correct answers, output any of them.
Examples
Input
19 3
5 4 10
Output
2 4
Input
28 3
5 6 30
Output
1 5
Submitted Solution:
```
a,b=input().split()
s=input()
a=int(a);b=int(b)
m=0
v=[]
v=s.split()
if a!=0:
for i in range(b):
v[i]=int(v[i])
if m<a//v[i]:
m=a//v[i]
mind=i+1
print(mind,m)
``` | instruction | 0 | 26,216 | 3 | 52,432 |
No | output | 1 | 26,216 | 3 | 52,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dima has a hamsters farm. Soon N hamsters will grow up on it and Dima will sell them in a city nearby.
Hamsters should be transported in boxes. If some box is not completely full, the hamsters in it are bored, that's why each box should be completely full with hamsters.
Dima can buy boxes at a factory. The factory produces boxes of K kinds, boxes of the i-th kind can contain in themselves ai hamsters. Dima can buy any amount of boxes, but he should buy boxes of only one kind to get a wholesale discount.
Of course, Dima would buy boxes in such a way that each box can be completely filled with hamsters and transported to the city. If there is no place for some hamsters, Dima will leave them on the farm.
Find out how many boxes and of which type should Dima buy to transport maximum number of hamsters.
Input
The first line contains two integers N and K (0 ≤ N ≤ 1018, 1 ≤ K ≤ 105) — the number of hamsters that will grow up on Dima's farm and the number of types of boxes that the factory produces.
The second line contains K integers a1, a2, ..., aK (1 ≤ ai ≤ 1018 for all i) — the capacities of boxes.
Output
Output two integers: the type of boxes that Dima should buy and the number of boxes of that type Dima should buy. Types of boxes are numbered from 1 to K in the order they are given in input.
If there are many correct answers, output any of them.
Examples
Input
19 3
5 4 10
Output
2 4
Input
28 3
5 6 30
Output
1 5
Submitted Solution:
```
l = list(map(lambda x: int(x), input().split(' ')))
n, k = l[0], l[1]
boxes = list(map(lambda x: int(x), input().split(' ')))
m = 0
box = -1
for i, b in enumerate(boxes):
v = n / b
if v > m:
m = v
box = i
print(str(box + 1) + ' ' + str(m))
``` | instruction | 0 | 26,217 | 3 | 52,434 |
No | output | 1 | 26,217 | 3 | 52,435 |
Provide a correct Python 3 solution for this coding contest problem.
problem
To the west of the Australian continent is the wide Indian Ocean. Marine researcher JOI is studying the properties of N species of fish in the Indian Ocean.
For each type of fish, a rectangular parallelepiped habitat range is determined in the sea. Fish can move anywhere in their habitat, including boundaries, but never leave their habitat. A point in the sea is represented by three real numbers (x, y, d): (x, y, d) is x to the east and y to the north with respect to a point when viewed from above. It is an advanced position and represents a point whose depth from the sea surface is d. However, the sea level is assumed to be flat.
Mr. JOI wants to know how many places the habitat range of K or more kinds of fish overlaps. Create a program to find the volume of the entire such place.
input
The input consists of 1 + N lines.
On the first line, two integers N and K (1 ≤ K ≤ N ≤ 50) are written with a blank as a delimiter. This means that there are N types of fish, and we want to find the volume of the place where the habitat ranges of K or more types of fish overlap.
In the i-th line (1 ≤ i ≤ N) of the following N lines, there are 6 integers Xi, 1, Yi, 1, Di, 1, Xi, 2, Yi, 2, Di, 2 (0 ≤ Xi, 1 <Xi, 2 ≤ 1000000 (= 106), 0 ≤ Yi, 1 <Yi, 2 ≤ 1000000 (= 106), 0 ≤ Di, 1 <Di, 2 ≤ 1000000 (= 106)) are written. This is because the habitat range of the i-type fish is 8 points (Xi, 1, Yi, 1, Di, 1), (Xi, 2, Yi, 1, Di, 1), (Xi, 2, Yi, 2, Di, 1), (Xi, 1, Yi, 2, Di, 1), (Xi, 1, Yi, 1, Di, 2), (Xi, 2, Yi, 1, Di, 2), (Xi, 2, Yi, 2, Di, 2), (Xi, 1, Yi, 2, Di, 2) represents a rectangular parallelepiped with vertices as vertices.
output
Output the volume of the entire area where the habitats of K or more kinds of fish overlap in one line.
Input / output example
Input example 1
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output example 1
49000
In input / output example 1, for example, the point (45, 65, 65) is the habitat range of the first type of fish and the third type of fish, so it is a place that satisfies the condition. On the other hand, points (25, 35, 45) are not the places that satisfy the conditions because they are the habitat range of only the second kind of fish. The habitat range of fish is as shown in the figure below. Point O represents a reference point on sea level.
<image>
Input example 2
1 1
0 0 0 1000000 1000000 1000000
Output example 2
1000000000000000000
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output
49000 | instruction | 0 | 26,425 | 3 | 52,850 |
"Correct Solution:
```
def main():
n, k = map(int, input().split())
plst = []
xlst = []
ylst = []
dlst = []
for i in range(n):
x1,y1,d1,x2,y2,d2 = map(int, input().split())
plst.append((x1,y1,d1,x2,y2,d2))
xlst.append(x1)
xlst.append(x2)
ylst.append(y1)
ylst.append(y2)
dlst.append(d1)
dlst.append(d2)
xlst = list(set(xlst))
ylst = list(set(ylst))
dlst = list(set(dlst))
xlst.sort()
ylst.sort()
dlst.sort()
lx = len(xlst)
ly = len(ylst)
ld = len(dlst)
xdic = {}
ydic = {}
ddic = {}
for i, v in enumerate(xlst):
xdic[v] = i
for i, v in enumerate(ylst):
ydic[v] = i
for i, v in enumerate(dlst):
ddic[v] = i
new_map = [[[0] * ld for _ in range(ly)] for _ in range(lx)]
for p in plst:
x1, y1, d1, x2, y2, d2 = p
x1, y1, d1, x2, y2, d2 = xdic[x1], ydic[y1], ddic[d1], xdic[x2], ydic[y2], ddic[d2]
for x in range(x1, x2):
for y in range(y1, y2):
for d in range(d1, d2):
new_map[x][y][d] += 1
ans = 0
for i in range(lx - 1):
xlsti = xlst[i]
xlsti1 = xlst[i + 1]
x = xdic[xlsti]
for j in range(ly - 1):
ylstj = ylst[j]
ylstj1 = ylst[j + 1]
y = ydic[ylstj]
for z in range(ld - 1):
dlstz = dlst[z]
dlstz1 = dlst[z + 1]
d = ddic[dlstz]
if new_map[x][y][d] >= k:
ans += (xlsti1 - xlsti) * (ylstj1 - ylstj) * (dlstz1 - dlstz)
print(ans)
main()
``` | output | 1 | 26,425 | 3 | 52,851 |
Provide a correct Python 3 solution for this coding contest problem.
problem
To the west of the Australian continent is the wide Indian Ocean. Marine researcher JOI is studying the properties of N species of fish in the Indian Ocean.
For each type of fish, a rectangular parallelepiped habitat range is determined in the sea. Fish can move anywhere in their habitat, including boundaries, but never leave their habitat. A point in the sea is represented by three real numbers (x, y, d): (x, y, d) is x to the east and y to the north with respect to a point when viewed from above. It is an advanced position and represents a point whose depth from the sea surface is d. However, the sea level is assumed to be flat.
Mr. JOI wants to know how many places the habitat range of K or more kinds of fish overlaps. Create a program to find the volume of the entire such place.
input
The input consists of 1 + N lines.
On the first line, two integers N and K (1 ≤ K ≤ N ≤ 50) are written with a blank as a delimiter. This means that there are N types of fish, and we want to find the volume of the place where the habitat ranges of K or more types of fish overlap.
In the i-th line (1 ≤ i ≤ N) of the following N lines, there are 6 integers Xi, 1, Yi, 1, Di, 1, Xi, 2, Yi, 2, Di, 2 (0 ≤ Xi, 1 <Xi, 2 ≤ 1000000 (= 106), 0 ≤ Yi, 1 <Yi, 2 ≤ 1000000 (= 106), 0 ≤ Di, 1 <Di, 2 ≤ 1000000 (= 106)) are written. This is because the habitat range of the i-type fish is 8 points (Xi, 1, Yi, 1, Di, 1), (Xi, 2, Yi, 1, Di, 1), (Xi, 2, Yi, 2, Di, 1), (Xi, 1, Yi, 2, Di, 1), (Xi, 1, Yi, 1, Di, 2), (Xi, 2, Yi, 1, Di, 2), (Xi, 2, Yi, 2, Di, 2), (Xi, 1, Yi, 2, Di, 2) represents a rectangular parallelepiped with vertices as vertices.
output
Output the volume of the entire area where the habitats of K or more kinds of fish overlap in one line.
Input / output example
Input example 1
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output example 1
49000
In input / output example 1, for example, the point (45, 65, 65) is the habitat range of the first type of fish and the third type of fish, so it is a place that satisfies the condition. On the other hand, points (25, 35, 45) are not the places that satisfy the conditions because they are the habitat range of only the second kind of fish. The habitat range of fish is as shown in the figure below. Point O represents a reference point on sea level.
<image>
Input example 2
1 1
0 0 0 1000000 1000000 1000000
Output example 2
1000000000000000000
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output
49000 | instruction | 0 | 26,426 | 3 | 52,852 |
"Correct Solution:
```
def main():
n, k = map(int, input().split())
plst = []
xlst = []
ylst = []
dlst = []
for i in range(n):
x1,y1,d1,x2,y2,d2 = map(int, input().split())
plst.append((x1,y1,d1,x2,y2,d2))
xlst.append(x1)
xlst.append(x2)
ylst.append(y1)
ylst.append(y2)
dlst.append(d1)
dlst.append(d2)
xlst = list(set(xlst))
ylst = list(set(ylst))
dlst = list(set(dlst))
xlst.sort()
ylst.sort()
dlst.sort()
xdic = {}
ydic = {}
ddic = {}
for i, v in enumerate(xlst):
xdic[v] = i
for i, v in enumerate(ylst):
ydic[v] = i
for i, v in enumerate(dlst):
ddic[v] = i
new_map = [[[0] * len(dlst) for _ in ylst] for _ in xlst]
for p in plst:
x1, y1, d1, x2, y2, d2 = p
x1, y1, d1, x2, y2, d2 = xdic[x1], ydic[y1], ddic[d1], xdic[x2], ydic[y2], ddic[d2]
for x in range(x1, x2):
for y in range(y1, y2):
for d in range(d1, d2):
new_map[x][y][d] += 1
ans = 0
for i in range(len(xlst) - 1):
xlsti = xlst[i]
xlsti1 = xlst[i + 1]
x = xdic[xlsti]
for j in range(len(ylst) - 1):
ylstj = ylst[j]
ylstj1 = ylst[j + 1]
y = ydic[ylstj]
for z in range(len(dlst) - 1):
dlstz = dlst[z]
dlstz1 = dlst[z + 1]
d = ddic[dlstz]
if new_map[x][y][d] >= k:
ans += (xlsti1 - xlsti) * (ylstj1 - ylstj) * (dlstz1 - dlstz)
print(ans)
main()
``` | output | 1 | 26,426 | 3 | 52,853 |
Provide a correct Python 3 solution for this coding contest problem.
problem
To the west of the Australian continent is the wide Indian Ocean. Marine researcher JOI is studying the properties of N species of fish in the Indian Ocean.
For each type of fish, a rectangular parallelepiped habitat range is determined in the sea. Fish can move anywhere in their habitat, including boundaries, but never leave their habitat. A point in the sea is represented by three real numbers (x, y, d): (x, y, d) is x to the east and y to the north with respect to a point when viewed from above. It is an advanced position and represents a point whose depth from the sea surface is d. However, the sea level is assumed to be flat.
Mr. JOI wants to know how many places the habitat range of K or more kinds of fish overlaps. Create a program to find the volume of the entire such place.
input
The input consists of 1 + N lines.
On the first line, two integers N and K (1 ≤ K ≤ N ≤ 50) are written with a blank as a delimiter. This means that there are N types of fish, and we want to find the volume of the place where the habitat ranges of K or more types of fish overlap.
In the i-th line (1 ≤ i ≤ N) of the following N lines, there are 6 integers Xi, 1, Yi, 1, Di, 1, Xi, 2, Yi, 2, Di, 2 (0 ≤ Xi, 1 <Xi, 2 ≤ 1000000 (= 106), 0 ≤ Yi, 1 <Yi, 2 ≤ 1000000 (= 106), 0 ≤ Di, 1 <Di, 2 ≤ 1000000 (= 106)) are written. This is because the habitat range of the i-type fish is 8 points (Xi, 1, Yi, 1, Di, 1), (Xi, 2, Yi, 1, Di, 1), (Xi, 2, Yi, 2, Di, 1), (Xi, 1, Yi, 2, Di, 1), (Xi, 1, Yi, 1, Di, 2), (Xi, 2, Yi, 1, Di, 2), (Xi, 2, Yi, 2, Di, 2), (Xi, 1, Yi, 2, Di, 2) represents a rectangular parallelepiped with vertices as vertices.
output
Output the volume of the entire area where the habitats of K or more kinds of fish overlap in one line.
Input / output example
Input example 1
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output example 1
49000
In input / output example 1, for example, the point (45, 65, 65) is the habitat range of the first type of fish and the third type of fish, so it is a place that satisfies the condition. On the other hand, points (25, 35, 45) are not the places that satisfy the conditions because they are the habitat range of only the second kind of fish. The habitat range of fish is as shown in the figure below. Point O represents a reference point on sea level.
<image>
Input example 2
1 1
0 0 0 1000000 1000000 1000000
Output example 2
1000000000000000000
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output
49000 | instruction | 0 | 26,427 | 3 | 52,854 |
"Correct Solution:
```
# copy
n, k = map(int, input().split())
plst = []
xlst = []
ylst = []
dlst = []
for _ in range(n):
x1, y1, d1, x2, y2, d2 = map(int, input().split())
plst.append((x1, y1, d1, x2, y2, d2))
xlst.append(x1)
xlst.append(x2)
ylst.append(y1)
ylst.append(y2)
dlst.append(d1)
dlst.append(d2)
xlst = list(set(xlst))
ylst = list(set(ylst))
dlst = list(set(dlst))
xlst.sort()
ylst.sort()
dlst.sort()
lx = len(xlst)
ly = len(ylst)
ld = len(dlst)
xdic = dict(reversed(t) for t in enumerate(xlst))
ydic = dict(reversed(t) for t in enumerate(ylst))
ddic = dict(reversed(t) for t in enumerate(dlst))
new_map = [[[0] * ld for _ in range(ly)] for _ in range(lx)]
for p in plst:
x1, y1, d1, x2, y2, d2 = p
x1, y1, d1, x2, y2, d2 = \
xdic[x1], ydic[y1], ddic[d1], xdic[x2], ydic[y2], ddic[d2]
for x in range(x1, x2):
for y in range(y1, y2):
for d in range(d1, d2):
new_map[x][y][d] += 1
ans = 0
for i in range(lx - 1):
xlsti = xlst[i]
xlsti1 = xlst[i + 1]
x = xdic[xlsti]
for j in range(ly - 1):
ylstj = ylst[j]
ylstj1 = ylst[j + 1]
y = ydic[ylstj]
for z in range(ld - 1):
dlstz = dlst[z]
dlstz1 = dlst[z + 1]
d = ddic[dlstz]
if new_map[x][y][d] >= k:
ans += (xlsti1 - xlsti) * (ylstj1 - ylstj) * (dlstz1 - dlstz)
print(ans)
``` | output | 1 | 26,427 | 3 | 52,855 |
Provide a correct Python 3 solution for this coding contest problem.
problem
To the west of the Australian continent is the wide Indian Ocean. Marine researcher JOI is studying the properties of N species of fish in the Indian Ocean.
For each type of fish, a rectangular parallelepiped habitat range is determined in the sea. Fish can move anywhere in their habitat, including boundaries, but never leave their habitat. A point in the sea is represented by three real numbers (x, y, d): (x, y, d) is x to the east and y to the north with respect to a point when viewed from above. It is an advanced position and represents a point whose depth from the sea surface is d. However, the sea level is assumed to be flat.
Mr. JOI wants to know how many places the habitat range of K or more kinds of fish overlaps. Create a program to find the volume of the entire such place.
input
The input consists of 1 + N lines.
On the first line, two integers N and K (1 ≤ K ≤ N ≤ 50) are written with a blank as a delimiter. This means that there are N types of fish, and we want to find the volume of the place where the habitat ranges of K or more types of fish overlap.
In the i-th line (1 ≤ i ≤ N) of the following N lines, there are 6 integers Xi, 1, Yi, 1, Di, 1, Xi, 2, Yi, 2, Di, 2 (0 ≤ Xi, 1 <Xi, 2 ≤ 1000000 (= 106), 0 ≤ Yi, 1 <Yi, 2 ≤ 1000000 (= 106), 0 ≤ Di, 1 <Di, 2 ≤ 1000000 (= 106)) are written. This is because the habitat range of the i-type fish is 8 points (Xi, 1, Yi, 1, Di, 1), (Xi, 2, Yi, 1, Di, 1), (Xi, 2, Yi, 2, Di, 1), (Xi, 1, Yi, 2, Di, 1), (Xi, 1, Yi, 1, Di, 2), (Xi, 2, Yi, 1, Di, 2), (Xi, 2, Yi, 2, Di, 2), (Xi, 1, Yi, 2, Di, 2) represents a rectangular parallelepiped with vertices as vertices.
output
Output the volume of the entire area where the habitats of K or more kinds of fish overlap in one line.
Input / output example
Input example 1
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output example 1
49000
In input / output example 1, for example, the point (45, 65, 65) is the habitat range of the first type of fish and the third type of fish, so it is a place that satisfies the condition. On the other hand, points (25, 35, 45) are not the places that satisfy the conditions because they are the habitat range of only the second kind of fish. The habitat range of fish is as shown in the figure below. Point O represents a reference point on sea level.
<image>
Input example 2
1 1
0 0 0 1000000 1000000 1000000
Output example 2
1000000000000000000
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output
49000 | instruction | 0 | 26,428 | 3 | 52,856 |
"Correct Solution:
```
import itertools
def main():
input_lines = []
input_lines.append(input())
N, K = [int(x) for x in input_lines[0].split(' ')]
for i in range(N):
input_lines.append(input())
grid = [set() for i in range(3)]
data = []
for line in input_lines[1:]:
x1, y1, d1, x2, y2, d2 = [int(x) for x in line.split(' ')]
data.append((x1, y1, d1, x2, y2, d2))
grid[0].add(x1)
grid[0].add(x2)
grid[1].add(y1)
grid[1].add(y2)
grid[2].add(d1)
grid[2].add(d2)
grid = [sorted(g) for g in grid]
grid_index = [{x[1]:x[0] for x in enumerate(g)} for g in grid]
grid_len = [len(g) for g in grid]
fish_dist = [[[0 for i in range(grid_len[2])] for i in range(grid_len[1])] for i in range(grid_len[0])]
for x1, y1, d1, x2, y2, d2 in data:
x1_index = grid_index[0][x1]
x2_index = grid_index[0][x2]
y1_index = grid_index[1][y1]
y2_index = grid_index[1][y2]
d1_index = grid_index[2][d1]
d2_index = grid_index[2][d2]
for x_index, y_index, d_index in itertools.product( range(x1_index, x2_index), range(y1_index, y2_index), range(d1_index, d2_index) ):
fish_dist[x_index][y_index][d_index] += 1
volume = 0
for x_index, y_index, d_index in itertools.product(range(grid_len[0]), range(grid_len[1]), range(grid_len[2])):
if fish_dist[x_index][y_index][d_index] >= K:
x_begin = grid[0][x_index]
y_begin = grid[1][y_index]
d_begin = grid[2][d_index]
x_end = grid[0][x_index + 1]
y_end = grid[1][y_index + 1]
d_end = grid[2][d_index + 1]
volume += (x_end - x_begin) * (y_end - y_begin) * (d_end - d_begin)
print(volume)
main()
``` | output | 1 | 26,428 | 3 | 52,857 |
Provide a correct Python 3 solution for this coding contest problem.
problem
To the west of the Australian continent is the wide Indian Ocean. Marine researcher JOI is studying the properties of N species of fish in the Indian Ocean.
For each type of fish, a rectangular parallelepiped habitat range is determined in the sea. Fish can move anywhere in their habitat, including boundaries, but never leave their habitat. A point in the sea is represented by three real numbers (x, y, d): (x, y, d) is x to the east and y to the north with respect to a point when viewed from above. It is an advanced position and represents a point whose depth from the sea surface is d. However, the sea level is assumed to be flat.
Mr. JOI wants to know how many places the habitat range of K or more kinds of fish overlaps. Create a program to find the volume of the entire such place.
input
The input consists of 1 + N lines.
On the first line, two integers N and K (1 ≤ K ≤ N ≤ 50) are written with a blank as a delimiter. This means that there are N types of fish, and we want to find the volume of the place where the habitat ranges of K or more types of fish overlap.
In the i-th line (1 ≤ i ≤ N) of the following N lines, there are 6 integers Xi, 1, Yi, 1, Di, 1, Xi, 2, Yi, 2, Di, 2 (0 ≤ Xi, 1 <Xi, 2 ≤ 1000000 (= 106), 0 ≤ Yi, 1 <Yi, 2 ≤ 1000000 (= 106), 0 ≤ Di, 1 <Di, 2 ≤ 1000000 (= 106)) are written. This is because the habitat range of the i-type fish is 8 points (Xi, 1, Yi, 1, Di, 1), (Xi, 2, Yi, 1, Di, 1), (Xi, 2, Yi, 2, Di, 1), (Xi, 1, Yi, 2, Di, 1), (Xi, 1, Yi, 1, Di, 2), (Xi, 2, Yi, 1, Di, 2), (Xi, 2, Yi, 2, Di, 2), (Xi, 1, Yi, 2, Di, 2) represents a rectangular parallelepiped with vertices as vertices.
output
Output the volume of the entire area where the habitats of K or more kinds of fish overlap in one line.
Input / output example
Input example 1
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output example 1
49000
In input / output example 1, for example, the point (45, 65, 65) is the habitat range of the first type of fish and the third type of fish, so it is a place that satisfies the condition. On the other hand, points (25, 35, 45) are not the places that satisfy the conditions because they are the habitat range of only the second kind of fish. The habitat range of fish is as shown in the figure below. Point O represents a reference point on sea level.
<image>
Input example 2
1 1
0 0 0 1000000 1000000 1000000
Output example 2
1000000000000000000
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output
49000 | instruction | 0 | 26,429 | 3 | 52,858 |
"Correct Solution:
```
n, k = map(int, input().split())
plst = []
xlst = []
ylst = []
dlst = []
for i in range(n):
x1,y1,d1,x2,y2,d2 = map(int, input().split())
plst.append((x1,y1,d1,x2,y2,d2))
xlst.append(x1)
xlst.append(x2)
ylst.append(y1)
ylst.append(y2)
dlst.append(d1)
dlst.append(d2)
xlst = list(set(xlst))
ylst = list(set(ylst))
dlst = list(set(dlst))
xlst.sort()
ylst.sort()
dlst.sort()
xdic = {}
ydic = {}
ddic = {}
for i, v in enumerate(xlst):
xdic[v] = i
for i, v in enumerate(ylst):
ydic[v] = i
for i, v in enumerate(dlst):
ddic[v] = i
new_map = [[[0] * len(dlst) for _ in ylst] for _ in xlst]
for p in plst:
x1, y1, d1, x2, y2, d2 = p
x1, y1, d1, x2, y2, d2 = xdic[x1], ydic[y1], ddic[d1], xdic[x2], ydic[y2], ddic[d2]
for x in range(x1, x2):
for y in range(y1, y2):
for d in range(d1, d2):
new_map[x][y][d] += 1
ans = 0
for i in range(len(xlst) - 1):
for j in range(len(ylst) - 1):
for z in range(len(dlst) - 1):
x, y, d = xdic[xlst[i]], ydic[ylst[j]], ddic[dlst[z]]
if new_map[x][y][d] >= k:
ans += (xlst[i + 1] - xlst[i]) *(ylst[j + 1] - ylst[j]) * (dlst[z + 1] - dlst[z])
print(ans)
``` | output | 1 | 26,429 | 3 | 52,859 |
Provide a correct Python 3 solution for this coding contest problem.
problem
To the west of the Australian continent is the wide Indian Ocean. Marine researcher JOI is studying the properties of N species of fish in the Indian Ocean.
For each type of fish, a rectangular parallelepiped habitat range is determined in the sea. Fish can move anywhere in their habitat, including boundaries, but never leave their habitat. A point in the sea is represented by three real numbers (x, y, d): (x, y, d) is x to the east and y to the north with respect to a point when viewed from above. It is an advanced position and represents a point whose depth from the sea surface is d. However, the sea level is assumed to be flat.
Mr. JOI wants to know how many places the habitat range of K or more kinds of fish overlaps. Create a program to find the volume of the entire such place.
input
The input consists of 1 + N lines.
On the first line, two integers N and K (1 ≤ K ≤ N ≤ 50) are written with a blank as a delimiter. This means that there are N types of fish, and we want to find the volume of the place where the habitat ranges of K or more types of fish overlap.
In the i-th line (1 ≤ i ≤ N) of the following N lines, there are 6 integers Xi, 1, Yi, 1, Di, 1, Xi, 2, Yi, 2, Di, 2 (0 ≤ Xi, 1 <Xi, 2 ≤ 1000000 (= 106), 0 ≤ Yi, 1 <Yi, 2 ≤ 1000000 (= 106), 0 ≤ Di, 1 <Di, 2 ≤ 1000000 (= 106)) are written. This is because the habitat range of the i-type fish is 8 points (Xi, 1, Yi, 1, Di, 1), (Xi, 2, Yi, 1, Di, 1), (Xi, 2, Yi, 2, Di, 1), (Xi, 1, Yi, 2, Di, 1), (Xi, 1, Yi, 1, Di, 2), (Xi, 2, Yi, 1, Di, 2), (Xi, 2, Yi, 2, Di, 2), (Xi, 1, Yi, 2, Di, 2) represents a rectangular parallelepiped with vertices as vertices.
output
Output the volume of the entire area where the habitats of K or more kinds of fish overlap in one line.
Input / output example
Input example 1
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output example 1
49000
In input / output example 1, for example, the point (45, 65, 65) is the habitat range of the first type of fish and the third type of fish, so it is a place that satisfies the condition. On the other hand, points (25, 35, 45) are not the places that satisfy the conditions because they are the habitat range of only the second kind of fish. The habitat range of fish is as shown in the figure below. Point O represents a reference point on sea level.
<image>
Input example 2
1 1
0 0 0 1000000 1000000 1000000
Output example 2
1000000000000000000
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output
49000 | instruction | 0 | 26,430 | 3 | 52,860 |
"Correct Solution:
```
import sys
import itertools
input_lines = sys.stdin.read().splitlines()
N, K = [int(x) for x in input_lines[0].split(' ')]
x_grid = set()
y_grid = set()
d_grid = set()
for line in input_lines[1:]:
x1, y1, d1, x2, y2, d2 = [int(x) for x in line.split(' ')]
x_grid.add(x1)
x_grid.add(x2)
y_grid.add(y1)
y_grid.add(y2)
d_grid.add(d1)
d_grid.add(d2)
x_grid = sorted(x_grid)
y_grid = sorted(y_grid)
d_grid = sorted(d_grid)
x_grid_index = {x[1]:x[0] for x in enumerate(x_grid)}
y_grid_index = {y[1]:y[0] for y in enumerate(y_grid)}
d_grid_index = {d[1]:d[0] for d in enumerate(d_grid)}
fish_dist = [[[0 for i in range(len(d_grid))] for i in range(len(y_grid))] for i in range(len(x_grid))]
for line in input_lines[1:]:
x1, y1, d1, x2, y2, d2 = [int(x) for x in line.split(' ')]
x1_index = x_grid_index[x1]
x2_index = x_grid_index[x2]
y1_index = y_grid_index[y1]
y2_index = y_grid_index[y2]
d1_index = d_grid_index[d1]
d2_index = d_grid_index[d2]
for x, y, d in itertools.product( range(x1_index, x2_index), range(y1_index, y2_index), range(d1_index, d2_index) ):
fish_dist[x][y][d] += 1
volume = 0
for x_index, y_index, d_index in itertools.product(range(len(x_grid)), range(len(y_grid)), range(len(d_grid))):
if fish_dist[x_index][y_index][d_index] >= K:
x_begin = x_grid[x_index]
y_begin = y_grid[y_index]
d_begin = d_grid[d_index]
x_end = x_grid[x_index + 1]
y_end = y_grid[y_index + 1]
d_end = d_grid[d_index + 1]
volume += (x_end - x_begin) * (y_end - y_begin) * (d_end - d_begin)
print(volume)
``` | output | 1 | 26,430 | 3 | 52,861 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
To the west of the Australian continent is the wide Indian Ocean. Marine researcher JOI is studying the properties of N species of fish in the Indian Ocean.
For each type of fish, a rectangular parallelepiped habitat range is determined in the sea. Fish can move anywhere in their habitat, including boundaries, but never leave their habitat. A point in the sea is represented by three real numbers (x, y, d): (x, y, d) is x to the east and y to the north with respect to a point when viewed from above. It is an advanced position and represents a point whose depth from the sea surface is d. However, the sea level is assumed to be flat.
Mr. JOI wants to know how many places the habitat range of K or more kinds of fish overlaps. Create a program to find the volume of the entire such place.
input
The input consists of 1 + N lines.
On the first line, two integers N and K (1 ≤ K ≤ N ≤ 50) are written with a blank as a delimiter. This means that there are N types of fish, and we want to find the volume of the place where the habitat ranges of K or more types of fish overlap.
In the i-th line (1 ≤ i ≤ N) of the following N lines, there are 6 integers Xi, 1, Yi, 1, Di, 1, Xi, 2, Yi, 2, Di, 2 (0 ≤ Xi, 1 <Xi, 2 ≤ 1000000 (= 106), 0 ≤ Yi, 1 <Yi, 2 ≤ 1000000 (= 106), 0 ≤ Di, 1 <Di, 2 ≤ 1000000 (= 106)) are written. This is because the habitat range of the i-type fish is 8 points (Xi, 1, Yi, 1, Di, 1), (Xi, 2, Yi, 1, Di, 1), (Xi, 2, Yi, 2, Di, 1), (Xi, 1, Yi, 2, Di, 1), (Xi, 1, Yi, 1, Di, 2), (Xi, 2, Yi, 1, Di, 2), (Xi, 2, Yi, 2, Di, 2), (Xi, 1, Yi, 2, Di, 2) represents a rectangular parallelepiped with vertices as vertices.
output
Output the volume of the entire area where the habitats of K or more kinds of fish overlap in one line.
Input / output example
Input example 1
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output example 1
49000
In input / output example 1, for example, the point (45, 65, 65) is the habitat range of the first type of fish and the third type of fish, so it is a place that satisfies the condition. On the other hand, points (25, 35, 45) are not the places that satisfy the conditions because they are the habitat range of only the second kind of fish. The habitat range of fish is as shown in the figure below. Point O represents a reference point on sea level.
<image>
Input example 2
1 1
0 0 0 1000000 1000000 1000000
Output example 2
1000000000000000000
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output
49000
Submitted Solution:
```
def main():
n, k = map(int, input().split())
plst = []
xlst = []
ylst = []
dlst = []
for i in range(n):
x1,y1,d1,x2,y2,d2 = map(int, input().split())
plst.append((x1,y1,d1,x2,y2,d2))
xlst.append(x1)
xlst.append(x2)
ylst.append(y1)
ylst.append(y2)
dlst.append(d1)
dlst.append(d2)
xlst = list(set(xlst))
ylst = list(set(ylst))
dlst = list(set(dlst))
xlst.sort()
ylst.sort()
dlst.sort()
xdic = {}
ydic = {}
ddic = {}
for i, v in enumerate(xlst):
xdic[v] = i
for i, v in enumerate(ylst):
ydic[v] = i
for i, v in enumerate(dlst):
ddic[v] = i
new_map = [[[0] * len(dlst) for _ in ylst] for _ in xlst]
for p in plst:
x1, y1, d1, x2, y2, d2 = p
x1, y1, d1, x2, y2, d2 = xdic[x1], ydic[y1], ddic[d1], xdic[x2], ydic[y2], ddic[d2]
for x in range(x1, x2):
for y in range(y1, y2):
for d in range(d1, d2):
new_map[x][y][d] += 1
ans = 0
for i in range(len(xlst) - 1):
xlsti = xlst[i]
xlsti1 = xlst[i - 1]
x = xdic[xlsti]
for j in range(len(ylst) - 1):
ylstj = ylst[j]
ylstj1 = ylst[j - 1]
y = ydic[ylstj]
for z in range(len(dlst) - 1):
dlstz = dlst[z]
dlstz1 = dlst[z - 1]
d = ddic[dlstz]
if new_map[x][y][d] >= k:
ans += (xlsti1 - xlsti) * (ylstj1 - ylstj) * (dlstz1 - dlstz)
print(ans)
main()
``` | instruction | 0 | 26,431 | 3 | 52,862 |
No | output | 1 | 26,431 | 3 | 52,863 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
To the west of the Australian continent is the wide Indian Ocean. Marine researcher JOI is studying the properties of N species of fish in the Indian Ocean.
For each type of fish, a rectangular parallelepiped habitat range is determined in the sea. Fish can move anywhere in their habitat, including boundaries, but never leave their habitat. A point in the sea is represented by three real numbers (x, y, d): (x, y, d) is x to the east and y to the north with respect to a point when viewed from above. It is an advanced position and represents a point whose depth from the sea surface is d. However, the sea level is assumed to be flat.
Mr. JOI wants to know how many places the habitat range of K or more kinds of fish overlaps. Create a program to find the volume of the entire such place.
input
The input consists of 1 + N lines.
On the first line, two integers N and K (1 ≤ K ≤ N ≤ 50) are written with a blank as a delimiter. This means that there are N types of fish, and we want to find the volume of the place where the habitat ranges of K or more types of fish overlap.
In the i-th line (1 ≤ i ≤ N) of the following N lines, there are 6 integers Xi, 1, Yi, 1, Di, 1, Xi, 2, Yi, 2, Di, 2 (0 ≤ Xi, 1 <Xi, 2 ≤ 1000000 (= 106), 0 ≤ Yi, 1 <Yi, 2 ≤ 1000000 (= 106), 0 ≤ Di, 1 <Di, 2 ≤ 1000000 (= 106)) are written. This is because the habitat range of the i-type fish is 8 points (Xi, 1, Yi, 1, Di, 1), (Xi, 2, Yi, 1, Di, 1), (Xi, 2, Yi, 2, Di, 1), (Xi, 1, Yi, 2, Di, 1), (Xi, 1, Yi, 1, Di, 2), (Xi, 2, Yi, 1, Di, 2), (Xi, 2, Yi, 2, Di, 2), (Xi, 1, Yi, 2, Di, 2) represents a rectangular parallelepiped with vertices as vertices.
output
Output the volume of the entire area where the habitats of K or more kinds of fish overlap in one line.
Input / output example
Input example 1
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output example 1
49000
In input / output example 1, for example, the point (45, 65, 65) is the habitat range of the first type of fish and the third type of fish, so it is a place that satisfies the condition. On the other hand, points (25, 35, 45) are not the places that satisfy the conditions because they are the habitat range of only the second kind of fish. The habitat range of fish is as shown in the figure below. Point O represents a reference point on sea level.
<image>
Input example 2
1 1
0 0 0 1000000 1000000 1000000
Output example 2
1000000000000000000
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output
49000
Submitted Solution:
```
import numpy as np
input_str = raw_input()
N, K = [int(x) for x in input_str.split(' ')]
input_lines = []
for n in range(N):
input_str = raw_input()
input_lines.append(input_str)
x_grid = set()
y_grid = set()
d_grid = set()
for line in input_lines:
x1, y1, d1, x2, y2, d2 = [int(x) for x in line.split(' ')]
x_grid.add(x1)
x_grid.add(x2)
y_grid.add(y1)
y_grid.add(y2)
d_grid.add(d1)
d_grid.add(d2)
x_grid = sorted(x_grid)
y_grid = sorted(y_grid)
d_grid = sorted(d_grid)
x_grid_index = {x[1]:x[0] for x in enumerate(x_grid)}
y_grid_index = {y[1]:y[0] for y in enumerate(y_grid)}
d_grid_index = {d[1]:d[0] for d in enumerate(d_grid)}
fish_dist = np.zeros( (len(x_grid), len(y_grid), len(d_grid)), dtype=int )
for line in input_lines:
x1, y1, d1, x2, y2, d2 = [int(x) for x in line.split(' ')]
x1_index = x_grid_index[x1]
x2_index = x_grid_index[x2]
y1_index = y_grid_index[y1]
y2_index = y_grid_index[y2]
d1_index = d_grid_index[d1]
d2_index = d_grid_index[d2]
fish_dist[x1_index:x2_index, y1_index:y2_index, d1_index:d2_index] += 1
volume = 0
for (x_index, y_index, d_index), num in np.ndenumerate(fish_dist):
if num >= K:
x_begin = x_grid[x_index]
y_begin = y_grid[y_index]
d_begin = d_grid[d_index]
x_end = x_grid[x_index + 1]
y_end = y_grid[y_index + 1]
d_end = d_grid[d_index + 1]
volume += (x_end - x_begin) * (y_end - y_begin) * (d_end - d_begin)
print(volume)
``` | instruction | 0 | 26,432 | 3 | 52,864 |
No | output | 1 | 26,432 | 3 | 52,865 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
To the west of the Australian continent is the wide Indian Ocean. Marine researcher JOI is studying the properties of N species of fish in the Indian Ocean.
For each type of fish, a rectangular parallelepiped habitat range is determined in the sea. Fish can move anywhere in their habitat, including boundaries, but never leave their habitat. A point in the sea is represented by three real numbers (x, y, d): (x, y, d) is x to the east and y to the north with respect to a point when viewed from above. It is an advanced position and represents a point whose depth from the sea surface is d. However, the sea level is assumed to be flat.
Mr. JOI wants to know how many places the habitat range of K or more kinds of fish overlaps. Create a program to find the volume of the entire such place.
input
The input consists of 1 + N lines.
On the first line, two integers N and K (1 ≤ K ≤ N ≤ 50) are written with a blank as a delimiter. This means that there are N types of fish, and we want to find the volume of the place where the habitat ranges of K or more types of fish overlap.
In the i-th line (1 ≤ i ≤ N) of the following N lines, there are 6 integers Xi, 1, Yi, 1, Di, 1, Xi, 2, Yi, 2, Di, 2 (0 ≤ Xi, 1 <Xi, 2 ≤ 1000000 (= 106), 0 ≤ Yi, 1 <Yi, 2 ≤ 1000000 (= 106), 0 ≤ Di, 1 <Di, 2 ≤ 1000000 (= 106)) are written. This is because the habitat range of the i-type fish is 8 points (Xi, 1, Yi, 1, Di, 1), (Xi, 2, Yi, 1, Di, 1), (Xi, 2, Yi, 2, Di, 1), (Xi, 1, Yi, 2, Di, 1), (Xi, 1, Yi, 1, Di, 2), (Xi, 2, Yi, 1, Di, 2), (Xi, 2, Yi, 2, Di, 2), (Xi, 1, Yi, 2, Di, 2) represents a rectangular parallelepiped with vertices as vertices.
output
Output the volume of the entire area where the habitats of K or more kinds of fish overlap in one line.
Input / output example
Input example 1
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output example 1
49000
In input / output example 1, for example, the point (45, 65, 65) is the habitat range of the first type of fish and the third type of fish, so it is a place that satisfies the condition. On the other hand, points (25, 35, 45) are not the places that satisfy the conditions because they are the habitat range of only the second kind of fish. The habitat range of fish is as shown in the figure below. Point O represents a reference point on sea level.
<image>
Input example 2
1 1
0 0 0 1000000 1000000 1000000
Output example 2
1000000000000000000
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output
49000
Submitted Solution:
```
import sys
import array
input_lines = sys.stdin.read().splitlines()
N, K = [int(x) for x in input_lines[0].split(' ')]
x_grid = set()
y_grid = set()
d_grid = set()
for line in input_lines[1:]:
x1, y1, d1, x2, y2, d2 = [int(x) for x in line.split(' ')]
x_grid.add(x1)
x_grid.add(x2)
y_grid.add(y1)
y_grid.add(y2)
d_grid.add(d1)
d_grid.add(d2)
x_grid = sorted(x_grid)
y_grid = sorted(y_grid)
d_grid = sorted(d_grid)
x_grid_index = {x[1]:x[0] for x in enumerate(x_grid)}
y_grid_index = {y[1]:y[0] for y in enumerate(y_grid)}
d_grid_index = {d[1]:d[0] for d in enumerate(d_grid)}
fish_dist = array.array('i', [0 for x in xrange(len(x_grid) * len(y_grid) * len(d_grid))])
def index2arr(x, y, d):
return x + len(x_grid) * y + len(x_grid) * len(y_grid) * d
def arr2index(index):
x = index % len(x_grid)
y = ((index - x) / len(x_grid)) % len(y_grid)
d = (index - x - len(x_grid) * y) / len(x_grid) / len(d_grid)
return x, y, d
for line in input_lines[1:]:
x1, y1, d1, x2, y2, d2 = [int(x) for x in line.split(' ')]
x1_index = x_grid_index[x1]
x2_index = x_grid_index[x2]
y1_index = y_grid_index[y1]
y2_index = y_grid_index[y2]
d1_index = d_grid_index[d1]
d2_index = d_grid_index[d2]
for x in xrange(x1_index, x2_index):
for y in xrange(y1_index, y2_index):
for d in xrange(d1_index, d2_index):
fish_dist[index2arr(x,y,d)] += 1
volume = 0
for index, num in [x for x in enumerate(fish_dist) if x[1] >= K]:
x_index, y_index, d_index = arr2index(index)
x_begin = x_grid[x_index]
y_begin = y_grid[y_index]
d_begin = d_grid[d_index]
x_end = x_grid[x_index + 1]
y_end = y_grid[y_index + 1]
d_end = d_grid[d_index + 1]
volume += (x_end - x_begin) * (y_end - y_begin) * (d_end - d_begin)
print(volume)
``` | instruction | 0 | 26,433 | 3 | 52,866 |
No | output | 1 | 26,433 | 3 | 52,867 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
To the west of the Australian continent is the wide Indian Ocean. Marine researcher JOI is studying the properties of N species of fish in the Indian Ocean.
For each type of fish, a rectangular parallelepiped habitat range is determined in the sea. Fish can move anywhere in their habitat, including boundaries, but never leave their habitat. A point in the sea is represented by three real numbers (x, y, d): (x, y, d) is x to the east and y to the north with respect to a point when viewed from above. It is an advanced position and represents a point whose depth from the sea surface is d. However, the sea level is assumed to be flat.
Mr. JOI wants to know how many places the habitat range of K or more kinds of fish overlaps. Create a program to find the volume of the entire such place.
input
The input consists of 1 + N lines.
On the first line, two integers N and K (1 ≤ K ≤ N ≤ 50) are written with a blank as a delimiter. This means that there are N types of fish, and we want to find the volume of the place where the habitat ranges of K or more types of fish overlap.
In the i-th line (1 ≤ i ≤ N) of the following N lines, there are 6 integers Xi, 1, Yi, 1, Di, 1, Xi, 2, Yi, 2, Di, 2 (0 ≤ Xi, 1 <Xi, 2 ≤ 1000000 (= 106), 0 ≤ Yi, 1 <Yi, 2 ≤ 1000000 (= 106), 0 ≤ Di, 1 <Di, 2 ≤ 1000000 (= 106)) are written. This is because the habitat range of the i-type fish is 8 points (Xi, 1, Yi, 1, Di, 1), (Xi, 2, Yi, 1, Di, 1), (Xi, 2, Yi, 2, Di, 1), (Xi, 1, Yi, 2, Di, 1), (Xi, 1, Yi, 1, Di, 2), (Xi, 2, Yi, 1, Di, 2), (Xi, 2, Yi, 2, Di, 2), (Xi, 1, Yi, 2, Di, 2) represents a rectangular parallelepiped with vertices as vertices.
output
Output the volume of the entire area where the habitats of K or more kinds of fish overlap in one line.
Input / output example
Input example 1
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output example 1
49000
In input / output example 1, for example, the point (45, 65, 65) is the habitat range of the first type of fish and the third type of fish, so it is a place that satisfies the condition. On the other hand, points (25, 35, 45) are not the places that satisfy the conditions because they are the habitat range of only the second kind of fish. The habitat range of fish is as shown in the figure below. Point O represents a reference point on sea level.
<image>
Input example 2
1 1
0 0 0 1000000 1000000 1000000
Output example 2
1000000000000000000
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
3 2
30 50 0 50 70 100
10 20 20 70 90 60
40 60 20 90 90 70
Output
49000
Submitted Solution:
```
import sys
import array
input_lines = sys.stdin.read().splitlines()
N, K = [int(x) for x in input_lines[0].split(' ')]
x_grid = set()
y_grid = set()
d_grid = set()
for line in input_lines[1:]:
x1, y1, d1, x2, y2, d2 = [int(x) for x in line.split(' ')]
x_grid.add(x1)
x_grid.add(x2)
y_grid.add(y1)
y_grid.add(y2)
d_grid.add(d1)
d_grid.add(d2)
x_grid = sorted(x_grid)
y_grid = sorted(y_grid)
d_grid = sorted(d_grid)
x_grid_index = {x[1]:x[0] for x in enumerate(x_grid)}
y_grid_index = {y[1]:y[0] for y in enumerate(y_grid)}
d_grid_index = {d[1]:d[0] for d in enumerate(d_grid)}
fish_dist = array.array('i', [0 for x in range(len(x_grid) * len(y_grid) * len(d_grid))])
def index2arr(x, y, d):
return x + len(x_grid) * y + len(x_grid) * len(y_grid) * d
def arr2index(index):
x = index % len(x_grid)
y = ((index - x) // len(x_grid)) % len(y_grid)
d = (index - x - len(x_grid) * y) // len(x_grid) // len(d_grid)
return x, y, d
for line in input_lines[1:]:
x1, y1, d1, x2, y2, d2 = [int(x) for x in line.split(' ')]
x1_index = x_grid_index[x1]
x2_index = x_grid_index[x2]
y1_index = y_grid_index[y1]
y2_index = y_grid_index[y2]
d1_index = d_grid_index[d1]
d2_index = d_grid_index[d2]
for x in range(x1_index, x2_index):
for y in range(y1_index, y2_index):
for d in range(d1_index, d2_index):
fish_dist[index2arr(x,y,d)] += 1
volume = 0
for index, num in [x for x in enumerate(fish_dist) if x[1] >= K]:
x_index, y_index, d_index = arr2index(index)
x_begin = x_grid[x_index]
y_begin = y_grid[y_index]
d_begin = d_grid[d_index]
x_end = x_grid[x_index + 1]
y_end = y_grid[y_index + 1]
d_end = d_grid[d_index + 1]
volume += (x_end - x_begin) * (y_end - y_begin) * (d_end - d_begin)
print(volume)
``` | instruction | 0 | 26,434 | 3 | 52,868 |
No | output | 1 | 26,434 | 3 | 52,869 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
James Bond, Johnny's favorite secret agent, has a new mission. There are n enemy bases, each of them is described by its coordinates so that we can think about them as points in the Cartesian plane.
The bases can communicate with each other, sending a signal, which is the ray directed from the chosen point to the origin or in the opposite direction. The exception is the central base, which lies at the origin and can send a signal in any direction.
When some two bases want to communicate, there are two possible scenarios. If they lie on the same line with the origin, one of them can send a signal directly to the other one. Otherwise, the signal is sent from the first base to the central, and then the central sends it to the second base. We denote the distance between two bases as the total Euclidean distance that a signal sent between them has to travel.
Bond can damage all but some k bases, which he can choose arbitrarily. A damaged base can't send or receive the direct signal but still can pass it between two working bases. In particular, James can damage the central base, and the signal can still be sent between any two undamaged bases as before, so the distance between them remains the same. What is the maximal sum of the distances between all pairs of remaining bases that 007 can achieve by damaging exactly n - k of them?
Input
The first line contains two integers n and k (2 ≤ k ≤ n ≤ 5 ⋅ 10^5) — the total number of bases and number of bases that have to remain, respectively.
Each of the next n lines contains two integers x and y (-10^9 ≤ x, y ≤ 10^9), i-th line contains coordinates of the i-th base. You can assume that no two points coincide and that one of them is (0, 0).
Output
You should output one number — the maximal possible sum of distances between all pairs of some k from given bases. Your answer will be accepted if the absolute or relative error is less than 10^{-6}.
Examples
Input
6 2
0 0
1 1
2 2
3 3
0 1
0 2
Output
6.24264069
Input
6 5
0 0
1 1
2 2
3 3
0 1
0 2
Output
32.62741700
Input
13 10
0 0
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0
0 -2
0 1
0 2
Output
237.00000000
Input
10 5
2 2
4 4
3 5
6 10
0 5
0 0
5 0
10 0
0 10
4 7
Output
181.52406315
Note
In the first example, in an optimal solution Bond doesn't destroy bases with indices 4 and 6 (marked in orange):
<image>
The following picture represents an optimal solution for the second example. These bases are are not destroyed: 2, 3, 4, 5, 6 (marked in orange).
<image>
An optimal solution for the third test is visible in the picture. Only bases 3, 4, 5 are destroyed. Again, the not destroyed bases are marked in orange.
<image>
Submitted Solution:
```
n, m = map(int, input().split())
graph = [[] for _ in range(n + 1)]
for i in range(m):
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
number = list(map(int, input().split()))
def process():
result = [[] for _ in range(500001)]
for a in range(1, n + 1):
adj = set()
result[number[a - 1]].append(a)
for b in graph[a]:
adj.add(number[b - 1])
if number[a - 1] in adj:
print(-1)
return
for i in range(1, number[a - 1]):
if i not in adj:
print(-1)
return
for i in range(500001):
for j in result[i]:
print(j, end=' ')
process()
``` | instruction | 0 | 26,701 | 3 | 53,402 |
No | output | 1 | 26,701 | 3 | 53,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arpa is researching the Mexican wave.
There are n spectators in the stadium, labeled from 1 to n. They start the Mexican wave at time 0.
* At time 1, the first spectator stands.
* At time 2, the second spectator stands.
* ...
* At time k, the k-th spectator stands.
* At time k + 1, the (k + 1)-th spectator stands and the first spectator sits.
* At time k + 2, the (k + 2)-th spectator stands and the second spectator sits.
* ...
* At time n, the n-th spectator stands and the (n - k)-th spectator sits.
* At time n + 1, the (n + 1 - k)-th spectator sits.
* ...
* At time n + k, the n-th spectator sits.
Arpa wants to know how many spectators are standing at time t.
Input
The first line contains three integers n, k, t (1 ≤ n ≤ 109, 1 ≤ k ≤ n, 1 ≤ t < n + k).
Output
Print single integer: how many spectators are standing at time t.
Examples
Input
10 5 3
Output
3
Input
10 5 7
Output
5
Input
10 5 12
Output
3
Note
In the following a sitting spectator is represented as -, a standing spectator is represented as ^.
* At t = 0 ---------- <image> number of standing spectators = 0.
* At t = 1 ^--------- <image> number of standing spectators = 1.
* At t = 2 ^^-------- <image> number of standing spectators = 2.
* At t = 3 ^^^------- <image> number of standing spectators = 3.
* At t = 4 ^^^^------ <image> number of standing spectators = 4.
* At t = 5 ^^^^^----- <image> number of standing spectators = 5.
* At t = 6 -^^^^^---- <image> number of standing spectators = 5.
* At t = 7 --^^^^^--- <image> number of standing spectators = 5.
* At t = 8 ---^^^^^-- <image> number of standing spectators = 5.
* At t = 9 ----^^^^^- <image> number of standing spectators = 5.
* At t = 10 -----^^^^^ <image> number of standing spectators = 5.
* At t = 11 ------^^^^ <image> number of standing spectators = 4.
* At t = 12 -------^^^ <image> number of standing spectators = 3.
* At t = 13 --------^^ <image> number of standing spectators = 2.
* At t = 14 ---------^ <image> number of standing spectators = 1.
* At t = 15 ---------- <image> number of standing spectators = 0.
Submitted Solution:
```
n, k, t = map(int, input().split())
if t <= k:
print(t)
elif t < n + 1:
print(k)
else:
print(k - abs(t - n))
``` | instruction | 0 | 27,073 | 3 | 54,146 |
Yes | output | 1 | 27,073 | 3 | 54,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arpa is researching the Mexican wave.
There are n spectators in the stadium, labeled from 1 to n. They start the Mexican wave at time 0.
* At time 1, the first spectator stands.
* At time 2, the second spectator stands.
* ...
* At time k, the k-th spectator stands.
* At time k + 1, the (k + 1)-th spectator stands and the first spectator sits.
* At time k + 2, the (k + 2)-th spectator stands and the second spectator sits.
* ...
* At time n, the n-th spectator stands and the (n - k)-th spectator sits.
* At time n + 1, the (n + 1 - k)-th spectator sits.
* ...
* At time n + k, the n-th spectator sits.
Arpa wants to know how many spectators are standing at time t.
Input
The first line contains three integers n, k, t (1 ≤ n ≤ 109, 1 ≤ k ≤ n, 1 ≤ t < n + k).
Output
Print single integer: how many spectators are standing at time t.
Examples
Input
10 5 3
Output
3
Input
10 5 7
Output
5
Input
10 5 12
Output
3
Note
In the following a sitting spectator is represented as -, a standing spectator is represented as ^.
* At t = 0 ---------- <image> number of standing spectators = 0.
* At t = 1 ^--------- <image> number of standing spectators = 1.
* At t = 2 ^^-------- <image> number of standing spectators = 2.
* At t = 3 ^^^------- <image> number of standing spectators = 3.
* At t = 4 ^^^^------ <image> number of standing spectators = 4.
* At t = 5 ^^^^^----- <image> number of standing spectators = 5.
* At t = 6 -^^^^^---- <image> number of standing spectators = 5.
* At t = 7 --^^^^^--- <image> number of standing spectators = 5.
* At t = 8 ---^^^^^-- <image> number of standing spectators = 5.
* At t = 9 ----^^^^^- <image> number of standing spectators = 5.
* At t = 10 -----^^^^^ <image> number of standing spectators = 5.
* At t = 11 ------^^^^ <image> number of standing spectators = 4.
* At t = 12 -------^^^ <image> number of standing spectators = 3.
* At t = 13 --------^^ <image> number of standing spectators = 2.
* At t = 14 ---------^ <image> number of standing spectators = 1.
* At t = 15 ---------- <image> number of standing spectators = 0.
Submitted Solution:
```
#Arpa and a research in Mexican wave (851A)
inp = input().split()
n = int(inp[0])
k = int(inp[1])
t = int(inp[2])
#print(n,k,t)
ans = 0
if (t<=k):
ans = t
else:
if t<=n:
ans = k
else:
ans = k-(t-n)
print(ans)
``` | instruction | 0 | 27,074 | 3 | 54,148 |
Yes | output | 1 | 27,074 | 3 | 54,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arpa is researching the Mexican wave.
There are n spectators in the stadium, labeled from 1 to n. They start the Mexican wave at time 0.
* At time 1, the first spectator stands.
* At time 2, the second spectator stands.
* ...
* At time k, the k-th spectator stands.
* At time k + 1, the (k + 1)-th spectator stands and the first spectator sits.
* At time k + 2, the (k + 2)-th spectator stands and the second spectator sits.
* ...
* At time n, the n-th spectator stands and the (n - k)-th spectator sits.
* At time n + 1, the (n + 1 - k)-th spectator sits.
* ...
* At time n + k, the n-th spectator sits.
Arpa wants to know how many spectators are standing at time t.
Input
The first line contains three integers n, k, t (1 ≤ n ≤ 109, 1 ≤ k ≤ n, 1 ≤ t < n + k).
Output
Print single integer: how many spectators are standing at time t.
Examples
Input
10 5 3
Output
3
Input
10 5 7
Output
5
Input
10 5 12
Output
3
Note
In the following a sitting spectator is represented as -, a standing spectator is represented as ^.
* At t = 0 ---------- <image> number of standing spectators = 0.
* At t = 1 ^--------- <image> number of standing spectators = 1.
* At t = 2 ^^-------- <image> number of standing spectators = 2.
* At t = 3 ^^^------- <image> number of standing spectators = 3.
* At t = 4 ^^^^------ <image> number of standing spectators = 4.
* At t = 5 ^^^^^----- <image> number of standing spectators = 5.
* At t = 6 -^^^^^---- <image> number of standing spectators = 5.
* At t = 7 --^^^^^--- <image> number of standing spectators = 5.
* At t = 8 ---^^^^^-- <image> number of standing spectators = 5.
* At t = 9 ----^^^^^- <image> number of standing spectators = 5.
* At t = 10 -----^^^^^ <image> number of standing spectators = 5.
* At t = 11 ------^^^^ <image> number of standing spectators = 4.
* At t = 12 -------^^^ <image> number of standing spectators = 3.
* At t = 13 --------^^ <image> number of standing spectators = 2.
* At t = 14 ---------^ <image> number of standing spectators = 1.
* At t = 15 ---------- <image> number of standing spectators = 0.
Submitted Solution:
```
n,k,t=[int(x) for x in input().split()]
res=0
if t<=k:
res=t
elif t>=n:
res=k-(t-n)
else:
res=k
print(res)
``` | instruction | 0 | 27,075 | 3 | 54,150 |
Yes | output | 1 | 27,075 | 3 | 54,151 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arpa is researching the Mexican wave.
There are n spectators in the stadium, labeled from 1 to n. They start the Mexican wave at time 0.
* At time 1, the first spectator stands.
* At time 2, the second spectator stands.
* ...
* At time k, the k-th spectator stands.
* At time k + 1, the (k + 1)-th spectator stands and the first spectator sits.
* At time k + 2, the (k + 2)-th spectator stands and the second spectator sits.
* ...
* At time n, the n-th spectator stands and the (n - k)-th spectator sits.
* At time n + 1, the (n + 1 - k)-th spectator sits.
* ...
* At time n + k, the n-th spectator sits.
Arpa wants to know how many spectators are standing at time t.
Input
The first line contains three integers n, k, t (1 ≤ n ≤ 109, 1 ≤ k ≤ n, 1 ≤ t < n + k).
Output
Print single integer: how many spectators are standing at time t.
Examples
Input
10 5 3
Output
3
Input
10 5 7
Output
5
Input
10 5 12
Output
3
Note
In the following a sitting spectator is represented as -, a standing spectator is represented as ^.
* At t = 0 ---------- <image> number of standing spectators = 0.
* At t = 1 ^--------- <image> number of standing spectators = 1.
* At t = 2 ^^-------- <image> number of standing spectators = 2.
* At t = 3 ^^^------- <image> number of standing spectators = 3.
* At t = 4 ^^^^------ <image> number of standing spectators = 4.
* At t = 5 ^^^^^----- <image> number of standing spectators = 5.
* At t = 6 -^^^^^---- <image> number of standing spectators = 5.
* At t = 7 --^^^^^--- <image> number of standing spectators = 5.
* At t = 8 ---^^^^^-- <image> number of standing spectators = 5.
* At t = 9 ----^^^^^- <image> number of standing spectators = 5.
* At t = 10 -----^^^^^ <image> number of standing spectators = 5.
* At t = 11 ------^^^^ <image> number of standing spectators = 4.
* At t = 12 -------^^^ <image> number of standing spectators = 3.
* At t = 13 --------^^ <image> number of standing spectators = 2.
* At t = 14 ---------^ <image> number of standing spectators = 1.
* At t = 15 ---------- <image> number of standing spectators = 0.
Submitted Solution:
```
from sys import stdin
input = lambda :stdin.readline().strip()
n, k, t = map(int, input().split())
if t <= k:
print(t)
elif k < t <= n:
print(k)
else:
print(n + k - t)
``` | instruction | 0 | 27,076 | 3 | 54,152 |
Yes | output | 1 | 27,076 | 3 | 54,153 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arpa is researching the Mexican wave.
There are n spectators in the stadium, labeled from 1 to n. They start the Mexican wave at time 0.
* At time 1, the first spectator stands.
* At time 2, the second spectator stands.
* ...
* At time k, the k-th spectator stands.
* At time k + 1, the (k + 1)-th spectator stands and the first spectator sits.
* At time k + 2, the (k + 2)-th spectator stands and the second spectator sits.
* ...
* At time n, the n-th spectator stands and the (n - k)-th spectator sits.
* At time n + 1, the (n + 1 - k)-th spectator sits.
* ...
* At time n + k, the n-th spectator sits.
Arpa wants to know how many spectators are standing at time t.
Input
The first line contains three integers n, k, t (1 ≤ n ≤ 109, 1 ≤ k ≤ n, 1 ≤ t < n + k).
Output
Print single integer: how many spectators are standing at time t.
Examples
Input
10 5 3
Output
3
Input
10 5 7
Output
5
Input
10 5 12
Output
3
Note
In the following a sitting spectator is represented as -, a standing spectator is represented as ^.
* At t = 0 ---------- <image> number of standing spectators = 0.
* At t = 1 ^--------- <image> number of standing spectators = 1.
* At t = 2 ^^-------- <image> number of standing spectators = 2.
* At t = 3 ^^^------- <image> number of standing spectators = 3.
* At t = 4 ^^^^------ <image> number of standing spectators = 4.
* At t = 5 ^^^^^----- <image> number of standing spectators = 5.
* At t = 6 -^^^^^---- <image> number of standing spectators = 5.
* At t = 7 --^^^^^--- <image> number of standing spectators = 5.
* At t = 8 ---^^^^^-- <image> number of standing spectators = 5.
* At t = 9 ----^^^^^- <image> number of standing spectators = 5.
* At t = 10 -----^^^^^ <image> number of standing spectators = 5.
* At t = 11 ------^^^^ <image> number of standing spectators = 4.
* At t = 12 -------^^^ <image> number of standing spectators = 3.
* At t = 13 --------^^ <image> number of standing spectators = 2.
* At t = 14 ---------^ <image> number of standing spectators = 1.
* At t = 15 ---------- <image> number of standing spectators = 0.
Submitted Solution:
```
import sys
import math
import bisect
def main():
n, k, t = map(int, input().split())
pos = [0 - k + 1, 0]
pos[0] += t - 1
pos[1] += t - 1
ans = 0
if pos[0] <= n - 1:
pos[1] = min(pos[1], n - 1)
ans = pos[1] - pos[0] + 1
print(ans)
if __name__ == "__main__":
main()
``` | instruction | 0 | 27,077 | 3 | 54,154 |
No | output | 1 | 27,077 | 3 | 54,155 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.