message stringlengths 2 44.5k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 276 109k | cluster float64 23 23 | __index_level_0__ int64 552 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane n rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other.
Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible.
Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length
<image> The picture corresponds to the first example
Input
The first line contains single integer n (1 ≤ n ≤ 5·105) — the number of rectangles.
n lines follow. The i-th of these lines contains four integers x1, y1, x2 and y2 ( - 109 ≤ x1 < x2 ≤ 109, - 109 ≤ y1 < y2 ≤ 109), that means that points (x1, y1) and (x2, y2) are the coordinates of two opposite corners of the i-th rectangle.
It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other.
Output
Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color.
Otherwise, print "YES" in the first line. Then print n lines, in the i-th of them print single integer ci (1 ≤ ci ≤ 4) — the color of i-th rectangle.
Example
Input
8
0 0 5 3
2 -1 5 0
-3 -4 2 -1
-1 -1 2 0
-3 0 0 5
5 2 10 3
7 -3 10 2
4 -2 7 -1
Output
YES
1
2
2
3
2
2
4
1 | instruction | 0 | 69,480 | 23 | 138,960 |
Tags: constructive algorithms, geometry
Correct Solution:
```
n = int(input())
print("YES")
for i in range(n):
a, b, c, d = map(int, input().split())
print(1 + (a % 2) + 2*(b % 2))
``` | output | 1 | 69,480 | 23 | 138,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane n rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other.
Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible.
Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length
<image> The picture corresponds to the first example
Input
The first line contains single integer n (1 ≤ n ≤ 5·105) — the number of rectangles.
n lines follow. The i-th of these lines contains four integers x1, y1, x2 and y2 ( - 109 ≤ x1 < x2 ≤ 109, - 109 ≤ y1 < y2 ≤ 109), that means that points (x1, y1) and (x2, y2) are the coordinates of two opposite corners of the i-th rectangle.
It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other.
Output
Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color.
Otherwise, print "YES" in the first line. Then print n lines, in the i-th of them print single integer ci (1 ≤ ci ≤ 4) — the color of i-th rectangle.
Example
Input
8
0 0 5 3
2 -1 5 0
-3 -4 2 -1
-1 -1 2 0
-3 0 0 5
5 2 10 3
7 -3 10 2
4 -2 7 -1
Output
YES
1
2
2
3
2
2
4
1 | instruction | 0 | 69,481 | 23 | 138,962 |
Tags: constructive algorithms, geometry
Correct Solution:
```
n = int(input())
ans = 'YES\n'
for i in range(n):
x1, y1, x2, y2 = map(int, input().split())
res = (x1 & 1) * 2 + (y1 & 1) + 1
ans += str(res) + '\n'
print(ans)
``` | output | 1 | 69,481 | 23 | 138,963 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane n rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other.
Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible.
Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length
<image> The picture corresponds to the first example
Input
The first line contains single integer n (1 ≤ n ≤ 5·105) — the number of rectangles.
n lines follow. The i-th of these lines contains four integers x1, y1, x2 and y2 ( - 109 ≤ x1 < x2 ≤ 109, - 109 ≤ y1 < y2 ≤ 109), that means that points (x1, y1) and (x2, y2) are the coordinates of two opposite corners of the i-th rectangle.
It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other.
Output
Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color.
Otherwise, print "YES" in the first line. Then print n lines, in the i-th of them print single integer ci (1 ≤ ci ≤ 4) — the color of i-th rectangle.
Example
Input
8
0 0 5 3
2 -1 5 0
-3 -4 2 -1
-1 -1 2 0
-3 0 0 5
5 2 10 3
7 -3 10 2
4 -2 7 -1
Output
YES
1
2
2
3
2
2
4
1 | instruction | 0 | 69,482 | 23 | 138,964 |
Tags: constructive algorithms, geometry
Correct Solution:
```
'''plan
noticed that if both upperle
'''
from sys import stdin, stdout
# n = int(stdin.readline().rstrip())
# n = int(input())
all_lines = stdin.read().split('\n')
stdout.write('YES\n')
for line in all_lines[1:-1]:
x1, y1, x2, y2 = (int(x) % 2 for x in line.split())
num = 2 * x2 + y2 + 1
# stdout.write(str(x2) + ' ' + str(y2) + '\n')
print(str(num) + '\n')
#stdout.flush()
#exit()
# for i in range(n):
# coordinates.append([int(x) % 2 for x in input().split()])
# for i in range(n):
# coordinates.append([int(x) % 2 for x in stdin.readline().rstrip().split()])
# stdout.write('YES\n')
# for coordinate in coordinates:
# x1, y1, x2, y2 = coordinate
# stdout.write(str(2 * x2 + y2 + 1) + '\n')
``` | output | 1 | 69,482 | 23 | 138,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane n rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other.
Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible.
Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length
<image> The picture corresponds to the first example
Input
The first line contains single integer n (1 ≤ n ≤ 5·105) — the number of rectangles.
n lines follow. The i-th of these lines contains four integers x1, y1, x2 and y2 ( - 109 ≤ x1 < x2 ≤ 109, - 109 ≤ y1 < y2 ≤ 109), that means that points (x1, y1) and (x2, y2) are the coordinates of two opposite corners of the i-th rectangle.
It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other.
Output
Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color.
Otherwise, print "YES" in the first line. Then print n lines, in the i-th of them print single integer ci (1 ≤ ci ≤ 4) — the color of i-th rectangle.
Example
Input
8
0 0 5 3
2 -1 5 0
-3 -4 2 -1
-1 -1 2 0
-3 0 0 5
5 2 10 3
7 -3 10 2
4 -2 7 -1
Output
YES
1
2
2
3
2
2
4
1
Submitted Solution:
```
n = int(input())
print("YES")
for i in range(n):
t1, y1, x2, y2 = input().split()
print((int(t1) % 2) * 2 + (int(y1) % 2) + 1)
``` | instruction | 0 | 69,483 | 23 | 138,966 |
Yes | output | 1 | 69,483 | 23 | 138,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane n rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other.
Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible.
Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length
<image> The picture corresponds to the first example
Input
The first line contains single integer n (1 ≤ n ≤ 5·105) — the number of rectangles.
n lines follow. The i-th of these lines contains four integers x1, y1, x2 and y2 ( - 109 ≤ x1 < x2 ≤ 109, - 109 ≤ y1 < y2 ≤ 109), that means that points (x1, y1) and (x2, y2) are the coordinates of two opposite corners of the i-th rectangle.
It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other.
Output
Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color.
Otherwise, print "YES" in the first line. Then print n lines, in the i-th of them print single integer ci (1 ≤ ci ≤ 4) — the color of i-th rectangle.
Example
Input
8
0 0 5 3
2 -1 5 0
-3 -4 2 -1
-1 -1 2 0
-3 0 0 5
5 2 10 3
7 -3 10 2
4 -2 7 -1
Output
YES
1
2
2
3
2
2
4
1
Submitted Solution:
```
'''plan
noticed that if both upperle
'''
from sys import stdin, stdout
# n = int(stdin.readline().rstrip())
# n = int(input())
all_lines = stdin.read().split('\n')
stdout.write('YES\n')
for line in all_lines[1:-1]:
x1, y1, x2, y2 = (int(x) % 2 for x in line.split())
num = 2 * x2 + y2 + 1
# stdout.write(str(x2) + ' ' + str(y2) + '\n')
stdout.write(str(num) + '\n')
#stdout.flush()
#exit()
# for i in range(n):
# coordinates.append([int(x) % 2 for x in input().split()])
# for i in range(n):
# coordinates.append([int(x) % 2 for x in stdin.readline().rstrip().split()])
# stdout.write('YES\n')
# for coordinate in coordinates:
# x1, y1, x2, y2 = coordinate
# stdout.write(str(2 * x2 + y2 + 1) + '\n')
``` | instruction | 0 | 69,484 | 23 | 138,968 |
Yes | output | 1 | 69,484 | 23 | 138,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane n rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other.
Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible.
Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length
<image> The picture corresponds to the first example
Input
The first line contains single integer n (1 ≤ n ≤ 5·105) — the number of rectangles.
n lines follow. The i-th of these lines contains four integers x1, y1, x2 and y2 ( - 109 ≤ x1 < x2 ≤ 109, - 109 ≤ y1 < y2 ≤ 109), that means that points (x1, y1) and (x2, y2) are the coordinates of two opposite corners of the i-th rectangle.
It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other.
Output
Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color.
Otherwise, print "YES" in the first line. Then print n lines, in the i-th of them print single integer ci (1 ≤ ci ≤ 4) — the color of i-th rectangle.
Example
Input
8
0 0 5 3
2 -1 5 0
-3 -4 2 -1
-1 -1 2 0
-3 0 0 5
5 2 10 3
7 -3 10 2
4 -2 7 -1
Output
YES
1
2
2
3
2
2
4
1
Submitted Solution:
```
from sys import stdin,stdout
n = int(stdin.readline())
stdout.write("YES")
stdout.write('\n')
for i in range(n):
x1, y1, x2, y2 = map(int,stdin.readline().split())
stdout.write(str((x1 % 2) * 2 + (y1 % 2) + 1))
stdout.write('\n')
``` | instruction | 0 | 69,485 | 23 | 138,970 |
Yes | output | 1 | 69,485 | 23 | 138,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane n rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other.
Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible.
Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length
<image> The picture corresponds to the first example
Input
The first line contains single integer n (1 ≤ n ≤ 5·105) — the number of rectangles.
n lines follow. The i-th of these lines contains four integers x1, y1, x2 and y2 ( - 109 ≤ x1 < x2 ≤ 109, - 109 ≤ y1 < y2 ≤ 109), that means that points (x1, y1) and (x2, y2) are the coordinates of two opposite corners of the i-th rectangle.
It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other.
Output
Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color.
Otherwise, print "YES" in the first line. Then print n lines, in the i-th of them print single integer ci (1 ≤ ci ≤ 4) — the color of i-th rectangle.
Example
Input
8
0 0 5 3
2 -1 5 0
-3 -4 2 -1
-1 -1 2 0
-3 0 0 5
5 2 10 3
7 -3 10 2
4 -2 7 -1
Output
YES
1
2
2
3
2
2
4
1
Submitted Solution:
```
n = int(input())
a = [0 for i in range(n)]
for i in range(n):
inp = input().split()
x = int(inp[0])
y = int(inp[1])
a[i] = 2 * (x % 2) + (y % 2) + 1
print("YES")
print("\n".join(str(i) for i in a))
``` | instruction | 0 | 69,486 | 23 | 138,972 |
Yes | output | 1 | 69,486 | 23 | 138,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane n rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other.
Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible.
Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length
<image> The picture corresponds to the first example
Input
The first line contains single integer n (1 ≤ n ≤ 5·105) — the number of rectangles.
n lines follow. The i-th of these lines contains four integers x1, y1, x2 and y2 ( - 109 ≤ x1 < x2 ≤ 109, - 109 ≤ y1 < y2 ≤ 109), that means that points (x1, y1) and (x2, y2) are the coordinates of two opposite corners of the i-th rectangle.
It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other.
Output
Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color.
Otherwise, print "YES" in the first line. Then print n lines, in the i-th of them print single integer ci (1 ≤ ci ≤ 4) — the color of i-th rectangle.
Example
Input
8
0 0 5 3
2 -1 5 0
-3 -4 2 -1
-1 -1 2 0
-3 0 0 5
5 2 10 3
7 -3 10 2
4 -2 7 -1
Output
YES
1
2
2
3
2
2
4
1
Submitted Solution:
```
from sys import stdin,stdout
n = int(stdin.readline())
stdout.write("YES")
for i in range(n):
x1, y1, x2, y2 = map(int,stdin.readline().split())
stdout.write(str((x1 % 2) * 2 + (y1 % 2) + 1))
``` | instruction | 0 | 69,487 | 23 | 138,974 |
No | output | 1 | 69,487 | 23 | 138,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane n rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other.
Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible.
Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length
<image> The picture corresponds to the first example
Input
The first line contains single integer n (1 ≤ n ≤ 5·105) — the number of rectangles.
n lines follow. The i-th of these lines contains four integers x1, y1, x2 and y2 ( - 109 ≤ x1 < x2 ≤ 109, - 109 ≤ y1 < y2 ≤ 109), that means that points (x1, y1) and (x2, y2) are the coordinates of two opposite corners of the i-th rectangle.
It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other.
Output
Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color.
Otherwise, print "YES" in the first line. Then print n lines, in the i-th of them print single integer ci (1 ≤ ci ≤ 4) — the color of i-th rectangle.
Example
Input
8
0 0 5 3
2 -1 5 0
-3 -4 2 -1
-1 -1 2 0
-3 0 0 5
5 2 10 3
7 -3 10 2
4 -2 7 -1
Output
YES
1
2
2
3
2
2
4
1
Submitted Solution:
```
from sys import stdin,stdout
n = int(stdin.readline())
stdout.write("YES")
for i in range(n):
x1, y1, x2, y2 = map(int,stdin.readline().split())
stdout.write(str((x1 % 2) * 2 + (y1 % 2) + 1))
stdout.write('\n')
``` | instruction | 0 | 69,488 | 23 | 138,976 |
No | output | 1 | 69,488 | 23 | 138,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of Timofey's birthday presents is a colourbook in a shape of an infinite plane. On the plane n rectangles with sides parallel to coordinate axes are situated. All sides of the rectangles have odd length. Rectangles cannot intersect, but they can touch each other.
Help Timofey to color his rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color, or determine that it is impossible.
Two rectangles intersect if their intersection has positive area. Two rectangles touch by sides if there is a pair of sides such that their intersection has non-zero length
<image> The picture corresponds to the first example
Input
The first line contains single integer n (1 ≤ n ≤ 5·105) — the number of rectangles.
n lines follow. The i-th of these lines contains four integers x1, y1, x2 and y2 ( - 109 ≤ x1 < x2 ≤ 109, - 109 ≤ y1 < y2 ≤ 109), that means that points (x1, y1) and (x2, y2) are the coordinates of two opposite corners of the i-th rectangle.
It is guaranteed, that all sides of the rectangles have odd lengths and rectangles don't intersect each other.
Output
Print "NO" in the only line if it is impossible to color the rectangles in 4 different colors in such a way that every two rectangles touching each other by side would have different color.
Otherwise, print "YES" in the first line. Then print n lines, in the i-th of them print single integer ci (1 ≤ ci ≤ 4) — the color of i-th rectangle.
Example
Input
8
0 0 5 3
2 -1 5 0
-3 -4 2 -1
-1 -1 2 0
-3 0 0 5
5 2 10 3
7 -3 10 2
4 -2 7 -1
Output
YES
1
2
2
3
2
2
4
1
Submitted Solution:
```
'''plan
noticed that if both upperle
'''
from sys import stdin, stdout
from itertools import islice
# n = int(stdin.readline().rstrip())
# n = int(input())
all_lines = stdin.read().split('\n')
stdout.write('YES\n')
for line in islice(all_lines, 1, len(all_lines) - 1):
x1, y1, x2, y2 = (int(x) % 2 for x in line.split())
num = 2 * x2 + y2 + 1
stdout.write(str(x2) + ' ' + str(y2) + '\n')
#print(num)
#stdout.flush()
#exit()
# for i in range(n):
# coordinates.append([int(x) % 2 for x in input().split()])
# for i in range(n):
# coordinates.append([int(x) % 2 for x in stdin.readline().rstrip().split()])
# stdout.write('YES\n')
# for coordinate in coordinates:
# x1, y1, x2, y2 = coordinate
# stdout.write(str(2 * x2 + y2 + 1) + '\n')
``` | instruction | 0 | 69,489 | 23 | 138,978 |
No | output | 1 | 69,489 | 23 | 138,979 |
Provide a correct Python 3 solution for this coding contest problem.
There are N points on a number line, i-th of which is placed on coordinate X_i. These points are numbered in the increasing order of coordinates. In other words, for all i (1 \leq i \leq N-1), X_i < X_{i+1} holds. In addition to that, an integer K is given.
Process Q queries.
In the i-th query, two integers L_i and R_i are given. Here, a set s of points is said to be a good set if it satisfies all of the following conditions. Note that the definition of good sets varies over queries.
* Each point in s is one of X_{L_i},X_{L_i+1},\ldots,X_{R_i}.
* For any two distinct points in s, the distance between them is greater than or equal to K.
* The size of s is maximum among all sets that satisfy the aforementioned conditions.
For each query, find the size of the union of all good sets.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 1 \leq K \leq 10^9
* 0 \leq X_1 < X_2 < \cdots < X_N \leq 10^9
* 1 \leq Q \leq 2 \times 10^5
* 1 \leq L_i \leq R_i \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
X_1 X_2 \cdots X_N
Q
L_1 R_1
L_2 R_2
\vdots
L_Q R_Q
Output
For each query, print the size of the union of all good sets in a line.
Examples
Input
5 3
1 2 4 7 8
2
1 5
1 2
Output
4
2
Input
15 220492538
4452279 12864090 23146757 31318558 133073771 141315707 263239555 350278176 401243954 418305779 450172439 560311491 625900495 626194585 891960194
5
6 14
1 8
1 13
7 12
4 12
Output
4
6
11
2
3 | instruction | 0 | 69,590 | 23 | 139,180 |
"Correct Solution:
```
import sys
readline = sys.stdin.buffer.readline
n,k = map(int,readline().split())
vs = list(map(int,readline().split()))
L=18
xid=[0]*(n*L)
xsum=[0]*(n*L)
yid=[0]*(n*L)
ysum=[0]*(n*L)
j=n
for i in reversed(range(n)):
while i<j and vs[i]+k<=vs[j-1]:
j-=1
xid[i*L+0]=j
xsum[i*L+0]=j
for lv in range(1,L):
a=xid[i*L+lv-1]
if a==n:
xid[i*L+lv]=n
else:
xid[i*L+lv]=xid[a*L+lv-1]
xsum[i*L+lv]=xsum[i*L+lv-1]+xsum[a*L+lv-1]
j=-1
for i in range(n):
while j<i and vs[j+1]+k<=vs[i]:
j+=1
yid[i*L+0]=j
ysum[i*L+0]=j
for lv in range(1,L):
a=yid[i*L+lv-1]
if a==-1:
yid[i*L+lv]=-1
else:
yid[i*L+lv]=yid[a*L+lv-1]
ysum[i*L+lv]=ysum[i*L+lv-1]+ysum[a*L+lv-1]
q=int(readline())
for tmp in range(q):
l,r=map(int,readline().split())
l-=1
r-=1
ans=0
i=l
ans-=i
for lv in reversed(range(L)):
if xid[i*L+lv]<=r:
ans-=xsum[i*L+lv]
i=xid[i*L+lv]
i=r
ans+=i+1
for lv in reversed(range(L)):
if yid[i*L+lv]>=l:
ans+=ysum[i*L+lv]+(1<<lv)
i=yid[i*L+lv]
print(ans)
``` | output | 1 | 69,590 | 23 | 139,181 |
Provide a correct Python 3 solution for this coding contest problem.
There are N points on a number line, i-th of which is placed on coordinate X_i. These points are numbered in the increasing order of coordinates. In other words, for all i (1 \leq i \leq N-1), X_i < X_{i+1} holds. In addition to that, an integer K is given.
Process Q queries.
In the i-th query, two integers L_i and R_i are given. Here, a set s of points is said to be a good set if it satisfies all of the following conditions. Note that the definition of good sets varies over queries.
* Each point in s is one of X_{L_i},X_{L_i+1},\ldots,X_{R_i}.
* For any two distinct points in s, the distance between them is greater than or equal to K.
* The size of s is maximum among all sets that satisfy the aforementioned conditions.
For each query, find the size of the union of all good sets.
Constraints
* 1 \leq N \leq 2 \times 10^5
* 1 \leq K \leq 10^9
* 0 \leq X_1 < X_2 < \cdots < X_N \leq 10^9
* 1 \leq Q \leq 2 \times 10^5
* 1 \leq L_i \leq R_i \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
X_1 X_2 \cdots X_N
Q
L_1 R_1
L_2 R_2
\vdots
L_Q R_Q
Output
For each query, print the size of the union of all good sets in a line.
Examples
Input
5 3
1 2 4 7 8
2
1 5
1 2
Output
4
2
Input
15 220492538
4452279 12864090 23146757 31318558 133073771 141315707 263239555 350278176 401243954 418305779 450172439 560311491 625900495 626194585 891960194
5
6 14
1 8
1 13
7 12
4 12
Output
4
6
11
2
3 | instruction | 0 | 69,591 | 23 | 139,182 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
INF = 10**18+3
N, K = map(int, input().split())
X = list(map(int, readline().split())) + [INF]
left = [None]*N
r = 0
for i in range(N):
while r < N and X[r+1] - X[i] < K:
r += 1
left[i] = (r, i)
left = [left]
nb = N.bit_length()
for _ in range(nb):
res = [None]*N
for idx in range(N):
r, i = left[-1][idx]
if r >= N-1:
res[idx] = (N, None)
else:
r1, i1 = left[-1][r+1]
if r1 == N:
res[idx] = (N, None)
else:
res[idx] = (r1, i+i1)
left.append(res)
right = [None]*N
l = N-1
for i in range(N-1, -1, -1):
while 0 < l and X[i] - X[l-1] < K:
l -= 1
right[i] = (l, i)
right = [right]
for _ in range(nb):
res = [None]*N
for idx in range(N):
l, i = right[-1][idx]
if l <= 0:
res[idx] = (-1, None)
else:
l1, i1 = right[-1][l-1]
if l1 == -1:
res[idx] = (-1, None)
else:
res[idx] = (l1, i+i1)
right.append(res)
Q = int(readline())
Ans = [None]*Q
for qu in range(Q):
l, r = map(int, readline().split())
l -= 1
vn = l
li = 0
ml = 0
for j in range(nb-1, -1, -1):
vf, ix = left[j][vn]
if vf < r:
vn = vf+1
li += ix
ml += 1<<j
if vn >= r:
break
if vn < r:
ml += 1
li += vn
l -= 1
r -= 1
vn = r
ri = 0
mr = 0
for j in range(nb-1, -1, -1):
vf, ix = right[j][vn]
if l < vf:
vn = vf-1
ri += ix
mr += 1<<j
if vn <= l:
break
if l < vn:
mr += 1
ri += vn
Ans[qu] = ri-li + ml
print('\n'.join(map(str, Ans)))
``` | output | 1 | 69,591 | 23 | 139,183 |
Provide a correct Python 3 solution for this coding contest problem.
In AtCoder city, there are five antennas standing in a straight line. They are called Antenna A, B, C, D and E from west to east, and their coordinates are a, b, c, d and e, respectively.
Two antennas can communicate directly if the distance between them is k or less, and they cannot if the distance is greater than k.
Determine if there exists a pair of antennas that cannot communicate directly.
Here, assume that the distance between two antennas at coordinates p and q (p < q) is q - p.
Constraints
* a, b, c, d, e and k are integers between 0 and 123 (inclusive).
* a < b < c < d < e
Input
Input is given from Standard Input in the following format:
a
b
c
d
e
k
Output
Print `:(` if there exists a pair of antennas that cannot communicate directly, and print `Yay!` if there is no such pair.
Examples
Input
1
2
4
8
9
15
Output
Yay!
Input
15
18
26
35
36
18
Output
:( | instruction | 0 | 69,629 | 23 | 139,258 |
"Correct Solution:
```
a = [int(input()) for _ in range(6)]
if a[4]-a[0] <= a[5]:
print('Yay!')
else:
print(':(')
``` | output | 1 | 69,629 | 23 | 139,259 |
Provide a correct Python 3 solution for this coding contest problem.
In AtCoder city, there are five antennas standing in a straight line. They are called Antenna A, B, C, D and E from west to east, and their coordinates are a, b, c, d and e, respectively.
Two antennas can communicate directly if the distance between them is k or less, and they cannot if the distance is greater than k.
Determine if there exists a pair of antennas that cannot communicate directly.
Here, assume that the distance between two antennas at coordinates p and q (p < q) is q - p.
Constraints
* a, b, c, d, e and k are integers between 0 and 123 (inclusive).
* a < b < c < d < e
Input
Input is given from Standard Input in the following format:
a
b
c
d
e
k
Output
Print `:(` if there exists a pair of antennas that cannot communicate directly, and print `Yay!` if there is no such pair.
Examples
Input
1
2
4
8
9
15
Output
Yay!
Input
15
18
26
35
36
18
Output
:( | instruction | 0 | 69,630 | 23 | 139,260 |
"Correct Solution:
```
a,b,c,d,e,k=[int(input()) for _ in range(6)]
print('Yay!' if abs(a-e) <= k else ':(')
``` | output | 1 | 69,630 | 23 | 139,261 |
Provide a correct Python 3 solution for this coding contest problem.
In AtCoder city, there are five antennas standing in a straight line. They are called Antenna A, B, C, D and E from west to east, and their coordinates are a, b, c, d and e, respectively.
Two antennas can communicate directly if the distance between them is k or less, and they cannot if the distance is greater than k.
Determine if there exists a pair of antennas that cannot communicate directly.
Here, assume that the distance between two antennas at coordinates p and q (p < q) is q - p.
Constraints
* a, b, c, d, e and k are integers between 0 and 123 (inclusive).
* a < b < c < d < e
Input
Input is given from Standard Input in the following format:
a
b
c
d
e
k
Output
Print `:(` if there exists a pair of antennas that cannot communicate directly, and print `Yay!` if there is no such pair.
Examples
Input
1
2
4
8
9
15
Output
Yay!
Input
15
18
26
35
36
18
Output
:( | instruction | 0 | 69,631 | 23 | 139,262 |
"Correct Solution:
```
A = [int(input()) for _ in range(6)]
ans = ":(" if A[4] - A[0] > A[5] else "Yay!"
print(ans)
``` | output | 1 | 69,631 | 23 | 139,263 |
Provide a correct Python 3 solution for this coding contest problem.
In AtCoder city, there are five antennas standing in a straight line. They are called Antenna A, B, C, D and E from west to east, and their coordinates are a, b, c, d and e, respectively.
Two antennas can communicate directly if the distance between them is k or less, and they cannot if the distance is greater than k.
Determine if there exists a pair of antennas that cannot communicate directly.
Here, assume that the distance between two antennas at coordinates p and q (p < q) is q - p.
Constraints
* a, b, c, d, e and k are integers between 0 and 123 (inclusive).
* a < b < c < d < e
Input
Input is given from Standard Input in the following format:
a
b
c
d
e
k
Output
Print `:(` if there exists a pair of antennas that cannot communicate directly, and print `Yay!` if there is no such pair.
Examples
Input
1
2
4
8
9
15
Output
Yay!
Input
15
18
26
35
36
18
Output
:( | instruction | 0 | 69,632 | 23 | 139,264 |
"Correct Solution:
```
a,b,c,d,e,f=map(int,open(0).readlines())
print(":("if e-a>f else"Yay!")
``` | output | 1 | 69,632 | 23 | 139,265 |
Provide a correct Python 3 solution for this coding contest problem.
In AtCoder city, there are five antennas standing in a straight line. They are called Antenna A, B, C, D and E from west to east, and their coordinates are a, b, c, d and e, respectively.
Two antennas can communicate directly if the distance between them is k or less, and they cannot if the distance is greater than k.
Determine if there exists a pair of antennas that cannot communicate directly.
Here, assume that the distance between two antennas at coordinates p and q (p < q) is q - p.
Constraints
* a, b, c, d, e and k are integers between 0 and 123 (inclusive).
* a < b < c < d < e
Input
Input is given from Standard Input in the following format:
a
b
c
d
e
k
Output
Print `:(` if there exists a pair of antennas that cannot communicate directly, and print `Yay!` if there is no such pair.
Examples
Input
1
2
4
8
9
15
Output
Yay!
Input
15
18
26
35
36
18
Output
:( | instruction | 0 | 69,633 | 23 | 139,266 |
"Correct Solution:
```
a = [int(input()) for _ in range(5)]
K = int(input())
print("Yay!" if a[-1]-a[0]<=K else ":(")
``` | output | 1 | 69,633 | 23 | 139,267 |
Provide a correct Python 3 solution for this coding contest problem.
In AtCoder city, there are five antennas standing in a straight line. They are called Antenna A, B, C, D and E from west to east, and their coordinates are a, b, c, d and e, respectively.
Two antennas can communicate directly if the distance between them is k or less, and they cannot if the distance is greater than k.
Determine if there exists a pair of antennas that cannot communicate directly.
Here, assume that the distance between two antennas at coordinates p and q (p < q) is q - p.
Constraints
* a, b, c, d, e and k are integers between 0 and 123 (inclusive).
* a < b < c < d < e
Input
Input is given from Standard Input in the following format:
a
b
c
d
e
k
Output
Print `:(` if there exists a pair of antennas that cannot communicate directly, and print `Yay!` if there is no such pair.
Examples
Input
1
2
4
8
9
15
Output
Yay!
Input
15
18
26
35
36
18
Output
:( | instruction | 0 | 69,634 | 23 | 139,268 |
"Correct Solution:
```
n=[int(input()) for _ in range(6)];print([':(','Yay!'][n[4]-n[0]<=n[5]])
``` | output | 1 | 69,634 | 23 | 139,269 |
Provide a correct Python 3 solution for this coding contest problem.
In AtCoder city, there are five antennas standing in a straight line. They are called Antenna A, B, C, D and E from west to east, and their coordinates are a, b, c, d and e, respectively.
Two antennas can communicate directly if the distance between them is k or less, and they cannot if the distance is greater than k.
Determine if there exists a pair of antennas that cannot communicate directly.
Here, assume that the distance between two antennas at coordinates p and q (p < q) is q - p.
Constraints
* a, b, c, d, e and k are integers between 0 and 123 (inclusive).
* a < b < c < d < e
Input
Input is given from Standard Input in the following format:
a
b
c
d
e
k
Output
Print `:(` if there exists a pair of antennas that cannot communicate directly, and print `Yay!` if there is no such pair.
Examples
Input
1
2
4
8
9
15
Output
Yay!
Input
15
18
26
35
36
18
Output
:( | instruction | 0 | 69,635 | 23 | 139,270 |
"Correct Solution:
```
*a,k=map(int,open(0));print("Y:a(y !"[a[4]-a[0]>k::2])
``` | output | 1 | 69,635 | 23 | 139,271 |
Provide a correct Python 3 solution for this coding contest problem.
In AtCoder city, there are five antennas standing in a straight line. They are called Antenna A, B, C, D and E from west to east, and their coordinates are a, b, c, d and e, respectively.
Two antennas can communicate directly if the distance between them is k or less, and they cannot if the distance is greater than k.
Determine if there exists a pair of antennas that cannot communicate directly.
Here, assume that the distance between two antennas at coordinates p and q (p < q) is q - p.
Constraints
* a, b, c, d, e and k are integers between 0 and 123 (inclusive).
* a < b < c < d < e
Input
Input is given from Standard Input in the following format:
a
b
c
d
e
k
Output
Print `:(` if there exists a pair of antennas that cannot communicate directly, and print `Yay!` if there is no such pair.
Examples
Input
1
2
4
8
9
15
Output
Yay!
Input
15
18
26
35
36
18
Output
:( | instruction | 0 | 69,636 | 23 | 139,272 |
"Correct Solution:
```
a, *_, e, k = [int(input()) for x in ' '*6]
print([':(', 'Yay!'][e-a<=k])
``` | output | 1 | 69,636 | 23 | 139,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya learned that, given two points with different x coordinates, you can draw through them exactly one parabola with equation of type y = x^2 + bx + c, where b and c are reals. Let's call such a parabola an U-shaped one.
Vasya drew several distinct points with integer coordinates on a plane and then drew an U-shaped parabola through each pair of the points that have different x coordinates. The picture became somewhat messy, but Vasya still wants to count how many of the parabolas drawn don't have any drawn point inside their internal area. Help Vasya.
The internal area of an U-shaped parabola is the part of the plane that lies strictly above the parabola when the y axis is directed upwards.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the number of points.
The next n lines describe the points, the i-th of them contains two integers x_i and y_i — the coordinates of the i-th point. It is guaranteed that all points are distinct and that the coordinates do not exceed 10^6 by absolute value.
Output
In the only line print a single integer — the number of U-shaped parabolas that pass through at least two of the given points and do not contain any of the given points inside their internal area (excluding the parabola itself).
Examples
Input
3
-1 0
0 2
1 0
Output
2
Input
5
1 0
1 -1
0 -1
-1 0
-1 -1
Output
1
Note
On the pictures below all U-shaped parabolas that pass through at least two given points are drawn for each of the examples. The U-shaped parabolas that do not have any given point inside their internal area are drawn in red.
<image> The first example. <image> The second example. | instruction | 0 | 69,888 | 23 | 139,776 |
Tags: geometry
Correct Solution:
```
import sys
def cross(o, a, b):
return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])
N = int(input())
A = [None]*N
for i in range(N):
x, y = map(int, sys.stdin.readline().split())
A[i] = (x, y-x*x)
A.sort()
upper = []
for p in reversed(A):
while len(upper) >= 2 and cross(upper[-2], upper[-1], p) <= 0:
upper.pop()
upper.append(p)
while len(upper) >= 2 and upper[-1][0] == upper[-2][0]:
upper.pop()
print(len(upper) - 1)
``` | output | 1 | 69,888 | 23 | 139,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya learned that, given two points with different x coordinates, you can draw through them exactly one parabola with equation of type y = x^2 + bx + c, where b and c are reals. Let's call such a parabola an U-shaped one.
Vasya drew several distinct points with integer coordinates on a plane and then drew an U-shaped parabola through each pair of the points that have different x coordinates. The picture became somewhat messy, but Vasya still wants to count how many of the parabolas drawn don't have any drawn point inside their internal area. Help Vasya.
The internal area of an U-shaped parabola is the part of the plane that lies strictly above the parabola when the y axis is directed upwards.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the number of points.
The next n lines describe the points, the i-th of them contains two integers x_i and y_i — the coordinates of the i-th point. It is guaranteed that all points are distinct and that the coordinates do not exceed 10^6 by absolute value.
Output
In the only line print a single integer — the number of U-shaped parabolas that pass through at least two of the given points and do not contain any of the given points inside their internal area (excluding the parabola itself).
Examples
Input
3
-1 0
0 2
1 0
Output
2
Input
5
1 0
1 -1
0 -1
-1 0
-1 -1
Output
1
Note
On the pictures below all U-shaped parabolas that pass through at least two given points are drawn for each of the examples. The U-shaped parabolas that do not have any given point inside their internal area are drawn in red.
<image> The first example. <image> The second example. | instruction | 0 | 69,889 | 23 | 139,778 |
Tags: geometry
Correct Solution:
```
import io, os
input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
INF = 10 ** 16
n = int(input())
d = {}
a = []
for i in range(n):
x, y = map(int, input().split())
d[x] = max(d.get(x, -INF), y - x * x)
a = sorted(d.items())
cross = lambda a, b, c: (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0])
s = []
for p in a:
while len(s) > 1 and cross(s[-2], s[-1], p) >= 0:
s.pop()
s.append(p)
print(len(s) - 1)
``` | output | 1 | 69,889 | 23 | 139,779 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya learned that, given two points with different x coordinates, you can draw through them exactly one parabola with equation of type y = x^2 + bx + c, where b and c are reals. Let's call such a parabola an U-shaped one.
Vasya drew several distinct points with integer coordinates on a plane and then drew an U-shaped parabola through each pair of the points that have different x coordinates. The picture became somewhat messy, but Vasya still wants to count how many of the parabolas drawn don't have any drawn point inside their internal area. Help Vasya.
The internal area of an U-shaped parabola is the part of the plane that lies strictly above the parabola when the y axis is directed upwards.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the number of points.
The next n lines describe the points, the i-th of them contains two integers x_i and y_i — the coordinates of the i-th point. It is guaranteed that all points are distinct and that the coordinates do not exceed 10^6 by absolute value.
Output
In the only line print a single integer — the number of U-shaped parabolas that pass through at least two of the given points and do not contain any of the given points inside their internal area (excluding the parabola itself).
Examples
Input
3
-1 0
0 2
1 0
Output
2
Input
5
1 0
1 -1
0 -1
-1 0
-1 -1
Output
1
Note
On the pictures below all U-shaped parabolas that pass through at least two given points are drawn for each of the examples. The U-shaped parabolas that do not have any given point inside their internal area are drawn in red.
<image> The first example. <image> The second example. | instruction | 0 | 69,890 | 23 | 139,780 |
Tags: geometry
Correct Solution:
```
n = int(input())
rows = [input().split() for _ in range(n)]
rows = [(int(x),int(y)) for x,y in rows]
points = {}
for x,y in rows:
if x in points:
points[x] = max(y, points[x])
else:
points[x] = y
points = sorted(points.items(),key=lambda point: point[0])
def above(p,p1,p2):
"""
x1 < x2
y1 = x1^2 + bx1 + c
y2 = x2^2 + bx2 + c
y >? x^2 + bx + c
y2 - y1 = x2^2 - x1^2 + bx2 - bx1
b = (y2 - y1 - x2^2 + x1^2) / (x2 - x1)
b * (x2 - x1) = y2 - y1 - x2^2 + x1^2
c = y1 - x1^2 - bx1
c * (x2 - x1) = (y1 - x1^2) * (x2 - x1) - x1 * (y2 - y1 - x2^2 + x1^2)
y * (x2 - x1) >? (x^2 + bx + c) * (x2 - x1)
y * (x2 - x1) >?
x^2 * (x2 - x1)
+ x * (y2 - y1 - x2^2 + x1^2)
+ (y1 - x1^2) * (x2 - x1) - x1 * (y2 - y1 - x2^2 + x1^2)
"""
x,y = p
x1,y1 = p1
x2,y2 = p2
x_2 = x**2
x12 = x1**2
x22 = x2**2
x2_x1 = x2 - x1
eq_b = y2 - y1 - x22 + x12
term_y = y * x2_x1
term_x2 = x_2 * x2_x1
term_x = x * eq_b
term_c = (y1 - x12) * x2_x1 - (x1 * eq_b)
return term_y >= term_x2 + term_x + term_c
#print(above(points[2],points[0],points[1]))
Us = []
for i, p in enumerate(points):
while len(Us) >= 2:
p1, p2 = Us[-2:]
if above(p,p1,p2):
Us.pop()
else:
break
Us.append(p)
out = len(Us) - 1
print(out)
``` | output | 1 | 69,890 | 23 | 139,781 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Vasya learned that, given two points with different x coordinates, you can draw through them exactly one parabola with equation of type y = x^2 + bx + c, where b and c are reals. Let's call such a parabola an U-shaped one.
Vasya drew several distinct points with integer coordinates on a plane and then drew an U-shaped parabola through each pair of the points that have different x coordinates. The picture became somewhat messy, but Vasya still wants to count how many of the parabolas drawn don't have any drawn point inside their internal area. Help Vasya.
The internal area of an U-shaped parabola is the part of the plane that lies strictly above the parabola when the y axis is directed upwards.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the number of points.
The next n lines describe the points, the i-th of them contains two integers x_i and y_i — the coordinates of the i-th point. It is guaranteed that all points are distinct and that the coordinates do not exceed 10^6 by absolute value.
Output
In the only line print a single integer — the number of U-shaped parabolas that pass through at least two of the given points and do not contain any of the given points inside their internal area (excluding the parabola itself).
Examples
Input
3
-1 0
0 2
1 0
Output
2
Input
5
1 0
1 -1
0 -1
-1 0
-1 -1
Output
1
Note
On the pictures below all U-shaped parabolas that pass through at least two given points are drawn for each of the examples. The U-shaped parabolas that do not have any given point inside their internal area are drawn in red.
<image> The first example. <image> The second example. | instruction | 0 | 69,891 | 23 | 139,782 |
Tags: geometry
Correct Solution:
```
import math
import io, os
input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
def cross(xA, yA, xB, yB):
return xA*yB - xB*yA
def clockwise(x0, y0, xA, yA, xB, yB):
return True if cross(xA-x0, yA-y0, xB-x0, yB-y0)<0 else False
n = int(input())
P = [list(map(int, input().split())) for _ in range(n)]
for i in range(n):
P[i][1] = P[i][1] - P[i][0] ** 2
P = sorted(P, key=lambda x: (x[0], x[1]))
d = {}
for x, y in P:
if x not in d:
d[x] = y
d[x] = max(d[x], y)
Q = [[x, y] for x, y in d.items()]
S = []
for x, y in Q:
if len(S) > 0 and S[-1][0] == x:
S.pop()
while len(S) >= 2 and clockwise(S[-2][0], S[-2][1], S[-1][0], S[-1][1], x, y)==False:
S.pop()
S.append([x, y])
print(len(S)-1)
``` | output | 1 | 69,891 | 23 | 139,783 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vasya learned that, given two points with different x coordinates, you can draw through them exactly one parabola with equation of type y = x^2 + bx + c, where b and c are reals. Let's call such a parabola an U-shaped one.
Vasya drew several distinct points with integer coordinates on a plane and then drew an U-shaped parabola through each pair of the points that have different x coordinates. The picture became somewhat messy, but Vasya still wants to count how many of the parabolas drawn don't have any drawn point inside their internal area. Help Vasya.
The internal area of an U-shaped parabola is the part of the plane that lies strictly above the parabola when the y axis is directed upwards.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the number of points.
The next n lines describe the points, the i-th of them contains two integers x_i and y_i — the coordinates of the i-th point. It is guaranteed that all points are distinct and that the coordinates do not exceed 10^6 by absolute value.
Output
In the only line print a single integer — the number of U-shaped parabolas that pass through at least two of the given points and do not contain any of the given points inside their internal area (excluding the parabola itself).
Examples
Input
3
-1 0
0 2
1 0
Output
2
Input
5
1 0
1 -1
0 -1
-1 0
-1 -1
Output
1
Note
On the pictures below all U-shaped parabolas that pass through at least two given points are drawn for each of the examples. The U-shaped parabolas that do not have any given point inside their internal area are drawn in red.
<image> The first example. <image> The second example.
Submitted Solution:
```
print("UKE")
``` | instruction | 0 | 69,892 | 23 | 139,784 |
No | output | 1 | 69,892 | 23 | 139,785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Vasya learned that, given two points with different x coordinates, you can draw through them exactly one parabola with equation of type y = x^2 + bx + c, where b and c are reals. Let's call such a parabola an U-shaped one.
Vasya drew several distinct points with integer coordinates on a plane and then drew an U-shaped parabola through each pair of the points that have different x coordinates. The picture became somewhat messy, but Vasya still wants to count how many of the parabolas drawn don't have any drawn point inside their internal area. Help Vasya.
The internal area of an U-shaped parabola is the part of the plane that lies strictly above the parabola when the y axis is directed upwards.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the number of points.
The next n lines describe the points, the i-th of them contains two integers x_i and y_i — the coordinates of the i-th point. It is guaranteed that all points are distinct and that the coordinates do not exceed 10^6 by absolute value.
Output
In the only line print a single integer — the number of U-shaped parabolas that pass through at least two of the given points and do not contain any of the given points inside their internal area (excluding the parabola itself).
Examples
Input
3
-1 0
0 2
1 0
Output
2
Input
5
1 0
1 -1
0 -1
-1 0
-1 -1
Output
1
Note
On the pictures below all U-shaped parabolas that pass through at least two given points are drawn for each of the examples. The U-shaped parabolas that do not have any given point inside their internal area are drawn in red.
<image> The first example. <image> The second example.
Submitted Solution:
```
"""def search(k):
m = 1
i = 1
while(i <= k):
arr = str(i)
arr = [int(a) for a in arr]
res = 1
for j in range(len(arr)):
res = res * int(arr[j])
if res > m:
m = res
i = i + 1
print(m)
def split2(n):
res = []
arr = str(n)
if len(arr) % 2 != 0:
res.append(int(arr[0]))
arr = arr[1:]
for i in range(0, len(arr), 2):
r = int(arr[i] + arr[i + 1])
if len(str(r)) < 2:
res.append(99)
else:
res.append
return res"""
"""n = int(input())
arr = str(n)
len_n = len(arr)
max_9 = len(arr) - 1
if int(str(arr)[0]) == 9:
max_9 = max_9 + 1
max_num = 0
for i in range(max_9):
max_num = max_num + 9 * 10 ** (i)
if max_num < n and max_num != 0:
arr = str(max_num)
res = 1
for i in range(len(arr)):
res = res * int(arr[i])
print(res)
else:
f = True
maxx = 1
cur_n = n
while(f and cur_n > 0):
res = 1
arr = str(cur_n)
for i in range(len(arr)):
res = res * int(arr[i])
if res > maxx:
maxx = res
cur_n = cur_n - 1
if len(str(cur_n)) < len_n - 1:
f = False
print(maxx)"""
import itertools
n = int(input())
x = []
y = []
for i in range(n):
xx, yy = input().split()
x.append(int(xx))
y.append(int(yy))
res = 0
combs = []
for comb in list(itertools.combinations(range(n), 2)):
c1 = comb[0]
c2 = comb[1]
x1 = x[c1]
y1 = y[c1]
x2 = x[c2]
y2 = y[c2]
if x1 != x2:
b = (y1-y2+x2**2-x1**2)/(x1-x2)
c = y1-x1**2-b*x1
i = 0
f = True
while (i < len(x)) and f:
if y[i] - x[i] ** 2 - b * x[i] - c > 0:
f = False
if y[i] - x[i] ** 2 - b * x[i] - c == 0:
for co in combs:
if (set([c1, i]) == set(co)) or (set([c2, i]) == set(co)) :
f = False
i = i + 1
if f :
res = res + 1
combs.append([c1, c2])
print(res)
"""len_n = len(str(n))
big = 0
for i in range(len_n):
big = big + 9 * 10 ** (i)
f = True
while(f):
if big < n:
f = False
else:
arr = str(big)
arr = [int(a) for a in arr]
arr[0] = arr[0] - 1
arr = [str(a) for a in arr]
big = int(''.join(arr))
print(big)
arr = str(big)
arr = [int(a) for a in arr]
res = 1
arr = str(big)
for i in range(len(arr)):
res = res * int(arr[i])
print(res)"""
``` | instruction | 0 | 69,893 | 23 | 139,786 |
No | output | 1 | 69,893 | 23 | 139,787 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image> | instruction | 0 | 70,005 | 23 | 140,010 |
Tags: constructive algorithms
Correct Solution:
```
def main():
n = int(input())
print(4+(n*3))
print(0,0)
print(0, 1)
st = -1
for i in range(1,n+1):
st+=1
for j in range(3):
print(i, j+st)
print(n+1, st+1)
print(n+1, st+2)
# for #!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | output | 1 | 70,005 | 23 | 140,011 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image> | instruction | 0 | 70,006 | 23 | 140,012 |
Tags: constructive algorithms
Correct Solution:
```
def solve():
k = int(input())
ans = [(0, 0)]
for i in range(1, k + 2):
ans.append((i-1,i))
ans.append((i, i-1))
ans.append((i, i))
print(len(ans))
for i in ans:
print(*i)
for i in range(1):
solve()
``` | output | 1 | 70,006 | 23 | 140,013 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image> | instruction | 0 | 70,007 | 23 | 140,014 |
Tags: constructive algorithms
Correct Solution:
```
n = int(input())
location = {(0, 0)}
cnt = 0
i = 1
j = 1
while n != cnt:
if (i, j) not in location:
location.add((i, j))
cnt += 1
i += 1
if (i, j) not in location:
location.add((i, j))
i -= 1
j += 1
if (i, j) not in location:
location.add((i, j))
i -= 1
j -= 1
if (i, j) not in location:
location.add((i, j))
i += 1
j -= 1
if (i, j) not in location:
location.add((i, j))
i += 1
j += 2
location.add((i, j))
print(len(location))
for elem in location:
print(*elem)
``` | output | 1 | 70,007 | 23 | 140,015 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image> | instruction | 0 | 70,008 | 23 | 140,016 |
Tags: constructive algorithms
Correct Solution:
```
from sys import stdout
class Solve:
def solve(self):
n = int(input())
ans = [str(3*n+4), '\n']
for i in range(1, n+1):
ans += [str(i), ' ', str(i), '\n']
ans += [str(i-1), ' ', str(i), '\n']
ans += [str(i), ' ', str(i-1), '\n']
if i == 1:
ans += [str(i-1), ' ', str(i-1), '\n']
if i == n:
ans += [str(i+1), ' ', str(i), '\n']
ans += [str(i), ' ', str(i+1), '\n']
ans += [str(i+1), ' ', str(i+1), '\n']
stdout.write(''.join(ans))
def main():
s = Solve()
s.solve()
main()
``` | output | 1 | 70,008 | 23 | 140,017 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image> | instruction | 0 | 70,009 | 23 | 140,018 |
Tags: constructive algorithms
Correct Solution:
```
import math
def gcd(a,b):
if (b == 0):
return a
return gcd(b, a%b)
def lcm(a,b):
return (a*b) / gcd(a,b)
def bs(arr, l, r, x):
while l <= r:
mid = l + (r - l)//2;
if(arr[mid]==x):
return arr[mid]
elif(arr[mid]<x):
l = mid + 1
else:
r = mid - 1
return -1
def swap(list, pos1, pos2):
list[pos1], list[pos2] = list[pos2], list[pos1]
return list
n = int(input())
x = []
x.append((1,1))
x.append((0,1))
x.append((1,0))
x.append((1,2))
x.append((2,1))
x.append((0,0))
x.append((2,2))
for i in range(n-1):
x.append((i+2,i+3))
x.append((i+3,i+2))
x.append((i+3,i+3))
print(len(x))
for i in range(len(x)):
print(x[i][0],x[i][1])
``` | output | 1 | 70,009 | 23 | 140,019 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image> | instruction | 0 | 70,010 | 23 | 140,020 |
Tags: constructive algorithms
Correct Solution:
```
n = int(input())
c=0
print(3*(n+1)+1)
for i in range(n+1):
print(i,c)
print(i,c+1)
print(i+1,c)
c+=1
print(i+1,c)
``` | output | 1 | 70,010 | 23 | 140,021 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image> | instruction | 0 | 70,011 | 23 | 140,022 |
Tags: constructive algorithms
Correct Solution:
```
n=int(input())
print(4+(n*3))
print(0,0)
print(0,1)
print(1,0)
print(1,1)
x,y=1,1
for i in range(n):
print(x+1,y)
print(x+1,y+1)
print(x,y+1)
x+=1
y+=1
``` | output | 1 | 70,011 | 23 | 140,023 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image> | instruction | 0 | 70,012 | 23 | 140,024 |
Tags: constructive algorithms
Correct Solution:
```
n=int(input())
print(n*3+4)
print(0,0)
print(0,1)
k=0
for i in range(1,n+1):
print(i,k)
print(i,k+1)
print(i,k+2)
k+=1
print(i+1,k)
print(i+1,k+1)
``` | output | 1 | 70,012 | 23 | 140,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image>
Submitted Solution:
```
a = int(input())
n = a*3+4
n1 = a+2
print(n)
for i in range(n1):
if i==0:
print(a, 0)
print(a+1, 0)
elif i<=a:
print(a-i, i)
print(a-i+1, i)
print(a-i+2, i)
else:
print(0, a+1)
print(1, a+1)
``` | instruction | 0 | 70,013 | 23 | 140,026 |
Yes | output | 1 | 70,013 | 23 | 140,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image>
Submitted Solution:
```
import sys
import heapq
import random
import collections
import bisect
# available on Google, not available on Codeforces
# import numpy as np
# import scipy
# from scipy.stats import binom
def solve(a):
# console("----- solving ------")
print(a+1 + a+1 + a+2)
for i in range(a+1):
print("{} {}".format(i, i+1))
for i in range(a+1):
print("{} {}".format(i+1, i))
for i in range(a+2):
print("{} {}".format(i, i))
def console(*args): # the judge will not read these print statement
print('\033[36m', *args, '\033[0m', file=sys.stderr)
# for case_num in range(int(input())):
# read line as a string
# strr = input()
# read line as an integer
k = int(input())
# read one line and parse each word as a string
# lst = input().split()
# read one line and parse each word as an integer
# a,b,c = list(map(int,input().split()))
# read matrix and parse as integers (after reading read nrows)
# lst = list(map(int,input().split()))
# nrows = lst[0] # index containing information, please change
# grid = []
# for _ in range(nrows):
# grid.append(list(map(int,input().split())))
res = solve(k) # please change
# Google - case number required
# print("Case #{}: {}".format(case_num+1, res))
# Codeforces - no case number required
# print(res)
``` | instruction | 0 | 70,014 | 23 | 140,028 |
Yes | output | 1 | 70,014 | 23 | 140,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image>
Submitted Solution:
```
from collections import *
from math import *
n = int(input())
ct = 0
i = 1
ans = [[0,0]]
while(ct <= n):
ans.append([i,i])
ans.append([i-1,i])
ans.append([i,i-1])
i += 1
ct += 1
print(len(ans))
for i in ans:
print(*i)
``` | instruction | 0 | 70,015 | 23 | 140,030 |
Yes | output | 1 | 70,015 | 23 | 140,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image>
Submitted Solution:
```
import sys
import math
from math import factorial, inf, gcd, sqrt
from heapq import *
from functools import *
from itertools import *
from collections import *
from typing import *
from bisect import *
import random
sys.setrecursionlimit(10**5)
def rarray():
return [int(i) for i in input().split()]
def f(ans):
x, y = ans[-1]
ans.append([x + 1, y])
ans.append([x, y + 1])
ans.append([x + 1, y + 1])
t = 1
# t = int(input())
for ii in range(t):
n = int(input())
ans = [[0, 0]]
f(ans)
for i in range(n):
f(ans)
print(len(ans))
for x, y in ans:
print(x, y)
``` | instruction | 0 | 70,016 | 23 | 140,032 |
Yes | output | 1 | 70,016 | 23 | 140,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image>
Submitted Solution:
```
t=int(input())
print(3*t + 1)
for i in range(t):
print(i,i)
print(i+1,i)
print(i,i+1)
if(i==(t-1)):
print(i+1,i+1)
``` | instruction | 0 | 70,017 | 23 | 140,034 |
No | output | 1 | 70,017 | 23 | 140,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image>
Submitted Solution:
```
from math import *
def rr(t):
zzz = [t(i) for i in input().split()]
if len(zzz) == 1:
return zzz[0]
return zzz
def r3(t):
return [t(i) for i in input()]
n = int(input())
cp = 1
print(n*7)
for i in range(n):
print(cp, 1)
print(cp, 2)
print(cp - 1, 2)
print(cp - 1, 1)
print(cp, 0)
print(cp + 1, 0)
print(cp + 1, 1)
cp += 4
``` | instruction | 0 | 70,018 | 23 | 140,036 |
No | output | 1 | 70,018 | 23 | 140,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image>
Submitted Solution:
```
n=int(input())
d=5004
if n%2==0:
d+=2*n
if n%2==1:
d+=2*n+1
print(d)
for i in range(2500):
print(1,i)
print(2,0)
print(3,0)
print(2,2499)
print(3,2499)
for i in range(2500):
print(4,i)
c=0
if n%2==0:
c=n-1
x=0
y=2
for i in range(0,c,2):
print(x,y)
print(x,y+1)
y+=3
x=2
y=2
for i in range(0,c,2):
print(x,y)
print(x,y+1)
y+=3
if n%2==1:
print(1,2500)
print(0,2499)
print(0,2500)
``` | instruction | 0 | 70,019 | 23 | 140,038 |
No | output | 1 | 70,019 | 23 | 140,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Leo Jr. draws pictures in his notebook with checkered sheets (that is, each sheet has a regular square grid printed on it). We can assume that the sheets are infinitely large in any direction.
To draw a picture, Leo Jr. colors some of the cells on a sheet gray. He considers the resulting picture beautiful if the following conditions are satisfied:
* The picture is connected, that is, it is possible to get from any gray cell to any other by following a chain of gray cells, with each pair of adjacent cells in the path being neighbours (that is, sharing a side).
* Each gray cell has an even number of gray neighbours.
* There are exactly n gray cells with all gray neighbours. The number of other gray cells can be arbitrary (but reasonable, so that they can all be listed).
Leo Jr. is now struggling to draw a beautiful picture with a particular choice of n. Help him, and provide any example of a beautiful picture.
To output cell coordinates in your answer, assume that the sheet is provided with a Cartesian coordinate system such that one of the cells is chosen to be the origin (0, 0), axes 0x and 0y are orthogonal and parallel to grid lines, and a unit step along any axis in any direction takes you to a neighbouring cell.
Input
The only line contains a single integer n (1 ≤ n ≤ 500) — the number of gray cells with all gray neighbours in a beautiful picture.
Output
In the first line, print a single integer k — the number of gray cells in your picture. For technical reasons, k should not exceed 5 ⋅ 10^5.
Each of the following k lines should contain two integers — coordinates of a gray cell in your picture. All listed cells should be distinct, and the picture should satisdfy all the properties listed above. All coordinates should not exceed 10^9 by absolute value.
One can show that there exists an answer satisfying all requirements with a small enough k.
Example
Input
4
Output
12
1 0
2 0
0 1
1 1
2 1
3 1
0 2
1 2
2 2
3 2
1 3
2 3
Note
The answer for the sample is pictured below:
<image>
Submitted Solution:
```
import sys, math
# input = lambda: sys.stdin.readline().rstrip()
a = int(input())
if a == 1:
print(1+5 + (a - 1) * 3)
else:
print(1+5 + (a - 1) * 3+1)
print(0,0)
print(1,0)
print(0,1)
print(1,1)
print(2,1)
print(1,2)
if a > 1:
print(2,2)
for i in range(a - 1):
print(2+i,3+i)
print(4+i-1,4+i-1)
print(4+i-1,3+i-1)
else:
print(2,2)
``` | instruction | 0 | 70,020 | 23 | 140,040 |
No | output | 1 | 70,020 | 23 | 140,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valera loves segments. He has recently come up with one interesting problem.
The Ox axis of coordinates has n segments, the i-th segment starts in position li and ends in position ri (we will mark it as [li, ri]). Your task is to process m queries, each consists of number cnti and a set of cnti coordinates of points located on the Ox axis. The answer to the query is the number of segments, such that each of them contains at least one point from the query. Segment [l, r] contains point q, if l ≤ q ≤ r.
Valera found the solution of this problem too difficult. So he asked you to help him. Help Valera.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 3·105) — the number of segments on the axis of coordinates and the number of queries.
Next n lines contain the descriptions of the segments. The i-th line contains two positive integers li, ri (1 ≤ li ≤ ri ≤ 106) — the borders of the i-th segment.
Next m lines contain the description of the queries, one per line. Each line starts from integer cnti (1 ≤ cnti ≤ 3·105) — the number of points in the i-th query. Then the line contains cnti distinct positive integers p1, p2, ..., pcnti (1 ≤ p1 < p2 < ... < pcnti ≤ 106) — the coordinates of points in the i-th query.
It is guaranteed that the total number of points in all queries doesn't exceed 3·105.
Output
Print m non-negative integers, where the i-th number is the response to the i-th query.
Examples
Input
3 3
1 3
4 5
6 7
3 1 4 7
2 4 5
1 8
Output
3
1
0
Submitted Solution:
```
n,m = map(int,input().split())
a = []
for i in range(n):
b = list(map(int,input().split()))
a.append(b)
val = [0]*(10**6 + 5)
a.sort()
i = 1
for l in range(len(a)-1):
j = a[l][0]
while j<=a[l][1] and j<a[l+1][0]:
val[j]=i
j+=1
i+=1
for j in range(a[-1][0],a[-1][1]+1):
val[j]=i
for i in range(m):
a = list(map(int,input().split()))
s = set()
for elem in a[1:]:
s.add(val[elem])
if (0 in s) and len(s)>1:
print(-1)
elif (0 in s) and len(s)==1:
print(0)
else:
print(len(s))
``` | instruction | 0 | 70,169 | 23 | 140,338 |
No | output | 1 | 70,169 | 23 | 140,339 |
Provide a correct Python 3 solution for this coding contest problem.
Problem
Beans are popular at Otsu University. N beans are lined up in a straight line. Each is numbered from 0 to N-1, and the hardness of the i-th bean is ai.
Cyan considers the ideal bean hardness to be D. However, Cyan doesn't want to go get the beans that are too far away because he is troublesome. Therefore, Cyan wants to know the beans whose hardness is closest to D among the l-th to r-th beans.
Cyan asks Q questions, so create a program to find the minimum value of | bean hardness − D | in the closed interval [l, r] for each question. (However, | a | represents the absolute value of a.)
Constraints
The input satisfies the following constraints.
* 1 ≤ N ≤ 105
* 0 ≤ | ai | ≤ 106 (0 ≤ i ≤ N−1)
* 1 ≤ Q ≤ 105
* 0 ≤ Di ≤ 106
* 0 ≤ li ≤ ri ≤ N-1
Input
The input is given in the following format.
N
a0 a1 ... aN−1
Q
l0 r0 D0
l1 r1 D1
..
..
..
lQ−1 rQ−1 DQ−1
The first line is given one integer N. On the second line, N integers are given, separated by blanks. On the third line, the number of queries is given as one integer Q. The query values l, r, and D are given in the following 4 to 3 + Q lines.
Output
For each query, output the absolute value of the difference between D and the hardness of the bean closest to hardness D among the [l, r] th beans on one line.
Examples
Input
3
1 2 3
3
0 2 2
0 2 4
0 0 2
Output
0
1
1
Input
10
4 5 0 21 9 100 12 9 0 8
5
0 3 20
2 5 100
8 9 9
5 5 10
0 9 20
Output
1
0
1
90
1 | instruction | 0 | 70,693 | 23 | 141,386 |
"Correct Solution:
```
class SegmentTree(object):
def __init__(self, a:list, default: int, op):
from math import ceil, log
real_size = len(a)
self.elem_size = elem_size = 1<<ceil(log(real_size, 2))
self.tree = tree = [default] * (elem_size * 2)
tree[elem_size:elem_size + real_size] = a
self.default = default
self.op = op
for i in range(elem_size - 1, 0, -1):
tree[i] = op(tree[i<<1], tree[(i<<1)+1])
def get_value(self, x:int, y:int):
l, r = x+self.elem_size, y+self.elem_size
tree, result, op = self.tree, self.default, self.op
while l<r:
if l & 1:
result = op(tree[l], result)
l += 1
if r&1:
r -= 1
result = op(tree[r], result)
l, r = l>>1, r>>1
return result
def set_value(self, i:int, value:int):
k = self.elem_size + i
self.tree[k] = value
self.update(k)
def update(self, i:int):
op, tree = self.op, self.tree
while i > 1:
i >>= 1
tree[i] = op(tree[i<<1], tree[(i<<1)+1])
N = int(input())
A = list(map(int, input().split()))
Q_ = int(input())
Q = []
for i in range(Q_):
l, r, d = map(int, input().split())
Q.append([l, r, d, i])
seg1 = SegmentTree([-1<<30]*N, -1<<30, max)
seg2 = SegmentTree(A, 1<<30, min)
from operator import itemgetter
Q.sort(key=itemgetter(2))
A = sorted(zip(A, range(N)), key=itemgetter(0))
a_idx = 0
Ans = [0] * Q_
for l, r, d, q_idx in Q:
while a_idx < N:
a0, a1 = A[a_idx]
if a0 > d:
break
else:
seg1.set_value(a1, a0)
seg2.set_value(a1, 1<<30)
a_idx += 1
an1 = abs(seg1.get_value(l, r+1) - d)
an2 = abs(seg2.get_value(l, r+1) - d)
Ans[q_idx] = min(an1, an2)
print(*Ans, sep="\n")
``` | output | 1 | 70,693 | 23 | 141,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We will consider the numbers a and b as adjacent if they differ by exactly one, that is, |a-b|=1.
We will consider cells of a square matrix n × n as adjacent if they have a common side, that is, for cell (r, c) cells (r, c-1), (r, c+1), (r-1, c) and (r+1, c) are adjacent to it.
For a given number n, construct a square matrix n × n such that:
* Each integer from 1 to n^2 occurs in this matrix exactly once;
* If (r_1, c_1) and (r_2, c_2) are adjacent cells, then the numbers written in them must not be adjacent.
Input
The first line contains one integer t (1 ≤ t ≤ 100). Then t test cases follow.
Each test case is characterized by one integer n (1 ≤ n ≤ 100).
Output
For each test case, output:
* -1, if the required matrix does not exist;
* the required matrix, otherwise (any such matrix if many of them exist).
The matrix should be outputted as n lines, where each line contains n integers.
Example
Input
3
1
2
3
Output
1
-1
2 9 7
4 6 3
1 8 5 | instruction | 0 | 70,980 | 23 | 141,960 |
Tags: constructive algorithms
Correct Solution:
```
for _ in range(int(input())):
a=int(input())
if a==1:
print(1)
elif a==2:
print(-1)
else:
l=[]
for i in range(1,a**2+1,1):
l.append(i)
c=[]
for i in range(0,len(l),2):
c.append(l[i])
for j in range(1,len(l),2):
c.append(l[j])
q=0
for i in range(a):
for j in range(a):
print(c[q],end=" ")
q=q+1
print()
``` | output | 1 | 70,980 | 23 | 141,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We will consider the numbers a and b as adjacent if they differ by exactly one, that is, |a-b|=1.
We will consider cells of a square matrix n × n as adjacent if they have a common side, that is, for cell (r, c) cells (r, c-1), (r, c+1), (r-1, c) and (r+1, c) are adjacent to it.
For a given number n, construct a square matrix n × n such that:
* Each integer from 1 to n^2 occurs in this matrix exactly once;
* If (r_1, c_1) and (r_2, c_2) are adjacent cells, then the numbers written in them must not be adjacent.
Input
The first line contains one integer t (1 ≤ t ≤ 100). Then t test cases follow.
Each test case is characterized by one integer n (1 ≤ n ≤ 100).
Output
For each test case, output:
* -1, if the required matrix does not exist;
* the required matrix, otherwise (any such matrix if many of them exist).
The matrix should be outputted as n lines, where each line contains n integers.
Example
Input
3
1
2
3
Output
1
-1
2 9 7
4 6 3
1 8 5 | instruction | 0 | 70,981 | 23 | 141,962 |
Tags: constructive algorithms
Correct Solution:
```
rn = lambda: int(input())
rl = lambda: [x for x in input().split()]
rln = lambda: [int(x) for x in input().split()]
rlfn = lambda: [float(x) for x in input().split()]
def solve():
return []
tests = rn()
for tc in range(1,tests+1):
n = rn()
if n == 1:
print(1)
elif n == 2:
print(-1)
else:
l = [i for i in range(1,n**2+1) if i % 2 == 0]
l += [i for i in range(1,n**2+1) if i%2 == 1]
for i in range(n):
s = ' '.join([str(l[i*n+j]) for j in range(n)])
print(s)
#rta = solve()
#print(' '.join(map(str,rta)))
``` | output | 1 | 70,981 | 23 | 141,963 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We will consider the numbers a and b as adjacent if they differ by exactly one, that is, |a-b|=1.
We will consider cells of a square matrix n × n as adjacent if they have a common side, that is, for cell (r, c) cells (r, c-1), (r, c+1), (r-1, c) and (r+1, c) are adjacent to it.
For a given number n, construct a square matrix n × n such that:
* Each integer from 1 to n^2 occurs in this matrix exactly once;
* If (r_1, c_1) and (r_2, c_2) are adjacent cells, then the numbers written in them must not be adjacent.
Input
The first line contains one integer t (1 ≤ t ≤ 100). Then t test cases follow.
Each test case is characterized by one integer n (1 ≤ n ≤ 100).
Output
For each test case, output:
* -1, if the required matrix does not exist;
* the required matrix, otherwise (any such matrix if many of them exist).
The matrix should be outputted as n lines, where each line contains n integers.
Example
Input
3
1
2
3
Output
1
-1
2 9 7
4 6 3
1 8 5 | instruction | 0 | 70,982 | 23 | 141,964 |
Tags: constructive algorithms
Correct Solution:
```
import math
def gen(brr):
arr=[]
crr=[]
drr=[]
for i in range(0,len(brr),2):
crr.append(brr[i])
for i in range(1,len(brr),2):
drr.append(brr[i])
return crr+drr
def generateMatrix(arr,A):
grid = [[0] * A for _ in range(A)]
L = 0
R = A - 1
T = 0
B = A - 1
direction = 0
num = 0
while L <= R and T <= B:
if direction == 0:
for i in range(L, R + 1):
grid[T][i] = arr[num]
num += 1
T += 1
elif direction == 1:
for i in range(T, B + 1):
grid[i][R] = arr[num]
num += 1
R -= 1
elif direction == 2:
for i in range(R, L - 1, -1):
grid[B][i] = arr[num]
num += 1
B -= 1
elif direction == 3:
for i in range(B, T-1, -1):
grid[i][L] = arr[num]
num += 1
L += 1
direction = (direction + 1) % 4
return grid
for _ in range(int(input())):
n=int(input())
k=n
if n==1:
print(1)
elif n==2:
print(-1)
elif n==3:
print('2 9 7')
print('4 6 3')
print('1 8 5')
elif n==4:
print('2 9 7 10')
print('4 6 3 12')
print('1 8 5 14')
print('15 13 11 16')
else:
arr=list(range(1,n**2+1))
for i in range(0,len(arr),k):
ar=arr[i:i+k]
ar=gen(ar)
print(' '.join(map(str,ar)))
``` | output | 1 | 70,982 | 23 | 141,965 |
Provide tags and a correct Python 3 solution for this coding contest problem.
We will consider the numbers a and b as adjacent if they differ by exactly one, that is, |a-b|=1.
We will consider cells of a square matrix n × n as adjacent if they have a common side, that is, for cell (r, c) cells (r, c-1), (r, c+1), (r-1, c) and (r+1, c) are adjacent to it.
For a given number n, construct a square matrix n × n such that:
* Each integer from 1 to n^2 occurs in this matrix exactly once;
* If (r_1, c_1) and (r_2, c_2) are adjacent cells, then the numbers written in them must not be adjacent.
Input
The first line contains one integer t (1 ≤ t ≤ 100). Then t test cases follow.
Each test case is characterized by one integer n (1 ≤ n ≤ 100).
Output
For each test case, output:
* -1, if the required matrix does not exist;
* the required matrix, otherwise (any such matrix if many of them exist).
The matrix should be outputted as n lines, where each line contains n integers.
Example
Input
3
1
2
3
Output
1
-1
2 9 7
4 6 3
1 8 5 | instruction | 0 | 70,984 | 23 | 141,968 |
Tags: constructive algorithms
Correct Solution:
```
t = int(input())
for x in range(t):
n = int(input())
if n == 1:
print(1)
elif n == 2:
print(-1)
else:
val = 1
v = []
for j in range(n):
ar = []
for k in range(n):
ar.append(0)
v.append(ar)
for k in range(n):
i = k
j = 0
while i < n:
v[i][j] = val
val += 1
i += 1
j += 1
if k == 0:
continue
i = 0
j = k
while j < n:
v[i][j] = val
val += 1
i += 1
j += 1
for j in range(n):
for k in range(n):
print(v[j][k], end=" ")
print()
``` | output | 1 | 70,984 | 23 | 141,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will consider the numbers a and b as adjacent if they differ by exactly one, that is, |a-b|=1.
We will consider cells of a square matrix n × n as adjacent if they have a common side, that is, for cell (r, c) cells (r, c-1), (r, c+1), (r-1, c) and (r+1, c) are adjacent to it.
For a given number n, construct a square matrix n × n such that:
* Each integer from 1 to n^2 occurs in this matrix exactly once;
* If (r_1, c_1) and (r_2, c_2) are adjacent cells, then the numbers written in them must not be adjacent.
Input
The first line contains one integer t (1 ≤ t ≤ 100). Then t test cases follow.
Each test case is characterized by one integer n (1 ≤ n ≤ 100).
Output
For each test case, output:
* -1, if the required matrix does not exist;
* the required matrix, otherwise (any such matrix if many of them exist).
The matrix should be outputted as n lines, where each line contains n integers.
Example
Input
3
1
2
3
Output
1
-1
2 9 7
4 6 3
1 8 5
Submitted Solution:
```
from sys import stdin, stdout
input = stdin.readline
def im():
return map(int,input().split())
def ii():
return int(input())
def il():
return list(map(int,input().split()))
def ins():
return input()[:-1]
for _ in range(ii()):
n = ii()
if n==1:
print(1)
continue
if n==2:
print(-1)
continue
lis = []
for i in range(n):
lis.append([0]*n)
c=flag=0
r=count=1
while True:
if r==n and c==n:
break
if flag==0:
j=c
i=0
flag=1
c+=1
else:
i=r
j=0
flag=0
r+=1
while i<n and j<n:
# print(i,j,count)
lis[i][j] = count
count+=1
i+=1
j+=1
# print(lis)
for i in lis:
print(*i)
``` | instruction | 0 | 70,985 | 23 | 141,970 |
Yes | output | 1 | 70,985 | 23 | 141,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We will consider the numbers a and b as adjacent if they differ by exactly one, that is, |a-b|=1.
We will consider cells of a square matrix n × n as adjacent if they have a common side, that is, for cell (r, c) cells (r, c-1), (r, c+1), (r-1, c) and (r+1, c) are adjacent to it.
For a given number n, construct a square matrix n × n such that:
* Each integer from 1 to n^2 occurs in this matrix exactly once;
* If (r_1, c_1) and (r_2, c_2) are adjacent cells, then the numbers written in them must not be adjacent.
Input
The first line contains one integer t (1 ≤ t ≤ 100). Then t test cases follow.
Each test case is characterized by one integer n (1 ≤ n ≤ 100).
Output
For each test case, output:
* -1, if the required matrix does not exist;
* the required matrix, otherwise (any such matrix if many of them exist).
The matrix should be outputted as n lines, where each line contains n integers.
Example
Input
3
1
2
3
Output
1
-1
2 9 7
4 6 3
1 8 5
Submitted Solution:
```
''' Question:
a and b adjacent if they differ by exactly one |a-b| = 1
Consider cells of square matrix nxn as adjacent if they have common side
for cell (r,c) cells (r,c-1) , (r,c+1), (r-1,c) and (r+1,c) are adjacent to it.
- Construct a square nxn:
Each int from 1 to n^2 occurs once
if (r1,c1) and (r2,c2) are adjacent then nums in those cells must not be adjacent
For n = 2 there is no answer
else:
cell (i,j) -> white if i+j = even else its black ie, odd
arrange cells => all white cells are first and if colors are equal, cells can be compared
lexicographically.
Arrange numbers from 1 to n^2 in ordered cells
'''
for _ in range (int(input())):
n = int(input())
if n == 2:
print(-1)
continue
a = [[0 for i in range(n)] for j in range(n)] # Build arr
c = -1
for i in range(n):
for j in range(n):
c += 2 # Start from 1
if c>n*n:
c = 2
a[i][j] = c
print(*a[i])
'''
n = 3
gp 1 -> 1 3 5
7 9 2
4 6 8 <- gp 2
'''
``` | instruction | 0 | 70,986 | 23 | 141,972 |
Yes | output | 1 | 70,986 | 23 | 141,973 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.