message stringlengths 2 19.9k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 322 108k | cluster float64 15 15 | __index_level_0__ int64 644 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is standing on a multiplication table with infinitely many rows and columns.
The square (i,j) contains the integer i \times j. Initially, Takahashi is standing at (1,1).
In one move, he can move from (i,j) to either (i+1,j) or (i,j+1).
Given an integer N, find the minimum number of moves needed to reach a square that contains N.
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the minimum number of moves needed to reach a square that contains the integer N.
Examples
Input
10
Output
5
Input
50
Output
13
Input
10000000019
Output
10000000018
Submitted Solution:
```
n=int(input())
ans=n-1
for i in range(2,int(n**(1/2))+1):
if n%i==0:
ans=min(ans,i+n//i-2)
print(ans)
``` | instruction | 0 | 29,783 | 15 | 59,566 |
Yes | output | 1 | 29,783 | 15 | 59,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is standing on a multiplication table with infinitely many rows and columns.
The square (i,j) contains the integer i \times j. Initially, Takahashi is standing at (1,1).
In one move, he can move from (i,j) to either (i+1,j) or (i,j+1).
Given an integer N, find the minimum number of moves needed to reach a square that contains N.
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the minimum number of moves needed to reach a square that contains the integer N.
Examples
Input
10
Output
5
Input
50
Output
13
Input
10000000019
Output
10000000018
Submitted Solution:
```
n = int(input())
p = 1
for i in range(2, int(n**0.5)+1):
if n%i == 0:
p = i
print(int(p+n/p-2))
``` | instruction | 0 | 29,784 | 15 | 59,568 |
Yes | output | 1 | 29,784 | 15 | 59,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is standing on a multiplication table with infinitely many rows and columns.
The square (i,j) contains the integer i \times j. Initially, Takahashi is standing at (1,1).
In one move, he can move from (i,j) to either (i+1,j) or (i,j+1).
Given an integer N, find the minimum number of moves needed to reach a square that contains N.
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the minimum number of moves needed to reach a square that contains the integer N.
Examples
Input
10
Output
5
Input
50
Output
13
Input
10000000019
Output
10000000018
Submitted Solution:
```
n=int(input())
x=int(n**0.5)
for i in range(x,0,-1):
if n%i==0:
print(-2+i+(n//i))
exit()
``` | instruction | 0 | 29,785 | 15 | 59,570 |
Yes | output | 1 | 29,785 | 15 | 59,571 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is standing on a multiplication table with infinitely many rows and columns.
The square (i,j) contains the integer i \times j. Initially, Takahashi is standing at (1,1).
In one move, he can move from (i,j) to either (i+1,j) or (i,j+1).
Given an integer N, find the minimum number of moves needed to reach a square that contains N.
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the minimum number of moves needed to reach a square that contains the integer N.
Examples
Input
10
Output
5
Input
50
Output
13
Input
10000000019
Output
10000000018
Submitted Solution:
```
N=int(input())
a=1
for i in range(1,int(N**(1/2))+2):
if N%i==0:
a=max(a,i)
print(a+N//a-2)
``` | instruction | 0 | 29,786 | 15 | 59,572 |
Yes | output | 1 | 29,786 | 15 | 59,573 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is standing on a multiplication table with infinitely many rows and columns.
The square (i,j) contains the integer i \times j. Initially, Takahashi is standing at (1,1).
In one move, he can move from (i,j) to either (i+1,j) or (i,j+1).
Given an integer N, find the minimum number of moves needed to reach a square that contains N.
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the minimum number of moves needed to reach a square that contains the integer N.
Examples
Input
10
Output
5
Input
50
Output
13
Input
10000000019
Output
10000000018
Submitted Solution:
```
inf = float('inf')
N = int(input())
from math import floor
# 約数全列挙(ソート済み)
# n = 24 -> [1,2,3,4,6,8,12,24]
def divisor(n):
left = [1]
right = [n]
sup = floor(pow(n,1/2))
for p in range(2,sup+1):
if n % p == 0:
if p == n//p:
left.append(p)
continue
left.append(p)
right.append(n//p)
return left, right
ans = inf
left, right = divisor(N)
for i, j in zip(left, right):
d = abs(i-1) + abs(j-1)
ans = min(ans, d)
print(ans)
``` | instruction | 0 | 29,787 | 15 | 59,574 |
No | output | 1 | 29,787 | 15 | 59,575 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is standing on a multiplication table with infinitely many rows and columns.
The square (i,j) contains the integer i \times j. Initially, Takahashi is standing at (1,1).
In one move, he can move from (i,j) to either (i+1,j) or (i,j+1).
Given an integer N, find the minimum number of moves needed to reach a square that contains N.
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the minimum number of moves needed to reach a square that contains the integer N.
Examples
Input
10
Output
5
Input
50
Output
13
Input
10000000019
Output
10000000018
Submitted Solution:
```
import math
N = int(input())
n = int(math.ceil(math.sqrt(N)))
ans = int(1e12)
for i in range(1,n):
j = N//i
if j*i==N:
ans =min(ans,j+i-2)
print(ans)
``` | instruction | 0 | 29,788 | 15 | 59,576 |
No | output | 1 | 29,788 | 15 | 59,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is standing on a multiplication table with infinitely many rows and columns.
The square (i,j) contains the integer i \times j. Initially, Takahashi is standing at (1,1).
In one move, he can move from (i,j) to either (i+1,j) or (i,j+1).
Given an integer N, find the minimum number of moves needed to reach a square that contains N.
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the minimum number of moves needed to reach a square that contains the integer N.
Examples
Input
10
Output
5
Input
50
Output
13
Input
10000000019
Output
10000000018
Submitted Solution:
```
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
N=int(input())
primes=[]
for x in factorization(N):
for y in range(x[1]):
primes.append(x[0])
ans=[1,1]
for x in reversed(primes):
if ans[0]>= ans[1]:
ans[1]*=x
else:
ans[0]*=x
print(ans[0]+ans[1]-2)
``` | instruction | 0 | 29,789 | 15 | 59,578 |
No | output | 1 | 29,789 | 15 | 59,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi is standing on a multiplication table with infinitely many rows and columns.
The square (i,j) contains the integer i \times j. Initially, Takahashi is standing at (1,1).
In one move, he can move from (i,j) to either (i+1,j) or (i,j+1).
Given an integer N, find the minimum number of moves needed to reach a square that contains N.
Constraints
* 2 \leq N \leq 10^{12}
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the minimum number of moves needed to reach a square that contains the integer N.
Examples
Input
10
Output
5
Input
50
Output
13
Input
10000000019
Output
10000000018
Submitted Solution:
```
n = int(input())
def prime_decomposition(n):
i = 2
table = []
while i * i <= n:
while n % i == 0:
n = int(n/i)
table.append(i)
i += 1
if n > 1:
table.append(n)
return table
l = prime_decomposition(n)
l.append(1)
l.sort()
a = 1
b = 1
s = len(l)//2
for i in range(s):
if i % 2 == 0:
a *= l[i]*l[len(l)-1-i]
else:
b *= l[i]*l[len(l)-1-i]
if len(l) % 2 == 1:
a *= l[s]
if len(l) == 2:
a = l[0]
b = l[1]
elif len(l) == 3:
a = l[0]*l[2]
b = l[1]
print(a+b-2)
``` | instruction | 0 | 29,790 | 15 | 59,580 |
No | output | 1 | 29,790 | 15 | 59,581 |
Provide a correct Python 3 solution for this coding contest problem.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL | instruction | 0 | 29,899 | 15 | 59,798 |
"Correct Solution:
```
class Board:
def __init__(self,m):
self.m = m
self.x = 0
self.y = 0
self.d = 'e'
def dir(self):
return self.d
def is_origin(self):
return (self.x==0) and (self.y==0)
def north_is_wall(self):
if self.y == 0:
return False
else:
if self.m[2*self.y-1][self.x] == '1':
return True
else:
return False
def east_is_wall(self):
if self.x == 4:
return False
elif m[2*self.y][self.x] == '1':
return True
else:
return False
def west_is_wall(self):
if self.x == 0:
return False
elif m[2*self.y][self.x-1] == '1':
return True
else:
return False
def south_is_wall(self):
# print("x={},y={}".format(self.x,self.y))
if self.y == 4:
return False
elif self.m[2*self.y+1][self.x] == '1':
return True
else:
return False
def go_north(self):
if self.y == 0:
raise "invalid"
else:
self.y -= 1
self.d = 'n'
print("U",end="")
def go_south(self):
if self.y == 5:
raise "invalid"
else:
self.y += 1
self.d = 's'
print("D",end="")
def go_east(self):
if self.x == 4:
raise "go_east"
else:
self.x += 1
self.d = 'e'
print("R",end="")
def go_west(self):
if self.x == 0:
raise "go_west"
else:
self.x -= 1
self.d = 'w'
print("L",end="")
def run(m):
b = Board(m)
init = True
while True:
d = b.dir()
if d == 'e':
if b.north_is_wall():
b.go_north()
elif b.east_is_wall():
b.go_east()
elif b.south_is_wall():
b.go_south()
else:
b.go_west()
elif d == 's':
if b.east_is_wall():
b.go_east()
elif b.south_is_wall():
b.go_south()
elif b.west_is_wall():
b.go_west()
else:
b.go_north()
elif d == 'w':
if b.south_is_wall():
b.go_south()
elif b.west_is_wall():
b.go_west()
elif b.north_is_wall():
b.go_north()
else:
b.go_east()
elif d == 'n':
if b.west_is_wall():
b.go_west()
elif b.north_is_wall():
b.go_north()
elif b.east_is_wall():
b.go_east()
else:
b.go_south()
if (not init) and b.is_origin():
print()
break
init = False
m = []
for _ in range(9):
m.append(list(input()))
run(m)
``` | output | 1 | 29,899 | 15 | 59,799 |
Provide a correct Python 3 solution for this coding contest problem.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL | instruction | 0 | 29,900 | 15 | 59,800 |
"Correct Solution:
```
class Coordinate(object):
def __init__(self):
self.path = [None, None, None, None]
class Maze(object):
def __init__(self):
self.a = [[Coordinate() for _ in [0]*5] for _ in [0]*5]
def get_room(self, x, y):
return self.a[y][x]
def set_path(self, pos1, pos2):
dir1, dir2 = (0, 2) if pos1[1] == pos2[1] else (1, 3)
self.get_room(*pos1).path[dir1] = pos2
self.get_room(*pos2).path[dir2] = pos1
def solve(self):
result, x, y, direction = "R", 1, 0, 0
direction_sign = "RDLU"
while not(x == 0 and y == 0):
current = self.get_room(x, y)
if current.path[(direction-1)%4]:
direction = (direction-1)%4
elif current.path[direction]:
pass
elif current.path[(direction+1)%4]:
direction = (direction+1)%4
else:
direction = (direction+2)%4
x, y = current.path[direction]
result += direction_sign[direction]
return result
maze = Maze()
for i in range(9):
y = i//2
dx, dy = (1, 0) if i%2 == 0 else (0, 1)
for x, c in enumerate(input()):
if c == "1":
maze.set_path((x, y), (x+dx, y+dy))
print(maze.solve())
``` | output | 1 | 29,900 | 15 | 59,801 |
Provide a correct Python 3 solution for this coding contest problem.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL | instruction | 0 | 29,901 | 15 | 59,802 |
"Correct Solution:
```
path = [[[] for i in range(5)] for i in range(5)]
for i in range(9):
if i%2 == 0:
a = [int(i) for i in list(input())]
for j in range(4):
if a[j] == 1:
path[int(i/2)][j].append("R")
path[int(i/2)][j+1].append("L")
else:
a = [int(i) for i in list(input())]
for j in range(5):
if a[j] == 1:
path[int(i/2)][j].append("D")
path[int(i/2)+1][j].append("U")
prev = "R"
p = "R"
x = 0
y = 0
while(1):
if prev == "R":
if "U" in path[x][y]:
x -= 1
prev = "U"
p += "U"
elif "R" in path[x][y]:
y += 1
prev = "R"
p += "R"
elif "D" in path[x][y]:
x += 1
prev = "D"
p += "D"
elif "L" in path[x][y]:
y -= 1
prev = "L"
p += "L"
elif prev == "L":
if "D" in path[x][y]:
x += 1
prev = "D"
p += "D"
elif "L" in path[x][y]:
y -= 1
prev = "L"
p += "L"
elif "U" in path[x][y]:
x -= 1
prev = "U"
p += "U"
elif "R" in path[x][y]:
y += 1
prev = "R"
p += "R"
elif prev == "U":
if "L" in path[x][y]:
y -= 1
prev = "L"
p += "L"
elif "U" in path[x][y]:
x -= 1
prev = "U"
p += "U"
elif "R" in path[x][y]:
y += 1
prev = "R"
p += "R"
elif "D" in path[x][y]:
x += 1
prev = "D"
p += "D"
elif prev == "D":
if "R" in path[x][y]:
y += 1
prev = "R"
p += "R"
elif "D" in path[x][y]:
x += 1
prev = "D"
p += "D"
elif "L" in path[x][y]:
y -= 1
prev = "L"
p += "L"
elif "U" in path[x][y]:
x -= 1
prev = "U"
p += "U"
if x == 0 and y == 0:
break
print(p[1:])
``` | output | 1 | 29,901 | 15 | 59,803 |
Provide a correct Python 3 solution for this coding contest problem.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL | instruction | 0 | 29,902 | 15 | 59,804 |
"Correct Solution:
```
g=[[0]*5 for _ in[0]*5]
for i in range(9):
e=input()
for j in range(4+i%2):
if int(e[j]):
if i%2:g[i//2][j]+=4;g[i//2+1][j]+=1
else:r=g[i//2];r[j]+=2;r[j+1]+=8
y,x=0,1
k=1
a='1'
while 1:
k=k%4+2
for _ in[0]*4:
k+=1
if g[y][x]&int(2**(k%4)):a+=str(k%4);break
if k%2:x+=[1,-1][(k%4)>1]
else:y+=[-1,1][(k%4)>0]
if x+y==0:break
print(''.join('URDL'[int(c)]for c in a))
``` | output | 1 | 29,902 | 15 | 59,805 |
Provide a correct Python 3 solution for this coding contest problem.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL | instruction | 0 | 29,905 | 15 | 59,810 |
"Correct Solution:
```
mat = [['0', '0', '0', '0', '0']]
for i in range(9):
if i%2 ==0:
tmpc = '0' + input() + '0'
else:
tmpc = input()
mat.append(list(tmpc))
mat.append(['0', '0', '0', '0', '0'])
pos = [0,1]
move = ['R']
while True:
mdict = {'U': [2*pos[0], pos[1]], 'R': [2*pos[0]+1, pos[1]+1], 'D': [2*pos[0]+2, pos[1]], 'L': [2*pos[0]+1, pos[1]]}
if move[-1] == 'R':
belst = ['U', 'R', 'D', 'L']
elif move[-1] == 'D':
belst = ['R', 'D', 'L', 'U']
elif move[-1] == 'L':
belst = ['D', 'L', 'U', 'R']
else:
belst = ['L', 'U', 'R', 'D']
for i in belst:
if mat[mdict[i][0]][mdict[i][1]] == '1':
be = i
break
if be == 'U':
pos[0] -= 1
elif be == 'R':
pos[1] += 1
elif be == 'D':
pos[0] += 1
else:
pos[1] -= 1
move.append(be)
if pos == [0, 0]:
break
print(''.join(move))
``` | output | 1 | 29,905 | 15 | 59,811 |
Provide a correct Python 3 solution for this coding contest problem.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL | instruction | 0 | 29,906 | 15 | 59,812 |
"Correct Solution:
```
import sys
n = [input() for i in range(9)]
path = [[0 for i in range(5)] for j in range(5)]
for i, v in enumerate([a[1] for a in enumerate(n) if a[0] % 2 == 0]):
for j in range(4):
if v[j] == '1':
path[i][j] += 1
path[i][j+1] += 2
for i, v in enumerate([a[1] for a in enumerate(n) if a[0] % 2 != 0]):
for j in range(5):
if v[j] == '1':
path[i][j] += 4
path[i+1][j] += 8
dur = {'R':(1, 0, 1),
'L':(2, 0, -1),
'U':(8, -1, 0),
'D':(4, 1, 0)}
dur_next = {'R':('U','R','D','L'),
'L':('D','L','U','R'),
'U':('L','U','R','D'),
'D':('R','D','L','U')}
def walk():
global cx, cy
cx = dur[d][2] + cx
cy = dur[d][1] + cy
def next_D():
global cx,cy,d,dur
for nd in dur_next[d]:
if path[cy][cx] & dur[nd][0]:
d = nd
break
cx = cy = 0
d = 'R'
log = []
while 1:
log.append(d)
walk()
if cx == cy == 0:
break
next_D()
print(''.join(log))
``` | output | 1 | 29,906 | 15 | 59,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Seen from above, there is a grid-like square shaped like Figure 1. The presence or absence of "walls" on each side of this grid is represented by a sequence of 0s and 1s. Create a program that stands at point A, puts your right hand on the wall, keeps walking in the direction of the arrow, and outputs the route to return to point A again.
<image>
---
Figure 1
---
Input
The input consists of 9 lines and is given in the following format, with 1 being the presence of a wall and 0 being the absence of a wall, as shown in Figure 2 below.
The first line is a character string that indicates the presence or absence of the top horizontal line wall as 0 and 1 from the left.
The second line is a character string that indicates the presence or absence of the vertical line wall below it with 0 and 1 from the left.
The third line is a character string that indicates the presence or absence of the wall of the second horizontal line from the top by 0 and 1 from the left.
...
The 9th line is a character string representing the presence or absence of the bottom horizontal line wall with 0 and 1 from the left.
<image>
---
Figure 2 (Thick line shows where the wall is) (corresponding numbers)
However, as shown by the thick line in Fig. 1, it is assumed that there is always a wall for one section to the right of point A. That is, the first character on the first line is always 1.
Output
"Advance one section to the left of the figure" is "L", "Advance one section to the right of the figure" is "R", "Advance one section to the top of the figure" is "U", "Figure" "Advance one block downward" is represented by "D", and "L", "R", "U", and "D" are output in the order of advance.
Example
Input
1111
00001
0110
01011
0010
01111
0010
01001
0111
Output
RRRRDDDDLLLUUURRDDLURULLDDDRRRUUUULLLL
Submitted Solution:
```
def move(position):
x = position[0]
y = position[1]
d = position[2]
if d == "L":
p = "DLUR"
elif d == "R":
p = "URDL"
elif d == "U":
p = "LURD"
else:
p = "RDLU"
for i in range(4):
if p[i] in grid[y][x]:
d = p[i]
if d == "L":
print("L",end="")
x -= 1
break
elif d == "R":
print("R",end="")
x += 1
break
elif d == "U":
print("U",end="")
y -= 1
break
else:
print("D",end="")
y += 1
break
return [x, y, d]
pos = [1,1,"R"]
grid = [["" for i in range(6)] for j in range(6)]
for i in range(9):
inp = input()
if i%2 == 0:
for j in range(4):
if inp[j] == "1":
grid[i//2 + 1][j + 1] += "R"
grid[i//2 + 1][j + 2] += "L"
else:
for j in range(5):
if inp[j] == "1":
grid[i//2 + 1][j + 1] += "D"
grid[i//2 + 2][j + 1] += "U"
while True:
pos = move(pos)
if pos[0] == 1 and pos[1] == 1:
break
``` | instruction | 0 | 29,914 | 15 | 59,828 |
No | output | 1 | 29,914 | 15 | 59,829 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2 | instruction | 0 | 30,617 | 15 | 61,234 |
Tags: constructive algorithms
Correct Solution:
```
from __future__ import print_function
n = int(input())
k = 3 * (n // 2) + n % 2
print(k)
a = list()
for i in range(2, n + 1, 2):
a.append(i)
for i in range(1, n + 1, 2):
a.append(i)
for i in range(2, n + 1, 2):
a.append(i)
print(*a, sep=' ')
``` | output | 1 | 30,617 | 15 | 61,235 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2 | instruction | 0 | 30,618 | 15 | 61,236 |
Tags: constructive algorithms
Correct Solution:
```
from sys import stdin, stdout
n = int(stdin.readline().rstrip())
if n%2==0:
print(3*(n//2))
else:
print(3*(n-1)//2+1)
bombOrder=[]
i=2
while i<=n:
bombOrder.append(str(i))
i+=2
i=1
while i<=n:
bombOrder.append(str(i))
i+=2
i=2
while i<=n:
bombOrder.append(str(i))
i+=2
print(' '.join(bombOrder))
``` | output | 1 | 30,618 | 15 | 61,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2 | instruction | 0 | 30,619 | 15 | 61,238 |
Tags: constructive algorithms
Correct Solution:
```
n=int(input())
l1=[]
l2=[]
for i in range(1,n+1,2):
l1.append(i)
for i in range(2,n+1,2):
l2.append(i)
ans=l2+l1+l2
print(len(ans))
print(*ans)
``` | output | 1 | 30,619 | 15 | 61,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2 | instruction | 0 | 30,620 | 15 | 61,240 |
Tags: constructive algorithms
Correct Solution:
```
from sys import stdin
n = int(input())
print(n + n // 2)
for i in range(2, n + 1, 2):
print(i)
for i in range(1, n + 1, 2):
print(i)
for i in range(2, n + 1, 2):
print(i)
``` | output | 1 | 30,620 | 15 | 61,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2 | instruction | 0 | 30,621 | 15 | 61,242 |
Tags: constructive algorithms
Correct Solution:
```
if __name__ == "__main__":
even = []
odd = []
n = input()
n = int(n)
list = []
for i in range (1,n+1):
if i&1 == 1:
odd.append(i)
else :
even.append(i)
print(2*len(even)+len(odd))
for i in even:
print(i,end=" ")
for i in odd:
print(i,end=" ")
for i in even:
print(i,end=" ")
``` | output | 1 | 30,621 | 15 | 61,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2 | instruction | 0 | 30,622 | 15 | 61,244 |
Tags: constructive algorithms
Correct Solution:
```
n=int(input())
ans=[]
for i in range(2,n+1,2):
ans.append(str(i))
for i in range(1,n+1,2):
ans.append(str(i))
for i in range(2,n+1,2):
ans.append(str(i))
print(len(ans))
print(' '.join(ans))
``` | output | 1 | 30,622 | 15 | 61,245 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2 | instruction | 0 | 30,623 | 15 | 61,246 |
Tags: constructive algorithms
Correct Solution:
```
n = int(input())
print(n + n // 2)
x = [i for i in range(2, n + 1, 2)]
x += [i for i in range(1, n + 1, 2)]
x += [i for i in range(2, n + 1, 2)]
print(' '.join(map(str, x)))
``` | output | 1 | 30,623 | 15 | 61,247 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2 | instruction | 0 | 30,624 | 15 | 61,248 |
Tags: constructive algorithms
Correct Solution:
```
from math import *
n = int(input())
print(n//2*2+ int(ceil(n/2)))
for i in range(2,n+1,2):
print(i,end= " ")
for i in range(1,n+1,2):
print(i,end= " ")
for i in range(2,n+1,2):
print(i,end= " ")
``` | output | 1 | 30,624 | 15 | 61,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2
Submitted Solution:
```
n=int(input())
print(n+n//2)
s=''
for i in range(2,n+1,2):
s+=str(i)+' '
for i in range(1,n+1,2):
s +=str(i) + ' '
for i in range(2,n+1,2):
s+=str(i)+' '
print(s)
``` | instruction | 0 | 30,625 | 15 | 61,250 |
Yes | output | 1 | 30,625 | 15 | 61,251 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2
Submitted Solution:
```
n=int(input())
if n==2 :
print(3)
print(2,1,2)
exit()
else :
l=[]
for i in range(2,n+1) :
if i%2==0 :
l.append(i)
for i in range(1,n+1) :
if i%2!=0 :
l.append(i)
for i in range(2,n+1) :
if i%2==0 :
l.append(i)
print(len(l))
print(*l)
``` | instruction | 0 | 30,626 | 15 | 61,252 |
Yes | output | 1 | 30,626 | 15 | 61,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2
Submitted Solution:
```
r = list(range(1, int(input()) + 1))
print(3 * len(r) // 2)
for i in r[1::2] + r[::2] + r[1::2]: print(i)
``` | instruction | 0 | 30,627 | 15 | 61,254 |
Yes | output | 1 | 30,627 | 15 | 61,255 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2
Submitted Solution:
```
import math;
n = int(input());
m = n + math.floor(n/2);
print(m);
for i in range(2, n+1, 2):
print(i, end = " ");
for i in range(1, n+1, 2):
print(i, end = " ");
for i in range(2, n+1, 2):
print(i, end = " ");
``` | instruction | 0 | 30,628 | 15 | 61,256 |
Yes | output | 1 | 30,628 | 15 | 61,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2
Submitted Solution:
```
n = list(range(1, int(input()) + 1))
if n[-1] == 2:
print(3)
print(2, 1, 2)
elif n[-1] == 3:
print(4)
print(2, 1, 3, 2)
elif n[-1] == 8:
print(13)
print(2, 7, 4, 5, 1, 8, 3, 6, 2, 7, 4, 5, 4)
elif n[-1] == 9:
print(13)
print(2, 4, 6, 8, 1, 3, 5, 7, 9, 2, 4, 6, 8)
else:
ans = [2, n[-2], 1, n[-1]]
for i in range(2, len(n) - 2):
if n[i] % 2 != 0:
ans.append(n[i])
for i in range(2, len(n) - 2):
if n[i] % 2 == 0:
ans.append(n[i])
ans += [2, n[-2]]
for i in range(2, len(n) - 2):
if n[i] % 2 != 0:
ans.append(n[i])
print(len(ans))
print(*ans)
``` | instruction | 0 | 30,629 | 15 | 61,258 |
No | output | 1 | 30,629 | 15 | 61,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2
Submitted Solution:
```
def f(n):
if n==2:
print(3)
return [2,1,2]
l=[]
for i in range(2,n):
l.append(i)
ans=l+[1,n]+l
print(len(ans))
return ans
print(*f(int(input())))
``` | instruction | 0 | 30,630 | 15 | 61,260 |
No | output | 1 | 30,630 | 15 | 61,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Oct 23 19:40:38 2017
@author: gleb
"""
n = int(input())
s = str()
if n == 2:
print(3)
print('2 1 2')
else:
print(2 * n - 2)
for i in range(n - 1):
s += str(i + 2)
s += ' '
s += str(i + 1)
s += ' '
print(s)
``` | instruction | 0 | 30,631 | 15 | 61,262 |
No | output | 1 | 30,631 | 15 | 61,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Slava plays his favorite game "Peace Lightning". Now he is flying a bomber on a very specific map.
Formally, map is a checkered field of size 1 × n, the cells of which are numbered from 1 to n, in each cell there can be one or several tanks. Slava doesn't know the number of tanks and their positions, because he flies very high, but he can drop a bomb in any cell. All tanks in this cell will be damaged.
If a tank takes damage for the first time, it instantly moves to one of the neighboring cells (a tank in the cell n can only move to the cell n - 1, a tank in the cell 1 can only move to the cell 2). If a tank takes damage for the second time, it's counted as destroyed and never moves again. The tanks move only when they are damaged for the first time, they do not move by themselves.
Help Slava to destroy all tanks using as few bombs as possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the size of the map.
Output
In the first line print m — the minimum number of bombs Slava needs to destroy all tanks.
In the second line print m integers k1, k2, ..., km. The number ki means that the i-th bomb should be dropped at the cell ki.
If there are multiple answers, you can print any of them.
Examples
Input
2
Output
3
2 1 2
Input
3
Output
4
2 1 3 2
Submitted Solution:
```
def main():
n = int(input())
if n == 2:
print(3)
print('1 2 1')
return
ans = []
if n%2 == 0:
first = n//2
second = first+1
while first > 0:
ans.append(first)
ans.append(second)
first -= 1
second += 1
first += 2
second -= 2
while first <= n//2:
ans.append(first)
ans.append(second)
first += 1
second -= 1
else:
mid = (n//2)+1
ans.append(mid)
first = mid-1
second = mid+1
while first > 0:
ans.append(first)
ans.append(second)
first -= 1
second += 1
first += 2
second -= 2
while first < mid:
ans.append(first)
ans.append(second)
first += 1
second -= 1
ans.append(first)
print(len(ans))
for i in ans:
print(i,end = ' ')
main()
``` | instruction | 0 | 30,632 | 15 | 61,264 |
No | output | 1 | 30,632 | 15 | 61,265 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given some Tetris field consisting of n columns. The initial height of the i-th column of the field is a_i blocks. On top of these columns you can place only figures of size 2 × 1 (i.e. the height of this figure is 2 blocks and the width of this figure is 1 block). Note that you cannot rotate these figures.
Your task is to say if you can clear the whole field by placing such figures.
More formally, the problem can be described like this:
The following process occurs while at least one a_i is greater than 0:
1. You place one figure 2 × 1 (choose some i from 1 to n and replace a_i with a_i + 2);
2. then, while all a_i are greater than zero, replace each a_i with a_i - 1.
And your task is to determine if it is possible to clear the whole field (i.e. finish the described process), choosing the places for new figures properly.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The next 2t lines describe test cases. The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of columns in the Tetris field. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100), where a_i is the initial height of the i-th column of the Tetris field.
Output
For each test case, print the answer — "YES" (without quotes) if you can clear the whole Tetris field and "NO" otherwise.
Example
Input
4
3
1 1 3
4
1 1 2 1
2
11 11
1
100
Output
YES
NO
YES
YES
Note
The first test case of the example field is shown below:
<image>
Gray lines are bounds of the Tetris field. Note that the field has no upper bound.
One of the correct answers is to first place the figure in the first column. Then after the second step of the process, the field becomes [2, 0, 2]. Then place the figure in the second column and after the second step of the process, the field becomes [0, 0, 0].
And the second test case of the example field is shown below:
<image>
It can be shown that you cannot do anything to end the process.
In the third test case of the example, you first place the figure in the second column after the second step of the process, the field becomes [0, 2]. Then place the figure in the first column and after the second step of the process, the field becomes [0, 0].
In the fourth test case of the example, place the figure in the first column, then the field becomes [102] after the first step of the process, and then the field becomes [0] after the second step of the process. | instruction | 0 | 31,119 | 15 | 62,238 |
Tags: implementation, number theory
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
data = tuple(map(int, input().split()))
f = data[0] % 2
for i in data:
if i % 2 != f:
print("NO")
break
else:
print("YES")
``` | output | 1 | 31,119 | 15 | 62,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given some Tetris field consisting of n columns. The initial height of the i-th column of the field is a_i blocks. On top of these columns you can place only figures of size 2 × 1 (i.e. the height of this figure is 2 blocks and the width of this figure is 1 block). Note that you cannot rotate these figures.
Your task is to say if you can clear the whole field by placing such figures.
More formally, the problem can be described like this:
The following process occurs while at least one a_i is greater than 0:
1. You place one figure 2 × 1 (choose some i from 1 to n and replace a_i with a_i + 2);
2. then, while all a_i are greater than zero, replace each a_i with a_i - 1.
And your task is to determine if it is possible to clear the whole field (i.e. finish the described process), choosing the places for new figures properly.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The next 2t lines describe test cases. The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of columns in the Tetris field. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100), where a_i is the initial height of the i-th column of the Tetris field.
Output
For each test case, print the answer — "YES" (without quotes) if you can clear the whole Tetris field and "NO" otherwise.
Example
Input
4
3
1 1 3
4
1 1 2 1
2
11 11
1
100
Output
YES
NO
YES
YES
Note
The first test case of the example field is shown below:
<image>
Gray lines are bounds of the Tetris field. Note that the field has no upper bound.
One of the correct answers is to first place the figure in the first column. Then after the second step of the process, the field becomes [2, 0, 2]. Then place the figure in the second column and after the second step of the process, the field becomes [0, 0, 0].
And the second test case of the example field is shown below:
<image>
It can be shown that you cannot do anything to end the process.
In the third test case of the example, you first place the figure in the second column after the second step of the process, the field becomes [0, 2]. Then place the figure in the first column and after the second step of the process, the field becomes [0, 0].
In the fourth test case of the example, place the figure in the first column, then the field becomes [102] after the first step of the process, and then the field becomes [0] after the second step of the process. | instruction | 0 | 31,120 | 15 | 62,240 |
Tags: implementation, number theory
Correct Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
ar=input().split()
ar=[int(y) for y in ar]
m=min(ar)
z=0
for i in ar:
if (i-m)%2:
z=1
break
if z:
print('NO')
else:
print('YES')
``` | output | 1 | 31,120 | 15 | 62,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given some Tetris field consisting of n columns. The initial height of the i-th column of the field is a_i blocks. On top of these columns you can place only figures of size 2 × 1 (i.e. the height of this figure is 2 blocks and the width of this figure is 1 block). Note that you cannot rotate these figures.
Your task is to say if you can clear the whole field by placing such figures.
More formally, the problem can be described like this:
The following process occurs while at least one a_i is greater than 0:
1. You place one figure 2 × 1 (choose some i from 1 to n and replace a_i with a_i + 2);
2. then, while all a_i are greater than zero, replace each a_i with a_i - 1.
And your task is to determine if it is possible to clear the whole field (i.e. finish the described process), choosing the places for new figures properly.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The next 2t lines describe test cases. The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of columns in the Tetris field. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100), where a_i is the initial height of the i-th column of the Tetris field.
Output
For each test case, print the answer — "YES" (without quotes) if you can clear the whole Tetris field and "NO" otherwise.
Example
Input
4
3
1 1 3
4
1 1 2 1
2
11 11
1
100
Output
YES
NO
YES
YES
Note
The first test case of the example field is shown below:
<image>
Gray lines are bounds of the Tetris field. Note that the field has no upper bound.
One of the correct answers is to first place the figure in the first column. Then after the second step of the process, the field becomes [2, 0, 2]. Then place the figure in the second column and after the second step of the process, the field becomes [0, 0, 0].
And the second test case of the example field is shown below:
<image>
It can be shown that you cannot do anything to end the process.
In the third test case of the example, you first place the figure in the second column after the second step of the process, the field becomes [0, 2]. Then place the figure in the first column and after the second step of the process, the field becomes [0, 0].
In the fourth test case of the example, place the figure in the first column, then the field becomes [102] after the first step of the process, and then the field becomes [0] after the second step of the process. | instruction | 0 | 31,121 | 15 | 62,242 |
Tags: implementation, number theory
Correct Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
even,odd=0,0
for i in a:
if i%2:
odd+=1
else:
even+=1
if even and odd:
print('NO')
else:
print("YES")
``` | output | 1 | 31,121 | 15 | 62,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given some Tetris field consisting of n columns. The initial height of the i-th column of the field is a_i blocks. On top of these columns you can place only figures of size 2 × 1 (i.e. the height of this figure is 2 blocks and the width of this figure is 1 block). Note that you cannot rotate these figures.
Your task is to say if you can clear the whole field by placing such figures.
More formally, the problem can be described like this:
The following process occurs while at least one a_i is greater than 0:
1. You place one figure 2 × 1 (choose some i from 1 to n and replace a_i with a_i + 2);
2. then, while all a_i are greater than zero, replace each a_i with a_i - 1.
And your task is to determine if it is possible to clear the whole field (i.e. finish the described process), choosing the places for new figures properly.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The next 2t lines describe test cases. The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of columns in the Tetris field. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100), where a_i is the initial height of the i-th column of the Tetris field.
Output
For each test case, print the answer — "YES" (without quotes) if you can clear the whole Tetris field and "NO" otherwise.
Example
Input
4
3
1 1 3
4
1 1 2 1
2
11 11
1
100
Output
YES
NO
YES
YES
Note
The first test case of the example field is shown below:
<image>
Gray lines are bounds of the Tetris field. Note that the field has no upper bound.
One of the correct answers is to first place the figure in the first column. Then after the second step of the process, the field becomes [2, 0, 2]. Then place the figure in the second column and after the second step of the process, the field becomes [0, 0, 0].
And the second test case of the example field is shown below:
<image>
It can be shown that you cannot do anything to end the process.
In the third test case of the example, you first place the figure in the second column after the second step of the process, the field becomes [0, 2]. Then place the figure in the first column and after the second step of the process, the field becomes [0, 0].
In the fourth test case of the example, place the figure in the first column, then the field becomes [102] after the first step of the process, and then the field becomes [0] after the second step of the process. | instruction | 0 | 31,122 | 15 | 62,244 |
Tags: implementation, number theory
Correct Solution:
```
try:
t=int(input())
while t:
n=int(input())
c=0
a = list(map(int,input().strip().split()))[:n]
for i in range(0,n):
if a[i]%2!=0:
c=c+1
if c==n or c==0:
print("YES")
else:
print("NO")
except:
pass
``` | output | 1 | 31,122 | 15 | 62,245 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given some Tetris field consisting of n columns. The initial height of the i-th column of the field is a_i blocks. On top of these columns you can place only figures of size 2 × 1 (i.e. the height of this figure is 2 blocks and the width of this figure is 1 block). Note that you cannot rotate these figures.
Your task is to say if you can clear the whole field by placing such figures.
More formally, the problem can be described like this:
The following process occurs while at least one a_i is greater than 0:
1. You place one figure 2 × 1 (choose some i from 1 to n and replace a_i with a_i + 2);
2. then, while all a_i are greater than zero, replace each a_i with a_i - 1.
And your task is to determine if it is possible to clear the whole field (i.e. finish the described process), choosing the places for new figures properly.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The next 2t lines describe test cases. The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of columns in the Tetris field. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100), where a_i is the initial height of the i-th column of the Tetris field.
Output
For each test case, print the answer — "YES" (without quotes) if you can clear the whole Tetris field and "NO" otherwise.
Example
Input
4
3
1 1 3
4
1 1 2 1
2
11 11
1
100
Output
YES
NO
YES
YES
Note
The first test case of the example field is shown below:
<image>
Gray lines are bounds of the Tetris field. Note that the field has no upper bound.
One of the correct answers is to first place the figure in the first column. Then after the second step of the process, the field becomes [2, 0, 2]. Then place the figure in the second column and after the second step of the process, the field becomes [0, 0, 0].
And the second test case of the example field is shown below:
<image>
It can be shown that you cannot do anything to end the process.
In the third test case of the example, you first place the figure in the second column after the second step of the process, the field becomes [0, 2]. Then place the figure in the first column and after the second step of the process, the field becomes [0, 0].
In the fourth test case of the example, place the figure in the first column, then the field becomes [102] after the first step of the process, and then the field becomes [0] after the second step of the process. | instruction | 0 | 31,123 | 15 | 62,246 |
Tags: implementation, number theory
Correct Solution:
```
import sys
input = sys.stdin.readline
def main():
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
even, odd = 0, 0
ans = "YES"
for i in range(n):
if a[i] % 2:
odd = 1
if not a[i] % 2:
even = 1
if even and odd:
ans = "NO"
break
print(ans)
main()
``` | output | 1 | 31,123 | 15 | 62,247 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given some Tetris field consisting of n columns. The initial height of the i-th column of the field is a_i blocks. On top of these columns you can place only figures of size 2 × 1 (i.e. the height of this figure is 2 blocks and the width of this figure is 1 block). Note that you cannot rotate these figures.
Your task is to say if you can clear the whole field by placing such figures.
More formally, the problem can be described like this:
The following process occurs while at least one a_i is greater than 0:
1. You place one figure 2 × 1 (choose some i from 1 to n and replace a_i with a_i + 2);
2. then, while all a_i are greater than zero, replace each a_i with a_i - 1.
And your task is to determine if it is possible to clear the whole field (i.e. finish the described process), choosing the places for new figures properly.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The next 2t lines describe test cases. The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of columns in the Tetris field. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100), where a_i is the initial height of the i-th column of the Tetris field.
Output
For each test case, print the answer — "YES" (without quotes) if you can clear the whole Tetris field and "NO" otherwise.
Example
Input
4
3
1 1 3
4
1 1 2 1
2
11 11
1
100
Output
YES
NO
YES
YES
Note
The first test case of the example field is shown below:
<image>
Gray lines are bounds of the Tetris field. Note that the field has no upper bound.
One of the correct answers is to first place the figure in the first column. Then after the second step of the process, the field becomes [2, 0, 2]. Then place the figure in the second column and after the second step of the process, the field becomes [0, 0, 0].
And the second test case of the example field is shown below:
<image>
It can be shown that you cannot do anything to end the process.
In the third test case of the example, you first place the figure in the second column after the second step of the process, the field becomes [0, 2]. Then place the figure in the first column and after the second step of the process, the field becomes [0, 0].
In the fourth test case of the example, place the figure in the first column, then the field becomes [102] after the first step of the process, and then the field becomes [0] after the second step of the process. | instruction | 0 | 31,124 | 15 | 62,248 |
Tags: implementation, number theory
Correct Solution:
```
from sys import stdin,stdout
import bisect
import math
def st():
return list(stdin.readline().strip())
def inp():
return int(stdin.readline())
def li():
return list(map(int,stdin.readline().split()))
def mp():
return map(int,stdin.readline().split())
def pr(n):
stdout.write(str(n)+"\n")
def soe(limit):
l=[1]*(limit+1)
prime=[]
for i in range(2,limit+1):
if l[i]:
for j in range(i*i,limit+1,i):
l[j]=0
for i in range(2,limit+1):
if l[i]:
prime.append(i)
return prime
def segsoe(low,high):
limit=int(high**0.5)+1
prime=soe(limit)
n=high-low+1
l=[0]*(n+1)
for i in range(len(prime)):
lowlimit=(low//prime[i])*prime[i]
if lowlimit<low:
lowlimit+=prime[i]
if lowlimit==prime[i]:
lowlimit+=prime[i]
for j in range(lowlimit,high+1,prime[i]):
l[j-low]=1
for i in range(low,high+1):
if not l[i-low]:
if i!=1:
print(i)
def power(a,n):
r=1
while n:
if n&1:
r=(r*a)
n=n-1
else:
a=(a*a)
n=n>>1
return r
def solve():
n=inp()
l=li()
e,o=0,0
for i in l:
if i&1:
o+=1
else:
e+=1
if e==n or o==n:
pr("YES")
else:
pr("NO")
for _ in range(inp()):
solve()
``` | output | 1 | 31,124 | 15 | 62,249 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given some Tetris field consisting of n columns. The initial height of the i-th column of the field is a_i blocks. On top of these columns you can place only figures of size 2 × 1 (i.e. the height of this figure is 2 blocks and the width of this figure is 1 block). Note that you cannot rotate these figures.
Your task is to say if you can clear the whole field by placing such figures.
More formally, the problem can be described like this:
The following process occurs while at least one a_i is greater than 0:
1. You place one figure 2 × 1 (choose some i from 1 to n and replace a_i with a_i + 2);
2. then, while all a_i are greater than zero, replace each a_i with a_i - 1.
And your task is to determine if it is possible to clear the whole field (i.e. finish the described process), choosing the places for new figures properly.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The next 2t lines describe test cases. The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of columns in the Tetris field. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100), where a_i is the initial height of the i-th column of the Tetris field.
Output
For each test case, print the answer — "YES" (without quotes) if you can clear the whole Tetris field and "NO" otherwise.
Example
Input
4
3
1 1 3
4
1 1 2 1
2
11 11
1
100
Output
YES
NO
YES
YES
Note
The first test case of the example field is shown below:
<image>
Gray lines are bounds of the Tetris field. Note that the field has no upper bound.
One of the correct answers is to first place the figure in the first column. Then after the second step of the process, the field becomes [2, 0, 2]. Then place the figure in the second column and after the second step of the process, the field becomes [0, 0, 0].
And the second test case of the example field is shown below:
<image>
It can be shown that you cannot do anything to end the process.
In the third test case of the example, you first place the figure in the second column after the second step of the process, the field becomes [0, 2]. Then place the figure in the first column and after the second step of the process, the field becomes [0, 0].
In the fourth test case of the example, place the figure in the first column, then the field becomes [102] after the first step of the process, and then the field becomes [0] after the second step of the process. | instruction | 0 | 31,125 | 15 | 62,250 |
Tags: implementation, number theory
Correct Solution:
```
t=int(input())
for i in range(t):
n=int(input())
l=list(map(int,input().split()))
mark=0
for j in range(n-1):
if abs(l[j]-l[j+1])%2!=0:
mark=1
break
if mark==1:
print("NO")
else:
print("YES")
``` | output | 1 | 31,125 | 15 | 62,251 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given some Tetris field consisting of n columns. The initial height of the i-th column of the field is a_i blocks. On top of these columns you can place only figures of size 2 × 1 (i.e. the height of this figure is 2 blocks and the width of this figure is 1 block). Note that you cannot rotate these figures.
Your task is to say if you can clear the whole field by placing such figures.
More formally, the problem can be described like this:
The following process occurs while at least one a_i is greater than 0:
1. You place one figure 2 × 1 (choose some i from 1 to n and replace a_i with a_i + 2);
2. then, while all a_i are greater than zero, replace each a_i with a_i - 1.
And your task is to determine if it is possible to clear the whole field (i.e. finish the described process), choosing the places for new figures properly.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The next 2t lines describe test cases. The first line of the test case contains one integer n (1 ≤ n ≤ 100) — the number of columns in the Tetris field. The second line of the test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100), where a_i is the initial height of the i-th column of the Tetris field.
Output
For each test case, print the answer — "YES" (without quotes) if you can clear the whole Tetris field and "NO" otherwise.
Example
Input
4
3
1 1 3
4
1 1 2 1
2
11 11
1
100
Output
YES
NO
YES
YES
Note
The first test case of the example field is shown below:
<image>
Gray lines are bounds of the Tetris field. Note that the field has no upper bound.
One of the correct answers is to first place the figure in the first column. Then after the second step of the process, the field becomes [2, 0, 2]. Then place the figure in the second column and after the second step of the process, the field becomes [0, 0, 0].
And the second test case of the example field is shown below:
<image>
It can be shown that you cannot do anything to end the process.
In the third test case of the example, you first place the figure in the second column after the second step of the process, the field becomes [0, 2]. Then place the figure in the first column and after the second step of the process, the field becomes [0, 0].
In the fourth test case of the example, place the figure in the first column, then the field becomes [102] after the first step of the process, and then the field becomes [0] after the second step of the process. | instruction | 0 | 31,126 | 15 | 62,252 |
Tags: implementation, number theory
Correct Solution:
```
for v in range(int(input())):
n=int(input())
x=[int(q) for q in input().split()]
t=min(x)
for i in range(len(x)):
x[i]=x[i]-t
c=0
for i in range(len(x)):
if x[i]%2==0:
c+=1
if c==len(x):
print("YES")
else:
print("NO")
``` | output | 1 | 31,126 | 15 | 62,253 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Princess Vlada enjoys springing in the meadows and walking in the forest. One day — wonderful, sunny day — during her walk Princess found out with astonishment that her shadow was missing! "Blimey!", — she thought and started her search of the shadow in the forest.
Normally the Shadow is too lazy and simply sleeps under the Princess. But at this terrifically hot summer day she got bored of such a dull life, so she decided to play with Vlada.
The forest, where our characters entertain themselves, may be represented as a set of integer cells in the plane, where the Shadow and the Princess can move only up, down, left and right by 1. Some cells (as it happens in decent forests) are occupied by trees. The Shadow and the Princess are not allowed to enter a cell occupied by a tree. Unfortunately, these are the hard times for the forest, so there are very few trees growing here...
At first the Princess was walking within the cell (vx, vy), while the Shadow hid from the Princess in the cell (sx, sy). The Princess, The Shadow and the trees are located in the different cells.
The Shadow is playing with the Princess. As soon as the Princess moves by 1 in some direction, the Shadow simultaneously flies by 1 in the same direction, if it is possible (if the cell to fly to is not occupied by some tree); otherwise, the Shadow doesn't move. The Shadow is very shadowy, so our characters do not interfere with each other.
We say that the Shadow is caught by the Princess if after some move both of them are located in the same cell. Vlada managed to catch her Shadow! Can you?
Input
First line of the input contains the coordinates of the characters vx, vy, sx, sy and the number of trees m (0 ≤ m ≤ 400). The following m lines contain the coordinates of the trees.
All the coordinates are integers between -100 and 100, inclusive. The Princess, The Shadow and the trees are located in the different cells.
Output
If it is impossible for the Princess to catch the Shadow, print "-1" (without quotes).
Otherwise print a sequence of characters "L", "R", "D", "U", corresponding to the Princess's moves, following which she will be able to catch the Shadow at some turn (L — move to the left, R — to the right, U — up, D — down; axis x is directed to the right, y — up).
The number of characters (that is, the number of moves) must not exceed 106. All the Princess's moves should be correct, that is must not lead to the cell where a tree grows. It is allowed for the Princess and the Shadow to occupy the same cell before the last turn.
Examples
Input
0 0 1 0 1
0 1
Output
LLUR
Input
5 0 3 0 8
2 -1
2 0
2 1
3 -1
4 1
4 0
3 1
4 -1
Output
-1
Input
3 2 1 1 3
0 1
1 0
0 0
Output
DLL
Note
Below the pictures for the samples are given (Princess, Shadow and the trees are colored in pink, gray and black correspondingly; the blue dot marks the lattice center).
In the first case the Princess may make two left steps, one step upwards and one right step: <image>
In the following case the Princess cannot catch the Shadow: <image>
In the last sample the Princess may make two left steps and one down step (in any order): <image>
Submitted Solution:
```
value = input("");
answer = -1;
argv = value.split(" ");
if ( value.strip() == "0 0 1 0 1" ) :
answer = "LLUR";
if ( value.strip() == "3 2 1 1 3" ) :
answer = "DLL";
m = int(argv[4]);
if not(0 <= m <= 400) :
m = 0;
# No trees, no option to catch
if (m == 0) :
print(answer);
exit();
for x in range(0, m) :
value = input("");
print(answer);
``` | instruction | 0 | 31,291 | 15 | 62,582 |
No | output | 1 | 31,291 | 15 | 62,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Princess Vlada enjoys springing in the meadows and walking in the forest. One day — wonderful, sunny day — during her walk Princess found out with astonishment that her shadow was missing! "Blimey!", — she thought and started her search of the shadow in the forest.
Normally the Shadow is too lazy and simply sleeps under the Princess. But at this terrifically hot summer day she got bored of such a dull life, so she decided to play with Vlada.
The forest, where our characters entertain themselves, may be represented as a set of integer cells in the plane, where the Shadow and the Princess can move only up, down, left and right by 1. Some cells (as it happens in decent forests) are occupied by trees. The Shadow and the Princess are not allowed to enter a cell occupied by a tree. Unfortunately, these are the hard times for the forest, so there are very few trees growing here...
At first the Princess was walking within the cell (vx, vy), while the Shadow hid from the Princess in the cell (sx, sy). The Princess, The Shadow and the trees are located in the different cells.
The Shadow is playing with the Princess. As soon as the Princess moves by 1 in some direction, the Shadow simultaneously flies by 1 in the same direction, if it is possible (if the cell to fly to is not occupied by some tree); otherwise, the Shadow doesn't move. The Shadow is very shadowy, so our characters do not interfere with each other.
We say that the Shadow is caught by the Princess if after some move both of them are located in the same cell. Vlada managed to catch her Shadow! Can you?
Input
First line of the input contains the coordinates of the characters vx, vy, sx, sy and the number of trees m (0 ≤ m ≤ 400). The following m lines contain the coordinates of the trees.
All the coordinates are integers between -100 and 100, inclusive. The Princess, The Shadow and the trees are located in the different cells.
Output
If it is impossible for the Princess to catch the Shadow, print "-1" (without quotes).
Otherwise print a sequence of characters "L", "R", "D", "U", corresponding to the Princess's moves, following which she will be able to catch the Shadow at some turn (L — move to the left, R — to the right, U — up, D — down; axis x is directed to the right, y — up).
The number of characters (that is, the number of moves) must not exceed 106. All the Princess's moves should be correct, that is must not lead to the cell where a tree grows. It is allowed for the Princess and the Shadow to occupy the same cell before the last turn.
Examples
Input
0 0 1 0 1
0 1
Output
LLUR
Input
5 0 3 0 8
2 -1
2 0
2 1
3 -1
4 1
4 0
3 1
4 -1
Output
-1
Input
3 2 1 1 3
0 1
1 0
0 0
Output
DLL
Note
Below the pictures for the samples are given (Princess, Shadow and the trees are colored in pink, gray and black correspondingly; the blue dot marks the lattice center).
In the first case the Princess may make two left steps, one step upwards and one right step: <image>
In the following case the Princess cannot catch the Shadow: <image>
In the last sample the Princess may make two left steps and one down step (in any order): <image>
Submitted Solution:
```
value = input("");
answer = -1;
argv = value.split(" ");
if ( value.strip() == "0 0 1 0 1" ) :
answer = "LLUR";
if ( value.strip() == "5 0 3 0 8" ) :
answer = -1;
if ( value.strip() == "3 2 1 1 3" ) :
answer = "DLL";
if ( value.strip() == "-4 -12 16 5 169" ) :
answer = "RURRURRRRUURRRRRRRRRRURUUUUURRUUUUUUURUURUURRRRDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRDRUUUUUUUUUUUUUUUUU";
m = int(argv[4]);
if not(0 <= m <= 400) :
m = 0;
# No trees, no option to catch
if (m == 0) :
print(answer);
exit();
for x in range(0, m) :
value = input("");
print(answer);
``` | instruction | 0 | 31,292 | 15 | 62,584 |
No | output | 1 | 31,292 | 15 | 62,585 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2 | instruction | 0 | 31,541 | 15 | 63,082 |
"Correct Solution:
```
N, *XY = [int(_) for _ in open(0).read().split()]
X = XY[::2]
Y = XY[1::2]
y_k = {}
k_y = {}
for y, k in zip(Y, range(N)):
y_k[y] = k
k_y[k] = y
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1] * (n + 1)
self.rank = [0] * (n + 1)
def find(self, x):
if self.root[x] < 0:
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return 0
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def is_same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.root[self.find(x)]
class SegmentTree():
def __init__(self, array, f, ti):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
ti :
identity element of the monoid
"""
self.f = f
self.ti = ti
self.n = n = 2**(len(array).bit_length())
self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def update(self, p, v): # set value at position p (0-indexed)
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = v
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def operate_right(self, p, v): # apply operator from the right side
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = f(dat[p], v)
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def operate_left(self, p, v): # apply operator from the left side
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = f(v, dat[p])
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def query(self, l, r): # result on interval [l, r) (0-indexed)
f, ti, n, dat = self.f, self.ti, self.n, self.dat
vl = vr = ti
l += n
r += n
while l < r:
if l & 1:
vl = f(vl, dat[l])
l += 1
if r & 1:
r -= 1
vr = f(dat[r], vr)
l >>= 1
r >>= 1
return f(vl, vr)
XY = sorted(zip(X, Y))
uf = UnionFind(N + 1)
stmin = SegmentTree([10**10] * (N + 1), min, 10**10)
stmax = SegmentTree([-10**10] * (N + 1), max, -10**10)
for x, y in XY:
ymin = stmin.query(0, x)
ymax = stmax.query(0, y)
stmin.update(x, y)
stmax.update(y, y)
for y2 in (ymin, ymax):
if abs(y2) != 10**10 and y > y2:
uf.unite(y, y2)
stmin = SegmentTree([10**10] * (N + 1), min, 10**10)
stmax = SegmentTree([-10**10] * (N + 1), max, -10**10)
for x, y in XY[::-1]:
ymin = stmin.query(y + 1, N + 1)
ymax = stmax.query(x + 1, N + 1)
stmax.update(x, y)
stmin.update(y, y)
for y2 in (ymin, ymax):
if abs(y2) != 10**10 and y < y2:
uf.unite(y, y2)
print('\n'.join(str(uf.size(k_y[k])) for k in range(N)))
``` | output | 1 | 31,541 | 15 | 63,083 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2 | instruction | 0 | 31,542 | 15 | 63,084 |
"Correct Solution:
```
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N = int(input())
idx_dic = {}
XY = []
for i in range(N):
x, y = mapint()
x, y = x-1, y-1
idx_dic[i] = y
XY.append((x, y))
XY.sort()
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
uf = UnionFind(N)
from heapq import heappush, heappop
Q = []
for i in range(N):
x, y = XY[i]
mini = None
while Q:
v = heappop(Q)
if v>y:
heappush(Q, v)
break
uf.union(v, y)
if mini is None:
mini = v
if mini is None:
heappush(Q, y)
else:
heappush(Q, mini)
for i in range(N):
print(uf.size(idx_dic[i]))
``` | output | 1 | 31,542 | 15 | 63,085 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2 | instruction | 0 | 31,543 | 15 | 63,086 |
"Correct Solution:
```
from heapq import heappush, heappop
class UnionFind:
def __init__(self, size):
self.data = [-1] * size
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
def size(self, x):
return -self.data[self.find(x)]
N, *XY = map(int, open(0).read().split())
XY = list(zip(*[iter(XY)] * 2))
YtoI = {y : i for i, (x, y) in enumerate(XY)}
XY.sort()
uf = UnionFind(N)
Q = []
for x, y in XY:
T = []
while Q and Q[0] < y:
yy = heappop(Q)
uf.union(YtoI[y], YtoI[yy])
T.append(yy)
if T:
heappush(Q, T[0])
else:
heappush(Q, y)
for i in range(N):
print(uf.size(i))
``` | output | 1 | 31,543 | 15 | 63,087 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2 | instruction | 0 | 31,544 | 15 | 63,088 |
"Correct Solution:
```
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c for j in range(b)] for i in range(a)]
def list3d(a, b, c, d): return [[[d for k in range(c)] for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e for l in range(d)] for k in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10**9)
INF = 10**19
MOD = 10**9 + 7
EPS = 10**-10
class BIT:
""" Binary Indexed Tree """
def __init__(self, n):
self.n = n
# 0-indexed
n += 1
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
""" [0, i]を合計する """
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
""" 値の追加：添字i, 値x """
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def query(self, l, r):
""" 区間和の取得 [l, r) """
return self.sum(r-1) - self.sum(l-1)
def get(self, i):
""" 一点取得 """
return self.query(i, i+1)
def update(self, i, x):
""" 値の更新：添字i, 値x """
self.add(i, x - self.get(i))
def print(self):
for i in range(self.n):
print(self.get(i), end=' ')
print()
def bisearch_fore(self, l, r, x):
""" 区間[l, r]を左から右に向かってx番目の値がある位置 """
l_sm = self.sum(l-1)
ok = r + 1
ng = l - 1
while ng+1 < ok:
mid = (ok+ng) // 2
if self.sum(mid) - l_sm >= x:
ok = mid
else:
ng = mid
if ok != r + 1:
return ok
else:
return INF
def bisearch_back(self, l, r, x):
""" 区間[l, r]を右から左に向かってx番目の値がある位置 """
r_sm = self.sum(r)
ok = l - 1
ng = r + 1
while ok+1 < ng:
mid = (ok+ng) // 2
if r_sm - self.sum(mid-1) >= x:
ok = mid
else:
ng = mid
if ok != l - 1:
return ok
else:
return -INF
class UnionFind:
""" Union-Find木 """
def __init__(self, n):
self.n = n
self.par = [i for i in range(n)]
self.rank = [0] * n
self.size = [1] * n
self.tree = [True] * n
self.grpcnt = n
def find(self, x):
""" 根の検索(グループ番号の取得) """
t = []
while self.par[x] != x:
t.append(x)
x = self.par[x]
for i in t:
self.par[i] = x
return self.par[x]
def union(self, x, y):
""" 併合 """
x = self.find(x)
y = self.find(y)
if x == y:
self.tree[x] = False
return
if not self.tree[x] or not self.tree[y]:
self.tree[x] = self.tree[y] = False
self.grpcnt -= 1
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def is_same(self, x, y):
""" 同じ集合に属するか判定 """
return self.find(x) == self.find(y)
def get_size(self, x=None):
if x is not None:
""" あるノードの属する集合のノード数 """
return self.size[self.find(x)]
else:
""" 集合の数 """
return self.grpcnt
def is_tree(self, x):
""" 木かどうかの判定 """
return self.tree[self.find(x)]
N = INT()
XY = []
XtoY = [0] * (N+1)
YtoI = [0] * (N+1)
for i in range(N):
x, y = MAP()
XY.append((x, y))
XtoY[x] = (y, i)
YtoI[y] = i
bit = BIT(N+1)
uf = UnionFind(N)
for i in range(1, N+1):
bit.add(i, 1)
for x in range(1, N+1):
y, i = XtoY[x]
cury = y
while 1:
nxty = bit.bisearch_fore(cury+1, N, 1)
if nxty == INF:
break
else:
j = YtoI[nxty]
if uf.is_same(i, j):
break
else:
uf.union(i, j)
cury = nxty
bit.add(y, -1)
for i in range(N):
ans = uf.get_size(i)
print(ans)
``` | output | 1 | 31,544 | 15 | 63,089 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2 | instruction | 0 | 31,545 | 15 | 63,090 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
from operator import itemgetter
class UF():
def __init__(self, num):
self.par = [-1]*num
def find(self, x):
if self.par[x] < 0:
return x
else:
stack = []
while self.par[x] >= 0:
stack.append(x)
x = self.par[x]
for xi in stack:
self.par[xi] = x
return x
def union(self, x, y):
rx = self.find(x)
ry = self.find(y)
if rx != ry:
if self.par[rx] > self.par[ry]:
rx, ry = ry, rx
self.par[rx] += self.par[ry]
self.par[ry] = rx
return rx
N = int(readline())
XY = []
for i in range(N):
x, y = map(int, readline().split())
XY.append((i, x, y))
_, _, Y = map(list, zip(*XY))
XY.sort(key = itemgetter(1))
T = UF(N)
stack = []
for i, _, y in XY:
my = i
while stack and Y[stack[-1]] < y:
if Y[stack[-1]] < Y[my]:
my = stack[-1]
T.union(stack.pop(), i)
stack.append(my)
ans = [-T.par[T.find(i)] for i in range(N)]
print('\n'.join(map(str, ans)))
``` | output | 1 | 31,545 | 15 | 63,091 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2 | instruction | 0 | 31,546 | 15 | 63,092 |
"Correct Solution:
```
n=int(input())
n+=1
p=[0]*n
a=[0]*n
an=[0]*n
for i in range(1, n):
p[i],a[p[i]]=map(int,input().split())
mi=n+1
cu=0
for i in range(1,n):
if mi>a[i]:
mi=a[i]
if n-i==mi:
cn=i-cu
while cu<i:
cu+=1
an[cu]=cn
for i in range(1,n):
print(an[p[i]])
``` | output | 1 | 31,546 | 15 | 63,093 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2 | instruction | 0 | 31,547 | 15 | 63,094 |
"Correct Solution:
```
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c for j in range(b)] for i in range(a)]
def list3d(a, b, c, d): return [[[d for k in range(c)] for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e for l in range(d)] for k in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10**9)
INF = 10**19
MOD = 10**9 + 7
EPS = 10**-10
class BIT:
""" Binary Indexed Tree """
def __init__(self, n):
self.n = n
# 0-indexed
n += 1
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
""" [0, i]を合計する """
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
""" 値の追加：添字i, 値x """
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def query(self, l, r):
""" 区間和の取得 [l, r) """
return self.sum(r-1) - self.sum(l-1)
def get(self, i):
""" 一点取得 """
return self.query(i, i+1)
def update(self, i, x):
""" 値の更新：添字i, 値x """
self.add(i, x - self.get(i))
def print(self):
for i in range(self.n):
print(self.get(i), end=' ')
print()
def bisearch_fore(self, l, r, x):
""" 区間[l, r]を左から右に向かってx番目の値がある位置 """
l_sm = self.sum(l-1)
ok = r + 1
ng = l - 1
while ng+1 < ok:
mid = (ok+ng) // 2
if self.sum(mid) - l_sm >= x:
ok = mid
else:
ng = mid
if ok != r + 1:
return ok
else:
return INF
def bisearch_back(self, l, r, x):
""" 区間[l, r]を右から左に向かってx番目の値がある位置 """
r_sm = self.sum(r)
ok = l - 1
ng = r + 1
while ok+1 < ng:
mid = (ok+ng) // 2
if r_sm - self.sum(mid-1) >= x:
ok = mid
else:
ng = mid
if ok != l - 1:
return ok
else:
return -INF
class UnionFind:
""" Union-Find木 """
def __init__(self, n):
self.n = n
self.par = [i for i in range(n)]
self.rank = [0] * n
self.size = [1] * n
self.tree = [True] * n
self.grpcnt = n
def find(self, x):
""" 根の検索(グループ番号の取得) """
t = []
while self.par[x] != x:
t.append(x)
x = self.par[x]
for i in t:
self.par[i] = x
return self.par[x]
def union(self, x, y):
""" 併合 """
x = self.find(x)
y = self.find(y)
if x == y:
self.tree[x] = False
return
if not self.tree[x] or not self.tree[y]:
self.tree[x] = self.tree[y] = False
self.grpcnt -= 1
if self.rank[x] < self.rank[y]:
self.par[x] = y
self.size[y] += self.size[x]
else:
self.par[y] = x
self.size[x] += self.size[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def is_same(self, x, y):
""" 同じ集合に属するか判定 """
return self.find(x) == self.find(y)
def get_size(self, x=None):
if x is not None:
""" あるノードの属する集合のノード数 """
return self.size[self.find(x)]
else:
""" 集合の数 """
return self.grpcnt
def is_tree(self, x):
""" 木かどうかの判定 """
return self.tree[self.find(x)]
N = INT()
XY = []
XtoY = [0] * (N+1)
YtoI = [0] * (N+1)
for i in range(N):
x, y = MAP()
XY.append((x, y))
XtoY[x] = (y, i)
YtoI[y] = i
bit = BIT(N+1)
uf = UnionFind(N)
for i in range(1, N+1):
bit.add(i, 1)
for x in range(1, N+1):
y, i = XtoY[x]
cury = y
while 1:
nxty = bit.bisearch_fore(cury+1, N, 1)
if nxty == INF:
break
else:
j = YtoI[nxty]
if uf.is_same(i, j):
break
else:
uf.union(i, j)
cury = nxty
bit.add(y, -1)
if uf.get_size() == 1:
break
for i in range(N):
ans = uf.get_size(i)
print(ans)
``` | output | 1 | 31,547 | 15 | 63,095 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2
Submitted Solution:
```
import heapq
from collections import deque
def bfs(i, c):
color[i] = c
cnt[c] += 1
q = deque()
q.append(i)
while q:
j = q.popleft()
for k in G[j]:
if color[k] == -1:
color[k] = c
cnt[c] += 1
q.append(k)
return
n = int(input())
xy = []
for i in range(n):
x, y = map(int, input().split())
xy.append([x, y, i])
xy.sort()
cnt = [0] * n
h = [[n + 1, n + 1]]
G = []
for _ in range(n):
G.append([])
for i in range(n):
c = 0
while h[0][0] < xy[i][1]:
p = heapq.heappop(h)
if c == 0:
minv = p
c = 1
G[p[1]].append(xy[i][2])
G[xy[i][2]].append(p[1])
#heapq.heappush(h, [xy[i][1], xy[i][2]])
if c:
heapq.heappush(h, minv)
else:
heapq.heappush(h, [xy[i][1], xy[i][2]])
color = [-1] * n
c = 0
for i in range(n):
if color[i] == -1:
bfs(i, c)
c += 1
for i in range(n):
ans = cnt[color[i]]
print(ans)
``` | instruction | 0 | 31,549 | 15 | 63,098 |
Yes | output | 1 | 31,549 | 15 | 63,099 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities on a 2D plane. The coordinate of the i-th city is (x_i, y_i). Here (x_1, x_2, \dots, x_N) and (y_1, y_2, \dots, y_N) are both permuations of (1, 2, \dots, N).
For each k = 1,2,\dots,N, find the answer to the following question:
Rng is in City k. Rng can perform the following move arbitrarily many times:
* move to another city that has a smaller x-coordinate and a smaller y-coordinate, or a larger x-coordinate and a larger y-coordinate, than the city he is currently in.
How many cities (including City k) are reachable from City k?
Constraints
* 1 \leq N \leq 200,000
* (x_1, x_2, \dots, x_N) is a permutation of (1, 2, \dots, N).
* (y_1, y_2, \dots, y_N) is a permutation of (1, 2, \dots, N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print N lines. In i-th line print the answer to the question when k = i.
Examples
Input
4
1 4
2 3
3 1
4 2
Output
1
1
2
2
Input
7
6 4
4 3
3 5
7 1
2 7
5 2
1 6
Output
3
3
1
1
2
3
2
Submitted Solution:
```
class UnionFind():
def __init__(self,n):
self.n=n
self.root=[-1]*(n+1)
self.rank=[0]*(n+1)
def FindRoot(self,x):
if self.root[x]<0:
return x
else:
self.root[x]=self.FindRoot(self.root[x])
return self.root[x]
def Unite(self,x,y):
x=self.FindRoot(x)
y=self.FindRoot(y)
if x==y:
return
else:
if self.rank[x]>self.rank[y]:
self.root[x]+=self.root[y]
self.root[y]=x
elif self.rank[x]<=self.rank[y]:
self.root[y]+=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y]+=1
def isSameGroup(self,x,y):
return self.FindRoot(x)==self.FindRoot(y)
def Count(self,x):
return -self.root[self.FindRoot(x)]
n=int(input())
uf=UnionFind(n)
arr=[list(map(int,input().split()))+[i+1] for i in range(n)]
arr=sorted(arr,key=lambda x:x[0])
x,y,i=arr[0]
tmp=[]
for tx,ty,j in arr:
if y<=ty:
uf.Unite(i,j)
for tx2,ty2,j2 in tmp:
if ty2<=ty:
uf.Unite(j,j2)
tmp=[]
else:
tmp.append([x,y,i])
x=tx
y=ty
i=j
arr=sorted(arr,reverse=True,key=lambda x:x[1])
x,y,i=arr[0]
tmp=[]
for tx,ty,j in arr:
if x>=tx:
uf.Unite(i,j)
for tx2,ty2,j2 in tmp:
if tx2>=tx:
uf.Unite(j,j2)
tmp=[]
else:
tmp.append([x,y,i])
x=tx
y=ty
i=j
for i in range(1,n+1):
print(uf.Count(i))
``` | instruction | 0 | 31,551 | 15 | 63,102 |
Yes | output | 1 | 31,551 | 15 | 63,103 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.