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.
Currently Tiny is learning Computational Geometry. When trying to solve a problem called "The Closest Pair Of Points In The Plane", he found that a code which gave a wrong time complexity got Accepted instead of Time Limit Exceeded.
The problem is the follows. Given n points in the plane, find a pair of points between which the distance is minimized. Distance between (x1, y1) and (x2, y2) is <image>.
The pseudo code of the unexpected code is as follows:
input n
for i from 1 to n
input the i-th point's coordinates into p[i]
sort array p[] by increasing of x coordinate first and increasing of y coordinate second
d=INF //here INF is a number big enough
tot=0
for i from 1 to n
for j from (i+1) to n
++tot
if (p[j].x-p[i].x>=d) then break //notice that "break" is only to be
//out of the loop "for j"
d=min(d,distance(p[i],p[j]))
output d
Here, tot can be regarded as the running time of the code. Due to the fact that a computer can only run a limited number of operations per second, tot should not be more than k in order not to get Time Limit Exceeded.
You are a great hacker. Would you please help Tiny generate a test data and let the code get Time Limit Exceeded?
Input
A single line which contains two space-separated integers n and k (2 ≤ n ≤ 2000, 1 ≤ k ≤ 109).
Output
If there doesn't exist such a data which let the given code get TLE, print "no solution" (without quotes); else print n lines, and the i-th line contains two integers xi, yi (|xi|, |yi| ≤ 109) representing the coordinates of the i-th point.
The conditions below must be held:
* All the points must be distinct.
* |xi|, |yi| ≤ 109.
* After running the given code, the value of tot should be larger than k.
Examples
Input
4 3
Output
0 0
0 1
1 0
1 1
Input
2 100
Output
no solution
Submitted Solution:
```
n,k=map(int,input().split())
if n*(n-1)/2<=k:
print("no solution")
else:
for i in range(0,n):print(0,i)
# Made By Mostafa_Khaled
``` | instruction | 0 | 23,190 | 3 | 46,380 |
Yes | output | 1 | 23,190 | 3 | 46,381 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Currently Tiny is learning Computational Geometry. When trying to solve a problem called "The Closest Pair Of Points In The Plane", he found that a code which gave a wrong time complexity got Accepted instead of Time Limit Exceeded.
The problem is the follows. Given n points in the plane, find a pair of points between which the distance is minimized. Distance between (x1, y1) and (x2, y2) is <image>.
The pseudo code of the unexpected code is as follows:
input n
for i from 1 to n
input the i-th point's coordinates into p[i]
sort array p[] by increasing of x coordinate first and increasing of y coordinate second
d=INF //here INF is a number big enough
tot=0
for i from 1 to n
for j from (i+1) to n
++tot
if (p[j].x-p[i].x>=d) then break //notice that "break" is only to be
//out of the loop "for j"
d=min(d,distance(p[i],p[j]))
output d
Here, tot can be regarded as the running time of the code. Due to the fact that a computer can only run a limited number of operations per second, tot should not be more than k in order not to get Time Limit Exceeded.
You are a great hacker. Would you please help Tiny generate a test data and let the code get Time Limit Exceeded?
Input
A single line which contains two space-separated integers n and k (2 ≤ n ≤ 2000, 1 ≤ k ≤ 109).
Output
If there doesn't exist such a data which let the given code get TLE, print "no solution" (without quotes); else print n lines, and the i-th line contains two integers xi, yi (|xi|, |yi| ≤ 109) representing the coordinates of the i-th point.
The conditions below must be held:
* All the points must be distinct.
* |xi|, |yi| ≤ 109.
* After running the given code, the value of tot should be larger than k.
Examples
Input
4 3
Output
0 0
0 1
1 0
1 1
Input
2 100
Output
no solution
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=10**9+7
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n,k=value()
if(k>=n*(n-1)//2): print("no solution")
else:
for i in range(n): print(0,i)
``` | instruction | 0 | 23,191 | 3 | 46,382 |
Yes | output | 1 | 23,191 | 3 | 46,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Currently Tiny is learning Computational Geometry. When trying to solve a problem called "The Closest Pair Of Points In The Plane", he found that a code which gave a wrong time complexity got Accepted instead of Time Limit Exceeded.
The problem is the follows. Given n points in the plane, find a pair of points between which the distance is minimized. Distance between (x1, y1) and (x2, y2) is <image>.
The pseudo code of the unexpected code is as follows:
input n
for i from 1 to n
input the i-th point's coordinates into p[i]
sort array p[] by increasing of x coordinate first and increasing of y coordinate second
d=INF //here INF is a number big enough
tot=0
for i from 1 to n
for j from (i+1) to n
++tot
if (p[j].x-p[i].x>=d) then break //notice that "break" is only to be
//out of the loop "for j"
d=min(d,distance(p[i],p[j]))
output d
Here, tot can be regarded as the running time of the code. Due to the fact that a computer can only run a limited number of operations per second, tot should not be more than k in order not to get Time Limit Exceeded.
You are a great hacker. Would you please help Tiny generate a test data and let the code get Time Limit Exceeded?
Input
A single line which contains two space-separated integers n and k (2 ≤ n ≤ 2000, 1 ≤ k ≤ 109).
Output
If there doesn't exist such a data which let the given code get TLE, print "no solution" (without quotes); else print n lines, and the i-th line contains two integers xi, yi (|xi|, |yi| ≤ 109) representing the coordinates of the i-th point.
The conditions below must be held:
* All the points must be distinct.
* |xi|, |yi| ≤ 109.
* After running the given code, the value of tot should be larger than k.
Examples
Input
4 3
Output
0 0
0 1
1 0
1 1
Input
2 100
Output
no solution
Submitted Solution:
```
n, k = map(int, input().split())
up = (int)(n * (n - 1) / 2);
if k >= up:
print ("no solution")
else:
for i in range (0, n):
print (0, i)
``` | instruction | 0 | 23,192 | 3 | 46,384 |
Yes | output | 1 | 23,192 | 3 | 46,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Currently Tiny is learning Computational Geometry. When trying to solve a problem called "The Closest Pair Of Points In The Plane", he found that a code which gave a wrong time complexity got Accepted instead of Time Limit Exceeded.
The problem is the follows. Given n points in the plane, find a pair of points between which the distance is minimized. Distance between (x1, y1) and (x2, y2) is <image>.
The pseudo code of the unexpected code is as follows:
input n
for i from 1 to n
input the i-th point's coordinates into p[i]
sort array p[] by increasing of x coordinate first and increasing of y coordinate second
d=INF //here INF is a number big enough
tot=0
for i from 1 to n
for j from (i+1) to n
++tot
if (p[j].x-p[i].x>=d) then break //notice that "break" is only to be
//out of the loop "for j"
d=min(d,distance(p[i],p[j]))
output d
Here, tot can be regarded as the running time of the code. Due to the fact that a computer can only run a limited number of operations per second, tot should not be more than k in order not to get Time Limit Exceeded.
You are a great hacker. Would you please help Tiny generate a test data and let the code get Time Limit Exceeded?
Input
A single line which contains two space-separated integers n and k (2 ≤ n ≤ 2000, 1 ≤ k ≤ 109).
Output
If there doesn't exist such a data which let the given code get TLE, print "no solution" (without quotes); else print n lines, and the i-th line contains two integers xi, yi (|xi|, |yi| ≤ 109) representing the coordinates of the i-th point.
The conditions below must be held:
* All the points must be distinct.
* |xi|, |yi| ≤ 109.
* After running the given code, the value of tot should be larger than k.
Examples
Input
4 3
Output
0 0
0 1
1 0
1 1
Input
2 100
Output
no solution
Submitted Solution:
```
n, k = map(int, input().split())
if (2 * k >= n * (n-1)):
print("no solution")
else:
print('\n'.join(["{} {}".format(0,i) for i in range(0,n)]))
``` | instruction | 0 | 23,193 | 3 | 46,386 |
Yes | output | 1 | 23,193 | 3 | 46,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Currently Tiny is learning Computational Geometry. When trying to solve a problem called "The Closest Pair Of Points In The Plane", he found that a code which gave a wrong time complexity got Accepted instead of Time Limit Exceeded.
The problem is the follows. Given n points in the plane, find a pair of points between which the distance is minimized. Distance between (x1, y1) and (x2, y2) is <image>.
The pseudo code of the unexpected code is as follows:
input n
for i from 1 to n
input the i-th point's coordinates into p[i]
sort array p[] by increasing of x coordinate first and increasing of y coordinate second
d=INF //here INF is a number big enough
tot=0
for i from 1 to n
for j from (i+1) to n
++tot
if (p[j].x-p[i].x>=d) then break //notice that "break" is only to be
//out of the loop "for j"
d=min(d,distance(p[i],p[j]))
output d
Here, tot can be regarded as the running time of the code. Due to the fact that a computer can only run a limited number of operations per second, tot should not be more than k in order not to get Time Limit Exceeded.
You are a great hacker. Would you please help Tiny generate a test data and let the code get Time Limit Exceeded?
Input
A single line which contains two space-separated integers n and k (2 ≤ n ≤ 2000, 1 ≤ k ≤ 109).
Output
If there doesn't exist such a data which let the given code get TLE, print "no solution" (without quotes); else print n lines, and the i-th line contains two integers xi, yi (|xi|, |yi| ≤ 109) representing the coordinates of the i-th point.
The conditions below must be held:
* All the points must be distinct.
* |xi|, |yi| ≤ 109.
* After running the given code, the value of tot should be larger than k.
Examples
Input
4 3
Output
0 0
0 1
1 0
1 1
Input
2 100
Output
no solution
Submitted Solution:
```
n,k=map(int,input().split())
if k*2>(n-1)*n:print('no solution')
else:[print(0,i)for i in range(n)]
``` | instruction | 0 | 23,194 | 3 | 46,388 |
No | output | 1 | 23,194 | 3 | 46,389 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Currently Tiny is learning Computational Geometry. When trying to solve a problem called "The Closest Pair Of Points In The Plane", he found that a code which gave a wrong time complexity got Accepted instead of Time Limit Exceeded.
The problem is the follows. Given n points in the plane, find a pair of points between which the distance is minimized. Distance between (x1, y1) and (x2, y2) is <image>.
The pseudo code of the unexpected code is as follows:
input n
for i from 1 to n
input the i-th point's coordinates into p[i]
sort array p[] by increasing of x coordinate first and increasing of y coordinate second
d=INF //here INF is a number big enough
tot=0
for i from 1 to n
for j from (i+1) to n
++tot
if (p[j].x-p[i].x>=d) then break //notice that "break" is only to be
//out of the loop "for j"
d=min(d,distance(p[i],p[j]))
output d
Here, tot can be regarded as the running time of the code. Due to the fact that a computer can only run a limited number of operations per second, tot should not be more than k in order not to get Time Limit Exceeded.
You are a great hacker. Would you please help Tiny generate a test data and let the code get Time Limit Exceeded?
Input
A single line which contains two space-separated integers n and k (2 ≤ n ≤ 2000, 1 ≤ k ≤ 109).
Output
If there doesn't exist such a data which let the given code get TLE, print "no solution" (without quotes); else print n lines, and the i-th line contains two integers xi, yi (|xi|, |yi| ≤ 109) representing the coordinates of the i-th point.
The conditions below must be held:
* All the points must be distinct.
* |xi|, |yi| ≤ 109.
* After running the given code, the value of tot should be larger than k.
Examples
Input
4 3
Output
0 0
0 1
1 0
1 1
Input
2 100
Output
no solution
Submitted Solution:
```
from random import randint
from math import sqrt
def dist(a,b):
return int(sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2))
d = 10000000
n,k = map(int,input().split())
fact = [1]
for i in range(1,n+1):
fact.append(fact[-1]*i)
def solve(g):
return fact[g]/(2*fact[g-2])
if solve(n) < k:
print('no solution')
else:
a = []
a.append((randint(0,n),randint(0,n)))
while len(a)!=n:
s = (randint(0,n),randint(0,n))
for i in a:
if s[0] - i[0] < d and i != s:
a.append(s)
d = min(d,dist(i,s))
else:
break
a = list(set(a))
a.sort()
for i in a:
print(*i)
``` | instruction | 0 | 23,195 | 3 | 46,390 |
No | output | 1 | 23,195 | 3 | 46,391 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Currently Tiny is learning Computational Geometry. When trying to solve a problem called "The Closest Pair Of Points In The Plane", he found that a code which gave a wrong time complexity got Accepted instead of Time Limit Exceeded.
The problem is the follows. Given n points in the plane, find a pair of points between which the distance is minimized. Distance between (x1, y1) and (x2, y2) is <image>.
The pseudo code of the unexpected code is as follows:
input n
for i from 1 to n
input the i-th point's coordinates into p[i]
sort array p[] by increasing of x coordinate first and increasing of y coordinate second
d=INF //here INF is a number big enough
tot=0
for i from 1 to n
for j from (i+1) to n
++tot
if (p[j].x-p[i].x>=d) then break //notice that "break" is only to be
//out of the loop "for j"
d=min(d,distance(p[i],p[j]))
output d
Here, tot can be regarded as the running time of the code. Due to the fact that a computer can only run a limited number of operations per second, tot should not be more than k in order not to get Time Limit Exceeded.
You are a great hacker. Would you please help Tiny generate a test data and let the code get Time Limit Exceeded?
Input
A single line which contains two space-separated integers n and k (2 ≤ n ≤ 2000, 1 ≤ k ≤ 109).
Output
If there doesn't exist such a data which let the given code get TLE, print "no solution" (without quotes); else print n lines, and the i-th line contains two integers xi, yi (|xi|, |yi| ≤ 109) representing the coordinates of the i-th point.
The conditions below must be held:
* All the points must be distinct.
* |xi|, |yi| ≤ 109.
* After running the given code, the value of tot should be larger than k.
Examples
Input
4 3
Output
0 0
0 1
1 0
1 1
Input
2 100
Output
no solution
Submitted Solution:
```
n, k = map(int, input().split())
if k >= n * (n - 1) // 2:
print("no solution")
else:
for i in range(n):
print(i, i)
``` | instruction | 0 | 23,196 | 3 | 46,392 |
No | output | 1 | 23,196 | 3 | 46,393 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Currently Tiny is learning Computational Geometry. When trying to solve a problem called "The Closest Pair Of Points In The Plane", he found that a code which gave a wrong time complexity got Accepted instead of Time Limit Exceeded.
The problem is the follows. Given n points in the plane, find a pair of points between which the distance is minimized. Distance between (x1, y1) and (x2, y2) is <image>.
The pseudo code of the unexpected code is as follows:
input n
for i from 1 to n
input the i-th point's coordinates into p[i]
sort array p[] by increasing of x coordinate first and increasing of y coordinate second
d=INF //here INF is a number big enough
tot=0
for i from 1 to n
for j from (i+1) to n
++tot
if (p[j].x-p[i].x>=d) then break //notice that "break" is only to be
//out of the loop "for j"
d=min(d,distance(p[i],p[j]))
output d
Here, tot can be regarded as the running time of the code. Due to the fact that a computer can only run a limited number of operations per second, tot should not be more than k in order not to get Time Limit Exceeded.
You are a great hacker. Would you please help Tiny generate a test data and let the code get Time Limit Exceeded?
Input
A single line which contains two space-separated integers n and k (2 ≤ n ≤ 2000, 1 ≤ k ≤ 109).
Output
If there doesn't exist such a data which let the given code get TLE, print "no solution" (without quotes); else print n lines, and the i-th line contains two integers xi, yi (|xi|, |yi| ≤ 109) representing the coordinates of the i-th point.
The conditions below must be held:
* All the points must be distinct.
* |xi|, |yi| ≤ 109.
* After running the given code, the value of tot should be larger than k.
Examples
Input
4 3
Output
0 0
0 1
1 0
1 1
Input
2 100
Output
no solution
Submitted Solution:
```
from random import randint
from math import sqrt
n,k = map(int,input().split())
def dist(a,b):
return int(sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2))
fact = [1]
for i in range(1,n+1):
fact.append(fact[-1]*i)
def solve(g):
return fact[g]/(2*fact[g-2])
if solve(n) < k:
print('no solution')
else:
a = []
d = 1000000
while len(a) != n:
x = [randint(0,n*2),randint(0,n*2)]
for i in a:
if x[0] - i[0] >= d:
break
d = min(d,dist(x,i))
if x not in a:
a.append(x)
a.sort()
for i in a:
print(*i)
``` | instruction | 0 | 23,197 | 3 | 46,394 |
No | output | 1 | 23,197 | 3 | 46,395 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
— This is not playing but duty as allies of justice, Nii-chan!
— Not allies but justice itself, Onii-chan!
With hands joined, go everywhere at a speed faster than our thoughts! This time, the Fire Sisters — Karen and Tsukihi — is heading for somewhere they've never reached — water-surrounded islands!
There are three clusters of islands, conveniently coloured red, blue and purple. The clusters consist of a, b and c distinct islands respectively.
Bridges have been built between some (possibly all or none) of the islands. A bridge bidirectionally connects two different islands and has length 1. For any two islands of the same colour, either they shouldn't be reached from each other through bridges, or the shortest distance between them is at least 3, apparently in order to prevent oddities from spreading quickly inside a cluster.
The Fire Sisters are ready for the unknown, but they'd also like to test your courage. And you're here to figure out the number of different ways to build all bridges under the constraints, and give the answer modulo 998 244 353. Two ways are considered different if a pair of islands exist, such that there's a bridge between them in one of them, but not in the other.
Input
The first and only line of input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 5 000) — the number of islands in the red, blue and purple clusters, respectively.
Output
Output one line containing an integer — the number of different ways to build bridges, modulo 998 244 353.
Examples
Input
1 1 1
Output
8
Input
1 2 2
Output
63
Input
1 3 5
Output
3264
Input
6 2 9
Output
813023575
Note
In the first example, there are 3 bridges that can possibly be built, and no setup of bridges violates the restrictions. Thus the answer is 23 = 8.
In the second example, the upper two structures in the figure below are instances of valid ones, while the lower two are invalid due to the blue and purple clusters, respectively.
<image>
Submitted Solution:
```
a,b,c=map(int,input().split())
MOD=998244353
factorials=[1]
ans=1
temp=1
for i in range(1,5001):
temp=(temp*i)%MOD
factorials.append(temp)
inverses=[]
for i in range(5001):
inverses.append(pow(factorials[i],MOD-2,MOD))
tmp=0
for n in range(0,min(a,b)+1):
tmp=(tmp+factorials[a]*factorials[b]*inverses[n]*inverses[b-n]*inverses[a-n])%MOD
ans=(ans*tmp)%MOD
tmp=0
for n in range(0,min(a,c)+1):
tmp=(tmp+factorials[a]*factorials[c]*inverses[n]*inverses[c-n]*inverses[a-n])%MOD
ans=(ans*tmp)%MOD
tmp=0
for n in range(0,min(c,b)+1):
tmp=(tmp+factorials[c]*factorials[b]*inverses[n]*inverses[b-n]*inverses[c-n])%MOD
ans=(ans*tmp)%MOD
print(ans)
``` | instruction | 0 | 23,470 | 3 | 46,940 |
Yes | output | 1 | 23,470 | 3 | 46,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
— This is not playing but duty as allies of justice, Nii-chan!
— Not allies but justice itself, Onii-chan!
With hands joined, go everywhere at a speed faster than our thoughts! This time, the Fire Sisters — Karen and Tsukihi — is heading for somewhere they've never reached — water-surrounded islands!
There are three clusters of islands, conveniently coloured red, blue and purple. The clusters consist of a, b and c distinct islands respectively.
Bridges have been built between some (possibly all or none) of the islands. A bridge bidirectionally connects two different islands and has length 1. For any two islands of the same colour, either they shouldn't be reached from each other through bridges, or the shortest distance between them is at least 3, apparently in order to prevent oddities from spreading quickly inside a cluster.
The Fire Sisters are ready for the unknown, but they'd also like to test your courage. And you're here to figure out the number of different ways to build all bridges under the constraints, and give the answer modulo 998 244 353. Two ways are considered different if a pair of islands exist, such that there's a bridge between them in one of them, but not in the other.
Input
The first and only line of input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 5 000) — the number of islands in the red, blue and purple clusters, respectively.
Output
Output one line containing an integer — the number of different ways to build bridges, modulo 998 244 353.
Examples
Input
1 1 1
Output
8
Input
1 2 2
Output
63
Input
1 3 5
Output
3264
Input
6 2 9
Output
813023575
Note
In the first example, there are 3 bridges that can possibly be built, and no setup of bridges violates the restrictions. Thus the answer is 23 = 8.
In the second example, the upper two structures in the figure below are instances of valid ones, while the lower two are invalid due to the blue and purple clusters, respectively.
<image>
Submitted Solution:
```
a,b,c=map(int,input().split())
mod=998244353
ab=0
fac=[1]*5001
def modinv(a):
global mod
return pow(a,mod-2,mod)
modiv=[0]*5001
for i in range(2,5001):
fac[i]=(fac[i-1]*i)%mod
for i in range(5001):
modiv[i]=modinv(fac[i])
def ncr(n,r):
global modiv,fac
ans=1
ans=fac[n]
ans*=modiv[n-r]
ans*=modiv[r]
return ans%mod
for i in range(min(a,b)+1):
ab+=ncr(a,i)*ncr(b,i)*fac[i]
bc=0
for i in range(min(c,b)+1):
bc+=ncr(c,i)*ncr(b,i)*fac[i]
ac=0
for i in range(min(a,c)+1):
ac+=ncr(a,i)*ncr(c,i)*fac[i]
print((ab*bc*ac)%mod)
``` | instruction | 0 | 23,471 | 3 | 46,942 |
Yes | output | 1 | 23,471 | 3 | 46,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
— This is not playing but duty as allies of justice, Nii-chan!
— Not allies but justice itself, Onii-chan!
With hands joined, go everywhere at a speed faster than our thoughts! This time, the Fire Sisters — Karen and Tsukihi — is heading for somewhere they've never reached — water-surrounded islands!
There are three clusters of islands, conveniently coloured red, blue and purple. The clusters consist of a, b and c distinct islands respectively.
Bridges have been built between some (possibly all or none) of the islands. A bridge bidirectionally connects two different islands and has length 1. For any two islands of the same colour, either they shouldn't be reached from each other through bridges, or the shortest distance between them is at least 3, apparently in order to prevent oddities from spreading quickly inside a cluster.
The Fire Sisters are ready for the unknown, but they'd also like to test your courage. And you're here to figure out the number of different ways to build all bridges under the constraints, and give the answer modulo 998 244 353. Two ways are considered different if a pair of islands exist, such that there's a bridge between them in one of them, but not in the other.
Input
The first and only line of input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 5 000) — the number of islands in the red, blue and purple clusters, respectively.
Output
Output one line containing an integer — the number of different ways to build bridges, modulo 998 244 353.
Examples
Input
1 1 1
Output
8
Input
1 2 2
Output
63
Input
1 3 5
Output
3264
Input
6 2 9
Output
813023575
Note
In the first example, there are 3 bridges that can possibly be built, and no setup of bridges violates the restrictions. Thus the answer is 23 = 8.
In the second example, the upper two structures in the figure below are instances of valid ones, while the lower two are invalid due to the blue and purple clusters, respectively.
<image>
Submitted Solution:
```
a, b, c = map(int, input().split(' '))
p = 998244353
def calc (a, b) :
if a > b:
a, b = b, a
ans = 0
tmp = 1
for i in range(a + 1):
ans = (ans + tmp) % p
tmp = tmp * (a - i) * (b - i) * pow(i + 1, p - 2, p) % p
return ans
ans = calc(a, b) * calc(b, c) * calc(a, c) % p
print(ans)
``` | instruction | 0 | 23,472 | 3 | 46,944 |
Yes | output | 1 | 23,472 | 3 | 46,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
— This is not playing but duty as allies of justice, Nii-chan!
— Not allies but justice itself, Onii-chan!
With hands joined, go everywhere at a speed faster than our thoughts! This time, the Fire Sisters — Karen and Tsukihi — is heading for somewhere they've never reached — water-surrounded islands!
There are three clusters of islands, conveniently coloured red, blue and purple. The clusters consist of a, b and c distinct islands respectively.
Bridges have been built between some (possibly all or none) of the islands. A bridge bidirectionally connects two different islands and has length 1. For any two islands of the same colour, either they shouldn't be reached from each other through bridges, or the shortest distance between them is at least 3, apparently in order to prevent oddities from spreading quickly inside a cluster.
The Fire Sisters are ready for the unknown, but they'd also like to test your courage. And you're here to figure out the number of different ways to build all bridges under the constraints, and give the answer modulo 998 244 353. Two ways are considered different if a pair of islands exist, such that there's a bridge between them in one of them, but not in the other.
Input
The first and only line of input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 5 000) — the number of islands in the red, blue and purple clusters, respectively.
Output
Output one line containing an integer — the number of different ways to build bridges, modulo 998 244 353.
Examples
Input
1 1 1
Output
8
Input
1 2 2
Output
63
Input
1 3 5
Output
3264
Input
6 2 9
Output
813023575
Note
In the first example, there are 3 bridges that can possibly be built, and no setup of bridges violates the restrictions. Thus the answer is 23 = 8.
In the second example, the upper two structures in the figure below are instances of valid ones, while the lower two are invalid due to the blue and purple clusters, respectively.
<image>
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
mod = 998244353
f = [1]
for i in range(1, 5010):
f += [f[i - 1] * i % mod]
def powmod(n, k):
if k == 0:
return 1
res = powmod(n, k // 2)
res *= res
res %= mod
if k % 2:
res *= n
res %= mod
return res
def inv(n):
return powmod(n, mod - 2)
def c(n, k):
return f[n] * inv(f[n - k]) % mod * inv(f[k]) % mod
def match(a, b):
res = 0
for i in range(min(a, b) + 1):
res += c(a, i) * c(b, i) * f[i] % mod
res %= mod
return res
n,m,k = list(map(int, input().split()))
print(match(n, m) * match(n, k) * match(m, k) % mod)
``` | instruction | 0 | 23,473 | 3 | 46,946 |
Yes | output | 1 | 23,473 | 3 | 46,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
— This is not playing but duty as allies of justice, Nii-chan!
— Not allies but justice itself, Onii-chan!
With hands joined, go everywhere at a speed faster than our thoughts! This time, the Fire Sisters — Karen and Tsukihi — is heading for somewhere they've never reached — water-surrounded islands!
There are three clusters of islands, conveniently coloured red, blue and purple. The clusters consist of a, b and c distinct islands respectively.
Bridges have been built between some (possibly all or none) of the islands. A bridge bidirectionally connects two different islands and has length 1. For any two islands of the same colour, either they shouldn't be reached from each other through bridges, or the shortest distance between them is at least 3, apparently in order to prevent oddities from spreading quickly inside a cluster.
The Fire Sisters are ready for the unknown, but they'd also like to test your courage. And you're here to figure out the number of different ways to build all bridges under the constraints, and give the answer modulo 998 244 353. Two ways are considered different if a pair of islands exist, such that there's a bridge between them in one of them, but not in the other.
Input
The first and only line of input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 5 000) — the number of islands in the red, blue and purple clusters, respectively.
Output
Output one line containing an integer — the number of different ways to build bridges, modulo 998 244 353.
Examples
Input
1 1 1
Output
8
Input
1 2 2
Output
63
Input
1 3 5
Output
3264
Input
6 2 9
Output
813023575
Note
In the first example, there are 3 bridges that can possibly be built, and no setup of bridges violates the restrictions. Thus the answer is 23 = 8.
In the second example, the upper two structures in the figure below are instances of valid ones, while the lower two are invalid due to the blue and purple clusters, respectively.
<image>
Submitted Solution:
```
a=input().split()
b=int(a[1])
c=int(a[2])
a=int(a[0])
def ali(x,y):
c=1
for i in range(x+1,y+1):
c*=i
for i in range (1,y-x+1):
c/=i
return(c)
q=0
qq=0
qqq=0
h=a
k=b
if(a>b):
h=b
k=a
for i in range(0,h+1):
q+=ali(i,h)*ali(i,k)
h=b
k=c
if(b>c):
h=c
k=b
for i in range(0,h+1):
qq+=ali(i,h)*ali(i,k)
h=a
k=c
if(a>c):
h=c
k=a
for i in range(0,h+1):
qqq+=ali(i,h)*ali(i,k)
print(int(q*qq*qqq)%998244353)
``` | instruction | 0 | 23,474 | 3 | 46,948 |
No | output | 1 | 23,474 | 3 | 46,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
— This is not playing but duty as allies of justice, Nii-chan!
— Not allies but justice itself, Onii-chan!
With hands joined, go everywhere at a speed faster than our thoughts! This time, the Fire Sisters — Karen and Tsukihi — is heading for somewhere they've never reached — water-surrounded islands!
There are three clusters of islands, conveniently coloured red, blue and purple. The clusters consist of a, b and c distinct islands respectively.
Bridges have been built between some (possibly all or none) of the islands. A bridge bidirectionally connects two different islands and has length 1. For any two islands of the same colour, either they shouldn't be reached from each other through bridges, or the shortest distance between them is at least 3, apparently in order to prevent oddities from spreading quickly inside a cluster.
The Fire Sisters are ready for the unknown, but they'd also like to test your courage. And you're here to figure out the number of different ways to build all bridges under the constraints, and give the answer modulo 998 244 353. Two ways are considered different if a pair of islands exist, such that there's a bridge between them in one of them, but not in the other.
Input
The first and only line of input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 5 000) — the number of islands in the red, blue and purple clusters, respectively.
Output
Output one line containing an integer — the number of different ways to build bridges, modulo 998 244 353.
Examples
Input
1 1 1
Output
8
Input
1 2 2
Output
63
Input
1 3 5
Output
3264
Input
6 2 9
Output
813023575
Note
In the first example, there are 3 bridges that can possibly be built, and no setup of bridges violates the restrictions. Thus the answer is 23 = 8.
In the second example, the upper two structures in the figure below are instances of valid ones, while the lower two are invalid due to the blue and purple clusters, respectively.
<image>
Submitted Solution:
```
from itertools import chain
import math
def matchings(a,b):
m = max(a,b)
n = min(a,b)
f = 998244353
t = 1
for i in range(0,n):
s = range(n-i,n+1)
r = range(m-i,m+1)
p = 1
for e in s:
p *= e
if p > f:
p = p % f
p /= math.factorial(i+1)
for e in r:
p *= e
if p > f:
p = p % f
t += int(p)
return(t)
inputs = [int(x) for x in input().split(" ")]
print(matchings(inputs[0],inputs[1])*matchings(inputs[0],inputs[2])*matchings(inputs[2],inputs[1]))
``` | instruction | 0 | 23,475 | 3 | 46,950 |
No | output | 1 | 23,475 | 3 | 46,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
— This is not playing but duty as allies of justice, Nii-chan!
— Not allies but justice itself, Onii-chan!
With hands joined, go everywhere at a speed faster than our thoughts! This time, the Fire Sisters — Karen and Tsukihi — is heading for somewhere they've never reached — water-surrounded islands!
There are three clusters of islands, conveniently coloured red, blue and purple. The clusters consist of a, b and c distinct islands respectively.
Bridges have been built between some (possibly all or none) of the islands. A bridge bidirectionally connects two different islands and has length 1. For any two islands of the same colour, either they shouldn't be reached from each other through bridges, or the shortest distance between them is at least 3, apparently in order to prevent oddities from spreading quickly inside a cluster.
The Fire Sisters are ready for the unknown, but they'd also like to test your courage. And you're here to figure out the number of different ways to build all bridges under the constraints, and give the answer modulo 998 244 353. Two ways are considered different if a pair of islands exist, such that there's a bridge between them in one of them, but not in the other.
Input
The first and only line of input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 5 000) — the number of islands in the red, blue and purple clusters, respectively.
Output
Output one line containing an integer — the number of different ways to build bridges, modulo 998 244 353.
Examples
Input
1 1 1
Output
8
Input
1 2 2
Output
63
Input
1 3 5
Output
3264
Input
6 2 9
Output
813023575
Note
In the first example, there are 3 bridges that can possibly be built, and no setup of bridges violates the restrictions. Thus the answer is 23 = 8.
In the second example, the upper two structures in the figure below are instances of valid ones, while the lower two are invalid due to the blue and purple clusters, respectively.
<image>
Submitted Solution:
```
def gcd(a, b,):
if b == 0:
return a, 1, 0
d, x, y = gcd(b, a % b)
return d, y, x - (a//b) * y
MOD = int(1e9+7)
a, b, c = map(int, input().split())
r, g, f = 0, [], [1]
for i in range(1, 5005):
f.append(f[-1] * i % MOD)
g = [(gcd(i, MOD)[1]) for i in f]
for i in range(min(a, b)+1):
r += (f[a] * g[i] * g[a-i] * f[b] * g[b-i]) % MOD
h = 0
for i in range(min(a, c)+1):
h += (f[a] * g[i] * g[a-i] * f[c] * g[c-i]) % MOD
v = 0
for i in range(min(c, b)+1):
v += (f[c] * g[i] * g[c-i] * f[b] * g[b-i]) % MOD
print(r * h * v % MOD)
``` | instruction | 0 | 23,476 | 3 | 46,952 |
No | output | 1 | 23,476 | 3 | 46,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
— This is not playing but duty as allies of justice, Nii-chan!
— Not allies but justice itself, Onii-chan!
With hands joined, go everywhere at a speed faster than our thoughts! This time, the Fire Sisters — Karen and Tsukihi — is heading for somewhere they've never reached — water-surrounded islands!
There are three clusters of islands, conveniently coloured red, blue and purple. The clusters consist of a, b and c distinct islands respectively.
Bridges have been built between some (possibly all or none) of the islands. A bridge bidirectionally connects two different islands and has length 1. For any two islands of the same colour, either they shouldn't be reached from each other through bridges, or the shortest distance between them is at least 3, apparently in order to prevent oddities from spreading quickly inside a cluster.
The Fire Sisters are ready for the unknown, but they'd also like to test your courage. And you're here to figure out the number of different ways to build all bridges under the constraints, and give the answer modulo 998 244 353. Two ways are considered different if a pair of islands exist, such that there's a bridge between them in one of them, but not in the other.
Input
The first and only line of input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 5 000) — the number of islands in the red, blue and purple clusters, respectively.
Output
Output one line containing an integer — the number of different ways to build bridges, modulo 998 244 353.
Examples
Input
1 1 1
Output
8
Input
1 2 2
Output
63
Input
1 3 5
Output
3264
Input
6 2 9
Output
813023575
Note
In the first example, there are 3 bridges that can possibly be built, and no setup of bridges violates the restrictions. Thus the answer is 23 = 8.
In the second example, the upper two structures in the figure below are instances of valid ones, while the lower two are invalid due to the blue and purple clusters, respectively.
<image>
Submitted Solution:
```
a, b, c = map(int, input().split())
mod = 998244353
def cal(x, y):
ans, tmp = 1, 1
for k in range(1, min(x, y) + 1):
tmp = tmp * (x - k + 1) * (y - k + 1) // k
ans = (ans + tmp) % mod
return ans
print(cal(a, b) * cal(b, c) * cal(c, a))
``` | instruction | 0 | 23,477 | 3 | 46,954 |
No | output | 1 | 23,477 | 3 | 46,955 |
Provide a correct Python 3 solution for this coding contest problem.
Bamboo Blossoms
The bamboos live for decades, and at the end of their lives, they flower to make their seeds. Dr. ACM, a biologist, was fascinated by the bamboos in blossom in his travel to Tsukuba. He liked the flower so much that he was tempted to make a garden where the bamboos bloom annually. Dr. ACM started research of improving breed of the bamboos, and finally, he established a method to develop bamboo breeds with controlled lifetimes. With this method, he can develop bamboo breeds that flower after arbitrarily specified years.
Let us call bamboos that flower k years after sowing "k-year-bamboos." k years after being sowed, k-year-bamboos make their seeds and then die, hence their next generation flowers after another k years. In this way, if he sows seeds of k-year-bamboos, he can see bamboo blossoms every k years. For example, assuming that he sows seeds of 15-year-bamboos, he can see bamboo blossoms every 15 years; 15 years, 30 years, 45 years, and so on, after sowing.
Dr. ACM asked you for designing his garden. His garden is partitioned into blocks, in each of which only a single breed of bamboo can grow. Dr. ACM requested you to decide which breeds of bamboos should he sow in the blocks in order to see bamboo blossoms in at least one block for as many years as possible.
You immediately suggested to sow seeds of one-year-bamboos in all blocks. Dr. ACM, however, said that it was difficult to develop a bamboo breed with short lifetime, and would like a plan using only those breeds with long lifetimes. He also said that, although he could wait for some years until he would see the first bloom, he would like to see it in every following year. Then, you suggested a plan to sow seeds of 10-year-bamboos, for example, in different blocks each year, that is, to sow in a block this year and in another block next year, and so on, for 10 years. Following this plan, he could see bamboo blossoms in one block every year except for the first 10 years. Dr. ACM objected again saying he had determined to sow in all blocks this year.
After all, you made up your mind to make a sowing plan where the bamboos bloom in at least one block for as many consecutive years as possible after the first m years (including this year) under the following conditions:
* the plan should use only those bamboo breeds whose lifetimes are m years or longer, and
* Dr. ACM should sow the seeds in all the blocks only this year.
Input
The input consists of at most 50 datasets, each in the following format.
m n
An integer m (2 ≤ m ≤ 100) represents the lifetime (in years) of the bamboos with the shortest lifetime that Dr. ACM can use for gardening. An integer n (1 ≤ n ≤ 500,000) represents the number of blocks.
The end of the input is indicated by a line containing two zeros.
Output
No matter how good your plan is, a "dull-year" would eventually come, in which the bamboos do not flower in any block. For each dataset, output in a line an integer meaning how many years from now the first dull-year comes after the first m years.
Note that the input of m = 2 and n = 500,000 (the last dataset of the Sample Input) gives the largest answer.
Sample Input
3 1
3 4
10 20
100 50
2 500000
0 0
Output for the Sample Input
4
11
47
150
7368791
Example
Input
3 1
3 4
10 20
100 50
2 500000
0 0
Output
4
11
47
150
7368791 | instruction | 0 | 23,779 | 3 | 47,558 |
"Correct Solution:
```
from bisect import bisect_left
def rwh_primes2(n):
# https://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
""" Input n>=6, Returns a list of primes, 2 <= p < n """
correction = (n%6>1)
n = {0:n,1:n-1,2:n+4,3:n+3,4:n+2,5:n+1}[n%6]
sieve = [True] * (n//3)
sieve[0] = False
for i in range(int(n**0.5)//3+1):
if sieve[i]:
k=3*i+1|1
sieve[ ((k*k)//3) ::2*k]=[False]*((n//6-(k*k)//6-1)//k+1)
sieve[(k*k+4*k-2*k*(i&1))//3::2*k]=[False]*((n//6-(k*k+4*k-2*k*(i&1))//6-1)//k+1)
return [2,3] + [3*i+1|1 for i in range(1,n//3-correction) if sieve[i]]
if __name__ == "__main__":
prime = rwh_primes2(7368791+10)
while True:
m,n = map(int,input().split())
if m == 0 and n == 0:
break
small_prime = prime[:bisect_left(prime,m**2)]
composite = []
for i in range(1,m+1):
for j in range(i,m+1):
x = i*j
if m <= x <= m**2 and x not in small_prime:
for p in small_prime:
if x%p == 0:
if x < m*p:
composite.append(x)
break
composite = sorted(list(set(composite)))
pp = bisect_left(prime,m)
cp = 0
sz = len(composite)
for i in range(n+1):
if cp < sz:
if composite[cp] < prime[pp]:
ans = composite[cp]
cp += 1
else:
ans = prime[pp]
pp += 1
else:
ans = prime[pp+n-i]
break
print(ans)
``` | output | 1 | 23,779 | 3 | 47,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bamboo Blossoms
The bamboos live for decades, and at the end of their lives, they flower to make their seeds. Dr. ACM, a biologist, was fascinated by the bamboos in blossom in his travel to Tsukuba. He liked the flower so much that he was tempted to make a garden where the bamboos bloom annually. Dr. ACM started research of improving breed of the bamboos, and finally, he established a method to develop bamboo breeds with controlled lifetimes. With this method, he can develop bamboo breeds that flower after arbitrarily specified years.
Let us call bamboos that flower k years after sowing "k-year-bamboos." k years after being sowed, k-year-bamboos make their seeds and then die, hence their next generation flowers after another k years. In this way, if he sows seeds of k-year-bamboos, he can see bamboo blossoms every k years. For example, assuming that he sows seeds of 15-year-bamboos, he can see bamboo blossoms every 15 years; 15 years, 30 years, 45 years, and so on, after sowing.
Dr. ACM asked you for designing his garden. His garden is partitioned into blocks, in each of which only a single breed of bamboo can grow. Dr. ACM requested you to decide which breeds of bamboos should he sow in the blocks in order to see bamboo blossoms in at least one block for as many years as possible.
You immediately suggested to sow seeds of one-year-bamboos in all blocks. Dr. ACM, however, said that it was difficult to develop a bamboo breed with short lifetime, and would like a plan using only those breeds with long lifetimes. He also said that, although he could wait for some years until he would see the first bloom, he would like to see it in every following year. Then, you suggested a plan to sow seeds of 10-year-bamboos, for example, in different blocks each year, that is, to sow in a block this year and in another block next year, and so on, for 10 years. Following this plan, he could see bamboo blossoms in one block every year except for the first 10 years. Dr. ACM objected again saying he had determined to sow in all blocks this year.
After all, you made up your mind to make a sowing plan where the bamboos bloom in at least one block for as many consecutive years as possible after the first m years (including this year) under the following conditions:
* the plan should use only those bamboo breeds whose lifetimes are m years or longer, and
* Dr. ACM should sow the seeds in all the blocks only this year.
Input
The input consists of at most 50 datasets, each in the following format.
m n
An integer m (2 ≤ m ≤ 100) represents the lifetime (in years) of the bamboos with the shortest lifetime that Dr. ACM can use for gardening. An integer n (1 ≤ n ≤ 500,000) represents the number of blocks.
The end of the input is indicated by a line containing two zeros.
Output
No matter how good your plan is, a "dull-year" would eventually come, in which the bamboos do not flower in any block. For each dataset, output in a line an integer meaning how many years from now the first dull-year comes after the first m years.
Note that the input of m = 2 and n = 500,000 (the last dataset of the Sample Input) gives the largest answer.
Sample Input
3 1
3 4
10 20
100 50
2 500000
0 0
Output for the Sample Input
4
11
47
150
7368791
Example
Input
3 1
3 4
10 20
100 50
2 500000
0 0
Output
4
11
47
150
7368791
Submitted Solution:
```
while True:
m, n = list(map(int,input().split()))
if m == 0 and n == 0:
break
sea = [True]*(7368792-m)
co = 0
for i in range(0, len(sea)):
if sea[i] == True:
co = co + 1
if co > n:
break
for j in range(i, len(sea), i+m):
sea[j] = False
print(sea.index(True)+m)
``` | instruction | 0 | 23,780 | 3 | 47,560 |
No | output | 1 | 23,780 | 3 | 47,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bamboo Blossoms
The bamboos live for decades, and at the end of their lives, they flower to make their seeds. Dr. ACM, a biologist, was fascinated by the bamboos in blossom in his travel to Tsukuba. He liked the flower so much that he was tempted to make a garden where the bamboos bloom annually. Dr. ACM started research of improving breed of the bamboos, and finally, he established a method to develop bamboo breeds with controlled lifetimes. With this method, he can develop bamboo breeds that flower after arbitrarily specified years.
Let us call bamboos that flower k years after sowing "k-year-bamboos." k years after being sowed, k-year-bamboos make their seeds and then die, hence their next generation flowers after another k years. In this way, if he sows seeds of k-year-bamboos, he can see bamboo blossoms every k years. For example, assuming that he sows seeds of 15-year-bamboos, he can see bamboo blossoms every 15 years; 15 years, 30 years, 45 years, and so on, after sowing.
Dr. ACM asked you for designing his garden. His garden is partitioned into blocks, in each of which only a single breed of bamboo can grow. Dr. ACM requested you to decide which breeds of bamboos should he sow in the blocks in order to see bamboo blossoms in at least one block for as many years as possible.
You immediately suggested to sow seeds of one-year-bamboos in all blocks. Dr. ACM, however, said that it was difficult to develop a bamboo breed with short lifetime, and would like a plan using only those breeds with long lifetimes. He also said that, although he could wait for some years until he would see the first bloom, he would like to see it in every following year. Then, you suggested a plan to sow seeds of 10-year-bamboos, for example, in different blocks each year, that is, to sow in a block this year and in another block next year, and so on, for 10 years. Following this plan, he could see bamboo blossoms in one block every year except for the first 10 years. Dr. ACM objected again saying he had determined to sow in all blocks this year.
After all, you made up your mind to make a sowing plan where the bamboos bloom in at least one block for as many consecutive years as possible after the first m years (including this year) under the following conditions:
* the plan should use only those bamboo breeds whose lifetimes are m years or longer, and
* Dr. ACM should sow the seeds in all the blocks only this year.
Input
The input consists of at most 50 datasets, each in the following format.
m n
An integer m (2 ≤ m ≤ 100) represents the lifetime (in years) of the bamboos with the shortest lifetime that Dr. ACM can use for gardening. An integer n (1 ≤ n ≤ 500,000) represents the number of blocks.
The end of the input is indicated by a line containing two zeros.
Output
No matter how good your plan is, a "dull-year" would eventually come, in which the bamboos do not flower in any block. For each dataset, output in a line an integer meaning how many years from now the first dull-year comes after the first m years.
Note that the input of m = 2 and n = 500,000 (the last dataset of the Sample Input) gives the largest answer.
Sample Input
3 1
3 4
10 20
100 50
2 500000
0 0
Output for the Sample Input
4
11
47
150
7368791
Example
Input
3 1
3 4
10 20
100 50
2 500000
0 0
Output
4
11
47
150
7368791
Submitted Solution:
```
while(True):
a = list(map(int, input().split()))
m , n = a[0], a[1]
if m == 0:
break
lis = [i for i in range(m,n * 16)]
for i in range(n):
lis = [i for i in lis if i % lis[0]]
print(lis[0])
``` | instruction | 0 | 23,781 | 3 | 47,562 |
No | output | 1 | 23,781 | 3 | 47,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bamboo Blossoms
The bamboos live for decades, and at the end of their lives, they flower to make their seeds. Dr. ACM, a biologist, was fascinated by the bamboos in blossom in his travel to Tsukuba. He liked the flower so much that he was tempted to make a garden where the bamboos bloom annually. Dr. ACM started research of improving breed of the bamboos, and finally, he established a method to develop bamboo breeds with controlled lifetimes. With this method, he can develop bamboo breeds that flower after arbitrarily specified years.
Let us call bamboos that flower k years after sowing "k-year-bamboos." k years after being sowed, k-year-bamboos make their seeds and then die, hence their next generation flowers after another k years. In this way, if he sows seeds of k-year-bamboos, he can see bamboo blossoms every k years. For example, assuming that he sows seeds of 15-year-bamboos, he can see bamboo blossoms every 15 years; 15 years, 30 years, 45 years, and so on, after sowing.
Dr. ACM asked you for designing his garden. His garden is partitioned into blocks, in each of which only a single breed of bamboo can grow. Dr. ACM requested you to decide which breeds of bamboos should he sow in the blocks in order to see bamboo blossoms in at least one block for as many years as possible.
You immediately suggested to sow seeds of one-year-bamboos in all blocks. Dr. ACM, however, said that it was difficult to develop a bamboo breed with short lifetime, and would like a plan using only those breeds with long lifetimes. He also said that, although he could wait for some years until he would see the first bloom, he would like to see it in every following year. Then, you suggested a plan to sow seeds of 10-year-bamboos, for example, in different blocks each year, that is, to sow in a block this year and in another block next year, and so on, for 10 years. Following this plan, he could see bamboo blossoms in one block every year except for the first 10 years. Dr. ACM objected again saying he had determined to sow in all blocks this year.
After all, you made up your mind to make a sowing plan where the bamboos bloom in at least one block for as many consecutive years as possible after the first m years (including this year) under the following conditions:
* the plan should use only those bamboo breeds whose lifetimes are m years or longer, and
* Dr. ACM should sow the seeds in all the blocks only this year.
Input
The input consists of at most 50 datasets, each in the following format.
m n
An integer m (2 ≤ m ≤ 100) represents the lifetime (in years) of the bamboos with the shortest lifetime that Dr. ACM can use for gardening. An integer n (1 ≤ n ≤ 500,000) represents the number of blocks.
The end of the input is indicated by a line containing two zeros.
Output
No matter how good your plan is, a "dull-year" would eventually come, in which the bamboos do not flower in any block. For each dataset, output in a line an integer meaning how many years from now the first dull-year comes after the first m years.
Note that the input of m = 2 and n = 500,000 (the last dataset of the Sample Input) gives the largest answer.
Sample Input
3 1
3 4
10 20
100 50
2 500000
0 0
Output for the Sample Input
4
11
47
150
7368791
Example
Input
3 1
3 4
10 20
100 50
2 500000
0 0
Output
4
11
47
150
7368791
Submitted Solution:
```
while 1:
m,n=map(int,input().split())
if m==0:break
a=[True]*7400000
while 1:
if a[m]:
if n==0:
print(m)
break
n-=1
for i in range(m*2,7368792,m):a[i]=False
m+=1
``` | instruction | 0 | 23,782 | 3 | 47,564 |
No | output | 1 | 23,782 | 3 | 47,565 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bamboo Blossoms
The bamboos live for decades, and at the end of their lives, they flower to make their seeds. Dr. ACM, a biologist, was fascinated by the bamboos in blossom in his travel to Tsukuba. He liked the flower so much that he was tempted to make a garden where the bamboos bloom annually. Dr. ACM started research of improving breed of the bamboos, and finally, he established a method to develop bamboo breeds with controlled lifetimes. With this method, he can develop bamboo breeds that flower after arbitrarily specified years.
Let us call bamboos that flower k years after sowing "k-year-bamboos." k years after being sowed, k-year-bamboos make their seeds and then die, hence their next generation flowers after another k years. In this way, if he sows seeds of k-year-bamboos, he can see bamboo blossoms every k years. For example, assuming that he sows seeds of 15-year-bamboos, he can see bamboo blossoms every 15 years; 15 years, 30 years, 45 years, and so on, after sowing.
Dr. ACM asked you for designing his garden. His garden is partitioned into blocks, in each of which only a single breed of bamboo can grow. Dr. ACM requested you to decide which breeds of bamboos should he sow in the blocks in order to see bamboo blossoms in at least one block for as many years as possible.
You immediately suggested to sow seeds of one-year-bamboos in all blocks. Dr. ACM, however, said that it was difficult to develop a bamboo breed with short lifetime, and would like a plan using only those breeds with long lifetimes. He also said that, although he could wait for some years until he would see the first bloom, he would like to see it in every following year. Then, you suggested a plan to sow seeds of 10-year-bamboos, for example, in different blocks each year, that is, to sow in a block this year and in another block next year, and so on, for 10 years. Following this plan, he could see bamboo blossoms in one block every year except for the first 10 years. Dr. ACM objected again saying he had determined to sow in all blocks this year.
After all, you made up your mind to make a sowing plan where the bamboos bloom in at least one block for as many consecutive years as possible after the first m years (including this year) under the following conditions:
* the plan should use only those bamboo breeds whose lifetimes are m years or longer, and
* Dr. ACM should sow the seeds in all the blocks only this year.
Input
The input consists of at most 50 datasets, each in the following format.
m n
An integer m (2 ≤ m ≤ 100) represents the lifetime (in years) of the bamboos with the shortest lifetime that Dr. ACM can use for gardening. An integer n (1 ≤ n ≤ 500,000) represents the number of blocks.
The end of the input is indicated by a line containing two zeros.
Output
No matter how good your plan is, a "dull-year" would eventually come, in which the bamboos do not flower in any block. For each dataset, output in a line an integer meaning how many years from now the first dull-year comes after the first m years.
Note that the input of m = 2 and n = 500,000 (the last dataset of the Sample Input) gives the largest answer.
Sample Input
3 1
3 4
10 20
100 50
2 500000
0 0
Output for the Sample Input
4
11
47
150
7368791
Example
Input
3 1
3 4
10 20
100 50
2 500000
0 0
Output
4
11
47
150
7368791
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
while True:
m,n = LI()
if n == 0 and m == 0:
break
l = min(7368792,n*20)
a = [None] * l
j = m
for i in range(n):
while a[j]:
j += 1
for k in range(j,l,j):
a[k] = True
while a[j]:
j += 1
print(j)
return
main()
``` | instruction | 0 | 23,783 | 3 | 47,566 |
No | output | 1 | 23,783 | 3 | 47,567 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Two friends are travelling through Bubble galaxy. They say "Hello!" via signals to each other if their distance is smaller or equal than d_1 and
* it's the first time they speak to each other or
* at some point in time after their last talk their distance was greater than d_2.
We need to calculate how many times friends said "Hello!" to each other. For N moments, you'll have an array of points for each friend representing their positions at that moment. A person can stay in the same position between two moments in time, but if a person made a move we assume this movement as movement with constant speed in constant direction.
Input
The first line contains one integer number N (2 ≤ N ≤ 100 000) representing number of moments in which we captured positions for two friends.
The second line contains two integer numbers d_1 and d_2 \ (0 < d_1 < d_2 < 1000).
The next N lines contains four integer numbers A_x,A_y,B_x,B_y (0 ≤ A_x, A_y, B_x, B_y ≤ 1000) representing coordinates of friends A and B in each captured moment.
Output
Output contains one integer number that represents how many times friends will say "Hello!" to each other.
Example
Input
4
2 5
0 0 0 10
5 5 5 6
5 0 10 5
14 7 10 5
Output
2
Note
<image> Explanation: Friends should send signals 2 times to each other, first time around point A2 and B2 and second time during A's travel from point A3 to A4 while B stays in point B3=B4. | instruction | 0 | 23,863 | 3 | 47,726 |
Tags: geometry
Correct Solution:
```
from sys import stdin
stdin = iter(stdin)
class Vector:
''''''
def __init__(self, x, y):
self.x = x
self.y = y
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def dot(self, vec2):
return self.x * vec2.x + self.y * vec2.y
def cross(self, vec2):
return self.x * vec2.y - self.y * vec2.x
def norm_square(self):
return self.dot(self)
def __str__(self):
return str((self.x, self.y))
__radd__ = __add__
__rsub__ = __sub__
def min_distnace_less_than_d1(ab1: Vector, ab2: Vector, d1: int):
''' '''
L = ab2 - ab1
proj1 = ab1.dot(L)
proj2 = ab2.dot(L)
between = (proj1 * proj2 < 0)
if between:
# altitude is minimum
# return altitude < d
# return |ab1.cross(L)| / sqrt(L.norm_square()) < d
return ab1.cross(L)**2 <= d1**2 * L.norm_square()
else:
# minimum edge is minimum distnace
minSquare = min([ab1.norm_square(), ab2.norm_square()])
return minSquare <= d1**2
if __name__ == "__main__":
N = int(next(stdin))
d1, d2 = (int(x) for x in next(stdin).split())
ABs = []
for _ in range(N):
Ax, Ay, Bx, By = (int(x) for x in next(stdin).split())
ABs.append(Vector(Bx, By) - Vector(Ax, Ay))
resetState = True
count = 0
for i in range(len(ABs)-1):
ab1, ab2 = ABs[i:i+2]
if resetState and min_distnace_less_than_d1(ab1, ab2, d1):
count += 1
resetState = False
resetState = resetState or (ab2.norm_square() > d2**2)
print(count)
``` | output | 1 | 23,863 | 3 | 47,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Two friends are travelling through Bubble galaxy. They say "Hello!" via signals to each other if their distance is smaller or equal than d_1 and
* it's the first time they speak to each other or
* at some point in time after their last talk their distance was greater than d_2.
We need to calculate how many times friends said "Hello!" to each other. For N moments, you'll have an array of points for each friend representing their positions at that moment. A person can stay in the same position between two moments in time, but if a person made a move we assume this movement as movement with constant speed in constant direction.
Input
The first line contains one integer number N (2 ≤ N ≤ 100 000) representing number of moments in which we captured positions for two friends.
The second line contains two integer numbers d_1 and d_2 \ (0 < d_1 < d_2 < 1000).
The next N lines contains four integer numbers A_x,A_y,B_x,B_y (0 ≤ A_x, A_y, B_x, B_y ≤ 1000) representing coordinates of friends A and B in each captured moment.
Output
Output contains one integer number that represents how many times friends will say "Hello!" to each other.
Example
Input
4
2 5
0 0 0 10
5 5 5 6
5 0 10 5
14 7 10 5
Output
2
Note
<image> Explanation: Friends should send signals 2 times to each other, first time around point A2 and B2 and second time during A's travel from point A3 to A4 while B stays in point B3=B4.
Submitted Solution:
```
from sys import stdin
class Vector:
''''''
def __init__(self, x, y):
self.x = x
self.y = y
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)
def __add__(self, other):
return Vector(self.x + self.x, self.y + other.y)
def dot(self, vec2):
return self.x * vec2.x + self.y * vec2.y
def cross(self, vec2):
return self.x * vec2.y - self.y * vec2.x
def norm_square(self):
return self.dot(self)
def __str__(self):
return str((self.x, self.y))
__radd__ = __add__
__rsub__ = __sub__
def min_distnace_less_than_d1(ab1: Vector, ab2: Vector, d1: int):
''' '''
L = ab2 - ab1
proj1 = ab1.dot(L)
proj2 = ab2.dot(L)
between = (proj1 * proj2 < 0)
if between:
# altitude is minimum
# return altitude < d
# return |ab1.cross(L)| / sqrt(L.norm_square()) < d
return ab1.cross(L)**2 < d1**2 * L.norm_square()
else:
# minimum edge is minimum distnace
minSquare = min([ab1.norm_square(), ab2.norm_square()])
return minSquare < d1**2
if __name__ == "__main__":
N = int(next(stdin))
d1, d2 = (int(x) for x in next(stdin).split())
ABs = []
for _ in range(N):
Ax, Ay, Bx, By = (int(x) for x in next(stdin).split())
ABs.append(Vector(Bx, By) - Vector(Ax, Ay))
resetState = True
count = 0
for i in range(len(ABs)-1):
ab1, ab2 = ABs[i:i+2]
if resetState and min_distnace_less_than_d1(ab1, ab2, d1):
count += 1
resetState = False
resetState = resetState or (ab2.norm_square() > d2**2)
print(count)
``` | instruction | 0 | 23,864 | 3 | 47,728 |
No | output | 1 | 23,864 | 3 | 47,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the next problem only in constraints.
Petya decided to visit Byteland during the summer holidays. It turned out that the history of this country is quite unusual.
Initially, there were n different countries on the land that is now Berland. Each country had its own territory that was represented as a rectangle on the map. The sides of the rectangle were parallel to the axes, and the corners were located at points with integer coordinates. Territories of no two countries intersected, but it was possible that some territories touched each other. As time passed, sometimes two countries merged into one. It only happened if the union of their territories was also a rectangle. In the end only one country remained — Byteland.
Initially, each country had a rectangular castle inside its territory. Its sides were parallel to the axes and its corners had integer coordinates. Some castles might touch the border of the corresponding country and sides or other castles. Miraculously, after all the unions the castles are still intact. Unfortunately, their locations are the only information we have to restore the initial territories of the countries.
<image> The possible formation of Byteland. The castles are shown in blue.
Petya wonders why no information about the initial countries remained. He suspected that the whole story is a fake. You were recommended to him as a smart person. Please check whether or not there exists a possible set of initial territories that could make the story true.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of countries and castles.
Each of the next n lines contains four integers a_i, b_i, c_i, d_i (0 ≤ a_i < c_i ≤ 10^9, 0 ≤ b_i < d_i ≤ 10^9) — the coordinates of the i-th castle, where (a_i, b_i) are the coordinates of the lower left corner and (c_i, d_i) are the coordinates of the upper right corner.
It is guaranteed, that no two castles intersect, however, they may touch.
Output
If there exists a possible set of territories that satisfies the story, print "YES", otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
4
0 0 1 2
0 2 1 3
1 0 2 1
1 1 2 3
Output
YES
Input
4
0 0 2 1
1 2 3 3
2 0 3 2
0 1 1 3
Output
NO
Note
The castles in the first and second examples are shown on the pictures below.
<image> <image>
Submitted Solution:
```
from collections import defaultdict as dd
import math
def nn():
return int(input())
def li():
return list(input())
def mi():
return map(int, input().split())
def lm():
return list(map(int, input().split()))
n=nn()
hrecs=[]
vrecs=[]
for i in range(n):
rec=lm()
hrecs.append([rec[0]]+[rec[2]]+[i])
vrecs.append([rec[1]]+[rec[3]]+[i])
hrecs=sorted(hrecs)
vrecs=sorted(vrecs)
def splitable(hrecs, vrecs):
#print(hrecs)
n=len(hrecs)
if n==1:
return True
for i in range(n-1):
if hrecs[i][1]<=hrecs[i+1][0]:
#print(hrecs,i)
newhrecs1=hrecs[:i+1]
newhrecs2=hrecs[i+1:]
h1set=set([h[2] for h in newhrecs1])
h2set=set([h[2] for h in newhrecs2])
newvrecs1=[]
newvrecs2=[]
for rec in vrecs:
if rec[2] in h1set:
newvrecs1.append(rec)
else:
newvrecs2.append(rec)
return splitable(newhrecs1, newvrecs1) and splitable(newhrecs2, newvrecs2)
for i in range(n-1):
if vrecs[i][1]<=vrecs[i+1][0]:
newvrecs1=vrecs[:i+1]
newvrecs2=vrecs[i+1:]
v1set=set([v[2] for v in newvrecs1])
v2set=set([v[2] for v in newvrecs2])
newhrecs1=[]
newhrecs2=[]
for rec in hrecs:
if rec[2] in v1set:
newhrecs1.append(rec)
else:
newhrecs2.append(rec)
return splitable(newhrecs1, newvrecs1) and splitable(newhrecs2, newvrecs2)
return False
if splitable(hrecs,vrecs):
print('YES')
else:
print('NO')
``` | instruction | 0 | 23,916 | 3 | 47,832 |
No | output | 1 | 23,916 | 3 | 47,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the next problem only in constraints.
Petya decided to visit Byteland during the summer holidays. It turned out that the history of this country is quite unusual.
Initially, there were n different countries on the land that is now Berland. Each country had its own territory that was represented as a rectangle on the map. The sides of the rectangle were parallel to the axes, and the corners were located at points with integer coordinates. Territories of no two countries intersected, but it was possible that some territories touched each other. As time passed, sometimes two countries merged into one. It only happened if the union of their territories was also a rectangle. In the end only one country remained — Byteland.
Initially, each country had a rectangular castle inside its territory. Its sides were parallel to the axes and its corners had integer coordinates. Some castles might touch the border of the corresponding country and sides or other castles. Miraculously, after all the unions the castles are still intact. Unfortunately, their locations are the only information we have to restore the initial territories of the countries.
<image> The possible formation of Byteland. The castles are shown in blue.
Petya wonders why no information about the initial countries remained. He suspected that the whole story is a fake. You were recommended to him as a smart person. Please check whether or not there exists a possible set of initial territories that could make the story true.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of countries and castles.
Each of the next n lines contains four integers a_i, b_i, c_i, d_i (0 ≤ a_i < c_i ≤ 10^9, 0 ≤ b_i < d_i ≤ 10^9) — the coordinates of the i-th castle, where (a_i, b_i) are the coordinates of the lower left corner and (c_i, d_i) are the coordinates of the upper right corner.
It is guaranteed, that no two castles intersect, however, they may touch.
Output
If there exists a possible set of territories that satisfies the story, print "YES", otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
4
0 0 1 2
0 2 1 3
1 0 2 1
1 1 2 3
Output
YES
Input
4
0 0 2 1
1 2 3 3
2 0 3 2
0 1 1 3
Output
NO
Note
The castles in the first and second examples are shown on the pictures below.
<image> <image>
Submitted Solution:
```
aa = int(input())
z = 0
ab = 0
cd = 0
while aa > 0:
a,b,c,d = input().split()
cc = []
a,b,c,d = int(a),int(b),int(c),int(d)
z += (c-a)*(d-b)
ab += a
cd += b
aa -= 1
if z >= (ab*cd):
print("yes")
else:
print('no')
``` | instruction | 0 | 23,917 | 3 | 47,834 |
No | output | 1 | 23,917 | 3 | 47,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the next problem only in constraints.
Petya decided to visit Byteland during the summer holidays. It turned out that the history of this country is quite unusual.
Initially, there were n different countries on the land that is now Berland. Each country had its own territory that was represented as a rectangle on the map. The sides of the rectangle were parallel to the axes, and the corners were located at points with integer coordinates. Territories of no two countries intersected, but it was possible that some territories touched each other. As time passed, sometimes two countries merged into one. It only happened if the union of their territories was also a rectangle. In the end only one country remained — Byteland.
Initially, each country had a rectangular castle inside its territory. Its sides were parallel to the axes and its corners had integer coordinates. Some castles might touch the border of the corresponding country and sides or other castles. Miraculously, after all the unions the castles are still intact. Unfortunately, their locations are the only information we have to restore the initial territories of the countries.
<image> The possible formation of Byteland. The castles are shown in blue.
Petya wonders why no information about the initial countries remained. He suspected that the whole story is a fake. You were recommended to him as a smart person. Please check whether or not there exists a possible set of initial territories that could make the story true.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of countries and castles.
Each of the next n lines contains four integers a_i, b_i, c_i, d_i (0 ≤ a_i < c_i ≤ 10^9, 0 ≤ b_i < d_i ≤ 10^9) — the coordinates of the i-th castle, where (a_i, b_i) are the coordinates of the lower left corner and (c_i, d_i) are the coordinates of the upper right corner.
It is guaranteed, that no two castles intersect, however, they may touch.
Output
If there exists a possible set of territories that satisfies the story, print "YES", otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
4
0 0 1 2
0 2 1 3
1 0 2 1
1 1 2 3
Output
YES
Input
4
0 0 2 1
1 2 3 3
2 0 3 2
0 1 1 3
Output
NO
Note
The castles in the first and second examples are shown on the pictures below.
<image> <image>
Submitted Solution:
```
class Territory:
def __init__(self, x, y, x_2, y_2):
self.x = x
self.y = y
self.x_2 = x_2
self.y_2 = y_2
self.width = x_2 - x
self.height = y_2 - y
def __str__(self):
return str(self.x) + " " + str(self.y) + " " + str(self.width) + " " + str(self.height)
def merge(self, territory):
if self.width == territory.width and self.x == territory.x:
if self.y < territory.y:
return Territory(self.x, self.y, territory.x_2, territory.y_2)
else:
return Territory(territory.x, territory.y, self.x_2, self.y_2)
elif self.height == territory.height and self.y == territory.y:
if self.x < territory.x:
return Territory(self.x, self.y, territory.x_2, territory.y_2)
else:
return Territory(territory.x, territory.y, self.x_2, self.y_2)
else:
return False
N = int(input())
territories = []
for i in range(N):
data = input().strip().split()
territories.append(Territory(int(data[0]), int(data[1]), int(data[2]), int(data[3])))
i = 0
while i < len(territories):
j = i+1
while j < len(territories):
new_territory = territories[i].merge(territories[j])
if new_territory:
territories[i] = new_territory
del territories[j]
i = 0
# j = 0
j += 1
i += 1
if len(territories) == 1:
print("YES")
else:
print("NO")
``` | instruction | 0 | 23,918 | 3 | 47,836 |
No | output | 1 | 23,918 | 3 | 47,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem differs from the next problem only in constraints.
Petya decided to visit Byteland during the summer holidays. It turned out that the history of this country is quite unusual.
Initially, there were n different countries on the land that is now Berland. Each country had its own territory that was represented as a rectangle on the map. The sides of the rectangle were parallel to the axes, and the corners were located at points with integer coordinates. Territories of no two countries intersected, but it was possible that some territories touched each other. As time passed, sometimes two countries merged into one. It only happened if the union of their territories was also a rectangle. In the end only one country remained — Byteland.
Initially, each country had a rectangular castle inside its territory. Its sides were parallel to the axes and its corners had integer coordinates. Some castles might touch the border of the corresponding country and sides or other castles. Miraculously, after all the unions the castles are still intact. Unfortunately, their locations are the only information we have to restore the initial territories of the countries.
<image> The possible formation of Byteland. The castles are shown in blue.
Petya wonders why no information about the initial countries remained. He suspected that the whole story is a fake. You were recommended to him as a smart person. Please check whether or not there exists a possible set of initial territories that could make the story true.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of countries and castles.
Each of the next n lines contains four integers a_i, b_i, c_i, d_i (0 ≤ a_i < c_i ≤ 10^9, 0 ≤ b_i < d_i ≤ 10^9) — the coordinates of the i-th castle, where (a_i, b_i) are the coordinates of the lower left corner and (c_i, d_i) are the coordinates of the upper right corner.
It is guaranteed, that no two castles intersect, however, they may touch.
Output
If there exists a possible set of territories that satisfies the story, print "YES", otherwise print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
4
0 0 1 2
0 2 1 3
1 0 2 1
1 1 2 3
Output
YES
Input
4
0 0 2 1
1 2 3 3
2 0 3 2
0 1 1 3
Output
NO
Note
The castles in the first and second examples are shown on the pictures below.
<image> <image>
Submitted Solution:
```
aa = int(input())
z = 0
ab = 0
cd = 0
while aa > 0:
a,b,c,d = input().split()
cc = []
a,b,c,d = int(a),int(b),int(c),int(d)
z += (c-a)*(d-b)
ab += a
cd += b
aa -= 1
if z == (ab*cd):
print("yes")
else:
print('no')
``` | instruction | 0 | 23,919 | 3 | 47,838 |
No | output | 1 | 23,919 | 3 | 47,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem.
To prevent the mischievous rabbits from freely roaming around the zoo, Zookeeper has set up a special lock for the rabbit enclosure. This lock is called the Rotary Laser Lock.
The lock consists of n concentric rings numbered from 0 to n-1. The innermost ring is ring 0 and the outermost ring is ring n-1. All rings are split equally into nm sections each. Each of those rings contains a single metal arc that covers exactly m contiguous sections. At the center of the ring is a core and surrounding the entire lock are nm receivers aligned to the nm sections.
The core has nm lasers that shine outward from the center, one for each section. The lasers can be blocked by any of the arcs. A display on the outside of the lock shows how many lasers hit the outer receivers.
<image>
In the example above, there are n=3 rings, each covering m=4 sections. The arcs are colored in green (ring 0), purple (ring 1), and blue (ring 2) while the lasers beams are shown in red. There are nm=12 sections and 3 of the lasers are not blocked by any arc, thus the display will show 3 in this case.
Wabbit is trying to open the lock to free the rabbits, but the lock is completely opaque, and he cannot see where any of the arcs are. Given the relative positions of the arcs, Wabbit can open the lock on his own.
To be precise, Wabbit needs n-1 integers p_1,p_2,…,p_{n-1} satisfying 0 ≤ p_i < nm such that for each i (1 ≤ i < n), Wabbit can rotate ring 0 clockwise exactly p_i times such that the sections that ring 0 covers perfectly aligns with the sections that ring i covers. In the example above, the relative positions are p_1 = 1 and p_2 = 7.
To operate the lock, he can pick any of the n rings and rotate them by 1 section either clockwise or anti-clockwise. You will see the number on the display after every rotation.
Because his paws are small, Wabbit has asked you to help him to find the relative positions of the arcs after all of your rotations are completed. You may perform up to 15000 rotations before Wabbit gets impatient.
Input
The first line consists of 2 integers n and m (2 ≤ n ≤ 100, 2 ≤ m ≤ 20), indicating the number of rings and the number of sections each ring covers.
Interaction
To perform a rotation, print on a single line "? x d" where x (0 ≤ x < n) is the ring that you wish to rotate and d (d ∈ \{-1,1\}) is the direction that you would like to rotate in. d=1 indicates a clockwise rotation by 1 section while d=-1 indicates an anticlockwise rotation by 1 section.
For each query, you will receive a single integer a: the number of lasers that are not blocked by any of the arcs after the rotation has been performed.
Once you have figured out the relative positions of the arcs, print ! followed by n-1 integers p_1, p_2, …, p_{n-1}.
Do note that the positions of the rings are predetermined for each test case and won't change during the interaction process.
After printing a query do not forget to output the end of line and flush the output. Otherwise, you will get Idleness limit exceeded verdict.
To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hacks:
To hack, use the following format of test:
The first line should contain two integers n and m.
The next line of should contain n-1 integers p_1,p_2,…,p_{n-1}: relative positions of rings 1,2,…,n-1.
Example
Input
3 4
4
4
3
Output
? 0 1
? 2 -1
? 1 1
! 1 5
Note
For the first test, the configuration is the same as shown on the picture from the statement.
After the first rotation (which is rotating ring 0 clockwise by 1 section), we obtain the following configuration:
<image>
After the second rotation (which is rotating ring 2 counter-clockwise by 1 section), we obtain the following configuration:
<image>
After the third rotation (which is rotating ring 1 clockwise by 1 section), we obtain the following configuration:
<image>
If we rotate ring 0 clockwise once, we can see that the sections ring 0 covers will be the same as the sections that ring 1 covers, hence p_1=1.
If we rotate ring 0 clockwise five times, the sections ring 0 covers will be the same as the sections that ring 2 covers, hence p_2=5.
Note that if we will make a different set of rotations, we can end up with different values of p_1 and p_2 at the end. | instruction | 0 | 23,998 | 3 | 47,996 |
Tags: binary search, interactive
Correct Solution:
```
import sys,random;Z=sys.stdin.readline
R=random.randint(0,1)*2-1
def P(d=1,x=0):
print('?',x,(2*d-1)*R);sys.stdout.flush()
return int(Z())
def poke(n):
global K,S,C,L
h=len(S);l=0;D=[0]*h
while h-l>1:
m=(l+h)//2;d=1-D[l]
for i in range(m-l):
v=P(d,S[l+i]);D[l+i]=d
if v<P()+n:
if d:l=m
else:h=m
else:
if d:h=m
else:l=m
P(0)
for i in range(len(S)):
if D[i]:P(0,S[i])
for i in range(M):v=P(0,S[l])
K[S[l]]=C;L=C;S=S[:l]+S[l+1:]
return v
N,M=map(int,Z().split())
if N==2:
while P()>0:pass
print('!',M);quit()
K=[-1]*N;S=[*range(1,N)]
pv=P();v=P();w=0
while 1-w or pv<=v:pv,v,w=v,P(),max(w,v>=pv)
pv,v=v,P(0)
good=[]
for i in S:
pv,v=v,P(1,i)
if v<pv:
pv,v=v,P()
if v>=pv:good.append(i);P(0,i);K[i]=0
pv,v=v,P(0)
for i in good:S.remove(i)
L=C=0
for i in range(len(S)):
n=0
while (C-L)%(N*M)<M:
pv,v,C=v,P(),C+1
if pv==v:n=1;break
else:
pv=v
while pv==v:pv,v,C=v,P(),C+1
P(0);C-=1;v=poke(n)
print('!',' '.join(map(str,[(R*(K[i]-C))%(M*N)for i in range(1,N)])))
``` | output | 1 | 23,998 | 3 | 47,997 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem.
To prevent the mischievous rabbits from freely roaming around the zoo, Zookeeper has set up a special lock for the rabbit enclosure. This lock is called the Rotary Laser Lock.
The lock consists of n concentric rings numbered from 0 to n-1. The innermost ring is ring 0 and the outermost ring is ring n-1. All rings are split equally into nm sections each. Each of those rings contains a single metal arc that covers exactly m contiguous sections. At the center of the ring is a core and surrounding the entire lock are nm receivers aligned to the nm sections.
The core has nm lasers that shine outward from the center, one for each section. The lasers can be blocked by any of the arcs. A display on the outside of the lock shows how many lasers hit the outer receivers.
<image>
In the example above, there are n=3 rings, each covering m=4 sections. The arcs are colored in green (ring 0), purple (ring 1), and blue (ring 2) while the lasers beams are shown in red. There are nm=12 sections and 3 of the lasers are not blocked by any arc, thus the display will show 3 in this case.
Wabbit is trying to open the lock to free the rabbits, but the lock is completely opaque, and he cannot see where any of the arcs are. Given the relative positions of the arcs, Wabbit can open the lock on his own.
To be precise, Wabbit needs n-1 integers p_1,p_2,…,p_{n-1} satisfying 0 ≤ p_i < nm such that for each i (1 ≤ i < n), Wabbit can rotate ring 0 clockwise exactly p_i times such that the sections that ring 0 covers perfectly aligns with the sections that ring i covers. In the example above, the relative positions are p_1 = 1 and p_2 = 7.
To operate the lock, he can pick any of the n rings and rotate them by 1 section either clockwise or anti-clockwise. You will see the number on the display after every rotation.
Because his paws are small, Wabbit has asked you to help him to find the relative positions of the arcs after all of your rotations are completed. You may perform up to 15000 rotations before Wabbit gets impatient.
Input
The first line consists of 2 integers n and m (2 ≤ n ≤ 100, 2 ≤ m ≤ 20), indicating the number of rings and the number of sections each ring covers.
Interaction
To perform a rotation, print on a single line "? x d" where x (0 ≤ x < n) is the ring that you wish to rotate and d (d ∈ \{-1,1\}) is the direction that you would like to rotate in. d=1 indicates a clockwise rotation by 1 section while d=-1 indicates an anticlockwise rotation by 1 section.
For each query, you will receive a single integer a: the number of lasers that are not blocked by any of the arcs after the rotation has been performed.
Once you have figured out the relative positions of the arcs, print ! followed by n-1 integers p_1, p_2, …, p_{n-1}.
Do note that the positions of the rings are predetermined for each test case and won't change during the interaction process.
After printing a query do not forget to output the end of line and flush the output. Otherwise, you will get Idleness limit exceeded verdict.
To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
Hacks:
To hack, use the following format of test:
The first line should contain two integers n and m.
The next line of should contain n-1 integers p_1,p_2,…,p_{n-1}: relative positions of rings 1,2,…,n-1.
Example
Input
3 4
4
4
3
Output
? 0 1
? 2 -1
? 1 1
! 1 5
Note
For the first test, the configuration is the same as shown on the picture from the statement.
After the first rotation (which is rotating ring 0 clockwise by 1 section), we obtain the following configuration:
<image>
After the second rotation (which is rotating ring 2 counter-clockwise by 1 section), we obtain the following configuration:
<image>
After the third rotation (which is rotating ring 1 clockwise by 1 section), we obtain the following configuration:
<image>
If we rotate ring 0 clockwise once, we can see that the sections ring 0 covers will be the same as the sections that ring 1 covers, hence p_1=1.
If we rotate ring 0 clockwise five times, the sections ring 0 covers will be the same as the sections that ring 2 covers, hence p_2=5.
Note that if we will make a different set of rotations, we can end up with different values of p_1 and p_2 at the end. | instruction | 0 | 23,999 | 3 | 47,998 |
Tags: binary search, interactive
Correct Solution:
```
import sys;Z=sys.stdin.readline
def P(d=1,x=0):
print('?',x,2*d-1);sys.stdout.flush()
return int(Z())
def poke(n):
global K,S,C,L
h=len(S);l=0;D=[0]*h
while h-l>1:
m=(l+h)//2;d=1-D[l]
for i in range(m-l):
v=P(d,S[l+i]);D[l+i]=d
if v<P()+n:
if d:l=m
else:h=m
else:
if d:h=m
else:l=m
P(0)
for i in range(len(S)):
if D[i]:P(0,S[i])
for i in range(M):v=P(0,S[l])
K[S[l]]=C;L=C;S=S[:l]+S[l+1:]
return v
N,M=map(int,Z().split())
if N==2:
while P()>0:pass
print('!',M);quit()
K=[-1]*N;S=[*range(1,N)]
pv=P();v=P();w=0
while 1-w or pv<=v:pv,v,w=v,P(),max(w,v>=pv)
pv,v=v,P(0)
good=[]
for i in S:
pv,v=v,P(1,i)
if v<pv:
pv,v=v,P()
if v>=pv:good.append(i);P(0,i);K[i]=0
pv,v=v,P(0)
for i in good:S.remove(i)
L=C=0
for i in range(len(S)):
n=0
while (C-L)%(N*M)<M:
pv,v,C=v,P(),C+1
if pv==v:n=1;break
else:
pv=v
while pv==v:pv,v,C=v,P(),C+1
P(0);C-=1;v=poke(n)
print('!',' '.join(map(str,[(K[i]-C)%(M*N)for i in range(1,N)])))
``` | output | 1 | 23,999 | 3 | 47,999 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a beautiful April day and Wallace is playing football with his friends. But his friends do not know that Wallace actually stayed home with Gromit and sent them his robotic self instead. Robo-Wallace has several advantages over the other guys. For example, he can hit the ball directly to the specified point. And yet, the notion of a giveaway is foreign to him. The combination of these features makes the Robo-Wallace the perfect footballer — as soon as the ball gets to him, he can just aim and hit the goal. He followed this tactics in the first half of the match, but he hit the goal rarely. The opposing team has a very good goalkeeper who catches most of the balls that fly directly into the goal. But Robo-Wallace is a quick thinker, he realized that he can cheat the goalkeeper. After all, they are playing in a football box with solid walls. Robo-Wallace can kick the ball to the other side, then the goalkeeper will not try to catch the ball. Then, if the ball bounces off the wall and flies into the goal, the goal will at last be scored.
Your task is to help Robo-Wallace to detect a spot on the wall of the football box, to which the robot should kick the ball, so that the ball bounces once and only once off this wall and goes straight to the goal. In the first half of the match Robo-Wallace got a ball in the head and was severely hit. As a result, some of the schemes have been damaged. Because of the damage, Robo-Wallace can only aim to his right wall (Robo-Wallace is standing with his face to the opposing team's goal).
The football box is rectangular. Let's introduce a two-dimensional coordinate system so that point (0, 0) lies in the lower left corner of the field, if you look at the box above. Robo-Wallace is playing for the team, whose goal is to the right. It is an improvised football field, so the gate of Robo-Wallace's rivals may be not in the middle of the left wall.
<image>
In the given coordinate system you are given:
* y1, y2 — the y-coordinates of the side pillars of the goalposts of robo-Wallace's opponents;
* yw — the y-coordinate of the wall to which Robo-Wallace is aiming;
* xb, yb — the coordinates of the ball's position when it is hit;
* r — the radius of the ball.
A goal is scored when the center of the ball crosses the OY axis in the given coordinate system between (0, y1) and (0, y2). The ball moves along a straight line. The ball's hit on the wall is perfectly elastic (the ball does not shrink from the hit), the angle of incidence equals the angle of reflection. If the ball bounces off the wall not to the goal, that is, if it hits the other wall or the goal post, then the opposing team catches the ball and Robo-Wallace starts looking for miscalculation and gets dysfunctional. Such an outcome, if possible, should be avoided. We assume that the ball touches an object, if the distance from the center of the ball to the object is no greater than the ball radius r.
Input
The first and the single line contains integers y1, y2, yw, xb, yb, r (1 ≤ y1, y2, yw, xb, yb ≤ 106; y1 < y2 < yw; yb + r < yw; 2·r < y2 - y1).
It is guaranteed that the ball is positioned correctly in the field, doesn't cross any wall, doesn't touch the wall that Robo-Wallace is aiming at. The goal posts can't be located in the field corners.
Output
If Robo-Wallace can't score a goal in the described manner, print "-1" (without the quotes). Otherwise, print a single number xw — the abscissa of his point of aiming.
If there are multiple points of aiming, print the abscissa of any of them. When checking the correctness of the answer, all comparisons are made with the permissible absolute error, equal to 10 - 8.
It is recommended to print as many characters after the decimal point as possible.
Examples
Input
4 10 13 10 3 1
Output
4.3750000000
Input
1 4 6 2 2 1
Output
-1
Input
3 10 15 17 9 2
Output
11.3333333333
Note
Note that in the first and third samples other correct values of abscissa xw are also possible.
Submitted Solution:
```
(y1, y2, yw, xb, yb, r) = map(int, input().split())
yt = yw*2-r*2-y1-r
xw = xb*(yt-yw+r)/(yt-yb)
if xw < 1e-8 + r or yt / xb * r > 1e-8 + ((y2-y1)**2 - r**2)**0.5:
print(-1)
else:
print(xw)
``` | instruction | 0 | 24,115 | 3 | 48,230 |
No | output | 1 | 24,115 | 3 | 48,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a beautiful April day and Wallace is playing football with his friends. But his friends do not know that Wallace actually stayed home with Gromit and sent them his robotic self instead. Robo-Wallace has several advantages over the other guys. For example, he can hit the ball directly to the specified point. And yet, the notion of a giveaway is foreign to him. The combination of these features makes the Robo-Wallace the perfect footballer — as soon as the ball gets to him, he can just aim and hit the goal. He followed this tactics in the first half of the match, but he hit the goal rarely. The opposing team has a very good goalkeeper who catches most of the balls that fly directly into the goal. But Robo-Wallace is a quick thinker, he realized that he can cheat the goalkeeper. After all, they are playing in a football box with solid walls. Robo-Wallace can kick the ball to the other side, then the goalkeeper will not try to catch the ball. Then, if the ball bounces off the wall and flies into the goal, the goal will at last be scored.
Your task is to help Robo-Wallace to detect a spot on the wall of the football box, to which the robot should kick the ball, so that the ball bounces once and only once off this wall and goes straight to the goal. In the first half of the match Robo-Wallace got a ball in the head and was severely hit. As a result, some of the schemes have been damaged. Because of the damage, Robo-Wallace can only aim to his right wall (Robo-Wallace is standing with his face to the opposing team's goal).
The football box is rectangular. Let's introduce a two-dimensional coordinate system so that point (0, 0) lies in the lower left corner of the field, if you look at the box above. Robo-Wallace is playing for the team, whose goal is to the right. It is an improvised football field, so the gate of Robo-Wallace's rivals may be not in the middle of the left wall.
<image>
In the given coordinate system you are given:
* y1, y2 — the y-coordinates of the side pillars of the goalposts of robo-Wallace's opponents;
* yw — the y-coordinate of the wall to which Robo-Wallace is aiming;
* xb, yb — the coordinates of the ball's position when it is hit;
* r — the radius of the ball.
A goal is scored when the center of the ball crosses the OY axis in the given coordinate system between (0, y1) and (0, y2). The ball moves along a straight line. The ball's hit on the wall is perfectly elastic (the ball does not shrink from the hit), the angle of incidence equals the angle of reflection. If the ball bounces off the wall not to the goal, that is, if it hits the other wall or the goal post, then the opposing team catches the ball and Robo-Wallace starts looking for miscalculation and gets dysfunctional. Such an outcome, if possible, should be avoided. We assume that the ball touches an object, if the distance from the center of the ball to the object is no greater than the ball radius r.
Input
The first and the single line contains integers y1, y2, yw, xb, yb, r (1 ≤ y1, y2, yw, xb, yb ≤ 106; y1 < y2 < yw; yb + r < yw; 2·r < y2 - y1).
It is guaranteed that the ball is positioned correctly in the field, doesn't cross any wall, doesn't touch the wall that Robo-Wallace is aiming at. The goal posts can't be located in the field corners.
Output
If Robo-Wallace can't score a goal in the described manner, print "-1" (without the quotes). Otherwise, print a single number xw — the abscissa of his point of aiming.
If there are multiple points of aiming, print the abscissa of any of them. When checking the correctness of the answer, all comparisons are made with the permissible absolute error, equal to 10 - 8.
It is recommended to print as many characters after the decimal point as possible.
Examples
Input
4 10 13 10 3 1
Output
4.3750000000
Input
1 4 6 2 2 1
Output
-1
Input
3 10 15 17 9 2
Output
11.3333333333
Note
Note that in the first and third samples other correct values of abscissa xw are also possible.
Submitted Solution:
```
y1 , y2 , yw , xb , yb , r = map(int,input().split())
Y = y1 + r
def f(y):
return (xb*(yw-y-r))/(2*yw-2*r-yb-y)
x = f(y2 - r)
if x > r and x < xb:
print('%.10f'%(x + 1e-5))
Y = yw-r-(x*(yw-r-yb)/(xb-x))
#print(Y)
else:
x = f(y1 + r)
if x > r and x < xb:
print('%.10f'%(x + 1e-5))
Y = yw-r-(x*(yw-r-yb)/(xb-x))
#print(Y)
else:
print("-1")
``` | instruction | 0 | 24,116 | 3 | 48,232 |
No | output | 1 | 24,116 | 3 | 48,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a beautiful April day and Wallace is playing football with his friends. But his friends do not know that Wallace actually stayed home with Gromit and sent them his robotic self instead. Robo-Wallace has several advantages over the other guys. For example, he can hit the ball directly to the specified point. And yet, the notion of a giveaway is foreign to him. The combination of these features makes the Robo-Wallace the perfect footballer — as soon as the ball gets to him, he can just aim and hit the goal. He followed this tactics in the first half of the match, but he hit the goal rarely. The opposing team has a very good goalkeeper who catches most of the balls that fly directly into the goal. But Robo-Wallace is a quick thinker, he realized that he can cheat the goalkeeper. After all, they are playing in a football box with solid walls. Robo-Wallace can kick the ball to the other side, then the goalkeeper will not try to catch the ball. Then, if the ball bounces off the wall and flies into the goal, the goal will at last be scored.
Your task is to help Robo-Wallace to detect a spot on the wall of the football box, to which the robot should kick the ball, so that the ball bounces once and only once off this wall and goes straight to the goal. In the first half of the match Robo-Wallace got a ball in the head and was severely hit. As a result, some of the schemes have been damaged. Because of the damage, Robo-Wallace can only aim to his right wall (Robo-Wallace is standing with his face to the opposing team's goal).
The football box is rectangular. Let's introduce a two-dimensional coordinate system so that point (0, 0) lies in the lower left corner of the field, if you look at the box above. Robo-Wallace is playing for the team, whose goal is to the right. It is an improvised football field, so the gate of Robo-Wallace's rivals may be not in the middle of the left wall.
<image>
In the given coordinate system you are given:
* y1, y2 — the y-coordinates of the side pillars of the goalposts of robo-Wallace's opponents;
* yw — the y-coordinate of the wall to which Robo-Wallace is aiming;
* xb, yb — the coordinates of the ball's position when it is hit;
* r — the radius of the ball.
A goal is scored when the center of the ball crosses the OY axis in the given coordinate system between (0, y1) and (0, y2). The ball moves along a straight line. The ball's hit on the wall is perfectly elastic (the ball does not shrink from the hit), the angle of incidence equals the angle of reflection. If the ball bounces off the wall not to the goal, that is, if it hits the other wall or the goal post, then the opposing team catches the ball and Robo-Wallace starts looking for miscalculation and gets dysfunctional. Such an outcome, if possible, should be avoided. We assume that the ball touches an object, if the distance from the center of the ball to the object is no greater than the ball radius r.
Input
The first and the single line contains integers y1, y2, yw, xb, yb, r (1 ≤ y1, y2, yw, xb, yb ≤ 106; y1 < y2 < yw; yb + r < yw; 2·r < y2 - y1).
It is guaranteed that the ball is positioned correctly in the field, doesn't cross any wall, doesn't touch the wall that Robo-Wallace is aiming at. The goal posts can't be located in the field corners.
Output
If Robo-Wallace can't score a goal in the described manner, print "-1" (without the quotes). Otherwise, print a single number xw — the abscissa of his point of aiming.
If there are multiple points of aiming, print the abscissa of any of them. When checking the correctness of the answer, all comparisons are made with the permissible absolute error, equal to 10 - 8.
It is recommended to print as many characters after the decimal point as possible.
Examples
Input
4 10 13 10 3 1
Output
4.3750000000
Input
1 4 6 2 2 1
Output
-1
Input
3 10 15 17 9 2
Output
11.3333333333
Note
Note that in the first and third samples other correct values of abscissa xw are also possible.
Submitted Solution:
```
(y1, y2, yw, xb, yb, r) = map(int, input().split())
yt = yw*2-r*2-y1
xw = xb*(yt-yw+r)/(yt-yb)
if xw < 1e-8 + r or yt / xb * r > 1e-8 + ((y2-y1)**2 - r**2)**0.5:
print(-1)
else:
print(xw)
``` | instruction | 0 | 24,117 | 3 | 48,234 |
No | output | 1 | 24,117 | 3 | 48,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's a beautiful April day and Wallace is playing football with his friends. But his friends do not know that Wallace actually stayed home with Gromit and sent them his robotic self instead. Robo-Wallace has several advantages over the other guys. For example, he can hit the ball directly to the specified point. And yet, the notion of a giveaway is foreign to him. The combination of these features makes the Robo-Wallace the perfect footballer — as soon as the ball gets to him, he can just aim and hit the goal. He followed this tactics in the first half of the match, but he hit the goal rarely. The opposing team has a very good goalkeeper who catches most of the balls that fly directly into the goal. But Robo-Wallace is a quick thinker, he realized that he can cheat the goalkeeper. After all, they are playing in a football box with solid walls. Robo-Wallace can kick the ball to the other side, then the goalkeeper will not try to catch the ball. Then, if the ball bounces off the wall and flies into the goal, the goal will at last be scored.
Your task is to help Robo-Wallace to detect a spot on the wall of the football box, to which the robot should kick the ball, so that the ball bounces once and only once off this wall and goes straight to the goal. In the first half of the match Robo-Wallace got a ball in the head and was severely hit. As a result, some of the schemes have been damaged. Because of the damage, Robo-Wallace can only aim to his right wall (Robo-Wallace is standing with his face to the opposing team's goal).
The football box is rectangular. Let's introduce a two-dimensional coordinate system so that point (0, 0) lies in the lower left corner of the field, if you look at the box above. Robo-Wallace is playing for the team, whose goal is to the right. It is an improvised football field, so the gate of Robo-Wallace's rivals may be not in the middle of the left wall.
<image>
In the given coordinate system you are given:
* y1, y2 — the y-coordinates of the side pillars of the goalposts of robo-Wallace's opponents;
* yw — the y-coordinate of the wall to which Robo-Wallace is aiming;
* xb, yb — the coordinates of the ball's position when it is hit;
* r — the radius of the ball.
A goal is scored when the center of the ball crosses the OY axis in the given coordinate system between (0, y1) and (0, y2). The ball moves along a straight line. The ball's hit on the wall is perfectly elastic (the ball does not shrink from the hit), the angle of incidence equals the angle of reflection. If the ball bounces off the wall not to the goal, that is, if it hits the other wall or the goal post, then the opposing team catches the ball and Robo-Wallace starts looking for miscalculation and gets dysfunctional. Such an outcome, if possible, should be avoided. We assume that the ball touches an object, if the distance from the center of the ball to the object is no greater than the ball radius r.
Input
The first and the single line contains integers y1, y2, yw, xb, yb, r (1 ≤ y1, y2, yw, xb, yb ≤ 106; y1 < y2 < yw; yb + r < yw; 2·r < y2 - y1).
It is guaranteed that the ball is positioned correctly in the field, doesn't cross any wall, doesn't touch the wall that Robo-Wallace is aiming at. The goal posts can't be located in the field corners.
Output
If Robo-Wallace can't score a goal in the described manner, print "-1" (without the quotes). Otherwise, print a single number xw — the abscissa of his point of aiming.
If there are multiple points of aiming, print the abscissa of any of them. When checking the correctness of the answer, all comparisons are made with the permissible absolute error, equal to 10 - 8.
It is recommended to print as many characters after the decimal point as possible.
Examples
Input
4 10 13 10 3 1
Output
4.3750000000
Input
1 4 6 2 2 1
Output
-1
Input
3 10 15 17 9 2
Output
11.3333333333
Note
Note that in the first and third samples other correct values of abscissa xw are also possible.
Submitted Solution:
```
(y1, y2, yw, xb, yb, r) = map(int, input().split())
yt = yw*2-r*2-y2+r
xw = xb*(yt-yw+r)/(yt-yb)
if xw < 1e-8 + r and r-(r**2-xw**2)**0.5 < 1e-8+yw-y2 or (yt-yb) / xb * r > 1e-8 + ((y2-y1)**2 - r**2)**0.5:
print(-1)
else:
print(xw)
``` | instruction | 0 | 24,118 | 3 | 48,236 |
No | output | 1 | 24,118 | 3 | 48,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond. | instruction | 0 | 24,153 | 3 | 48,306 |
Tags: brute force, graphs, math
Correct Solution:
```
a=[*map(int,input().split())]
s=sum(a)
if s%2 or any(s//2-j<0 for j in a):
print('Impossible')
else:
print(s//2-a[2],s//2-a[0],s//2-a[1])
``` | output | 1 | 24,153 | 3 | 48,307 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond. | instruction | 0 | 24,154 | 3 | 48,308 |
Tags: brute force, graphs, math
Correct Solution:
```
a, b, c = map(int, input().split())
summ = (a + b + c)// 2
if a > b + c or b > a + c or c > a + b or (a + b + c) % 2:
print("Impossible")
exit(0)
print(summ - c, summ - a, summ - b)
``` | output | 1 | 24,154 | 3 | 48,309 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond. | instruction | 0 | 24,155 | 3 | 48,310 |
Tags: brute force, graphs, math
Correct Solution:
```
a, b, c = map(int, input().split())
if (a + b + c) % 2 != 0:
print('Impossible')
else:
x = ( a + b + c) // 2 - a
y = ( a + b + c ) // 2 - b
z = ( a + b + c) // 2 - c
if x >= 0 and y >= 0 and z >= 0:
print(z, x, y)
else:
print('Impossible')
``` | output | 1 | 24,155 | 3 | 48,311 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond. | instruction | 0 | 24,156 | 3 | 48,312 |
Tags: brute force, graphs, math
Correct Solution:
```
import sys
a, b, c = list(map(int, input().split()))
if c - b + a < 0 or (c - b + a) % 2 == 1:
print("Impossible")
sys.exit()
f = (c - b + a) // 2
e = b - a + f
d = a - f
if d < 0 or f < 0 or e < 0:
print("Impossible")
sys.exit()
print(d, e, f)
``` | output | 1 | 24,156 | 3 | 48,313 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond. | instruction | 0 | 24,157 | 3 | 48,314 |
Tags: brute force, graphs, math
Correct Solution:
```
import math
#n,m=map(int,input().split())
from collections import Counter
#for i in range(n):
import math
#for _ in range(int(input())):
#n = int(input())
a, b, c = map(int, input().split())
if (a + b + c) % 2 != 0:
print("Impossible")
else:
x=(a + b - c) // 2
y=b-x
z=a-x
if x>=0 and y>=0 and z>=0:
print(x, y, z)
else:
print("Impossible")
``` | output | 1 | 24,157 | 3 | 48,315 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond. | instruction | 0 | 24,158 | 3 | 48,316 |
Tags: brute force, graphs, math
Correct Solution:
```
a, b, c = map(int, input().split())
s = (a + b + c) // 2
if (a+b+c) % 2 == 1 or s - a < 0 or s - b < 0 or s - c < 0:
print("Impossible")
else:
print(s - c, s - a, s - b)
``` | output | 1 | 24,158 | 3 | 48,317 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond. | instruction | 0 | 24,159 | 3 | 48,318 |
Tags: brute force, graphs, math
Correct Solution:
```
a,b,c=map(int,input().split())
if (a+b+c)%2==0 and a+b>=c and b+c>=a and c+a>=b:
print(abs((a+b-c)//2),abs((b+c-a)//2),abs((c+a-b)//2))
else:
print('Impossible')
``` | output | 1 | 24,159 | 3 | 48,319 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond.
Submitted Solution:
```
a,b,c=map(int,input().split(' '))
y=(b+c-a)//2
z=b-y
x=a-z
if x>=0 and y>=0 and z>=0 and (b+c-a)%2==0:
print(z,y,x)
else:
print('Impossible')
``` | instruction | 0 | 24,160 | 3 | 48,320 |
Yes | output | 1 | 24,160 | 3 | 48,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond.
Submitted Solution:
```
a, b, c = map(int, input().split())
x = a
y = b
z = c
g = 0
if a > b + c or b > a + c or c > a + b or (a + b + c) % 2 != 0:
print('Impossible')
exit(0)
if a >= b and a >= c:
while x != y + z:
g += 1
y -= 1
z -= 1
print(y, g, z)
exit(0)
if b >= a and b >= c:
while y != x + z:
g += 1
x -= 1
z -= 1
print(x, z, g)
exit(0)
if c >= a and c >= b:
while z != x + y:
g += 1
x -= 1
y -= 1
print(g, y, x)
``` | instruction | 0 | 24,161 | 3 | 48,322 |
Yes | output | 1 | 24,161 | 3 | 48,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond.
Submitted Solution:
```
from operator import itemgetter
class CodeforcesTask344BSolution:
def __init__(self):
self.result = ''
self.a_b_c = []
def read_input(self):
self.a_b_c = [int(x) for x in input().split(" ")]
def process_task(self):
a = self.a_b_c[0]
b = self.a_b_c[1]
c = self.a_b_c[2]
if a > b + c or b > a + c or c > a + b:
self.result = "Impossible"
else:
connections = [0, 0, 0]
updating = [[0, a], [1, b], [2, c]]
cannot = False
while sum(connections) * 2 != sum(self.a_b_c) and not cannot:
updating.sort(key=itemgetter(1), reverse=True)
update_rate = updating[1][1] - updating[2][1]
if not update_rate:
if updating[1][1]:
update_rate = updating[1][1] // 4
if not update_rate:
update_rate = 1
else:
cannot = True
updating[0][1] -= update_rate
updating[1][1] -= update_rate
if updating[0][0] > updating[1][0]:
if updating[0][0] - updating[1][0] > 1:
connections[2] += update_rate
else:
connections[updating[1][0]] += update_rate
else:
if updating[1][0] - updating[0][0] > 1:
connections[2] += update_rate
else:
connections[updating[0][0]] += update_rate
if cannot:
self.result = "Impossible"
else:
self.result = " ".join([str(x) for x in connections])
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask344BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
``` | instruction | 0 | 24,162 | 3 | 48,324 |
Yes | output | 1 | 24,162 | 3 | 48,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond.
Submitted Solution:
```
a,b,c=map(int,input().split())
if True:
diff=abs(b-c)
if diff>a:
print('Impossible')
else:
a-=diff
if a%2==0 and a<=2*min(c,b):
if max(c,b)==b:
print(diff+a//2,c-a//2,a//2)
else:
print(a//2,b-a//2,diff+a//2)
else:
print("Impossible")
``` | instruction | 0 | 24,163 | 3 | 48,326 |
Yes | output | 1 | 24,163 | 3 | 48,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond.
Submitted Solution:
```
a, b, c = map(int, input().split())
su = sum([a, b, c])
for n in [a, b, c]:
if (su - n < n):
print ('Impossible')
exit()
for i in range(max([a, b, c])):
ab = i
bc = b - ab
ca = c - bc
if (bc > 0 or ca > 0) and (bc >= 0 and ca >= 0):
if (ab + ca == a):
print (ab, bc, ca)
exit()
``` | instruction | 0 | 24,164 | 3 | 48,328 |
No | output | 1 | 24,164 | 3 | 48,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond.
Submitted Solution:
```
a, b, c = map(int, input().split())
x = (b + c - a) / 2
y = (c + a - b) / 2
z = (a + b - c) / 2
if x != round(x) or y != round(y) or z != round(z):
print("Impossible")
print(round(x), round(y), round(z))
``` | instruction | 0 | 24,165 | 3 | 48,330 |
No | output | 1 | 24,165 | 3 | 48,331 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond.
Submitted Solution:
```
a,b,c = map(int,input().split())
if a>=b and a>=c:
if a>b+c:
print('Impossible')
elif a==b+c:
print(b,0,c)
else:
i=2
flag=0
while b+c-i>=a:
if a==b+c-i:
print(b-(i//2),i//2,c-(i//2))
flag=1
break
i+=2
if flag==0:
print('Impossible')
if b>=a and b>=c:
if b>a+c:
print('Impossible')
elif b==a+c:
print(a,c,0)
else:
i=2
flag=0
while a+c-i>=b:
if b==a+c-i:
print(a-(i//2),c-(i//2),i//2)
flag=1
break
i+=2
if flag==0:
print('Impossible')
if c>=b and c>=a:
if c>b+a:
print('Impossible')
elif c==b+a:
print(0,b,a)
else:
i=2
flag=0
while b+a-i>=c:
if c==b+a-i:
print(i//2,b-(i//2),a-(i//2))
flag=1
break
i+=2
if flag==0:
print('Impossible')
``` | instruction | 0 | 24,166 | 3 | 48,332 |
No | output | 1 | 24,166 | 3 | 48,333 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mad scientist Mike is busy carrying out experiments in chemistry. Today he will attempt to join three atoms into one molecule.
A molecule consists of atoms, with some pairs of atoms connected by atomic bonds. Each atom has a valence number — the number of bonds the atom must form with other atoms. An atom can form one or multiple bonds with any other atom, but it cannot form a bond with itself. The number of bonds of an atom in the molecule must be equal to its valence number.
<image>
Mike knows valence numbers of the three atoms. Find a molecule that can be built from these atoms according to the stated rules, or determine that it is impossible.
Input
The single line of the input contains three space-separated integers a, b and c (1 ≤ a, b, c ≤ 106) — the valence numbers of the given atoms.
Output
If such a molecule can be built, print three space-separated integers — the number of bonds between the 1-st and the 2-nd, the 2-nd and the 3-rd, the 3-rd and the 1-st atoms, correspondingly. If there are multiple solutions, output any of them. If there is no solution, print "Impossible" (without the quotes).
Examples
Input
1 1 2
Output
0 1 1
Input
3 4 5
Output
1 3 2
Input
4 1 1
Output
Impossible
Note
The first sample corresponds to the first figure. There are no bonds between atoms 1 and 2 in this case.
The second sample corresponds to the second figure. There is one or more bonds between each pair of atoms.
The third sample corresponds to the third figure. There is no solution, because an atom cannot form bonds with itself.
The configuration in the fourth figure is impossible as each atom must have at least one atomic bond.
Submitted Solution:
```
l=list(map(int,input().split()))
a=sum(l)
d1=l[0]
d2=l[1]
d3=l[2]
a=d1+d2-d3
b=d2+d3-d1
c=d1+d3-d2
if min(a,b,c)<0:
print("Impossible")
else:
print(a//2,b//2,c//2)
``` | instruction | 0 | 24,167 | 3 | 48,334 |
No | output | 1 | 24,167 | 3 | 48,335 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The research center Q has developed a new multi-core processor. The processor consists of n cores and has k cells of cache memory. Consider the work of this processor.
At each cycle each core of the processor gets one instruction: either do nothing, or the number of the memory cell (the core will write an information to the cell). After receiving the command, the core executes it immediately. Sometimes it happens that at one cycle, multiple cores try to write the information into a single cell. Unfortunately, the developers did not foresee the possibility of resolving conflicts between cores, so in this case there is a deadlock: all these cores and the corresponding memory cell are locked forever. Each of the locked cores ignores all further commands, and no core in the future will be able to record an information into the locked cell. If any of the cores tries to write an information into some locked cell, it is immediately locked.
The development team wants to explore the deadlock situation. Therefore, they need a program that will simulate the processor for a given set of instructions for each core within m cycles . You're lucky, this interesting work is entrusted to you. According to the instructions, during the m cycles define for each core the number of the cycle, during which it will become locked. It is believed that initially all cores and all memory cells are not locked.
Input
The first line contains three integers n, m, k (1 ≤ n, m, k ≤ 100). Then follow n lines describing instructions. The i-th line contains m integers: xi1, xi2, ..., xim (0 ≤ xij ≤ k), where xij is the instruction that must be executed by the i-th core at the j-th cycle. If xij equals 0, then the corresponding instruction is «do nothing». But if xij is a number from 1 to k, then the corresponding instruction is «write information to the memory cell number xij».
We assume that the cores are numbered from 1 to n, the work cycles are numbered from 1 to m and the memory cells are numbered from 1 to k.
Output
Print n lines. In the i-th line print integer ti. This number should be equal to 0 if the i-th core won't be locked, or it should be equal to the number of the cycle when this core will be locked.
Examples
Input
4 3 5
1 0 0
1 0 2
2 3 1
3 2 0
Output
1
1
3
0
Input
3 2 2
1 2
1 2
2 2
Output
1
1
0
Input
1 1 1
0
Output
0
Submitted Solution:
```
b=input().split()
core=[]
kcore=int(b[0])
ktact=int(b[1])
for i in range(kcore):
work=input().split()
core.append([])
for j in range(ktact):
core[i].append(int(work[j]))
#...
zmemory=[]
for i in range(int(b[2])):
zmemory.append(0)
zcore=[]
answer=[]
for i in range(kcore):
zcore.append(0)
answer.append(0)
#...
for i in range(ktact):
freecore=[]
for j in range(kcore):
if zcore[j]==0:
freecore.append(j)
for j in freecore:
if not(core[j][i]==0):
if zmemory[core[j][i]-1]:
zcore[j]=1
answer[j]=i+1
for k in freecore:
if not(k==j):
if core[j][i]==core[k][i]:
zmemory[core[j][i]-1]=1
zcore[j]=1
answer[j]=i+1
zcore[k]=1
answer[k]=i+1
#...
for i in range(kcore):
print(answer[i])
``` | instruction | 0 | 24,176 | 3 | 48,352 |
Yes | output | 1 | 24,176 | 3 | 48,353 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The research center Q has developed a new multi-core processor. The processor consists of n cores and has k cells of cache memory. Consider the work of this processor.
At each cycle each core of the processor gets one instruction: either do nothing, or the number of the memory cell (the core will write an information to the cell). After receiving the command, the core executes it immediately. Sometimes it happens that at one cycle, multiple cores try to write the information into a single cell. Unfortunately, the developers did not foresee the possibility of resolving conflicts between cores, so in this case there is a deadlock: all these cores and the corresponding memory cell are locked forever. Each of the locked cores ignores all further commands, and no core in the future will be able to record an information into the locked cell. If any of the cores tries to write an information into some locked cell, it is immediately locked.
The development team wants to explore the deadlock situation. Therefore, they need a program that will simulate the processor for a given set of instructions for each core within m cycles . You're lucky, this interesting work is entrusted to you. According to the instructions, during the m cycles define for each core the number of the cycle, during which it will become locked. It is believed that initially all cores and all memory cells are not locked.
Input
The first line contains three integers n, m, k (1 ≤ n, m, k ≤ 100). Then follow n lines describing instructions. The i-th line contains m integers: xi1, xi2, ..., xim (0 ≤ xij ≤ k), where xij is the instruction that must be executed by the i-th core at the j-th cycle. If xij equals 0, then the corresponding instruction is «do nothing». But if xij is a number from 1 to k, then the corresponding instruction is «write information to the memory cell number xij».
We assume that the cores are numbered from 1 to n, the work cycles are numbered from 1 to m and the memory cells are numbered from 1 to k.
Output
Print n lines. In the i-th line print integer ti. This number should be equal to 0 if the i-th core won't be locked, or it should be equal to the number of the cycle when this core will be locked.
Examples
Input
4 3 5
1 0 0
1 0 2
2 3 1
3 2 0
Output
1
1
3
0
Input
3 2 2
1 2
1 2
2 2
Output
1
1
0
Input
1 1 1
0
Output
0
Submitted Solution:
```
import sys
read = lambda: list(map(int, sys.stdin.readline().split()))
n, m, k = read()
table = []
for _ in range(n):
table.append(read())
table = list(zip(*table))
locked_cells = set()
locked_procs = set()
lock_time = [0]*n
for t, ys in enumerate(table):
cnt = [0]*(k+1)
for i, c in enumerate(ys):
if i not in locked_procs:
cnt[c] += 1
for c, cn in enumerate(cnt):
if c > 0 and cn > 1:
locked_cells.add(c)
for i, c in enumerate(ys):
if c in locked_cells and i not in locked_procs:
locked_procs.add(i)
lock_time[i] = t+1
for t in lock_time:
print(t)
``` | instruction | 0 | 24,177 | 3 | 48,354 |
Yes | output | 1 | 24,177 | 3 | 48,355 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.