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 |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given four different integer points p_1, p_2, p_3 and p_4 on XY grid.
In one step you can choose one of the points p_i and move it in one of four directions by one. In other words, if you have chosen point p_i = (x, y) you can move it to (x, y + 1), (x, y - 1), (x + 1, y) or (x - 1, y).
Your goal to move points in such a way that they will form a square with sides parallel to OX and OY axes (a square with side 0 is allowed).
What is the minimum number of steps you need to make such a square?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of four lines. Each line contains two integers x and y (0 ≤ x, y ≤ 10^9) — coordinates of one of the points p_i = (x, y).
All points are different in one test case.
Output
For each test case, print the single integer — the minimum number of steps to make a square.
Example
Input
3
0 2
4 2
2 0
2 4
1 0
2 0
4 0
6 0
1 6
2 2
2 5
4 1
Output
8
7
5
Note
In the first test case, one of the optimal solutions is shown below:
<image> Each point was moved two times, so the answer 2 + 2 + 2 + 2 = 8.
In the second test case, one of the optimal solutions is shown below:
<image> The answer is 3 + 1 + 0 + 3 = 7.
In the third test case, one of the optimal solutions is shown below:
<image> The answer is 1 + 1 + 2 + 1 = 5. | instruction | 0 | 16,185 | 15 | 32,370 |
Tags: brute force, constructive algorithms, flows, geometry, greedy, implementation, math, ternary search
Correct Solution:
```
t = int(input())
def solvePerm(points):
x1 = [points[0][0], points[1][0]]
segX1 = min(*x1), max(*x1)
x2 = [points[2][0], points[3][0]]
segX2 = min(*x2), max(*x2)
xRange = max(0, min(*segX2) - max(*segX1)), max(*segX2) - min(*segX1)
if xRange[1] < xRange[0]:
return 10**20
y1 = [points[1][1], points[2][1]]
segY1 = min(*y1), max(*y1)
y2 = [points[3][1], points[0][1]]
segY2 = min(*y2), max(*y2)
yRange = max(0, min(*segY2) - max(*segY1)), max(*segY2) - min(*segY1)
if yRange[1] < yRange[0]:
return 10**20
s = (segX1[1] - segX1[0]) + (segX2[1] - segX2[0])
s += (segY1[1] - segY1[0]) + (segY2[1] - segY2[0])
#print(xRange, yRange)
if yRange[0] <= xRange[1] and xRange[0] <= yRange[1]:
# Overlap
pass
else:
# No overlap
d = max(yRange[0] - xRange[1], xRange[0] - yRange[1])
#print("-", d)
s += 2 * d
return s
from itertools import permutations
for _ in range(t):
points = [tuple(map(int, input().split())) for _ in range(4)]
mi = 10**20
for p in permutations(points):
mi = min(mi, solvePerm(p))
print(mi)
``` | output | 1 | 16,185 | 15 | 32,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Theseus has just arrived to Crete to fight Minotaur. He found a labyrinth that has a form of a rectangular field of size n × m and consists of blocks of size 1 × 1.
Each block of the labyrinth has a button that rotates all blocks 90 degrees clockwise. Each block rotates around its center and doesn't change its position in the labyrinth. Also, each block has some number of doors (possibly none). In one minute, Theseus can either push the button in order to rotate all the blocks 90 degrees clockwise or pass to the neighbouring block. Theseus can go from block A to some neighbouring block B only if block A has a door that leads to block B and block B has a door that leads to block A.
Theseus found an entrance to labyrinth and is now located in block (xT, yT) — the block in the row xT and column yT. Theseus know that the Minotaur is hiding in block (xM, yM) and wants to know the minimum number of minutes required to get there.
Theseus is a hero, not a programmer, so he asks you to help him.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in labyrinth, respectively.
Each of the following n lines contains m characters, describing the blocks of the labyrinth. The possible characters are:
* «+» means this block has 4 doors (one door to each neighbouring block);
* «-» means this block has 2 doors — to the left and to the right neighbours;
* «|» means this block has 2 doors — to the top and to the bottom neighbours;
* «^» means this block has 1 door — to the top neighbour;
* «>» means this block has 1 door — to the right neighbour;
* «<» means this block has 1 door — to the left neighbour;
* «v» means this block has 1 door — to the bottom neighbour;
* «L» means this block has 3 doors — to all neighbours except left one;
* «R» means this block has 3 doors — to all neighbours except right one;
* «U» means this block has 3 doors — to all neighbours except top one;
* «D» means this block has 3 doors — to all neighbours except bottom one;
* «*» means this block is a wall and has no doors.
Left, right, top and bottom are defined from representing labyrinth as a table, where rows are numbered from 1 to n from top to bottom and columns are numbered from 1 to m from left to right.
Next line contains two integers — coordinates of the block (xT, yT) (1 ≤ xT ≤ n, 1 ≤ yT ≤ m), where Theseus is initially located.
Last line contains two integers — coordinates of the block (xM, yM) (1 ≤ xM ≤ n, 1 ≤ yM ≤ m), where Minotaur hides.
It's guaranteed that both the block where Theseus starts and the block where Minotaur is hiding have at least one door. Theseus and Minotaur may be initially located at the same block.
Output
If Theseus is not able to get to Minotaur, then print -1 in the only line of the output. Otherwise, print the minimum number of minutes required to get to the block where Minotaur is hiding.
Examples
Input
2 2
+*
*U
1 1
2 2
Output
-1
Input
2 3
<><
><>
1 1
2 1
Output
4
Note
Assume that Theseus starts at the block (xT, yT) at the moment 0.
Submitted Solution:
```
import sys
import collections
R = dict()
R = {'+':'+', '-':'|', '|':'-', '^':'>', '>':'v', 'v':'<', '<':'^', 'L':'U', 'R':'D', 'U':'R', 'D':'L', '*':'*'}
class Entity :
def __init__(self, x, y, z, c, d):
self.x, self.y, self.z, self.c, self.d = x, y, z, c, d
for i in range(z): self.c = R[self.c]
def CanGoTo(self, P):
if self.x + 1 == P.x:return True if self.c in 'v|LRU+' and P.c in '^|LRD+' else False
if self.x - 1 == P.x:return True if self.c in '^|LRD+' and P.c in 'v|LRU+' else False
if self.y + 1 == P.y:return True if self.c in '>-LUD+' and P.c in '<-RUD+' else False
if self.y - 1 == P.y:return True if self.c in '<-RUD+' and P.c in '>-LUD+' else False
def Rotate(self):self.c, self.z, self.d = R[self.c], self.z+1 if self.z < 3 else 0, self.d+1
Dx, Dy = (-1, 0, 0, 1), (0, -1, 1, 0)
n, m = map(int, input().split())
M = [ sys.stdin.readline() for _ in range(n)]
Xt, Yt = map(int, input().split())
Xm, Ym = map(int, input().split())
Xt, Yt, Xm, Ym = Xt-1, Yt-1, Xm-1, Ym-1
Q = collections.deque()
Q.append( Entity(Xt, Yt, 0, M[Xt][Yt], 0) )
V = [False]*10010000
V[10000*Xt+10*Yt+0] = 1
#V = [[[False]*4 for j in range(m)] for i in range(n)]
#V[Xt][Yt][0] = True
ans = -1
cnt = 0
while Q:
cnt += 1
if cnt % 100000 == 0 : print(cnt)
e = Q.popleft()
#print(e.x, e.y, e.z, e.c, e.d)
if e.x == Xm and e.y == Ym :
ans = e.d
break
for i in range(4) :
nx, ny = e.x + Dx[i], e.y + Dy[i]
if nx < 0 or nx >= n or ny < 0 or ny >= m : continue
#if V[nx][ny][e.z] : continue
if V[10000*nx+10*ny+e.z]:continue
P = Entity(nx, ny, e.z, M[nx][ny], e.d + 1)
if e.CanGoTo(P) :
Q.append(P)
#V[nx][ny][e.z] = True
V[10000*nx+10*ny+e.z]=1
#if not V[e.x][e.y][e.z+1 if e.z < 3 else 0] :
if V[10000*nx+10*ny+(e.z+1 if e.z < 3 else 0)]==0:
e.Rotate()
Q.append(e)
#V[e.x][e.y][e.z] = True
V[10000 * nx + 10 * ny + e.z] = 1
print(ans)
``` | instruction | 0 | 17,274 | 15 | 34,548 |
No | output | 1 | 17,274 | 15 | 34,549 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Theseus has just arrived to Crete to fight Minotaur. He found a labyrinth that has a form of a rectangular field of size n × m and consists of blocks of size 1 × 1.
Each block of the labyrinth has a button that rotates all blocks 90 degrees clockwise. Each block rotates around its center and doesn't change its position in the labyrinth. Also, each block has some number of doors (possibly none). In one minute, Theseus can either push the button in order to rotate all the blocks 90 degrees clockwise or pass to the neighbouring block. Theseus can go from block A to some neighbouring block B only if block A has a door that leads to block B and block B has a door that leads to block A.
Theseus found an entrance to labyrinth and is now located in block (xT, yT) — the block in the row xT and column yT. Theseus know that the Minotaur is hiding in block (xM, yM) and wants to know the minimum number of minutes required to get there.
Theseus is a hero, not a programmer, so he asks you to help him.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in labyrinth, respectively.
Each of the following n lines contains m characters, describing the blocks of the labyrinth. The possible characters are:
* «+» means this block has 4 doors (one door to each neighbouring block);
* «-» means this block has 2 doors — to the left and to the right neighbours;
* «|» means this block has 2 doors — to the top and to the bottom neighbours;
* «^» means this block has 1 door — to the top neighbour;
* «>» means this block has 1 door — to the right neighbour;
* «<» means this block has 1 door — to the left neighbour;
* «v» means this block has 1 door — to the bottom neighbour;
* «L» means this block has 3 doors — to all neighbours except left one;
* «R» means this block has 3 doors — to all neighbours except right one;
* «U» means this block has 3 doors — to all neighbours except top one;
* «D» means this block has 3 doors — to all neighbours except bottom one;
* «*» means this block is a wall and has no doors.
Left, right, top and bottom are defined from representing labyrinth as a table, where rows are numbered from 1 to n from top to bottom and columns are numbered from 1 to m from left to right.
Next line contains two integers — coordinates of the block (xT, yT) (1 ≤ xT ≤ n, 1 ≤ yT ≤ m), where Theseus is initially located.
Last line contains two integers — coordinates of the block (xM, yM) (1 ≤ xM ≤ n, 1 ≤ yM ≤ m), where Minotaur hides.
It's guaranteed that both the block where Theseus starts and the block where Minotaur is hiding have at least one door. Theseus and Minotaur may be initially located at the same block.
Output
If Theseus is not able to get to Minotaur, then print -1 in the only line of the output. Otherwise, print the minimum number of minutes required to get to the block where Minotaur is hiding.
Examples
Input
2 2
+*
*U
1 1
2 2
Output
-1
Input
2 3
<><
><>
1 1
2 1
Output
4
Note
Assume that Theseus starts at the block (xT, yT) at the moment 0.
Submitted Solution:
```
l = input().split(" ")
n = int(l[0])
m = int(l[1])
lab = [[[' ' for i in range(m)] for j in range(n)] for z in range(4)]
visited = [[[False for i in range(m)] for j in range(n)] for z in range(4)]
for r in range(n):
line = input()
for c in range(m):
lab[0][r][c] = line[c]
class Node:
def __init__(self, x, y, r):
self.x = x
self.y = y
self.r = r
rotationMap = {'+': '+',
'|': '-',
'-': '|',
'^': '>',
'>': 'v',
'v': '<',
'<': '^',
'L': 'U',
'U': 'R',
'R': 'D',
'D': 'L',
'*': '*'}
topMoves = {'+': True,
'|': True,
'-': False,
'^': True,
'>': False,
'v': False,
'<': False,
'L': True,
'U': False,
'R': True,
'D': True,
'*': False}
bottomMoves = {'+': True,
'|': True,
'-': False,
'^': False,
'>': False,
'v': True,
'<': False,
'L': True,
'U': True,
'R': True,
'D': False,
'*': False}
rightMoves = {'+': True,
'|': False,
'-': True,
'^': False,
'>': True,
'v': False,
'<': False,
'L': True,
'U': True,
'R': False,
'D': True,
'*': False}
leftMoves = {'+': True,
'|': False,
'-': True,
'^': False,
'>': False,
'v': False,
'<': True,
'L': False,
'U': True,
'R': True,
'D': True,
'*': False}
for i in range(n):
for j in range(m):
for k in range(1,4):
lab[k][i][j] = rotationMap[lab[k-1][i][j]]
l = input().split(" ")
xt = int(l[0])-1
yt = int(l[0])-1
l = input().split(" ")
xm = int(l[0])-1
ym = int(l[0])-1
root = Node(xt, yt, 0)
visited[0][xt][yt] = True
moves = [root]
nextMoves = []
ctr = 0
found = -1
while (len(moves) > 0):
for i in range(len(moves)):
curr = moves[i]
if (curr.x == xm and curr.y == ym):
found = ctr
break
currCell = lab[curr.r][curr.x][curr.y]
if curr.x > 0 and not visited[curr.r][curr.x-1][curr.y] and topMoves[currCell]:
# do top move
nextMoves.append(Node(curr.x-1, curr.y, curr.r))
visited[curr.r][curr.x-1][curr.y] = True
if curr.x < n-1 and not visited[curr.r][curr.x+1][curr.y] and bottomMoves[currCell]:
nextMoves.append(Node(curr.x+1, curr.y, curr.r))
visited[curr.r][curr.x+1][curr.y] = True
if curr.y > 0 and not visited[curr.r][curr.x][curr.y-1] and leftMoves[currCell]:
nextMoves.append(Node(curr.x, curr.y-1, curr.r))
visited[curr.r][curr.x][curr.y-1] = True
if curr.y < m-1 and not visited[curr.r][curr.x][curr.y+1] and rightMoves[currCell]:
nextMoves.append(Node(curr.x, curr.y+1, curr.r))
visited[curr.r][curr.x][curr.y+1] = True
if (not visited[(curr.r+1) % 4][curr.x][curr.y]):
nextMoves.append(Node(curr.x, curr.y, (curr.r+1)%4))
visited[(curr.r+1) % 4][curr.x][curr.y] = True
if (not visited[(curr.r-1) % 4][curr.x][curr.y]):
nextMoves.append(Node(curr.x, curr.y, (curr.r-1) % 4))
visited[(curr.r-1) % 4][curr.x][curr.y] = True
if (found >= 0):
break
moves = nextMoves
nextMoves = []
ctr += 1
print(found)
``` | instruction | 0 | 17,275 | 15 | 34,550 |
No | output | 1 | 17,275 | 15 | 34,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Theseus has just arrived to Crete to fight Minotaur. He found a labyrinth that has a form of a rectangular field of size n × m and consists of blocks of size 1 × 1.
Each block of the labyrinth has a button that rotates all blocks 90 degrees clockwise. Each block rotates around its center and doesn't change its position in the labyrinth. Also, each block has some number of doors (possibly none). In one minute, Theseus can either push the button in order to rotate all the blocks 90 degrees clockwise or pass to the neighbouring block. Theseus can go from block A to some neighbouring block B only if block A has a door that leads to block B and block B has a door that leads to block A.
Theseus found an entrance to labyrinth and is now located in block (xT, yT) — the block in the row xT and column yT. Theseus know that the Minotaur is hiding in block (xM, yM) and wants to know the minimum number of minutes required to get there.
Theseus is a hero, not a programmer, so he asks you to help him.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in labyrinth, respectively.
Each of the following n lines contains m characters, describing the blocks of the labyrinth. The possible characters are:
* «+» means this block has 4 doors (one door to each neighbouring block);
* «-» means this block has 2 doors — to the left and to the right neighbours;
* «|» means this block has 2 doors — to the top and to the bottom neighbours;
* «^» means this block has 1 door — to the top neighbour;
* «>» means this block has 1 door — to the right neighbour;
* «<» means this block has 1 door — to the left neighbour;
* «v» means this block has 1 door — to the bottom neighbour;
* «L» means this block has 3 doors — to all neighbours except left one;
* «R» means this block has 3 doors — to all neighbours except right one;
* «U» means this block has 3 doors — to all neighbours except top one;
* «D» means this block has 3 doors — to all neighbours except bottom one;
* «*» means this block is a wall and has no doors.
Left, right, top and bottom are defined from representing labyrinth as a table, where rows are numbered from 1 to n from top to bottom and columns are numbered from 1 to m from left to right.
Next line contains two integers — coordinates of the block (xT, yT) (1 ≤ xT ≤ n, 1 ≤ yT ≤ m), where Theseus is initially located.
Last line contains two integers — coordinates of the block (xM, yM) (1 ≤ xM ≤ n, 1 ≤ yM ≤ m), where Minotaur hides.
It's guaranteed that both the block where Theseus starts and the block where Minotaur is hiding have at least one door. Theseus and Minotaur may be initially located at the same block.
Output
If Theseus is not able to get to Minotaur, then print -1 in the only line of the output. Otherwise, print the minimum number of minutes required to get to the block where Minotaur is hiding.
Examples
Input
2 2
+*
*U
1 1
2 2
Output
-1
Input
2 3
<><
><>
1 1
2 1
Output
4
Note
Assume that Theseus starts at the block (xT, yT) at the moment 0.
Submitted Solution:
```
l = input().split(" ")
n = int(l[0])
m = int(l[1])
lab = [[[' ' for i in range(m)] for j in range(n)] for z in range(4)]
visited = [[[False for i in range(m)] for j in range(n)] for z in range(4)]
for r in range(n):
line = input()
for c in range(m):
lab[0][r][c] = line[c]
class Node:
def __init__(self, x, y, r, c):
self.x = x
self.y = y
self.r = r
self.curr = []
if (c is not None):
self.curr.extend(c.curr)
self.curr.append(self)
def printList(self):
for i in range(len(self.curr)):
print(self.curr[i])
def __str__(self):
return "x y r: %d %d %d = %c" % (self.x, self.y, self.r, lab[self.r][self.x][self.y])
rotationMap = {'+': '+',
'|': '-',
'-': '|',
'^': '>',
'>': 'v',
'v': '<',
'<': '^',
'L': 'U',
'U': 'R',
'R': 'D',
'D': 'L',
'*': '*'}
topMoves = {'+': True,
'|': True,
'-': False,
'^': True,
'>': False,
'v': False,
'<': False,
'L': True,
'U': False,
'R': True,
'D': True,
'*': False}
bottomMoves = {'+': True,
'|': True,
'-': False,
'^': False,
'>': False,
'v': True,
'<': False,
'L': True,
'U': True,
'R': True,
'D': False,
'*': False}
rightMoves = {'+': True,
'|': False,
'-': True,
'^': False,
'>': True,
'v': False,
'<': False,
'L': True,
'U': True,
'R': False,
'D': True,
'*': False}
leftMoves = {'+': True,
'|': False,
'-': True,
'^': False,
'>': False,
'v': False,
'<': True,
'L': False,
'U': True,
'R': True,
'D': True,
'*': False}
for i in range(n):
for j in range(m):
for k in range(1,4):
lab[k][i][j] = rotationMap[lab[k-1][i][j]]
l = input().split(" ")
xt = int(l[0])-1
yt = int(l[1])-1
l = input().split(" ")
xm = int(l[0])-1
ym = int(l[1])-1
root = Node(xt, yt, 0, None)
visited[0][xt][yt] = True
moves = [root]
nextMoves = []
ctr = 0
found = -1
while (len(moves) > 0):
for i in range(len(moves)):
curr = moves[i]
if (curr.x == xm and curr.y == ym):
found = ctr
curr.printList()
break
currCell = lab[curr.r][curr.x][curr.y]
if curr.x-1 >= 0 and not visited[curr.r][curr.x-1][curr.y] and topMoves[currCell] and bottomMoves[lab[curr.r][curr.x-1][curr.y]]:
# do top move
nextMoves.append(Node(curr.x-1, curr.y, curr.r, curr))
visited[curr.r][curr.x-1][curr.y] = True
if curr.x+1 < n and not visited[curr.r][curr.x+1][curr.y] and bottomMoves[currCell] and topMoves[lab[curr.r][curr.x+1][curr.y]]:
nextMoves.append(Node(curr.x+1, curr.y, curr.r, curr))
visited[curr.r][curr.x+1][curr.y] = True
if curr.y-1 >= 0 and not visited[curr.r][curr.x][curr.y-1] and leftMoves[currCell] and rightMoves[lab[curr.r][curr.x][curr.y-1]]:
nextMoves.append(Node(curr.x, curr.y-1, curr.r, curr))
visited[curr.r][curr.x][curr.y-1] = True
if curr.y+1 < m and not visited[curr.r][curr.x][curr.y+1] and rightMoves[currCell] and leftMoves[lab[curr.r][curr.x][curr.y+1]]:
nextMoves.append(Node(curr.x, curr.y+1, curr.r, curr))
visited[curr.r][curr.x][curr.y+1] = True
if (not visited[(curr.r+1) % 4][curr.x][curr.y]):
nextMoves.append(Node(curr.x, curr.y, (curr.r+1)%4, curr))
visited[(curr.r+1) % 4][curr.x][curr.y] = True
if (found >= 0):
break
moves = nextMoves
nextMoves = []
ctr += 1
print(found)
``` | instruction | 0 | 17,276 | 15 | 34,552 |
No | output | 1 | 17,276 | 15 | 34,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Theseus has just arrived to Crete to fight Minotaur. He found a labyrinth that has a form of a rectangular field of size n × m and consists of blocks of size 1 × 1.
Each block of the labyrinth has a button that rotates all blocks 90 degrees clockwise. Each block rotates around its center and doesn't change its position in the labyrinth. Also, each block has some number of doors (possibly none). In one minute, Theseus can either push the button in order to rotate all the blocks 90 degrees clockwise or pass to the neighbouring block. Theseus can go from block A to some neighbouring block B only if block A has a door that leads to block B and block B has a door that leads to block A.
Theseus found an entrance to labyrinth and is now located in block (xT, yT) — the block in the row xT and column yT. Theseus know that the Minotaur is hiding in block (xM, yM) and wants to know the minimum number of minutes required to get there.
Theseus is a hero, not a programmer, so he asks you to help him.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of rows and the number of columns in labyrinth, respectively.
Each of the following n lines contains m characters, describing the blocks of the labyrinth. The possible characters are:
* «+» means this block has 4 doors (one door to each neighbouring block);
* «-» means this block has 2 doors — to the left and to the right neighbours;
* «|» means this block has 2 doors — to the top and to the bottom neighbours;
* «^» means this block has 1 door — to the top neighbour;
* «>» means this block has 1 door — to the right neighbour;
* «<» means this block has 1 door — to the left neighbour;
* «v» means this block has 1 door — to the bottom neighbour;
* «L» means this block has 3 doors — to all neighbours except left one;
* «R» means this block has 3 doors — to all neighbours except right one;
* «U» means this block has 3 doors — to all neighbours except top one;
* «D» means this block has 3 doors — to all neighbours except bottom one;
* «*» means this block is a wall and has no doors.
Left, right, top and bottom are defined from representing labyrinth as a table, where rows are numbered from 1 to n from top to bottom and columns are numbered from 1 to m from left to right.
Next line contains two integers — coordinates of the block (xT, yT) (1 ≤ xT ≤ n, 1 ≤ yT ≤ m), where Theseus is initially located.
Last line contains two integers — coordinates of the block (xM, yM) (1 ≤ xM ≤ n, 1 ≤ yM ≤ m), where Minotaur hides.
It's guaranteed that both the block where Theseus starts and the block where Minotaur is hiding have at least one door. Theseus and Minotaur may be initially located at the same block.
Output
If Theseus is not able to get to Minotaur, then print -1 in the only line of the output. Otherwise, print the minimum number of minutes required to get to the block where Minotaur is hiding.
Examples
Input
2 2
+*
*U
1 1
2 2
Output
-1
Input
2 3
<><
><>
1 1
2 1
Output
4
Note
Assume that Theseus starts at the block (xT, yT) at the moment 0.
Submitted Solution:
```
import queue as Q
q = Q.PriorityQueue()
n,m = input().split()
n = int(n)
m = int(m)
grid = []
for row in range(n):
grid.append(input())
tx,ty = input().split()
tx = int(tx)-1
ty = int(ty)-1
mx,my = input().split()
mx = int(mx)-1
my = int(my)-1
'''
for r in grid:
for c in r:
print(c,end=" ")
print()
'''
def rotate(piece, rotations):
if piece == "+" or piece == "*" or rotations ==0:
return piece
if piece == "-":
piece = "|"
elif piece == "|":
piece = "-"
if piece == "^":
piece = ">"
elif piece == ">":
piece = "v"
elif piece == "v":
piece = "<"
elif piece == "<":
piece = "^"
elif piece == "L":
piece = "U"
elif piece == "U":
piece = "R"
elif piece == "R":
piece = "D"
elif piece == "D":
piece = "L"
return rotate(piece, rotations-1)
#print(rotate('<',4))
assert rotate('<',4) == '<'
def getNeighbors(x,y):
around = []
if y>0 and grid[x][y-1] != '*':
around.append([x,y-1,0])
if y<m-1 and grid[x][y+1] != '*':
around.append([x,y+1,2])
if x>0 and grid[x-1][y] != '*':
around.append([x-1,y,1])
if x<n-1 and grid[x+1][y] != '*':
around.append([x+1,y,3])
return around
def canMove(bk1, bk2):
if bk1 == 'U' or bk1 == '<' or bk1 == '>' or bk1 == 'v'\
or bk1 == '-' or bk2 == '<' or bk2 == '>' or bk2 == '^'\
or bk2 == 'D' or bk2 == '-':
return False
return True
assert canMove('^','v')
assert not canMove('<','v')
q.put((0,tx,ty,0))
found = -1
while not q.empty():
focus = q.get()
#print(focus)
#print(q.qsize())
ftim = focus[0]
if focus[1] == mx and focus[2] == my:
found = ftim
break
for neighbor in getNeighbors(focus[1],focus[2]):
bk1 = rotate(grid[focus[1]][focus[2]],focus[3]+neighbor[2])
bk2 = rotate(grid[neighbor[0]][neighbor[1]],focus[3]+neighbor[2])
rotations = 0
good = False
for r in range(4):
if canMove(rotate(bk1, r), rotate(bk2, r)):
good = True
rotations = r+1
continue
if good:
q.put((1+rotations+focus[0],neighbor[0],neighbor[1],(focus[3]+neighbor[2]+rotations)%4))
print(found)
``` | instruction | 0 | 17,277 | 15 | 34,554 |
No | output | 1 | 17,277 | 15 | 34,555 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image> | instruction | 0 | 17,827 | 15 | 35,654 |
Tags: constructive algorithms, dfs and similar, graphs, implementation
Correct Solution:
```
from collections import deque
import sys
def input(): return sys.stdin.readline().strip()
def main():
n = int(input())
res = [['' for _ in range(n)] for _ in range(n)]
data = [[None for _ in range(n)] for _ in range(n)]
q = deque()
for i in range(n):
row = [int(x) - 1 for x in input().split()]
for j in range(n):
data[i][j] = (row[j * 2], row[j * 2 + 1])
if (i, j) == data[i][j]:
q.append((i, j))
res[i][j] = 'X'
while q:
i, j = q.popleft()
if 0 <= i + 1 < n and 0 <= j < n and data[i+1][j] == data[i][j] and not res[i+1][j]:
res[i + 1][j] = 'U'
q.append((i + 1, j))
if 0 <= i - 1 < n and 0 <= j < n and data[i-1][j] == data[i][j] and not res[i-1][j]:
res[i - 1][j] = 'D'
q.append((i - 1, j))
if 0 <= i < n and 0 <= j + 1 < n and data[i][j+1] == data[i][j] and not res[i][j+1]:
res[i][j + 1] = 'L'
q.append((i, j + 1))
if 0 <= i < n and 0 <= j - 1 < n and data[i][j-1] == data[i][j] and not res[i][j-1]:
res[i][j - 1] = 'R'
q.append((i, j - 1))
for i in range(n):
for j in range(n):
if data[i][j] == (-2, -2):
if 0 <= i + 1 < n and 0 <= j < n and data[i+1][j] == (-2, -2):
res[i][j] = 'D'
elif 0 <= i - 1 < n and 0 <= j < n and data[i-1][j] == (-2, -2):
res[i][j] = 'U'
elif 0 <= i < n and 0 <= j + 1 < n and data[i][j+1] == (-2, -2):
res[i][j] = 'R'
elif 0 <= i < n and 0 <= j - 1 < n and data[i][j-1] == (-2, -2):
res[i][j] = 'L'
else:
print("INVALID")
exit()
total = []
for e in res:
if '' in e:
print("INVALID")
exit()
total.append(''.join(e))
print("VALID")
print('\n'.join(total))
main()
``` | output | 1 | 17,827 | 15 | 35,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image> | instruction | 0 | 17,828 | 15 | 35,656 |
Tags: constructive algorithms, dfs and similar, graphs, implementation
Correct Solution:
```
d4i=[0,-1,0,1]
d4j=[-1,0,1,0]
direction=['L','U','R','D']
back=['R','D','L','U']
def main():
# Observations:
# if ri,cj==xi,yj, i,j is x
# if ri,cj==-1,-1, i,j is cycle:
# Steps:
# Mark cycles and Xs
# DFS from all X only to nodes pointing to x
# Fill cycles by pointing to an adjacent cycle square
# Check that all cells are marked
n=int(input())
finalState=[[] for _ in range(n)] #[xi,yj]
ans=[[None for _ in range(n+1)] for __ in range(n+1)]
for i in range(n):
temp=readIntArr()
temp.append(-11) #adding extra col to avoid checking for out of grid
temp.append(-11)
for j in range(n+1):
finalState[i].append([temp[2*j]-1,temp[2*j+1]-1]) #0-indexing
finalState.append([None]*(n+1)) #adding extra row to avoid checking for out of grid
endPoints=[]
cyclePoints=set()
for i in range(n):
for j in range(n):
x,y=finalState[i][j]
if x==i and y==j:
ans[i][j]='X'
endPoints.append([x,y])
elif x==-2: #due to 0-indexing
ans[i][j]='c' #cycle
cyclePoints.add((i,j))
# multiLineArrayOfArraysPrint(finalState)
# multiLineArrayOfArraysPrint(ans)
for endX,endY in endPoints:
stack=[[endX,endY]]
while stack:
i,j=stack.pop()
for z in range(4):
ii=i+d4i[z]
jj=j+d4j[z]
if ans[ii][jj]==None and finalState[ii][jj]==[endX,endY]:
ans[ii][jj]=back[z]
stack.append([ii,jj])
# Fill Cycles (point each cycle point to another cycle point)
for ci,cj in cyclePoints:
for z in range(4):
ii=ci+d4i[z]
jj=cj+d4j[z]
if (ii,jj) in cyclePoints:
ans[ci][cj]=direction[z]
break
ok=True
outcomes={'U','D','R','L','X'}
for i in range(n):
for j in range(n):
if ans[i][j] not in outcomes:
ok=False
if ok:
print('VALID')
ans.pop()#remove extra row
for i in range(n):
ans[i].pop() #remove extra col
multiLineArrayOfArraysPrint(ans)
else:
print('INVALID')
return
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
# import sys
# input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([''.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
inf=float('inf')
MOD=10**9+7
for _ in range(1):
main()
``` | output | 1 | 17,828 | 15 | 35,657 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image> | instruction | 0 | 17,829 | 15 | 35,658 |
Tags: constructive algorithms, dfs and similar, graphs, implementation
Correct Solution:
```
from collections import deque
def problem(m):
def bfs (i, j):
q = deque([ (i, j) ])
while len(q):
i, j = q.popleft()
for a, b, d in [ (i-1, j, 'D'), (i+1, j, 'U'), (i, j-1, 'R'), (i, j+1, 'L') ]:
if a == -1 or a == n or b == -1 or b == n or v[a][b]: continue
if m[i][j] == m[a][b]:
v[a][b] = d
q.append((a, b))
for i in range(n):
for j in range(n):
if m[i][j] == (i, j):
v[i][j] = 'X'
bfs(i, j)
if m[i][j] == (-2, -2):
for a, b, nxt, prv in [ (i+1, j, 'D', 'U'), (i-1, j, 'U', 'D'), (i, j+1, 'R', 'L'), (i, j-1, 'L', 'R') ]:
if a == -1 or a == n or b == -1 or b == n: continue
if m[a][b] == (-2, -2):
v[i][j], v[a][b] = nxt, prv
break
else:
return 'INVALID'
for i in range(n):
for j in range(n):
if not v[i][j]: return 'INVALID'
return 'VALID\n' + '\n'.join([ ''.join(x) for x in v ])
n = int(input())
m = [ [None] * n for _ in range(n) ]
v = [ [False] * n for _ in range(n) ]
for i in range(n):
r = list(map(int, input().split()))
for j in range(n):
a, b = r[2*j] - 1, r[2*j + 1] - 1
m[i][j] = (a, b)
print(problem(m))
``` | output | 1 | 17,829 | 15 | 35,659 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image> | instruction | 0 | 17,830 | 15 | 35,660 |
Tags: constructive algorithms, dfs and similar, graphs, implementation
Correct Solution:
```
from collections import deque
import sys
def input(): return sys.stdin.buffer.readline()[:-1]
def main():
n = int(input())
res = [[''] * n for _ in range(n)]
data = [[None] * n for _ in range(n)]
q = deque()
cnt = 0
for i in range(n):
row = [int(x) - 1 for x in input().split()]
for j in range(n):
data[i][j] = (row[j * 2], row[j * 2 + 1])
if (i, j) == data[i][j]:
q.append((i, j))
res[i][j] = 'X'
cnt += 1
while q:
i, j = q.popleft()
if 0 <= i + 1 < n and 0 <= j < n and data[i+1][j] == data[i][j] and not res[i+1][j]:
res[i + 1][j] = 'U'
q.append((i + 1, j))
cnt += 1
if 0 <= i - 1 < n and 0 <= j < n and data[i-1][j] == data[i][j] and not res[i-1][j]:
res[i - 1][j] = 'D'
q.append((i - 1, j))
cnt += 1
if 0 <= i < n and 0 <= j + 1 < n and data[i][j+1] == data[i][j] and not res[i][j+1]:
res[i][j + 1] = 'L'
q.append((i, j + 1))
cnt += 1
if 0 <= i < n and 0 <= j - 1 < n and data[i][j-1] == data[i][j] and not res[i][j-1]:
res[i][j - 1] = 'R'
q.append((i, j - 1))
cnt += 1
for i in range(n):
for j in range(n):
if data[i][j] == (-2, -2):
cnt += 1
if 0 <= i + 1 < n and 0 <= j < n and data[i+1][j] == (-2, -2):
res[i][j] = 'D'
elif 0 <= i - 1 < n and 0 <= j < n and data[i-1][j] == (-2, -2):
res[i][j] = 'U'
elif 0 <= i < n and 0 <= j + 1 < n and data[i][j+1] == (-2, -2):
res[i][j] = 'R'
elif 0 <= i < n and 0 <= j - 1 < n and data[i][j-1] == (-2, -2):
res[i][j] = 'L'
else:
print("INVALID")
exit()
if cnt != n * n:
print("INVALID")
exit()
print('VALID')
for e in res:
print(''.join(e))
main()
``` | output | 1 | 17,830 | 15 | 35,661 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image> | instruction | 0 | 17,831 | 15 | 35,662 |
Tags: constructive algorithms, dfs and similar, graphs, implementation
Correct Solution:
```
n = int(input())
d = [[0] * n for _ in range(n)]
for r in range(n):
nums = list(map(int, input().split()))
i = 0
while i + 1 < 2 * n:
d[r][i // 2] = (nums[i], nums[i + 1])
i += 2
result = [[None] * n for _ in range(n)]
moves = [(0, 1, 'L', 'R'), (0, -1, 'R', 'L'), (1, 0, 'U', 'D'), (-1, 0, 'D', 'U')]
def consider(r, c, v):
if not 0 <= r < n or not 0 <= c < n:
return False
if result[r][c] is not None:
return False
if d[r][c] != v:
return False
return True
def bfs(rs, cs, val):
q = [(rs, cs)]
while q:
r, c = q.pop()
for dr, dc, dir, _ in moves:
r2, c2 = r + dr, c + dc
if not consider(r2, c2, val):
continue
result[r2][c2] = dir
q.append((r2, c2))
for r in range(n):
for c in range(n):
if result[r][c] is not None:
continue
if d[r][c] == (r + 1, c + 1):
result[r][c] = 'X'
bfs(r, c, d[r][c])
elif d[r][c] == (-1, -1):
for dr, dc, dir, opp in moves:
r2, c2 = r + dr, c + dc
if not consider(r2, c2, d[r][c]):
continue
result[r2][c2] = dir
result[r][c] = opp
bfs(r2, c2, (-1, -1))
bfs(r, c, (-1, -1))
break
else:
print("INVALID")
exit(0)
for r in range(n):
for c in range(n):
if result[r][c] is None:
print("INVALID")
exit(0)
print("VALID")
for r in result:
print(''.join(r))
``` | output | 1 | 17,831 | 15 | 35,663 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image> | instruction | 0 | 17,832 | 15 | 35,664 |
Tags: constructive algorithms, dfs and similar, graphs, implementation
Correct Solution:
```
import sys
input = iter(sys.stdin.readlines()).__next__
n = int(input())
plans = [[None]*(n+2) for _ in range(n+2)]
blocked = set()
for r in range(1,n+1):
line_iter = map(int, input().split())
for c in range(1,n+1):
x = next(line_iter)
y = next(line_iter)
if (x,y) == (-1,-1):
plans[r][c] = -1
else:
plans[r][c] = x,y
if (x,y) == (r,c): blocked.add((x,y))
def build(plans, blocked):
board = [[None]*n for _ in range(n)]
D_PAD = {
'D': (1,0),
'U': (-1,0),
'R': (0,1),
'L': (0,-1)
}
# build loops
for r in range(1,n+1):
for c in range(1,n+1):
if plans[r][c] == -1:
for char, d in D_PAD.items():
if plans[r+d[0]][c+d[1]] == -1:
board[r-1][c-1] = char
break
else:
return None
# build paths
for sx, sy in blocked:
queue = [(sx,sy, 'X')]
visited = set([(sx,sy)])
while queue:
ux, uy, char = queue.pop()
board[ux-1][uy-1] = char
for char, d in D_PAD.items():
v = (ux-d[0], uy-d[1])
if v not in visited:
visited.add(v)
if plans[v[0]][v[1]] == (sx, sy):
queue.append((v[0],v[1], char))
# check unconnected
for row in board:
if any(x is None for x in row): return None
return board
board = build(plans, blocked)
if board:
print("VALID")
print(*(''.join(row) for row in board), sep='\n')
else:
print("INVALID")
``` | output | 1 | 17,832 | 15 | 35,665 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image> | instruction | 0 | 17,833 | 15 | 35,666 |
Tags: constructive algorithms, dfs and similar, graphs, implementation
Correct Solution:
```
from collections import deque
import sys
def input(): return sys.stdin.buffer.readline()[:-1]
def main():
n = int(input())
res = [[''] * n for _ in range(n)]
data = [[None] * n for _ in range(n)]
q = deque()
cnt = 0
for i in range(n):
row = [int(x) - 1 for x in input().split()]
for j in range(n):
data[i][j] = (row[j * 2], row[j * 2 + 1])
if (i, j) == data[i][j]:
q.append((i, j))
res[i][j] = 'X'
cnt += 1
while q:
i, j = q.popleft()
if 0 <= i + 1 < n and 0 <= j < n and data[i+1][j] == data[i][j] and not res[i+1][j]:
res[i + 1][j] = 'U'
q.append((i + 1, j))
cnt += 1
if 0 <= i - 1 < n and 0 <= j < n and data[i-1][j] == data[i][j] and not res[i-1][j]:
res[i - 1][j] = 'D'
q.append((i - 1, j))
cnt += 1
if 0 <= i < n and 0 <= j + 1 < n and data[i][j+1] == data[i][j] and not res[i][j+1]:
res[i][j + 1] = 'L'
q.append((i, j + 1))
cnt += 1
if 0 <= i < n and 0 <= j - 1 < n and data[i][j-1] == data[i][j] and not res[i][j-1]:
res[i][j - 1] = 'R'
q.append((i, j - 1))
cnt += 1
for i in range(n):
for j in range(n):
if data[i][j] == (-2, -2):
cnt += 1
if 0 <= i + 1 < n and 0 <= j < n and data[i+1][j] == (-2, -2):
res[i][j] = 'D'
elif 0 <= i - 1 < n and 0 <= j < n and data[i-1][j] == (-2, -2):
res[i][j] = 'U'
elif 0 <= i < n and 0 <= j + 1 < n and data[i][j+1] == (-2, -2):
res[i][j] = 'R'
elif 0 <= i < n and 0 <= j - 1 < n and data[i][j-1] == (-2, -2):
res[i][j] = 'L'
else:
print("INVALID")
exit()
if cnt != n * n:
print("INVALID")
sys.exit()
print('VALID')
for e in res:
print(''.join(e))
main()
``` | output | 1 | 17,833 | 15 | 35,667 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image> | instruction | 0 | 17,834 | 15 | 35,668 |
Tags: constructive algorithms, dfs and similar, graphs, implementation
Correct Solution:
```
from collections import deque
n = int(input())
d = [[0] * n for _ in range(n)]
for r in range(n):
nums = list(map(int, input().split()))
i = 0
while i + 1 < 2 * n:
d[r][i // 2] = (nums[i], nums[i + 1])
i += 2
result = [[None] * n for _ in range(n)]
def bfs(rs, cs, val):
queue = deque([(rs, cs)])
while queue:
r, c = queue.popleft()
for dr, dc, dir in [(0, 1, 'L'), (0, -1, 'R'), (1, 0, 'U'), (-1, 0, 'D')]:
r2, c2 = r + dr, c + dc
if not 0 <= r2 < n or not 0 <= c2 < n:
continue
if result[r2][c2] is not None:
continue
if d[r2][c2] != val:
continue
result[r2][c2] = dir
queue.append((r2, c2))
for r in range(n):
for c in range(n):
if result[r][c] is not None:
continue
if d[r][c] == (r + 1, c + 1):
result[r][c] = 'X'
bfs(r, c, d[r][c])
elif d[r][c] == (-1, -1):
for dr, dc, dir, opp in [(0, 1, 'L', 'R'), (0, -1, 'R', 'L'), (1, 0, 'U', 'D'), (-1, 0, 'D', 'U')]:
r2, c2 = r + dr, c + dc
if not 0 <= r2 < n or not 0 <= c2 < n:
continue
if result[r2][c2] is not None:
continue
if d[r2][c2] != (-1, -1):
continue
result[r2][c2] = dir
result[r][c] = opp
bfs(r2, c2, (-1, -1))
bfs(r, c, (-1, -1))
break
else:
print("INVALID")
exit(0)
for r in range(n):
for c in range(n):
if result[r][c] is None:
# print(r, c)
print("INVALID")
exit(0)
print("VALID")
for r in result:
print(''.join(r))
``` | output | 1 | 17,834 | 15 | 35,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image>
Submitted Solution:
```
from sys import stdin
def input():
return stdin.buffer.readline()
n=int(input())
a=[]
b=[]
for _ in range(n):
s=map(int,input().split())
s=list(s)
i=0
a.append([])
b.append([])
while i!=len(s):
if s[i]!=-1:
s[i]-=1
s[i+1]-=1
a[-1].append(s[i])
b[-1].append(s[i+1])
i+=2
ans={}
dir=[[0,1],[1,0],[0,-1],[-1,0]]
c='LURD'
pa=pb=None
def f(A,B):
stack=[(A,B)]
while len(stack)!=0:
A,B=stack.pop()
for i in range(4):
[ga,gb]=dir[i]
ga+=A
gb+=B
if (ga,gb) not in ans and 0<=ga<n and 0<=gb<n and a[ga][gb]==pa and b[ga][gb]==pb:
ans[ga,gb]=c[i]
stack.append((ga,gb))
#f(ga,gb)
for i in range(n):
for j in range(n):
if (i,j) not in ans:
if a[i][j]==i and b[i][j]==j:
pa=i
pb=j
ans[i,j]='X'
f(i,j)
if a[i][j]==-1:
pa=pb=-1
for k in range(4):
[ga,gb]=dir[k]
ga+=i
gb+=j
if 0<=ga<n and 0<=gb<n and a[ga][gb]==-1:
ans[i,j]=c[(k+2)%4]
f(i,j)
break
#print(ans)
for i in range(n):
for j in range(n):
if (i,j) not in ans:
print('INVALID')
exit()
print('VALID')
for i in range(n):
print(''.join([ans[i,j] for j in range(n)]))
``` | instruction | 0 | 17,835 | 15 | 35,670 |
Yes | output | 1 | 17,835 | 15 | 35,671 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image>
Submitted Solution:
```
from collections import deque
import sys
def input(): return sys.stdin.buffer.readline()[:-1]
def main():
n = int(input())
res = [[''] * n for _ in range(n)]
data = [[None] * n for _ in range(n)]
q = deque()
cnt = 0
for i in range(n):
row = [int(x) - 1 for x in input().split()]
for j in range(n):
data[i][j] = (row[j * 2], row[j * 2 + 1])
if (i, j) == data[i][j]:
q.append((i, j))
res[i][j] = 'X'
cnt += 1
while q:
i, j = q.popleft()
if 0 <= i + 1 < n and 0 <= j < n and data[i+1][j] == data[i][j] and not res[i+1][j]:
res[i + 1][j] = 'U'
q.append((i + 1, j))
cnt += 1
if 0 <= i - 1 < n and 0 <= j < n and data[i-1][j] == data[i][j] and not res[i-1][j]:
res[i - 1][j] = 'D'
q.append((i - 1, j))
cnt += 1
if 0 <= i < n and 0 <= j + 1 < n and data[i][j+1] == data[i][j] and not res[i][j+1]:
res[i][j + 1] = 'L'
q.append((i, j + 1))
cnt += 1
if 0 <= i < n and 0 <= j - 1 < n and data[i][j-1] == data[i][j] and not res[i][j-1]:
res[i][j - 1] = 'R'
q.append((i, j - 1))
cnt += 1
for i in range(n):
for j in range(n):
if data[i][j] == (-2, -2):
cnt += 1
if 0 <= i + 1 < n and 0 <= j < n and data[i+1][j] == (-2, -2):
res[i][j] = 'D'
elif 0 <= i - 1 < n and 0 <= j < n and data[i-1][j] == (-2, -2):
res[i][j] = 'U'
elif 0 <= i < n and 0 <= j + 1 < n and data[i][j+1] == (-2, -2):
res[i][j] = 'R'
elif 0 <= i < n and 0 <= j - 1 < n and data[i][j-1] == (-2, -2):
res[i][j] = 'L'
else:
print("INVALID")
exit()
if cnt != n * n:
print("INVALID")
sys.exit()
print('VALID')
for e in res:
sys.stdout.write(''.join(e))
sys.stdout.write('\n')
main()
``` | instruction | 0 | 17,836 | 15 | 35,672 |
Yes | output | 1 | 17,836 | 15 | 35,673 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image>
Submitted Solution:
```
d4i=[0,-1,0,1]
d4j=[-1,0,1,0]
direction=['L','U','R','D']
back=['R','D','L','U']
def main():
# Observations:
# if ri,cj==xi,yj, i,j is x
# if ri,cj==-1,-1, i,j is cycle:
# Steps:
# Mark cycles and Xs
# DFS from all X only to nodes pointing to x
# Fill cycles by pointing to an adjacent cycle square
# Check that all cells are marked
n=int(input())
finalState=[[] for _ in range(n)] #[xi,yj]
ans=[[None for _ in range(n)] for __ in range(n)]
for i in range(n):
temp=readIntArr()
for j in range(n):
finalState[i].append([temp[2*j]-1,temp[2*j+1]-1]) #0-indexing
endPoints=[]
cyclePoints=set()
for i in range(n):
for j in range(n):
x,y=finalState[i][j]
if x==i and y==j:
ans[i][j]='X'
endPoints.append([x,y])
elif x==-2: #due to 0-indexing
ans[i][j]='c' #cycle
cyclePoints.add((i,j))
for endX,endY in endPoints:
stack=[[endX,endY]]
while stack:
i,j=stack.pop()
for z in range(4):
ii=i+d4i[z]
if not 0<=ii<n:
continue
jj=j+d4j[z]
if not 0<=jj<n:
continue
if ans[ii][jj]==None and finalState[ii][jj]==[endX,endY]:
ans[ii][jj]=back[z]
stack.append([ii,jj])
# Fill Cycles (point each cycle point to another cycle point)
for ci,cj in cyclePoints:
for z in range(4):
ii=ci+d4i[z]
jj=cj+d4j[z]
if (ii,jj) in cyclePoints:
ans[ci][cj]=direction[z]
break
ok=True
outcomes={'U','D','R','L','X'}
for i in range(n):
for j in range(n):
if ans[i][j] not in outcomes:
ok=False
if ok:
print('VALID')
multiLineArrayOfArraysPrint(ans)
else:
print('INVALID')
return
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
# import sys
# input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([''.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
inf=float('inf')
MOD=10**9+7
for _ in range(1):
main()
``` | instruction | 0 | 17,837 | 15 | 35,674 |
Yes | output | 1 | 17,837 | 15 | 35,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image>
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
from collections import defaultdict
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def slv(N, G):
ans = [['.'] * N for _ in range(N)]
inf = (-2, -2)
goals = set()
for i in range(N):
for j in range(N):
if G[i][j] != inf:
x, y = G[i][j]
if G[x][y] != (x, y):
return 'INVALID'
ans[x][y] = 'X'
goals.add((x, y))
def f(g, s):
stack = [s]
g[s] = s
while stack:
x, y = stack.pop()
for i, j in ((-1, 0), (1, 0), (0, -1), (0, 1)):
nx = x+i
ny = y+j
if 0 <= nx < N and 0 <= ny < N:
if G[nx][ny] == s and (nx, ny) not in g:
g[(nx, ny)] = (x, y)
stack.append((nx, ny))
return g
g = {}
while goals:
g = f(g, goals.pop())
for x in range(N):
for y in range(N):
if G[x][y][0] >= 0:
continue
if (x, y) in g:
continue
for i, j in ((-1, 0), (1, 0), (0, -1), (0, 1)):
nx = x+i
ny = y+j
if 0 <= nx < N and 0 <= ny < N:
if G[nx][ny][0] < 0:
g[(x, y)] = (nx, ny)
if (nx, ny) not in g:
g[(nx, ny)] = (x, y)
break
for u, v in g.items():
x, y = u
if u[0] > v[0]:
ans[x][y] = 'U'
elif u[0] < v[0]:
ans[x][y] = 'D'
elif u[1] > v[1]:
ans[x][y] = 'L'
elif u[1] < v[1]:
ans[x][y] = 'R'
for i in range(N):
for j in range(N):
if ans[i][j] == '.':
return 'INVALID'
return 'VALID\n' + '\n'.join([''.join(r) for r in ans])
def main():
N = read_int()
GRID = [read_int_n() for _ in range(N)]
# N = 1000
# GRID = [[1000] * (2*N) for _ in range(N)]
GRID = [[(r[2*i]-1, r[2*i+1]-1) for i in range(N)] for r in GRID]
print(slv(N, GRID))
if __name__ == '__main__':
main()
``` | instruction | 0 | 17,838 | 15 | 35,676 |
Yes | output | 1 | 17,838 | 15 | 35,677 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image>
Submitted Solution:
```
import collections
def f():
n = int(input())
ends = [[None for i in range(n)] for j in range(n)]
tags = [["" for i in range(n)] for j in range(n)]
for i in range(n):
row = [int(s)-1 for s in input().split()]
for j in range(n):
x = row[2*j]
if x != -2:
y = row[2*j+1]
ends[i][j] = (x,y)
tags[x][y] = 'X'
# showMatrix(ends)
# showMatrix(tags)
gos = {'U':(-1,0),'D':(1,0),'L':(0,-1),'R':(0,1)}
def checkValid(x,y):
if 0<=x and x<n and 0<=y and y<n:
return True
return False
# infinite tag
def goToInfNb(i,j):
for dir in gos:
x, y = gos[dir]
if checkValid(i+x, j+y) and not ends[i+x][j+y]:
return dir
return None
for i in range(n):
for j in range(n):
if not ends[i][j] and not tags[i][j]:
dr = goToInfNb(i,j)
if not dr:
print('INVALID')
return
tags[i][j] = dr
# showMatrix(ends)
# showMatrix(tags)
# finite tag
backs = {'D':(-1,0),'U':(1,0),'R':(0,-1),'L':(0,1)}
def bfs(root):
q = collections.deque()
q.append(root)
while q:
i, j = q.popleft()
for dir in backs:
x, y = backs[dir]
ni, nj = i+x, y+j
if checkValid(ni, nj):
if not tags[ni][nj] and ends[ni][nj]==root:
tags[ni][nj] = dir
q.append((ni,nj))
for i in range(n):
for j in range(n):
if tags[i][j] == 'X':
bfs((i,j))
# showMatrix(ends)
# showMatrix(tags)
# check
for i in range(n):
for j in range(n):
if not tags[i][j]:
print('INVALID')
return
print("VALID")
for i in range(n):
print(''.join(tags[i]))
f()
``` | instruction | 0 | 17,839 | 15 | 35,678 |
No | output | 1 | 17,839 | 15 | 35,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image>
Submitted Solution:
```
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from functools import *
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def Golf():*a,=map(int,open(0))
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def I():return int(input())
def MI():return map(int,input().split())
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoI():return [ord(i)-97 for i in input()]
def ItoS(nn):return chr(nn+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0}):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0}) # sample usage
mp=[1]*(w+2)
found={}
for i in range(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[1]+[mp_def[j] for j in s]+[1]
mp+=[1]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)]
rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['YES','NO']
Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
#sys.setrecursionlimit(10**7)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
rmin,rmax=1,10
a=[random.randint(rmin,rmax) for _ in range(n)]
return n,a
show_flg=False
show_flg=True
n=I()
h=n+2
mp= [[-2]*h]+ [[-2]+[None]*n+[-2] for i in range(n)] + [[-2]*h]
ch=[[None]*h for i in range(h)]
gl=[]
fv=[]
for i in range(n):
a=LI()
for j in range(n):
r,c=a[2*j:2*j+2]
if (r,c)==(-1,-1):
mp[i+1][j+1]=-1
fv.append((i+1)*h+(j+1))
else:
mp[i+1][j+1]=r*h+c
if (i+1)*h+(j+1)==mp[i+1][j+1]:
ch[i+1][j+1]='X'
gl.append(mp[i+1][j+1])
#show(fv,gl)
dc={-1:'R',1:'L',-h:'D',h:'U'}
while gl:
Q=[gl.pop()]
while Q:
q=Q.pop()
r,c=q//h,q%h
for i in [+1,-1,+h,-h]:
nr,nc=(q+i)//h,(q+i)%h
if mp[nr][nc]==mp[r][c] and ch[nr][nc]==None:
ch[nr][nc]=dc[i]
Q.append(q+i)
while fv:
Q=[fv.pop()]
while Q:
q=Q.pop()
r,c=q//h,q%h
for i in [+1,-1,+h,-h]:
nr,nc=(q+i)//h,(q+i)%h
if mp[nr][nc]==mp[r][c] and ch[nr][nc]==None:
ch[nr][nc]=dc[i]
if ch[r][c]==None:
ch[r][c]=dc[-i]
Q.append(q+i)
#show(h,n)
for i in mp:
0#show(*i)
for i in range(1,n+1):
for j in range(1,n+1):
if ch[i][j]==None:
print('INVALID')
exit()
print('VALID')
for i in range(1,n+1):
show(*ch[i][1:n+1])
``` | instruction | 0 | 17,840 | 15 | 35,680 |
No | output | 1 | 17,840 | 15 | 35,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image>
Submitted Solution:
```
n = int(input())
N = n
lis = [ [] for i in range(n)]
ans = [ [None] * n for i in range(n)]
plis = []
vlis = []
for i in range(n):
a = list(map(int,input().split()))
for j in range(0,2*n-1,2):
lis[i].append( [ a[j]-1 , a[j+1]-1 ] )
if a[j]-1 == i and a[j+1]-1 == j // 2:
ans[i][j//2] = "X"
plis.append([i,j//2])
elif a[j] == -1:
ans[i][j//2] = "V"
vlis.append([i,j//2])
from collections import deque
tl = [ [-1,0,"D"] , [1,0,"U"] , [0,-1,"R"] , [0,1,"L"] ]
for px,py in plis:
q = deque([[px,py]])
while len(q) > 0:
x,y = q.popleft()
for sx,sy,d in tl:
if 0<=x+sx<N and 0<=y+sy<N and ans[x+sx][y+sy] == None and lis[x+sx][y+sy][0] == px and lis[x+sx][y+sy][1] == py:
ans[x+sx][y+sy] = d
q.append([x+sx,y+sy])
tl = [ [-1,0,"D","U"] , [1,0,"U","D"] , [0,-1,"R","L"] , [0,1,"L","R"] ]
for x,y in vlis:
for sx,sy,d,nd in tl:
if 0<=x+sx<N and 0<=y+sy<N and ans[x+sx][y+sy] in [d,"V"]:
ans[x][y] = nd
import sys
for i in range(N):
for j in range(N):
if ans[i][j] == None or ans[i][j] == "V":
print ("INVALID")
sys.exit()
print ("VALID")
for i in ans:
print ("".join(i))
``` | instruction | 0 | 17,841 | 15 | 35,682 |
No | output | 1 | 17,841 | 15 | 35,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nash designed an interesting yet simple board game where a player is simply required to follow instructions written on the cell where the player currently stands.
This board game is played on the n× n board. Rows and columns of this board are numbered from 1 to n. The cell on the intersection of the r-th row and c-th column is denoted by (r, c).
Some cells on the board are called blocked zones. On each cell of the board, there is written one of the following 5 characters — U, D, L, R or X — instructions for the player. Suppose that the current cell is (r, c). If the character is R, the player should move to the right cell (r, c+1), for L the player should move to the left cell (r, c-1), for U the player should move to the top cell (r-1, c), for D the player should move to the bottom cell (r+1, c). Finally, if the character in the cell is X, then this cell is the blocked zone. The player should remain in this cell (the game for him isn't very interesting from now on).
It is guaranteed that the characters are written in a way that the player will never have to step outside of the board, no matter at which cell he starts.
As a player starts from a cell, he moves according to the character in the current cell. The player keeps moving until he lands in a blocked zone. It is also possible that the player will keep moving infinitely long.
For every of the n^2 cells of the board Alice, your friend, wants to know, how will the game go, if the player starts in this cell. For each starting cell of the board, she writes down the cell that the player stops at, or that the player never stops at all. She gives you the information she has written: for each cell (r, c) she wrote:
* a pair (x,y), meaning if a player had started at (r, c), he would end up at cell (x,y).
* or a pair (-1,-1), meaning if a player had started at (r, c), he would keep moving infinitely long and would never enter the blocked zone.
It might be possible that Alice is trying to fool you and there's no possible grid that satisfies all the constraints Alice gave you. For the given information Alice provided you, you are required to decipher a possible board, or to determine that such a board doesn't exist. If there exist several different boards that satisfy the provided information, you can find any of them.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 10^{3}) — the side of the board.
The i-th of the next n lines of the input contains 2n integers x_1, y_1, x_2, y_2, ..., x_n, y_n, where (x_j, y_j) (1 ≤ x_j ≤ n, 1 ≤ y_j ≤ n, or (x_j,y_j)=(-1,-1)) is the pair written by Alice for the cell (i, j).
Output
If there doesn't exist a board satisfying the information that Alice gave you, print a single line containing INVALID.
Otherwise, in the first line print VALID. In the i-th of the next n lines, print the string of n characters, corresponding to the characters in the i-th row of the suitable board you found. Each character of a string can either be U, D, L, R or X. If there exist several different boards that satisfy the provided information, you can find any of them.
Examples
Input
2
1 1 1 1
2 2 2 2
Output
VALID
XL
RX
Input
3
-1 -1 -1 -1 -1 -1
-1 -1 2 2 -1 -1
-1 -1 -1 -1 -1 -1
Output
VALID
RRD
UXD
ULL
Note
For the sample test 1 :
The given grid in output is a valid one.
* If the player starts at (1,1), he doesn't move any further following X and stops there.
* If the player starts at (1,2), he moves to left following L and stops at (1,1).
* If the player starts at (2,1), he moves to right following R and stops at (2,2).
* If the player starts at (2,2), he doesn't move any further following X and stops there.
The simulation can be seen below :
<image>
For the sample test 2 :
The given grid in output is a valid one, as a player starting at any cell other than the one at center (2,2), keeps moving in an infinitely long cycle and never stops. Had he started at (2,2), he wouldn't have moved further following instruction X .
The simulation can be seen below :
<image>
Submitted Solution:
```
import collections
n = int(input())
xy = [list(map(int, input().split())) for i in range(n)]
xy = [[(xy[i][j], xy[i][j+1]) for j in range(0, n*2, 2)] for i in range(n)]
G = [[""]*n for i in range(n)]
s = set()
table = collections.defaultdict(set)
for i in range(n):
for j in range(n):
x, y = xy[i][j]
if x > 0:
s.add((x-1, y-1))
G[y-1][x-1] = "X"
table[(x-1, y-1)].add((i, j))
flag = True
q = collections.deque()
for x, y in s:
if xy[y][x] != (x+1, y+1):
flag = False
break
q.append((x, y))
while(q):
j, i = q.popleft()
if i < n-1:
if (i+1, j) in table[(x, y)]:
if G[i+1][j] == "":
q.append((j, i+1))
G[i+1][j] = "D"
if i > 0:
if (i-1, j) in table[(x, y)]:
if G[i-1][j] == "":
q.append((j, i-1))
G[i-1][j] = "U"
if j < n-1:
if (i, j+1) in table[(x, y)]:
if G[i][j+1] == "":
q.append((j+1, i))
G[i][j+1] = "L"
if j > 0:
if (i, j-1) in table[(x, y)]:
if G[i][j-1] == "":
q.append((j-1, i))
G[i][j-1] = "R"
for ti, tj in table[(x, y)]:
if G[ti][tj] != "":
continue
else:
flag = False
break
for i in range(n):
for j in range(n):
if G[i][j] == "":
if i > 0 and xy[i-1][j][0] < 0:
G[i][j] = "U"
elif i < n-1 and xy[i+1][j][0] < 0:
G[i][j] = "D"
elif j > 0 and xy[i][j-1][0] < 0:
G[i][j] = "L"
elif j < n-1 and xy[i][j+1][0] < 0:
G[i][j] = "R"
else:
flag = False
break
if flag == False:
break
if flag:
print("VALID")
for i in range(n):
print("".join(G[i]))
else:
print("INVALID")
``` | instruction | 0 | 17,842 | 15 | 35,684 |
No | output | 1 | 17,842 | 15 | 35,685 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image> | instruction | 0 | 17,901 | 15 | 35,802 |
Tags: constructive algorithms, dfs and similar, greedy, implementation
Correct Solution:
```
n=int(input())
arr=[]
diag=[int(x) for x in input().split()]
for i in range(n):
temp=[0 for x in range(i+1)]
temp[i]=diag[i]
arr.append(temp)
for i in range(n):
c=diag[i]
val=c
arr[i][i]=0
j=i
temp=i
while (c>0):
while (j>-1) and (c>0):
if (arr[temp][j]!=0):
break
arr[temp][j]=val
c-=1
j-=1
j+=1
temp+=1
# for m in range(n):
# print(*arr[m])
# print("after "+str(i)+":iteration")
for i in range(n):
print(*arr[i])
``` | output | 1 | 17,901 | 15 | 35,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image> | instruction | 0 | 17,902 | 15 | 35,804 |
Tags: constructive algorithms, dfs and similar, greedy, implementation
Correct Solution:
```
#Collaborated with no one
# Problem C
ans = []
n=int(input())
cells = [int(x) for x in input().split(" ")]
for i in range(n):
ans.append([-1]*n)
for i in range(n):
ans[i][i] = cells[i]
amount = cells[i]-1
x = i - 1
y = i
while amount > 0:
if x > 0 and ans[y][x] == -1:
ans[y][x] = cells[i]
x -= 1
amount -= 1
elif x == 0 and ans[y][x] == -1:
ans[y][x] = cells[i]
y += 1
amount -= 1
else:
x += 1
y += 1
for i in range(n):
ans_str = ""
for x in range(i+1):
ans_str += str(ans[i][x]) + " "
print(ans_str)
``` | output | 1 | 17,902 | 15 | 35,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image> | instruction | 0 | 17,903 | 15 | 35,806 |
Tags: constructive algorithms, dfs and similar, greedy, implementation
Correct Solution:
```
def ii():
return int(input())
def li():
return [int(i) for i in input().split()]
for t in range(1):
n = ii()
p = li()
ans = [ [-1 for j in range(n)] for i in range(n)]
for index in range(n):
x = p[index]
i = index
j = index
while(x>0):
# print(i,j)
ans[i][j] = p[index]
# if i == n-1:
# j-=1
# x-=1
# continue
if(j!=0):
if ans[i][j-1]==-1:
j = j-1
else:
i+=1
else:
i+=1
x-=1
for i in range(n):
print(*ans[i][:i+1])
``` | output | 1 | 17,903 | 15 | 35,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image> | instruction | 0 | 17,904 | 15 | 35,808 |
Tags: constructive algorithms, dfs and similar, greedy, implementation
Correct Solution:
```
'''Author- Akshit Monga'''
from sys import stdin, stdout
input = stdin.readline
def f():
global mat,val,i
x=i
y=i
# print()
# print(x,y)
for k in range(val-1):
# print(x,y,k,val)
if x!=0 and mat[x-1][y]==-1 and y<=x-1:
mat[x-1][y]=val
x-=1
elif y!=0 and mat[x][y-1]==-1 and y-1<=x:
mat[x][y-1]=val
y-=1
elif x!=n-1 and mat[x+1][y]==-1 and y<=x+1:
mat[x+1][y]=val
x+=1
elif y!=n-1 and mat[x][y+1]==-1 and y+1<=x:
mat[x][y+1]=val
y+=1
else:
return False
# print(x,y)
return True
t = 1
for _ in range(t):
n=int(input())
p=[int(x) for x in input().split()]
mat=[[-1 for i in range(n)] for j in range(n)]
ans=0
for i in range(n):
val=p[i]
mat[i][i]=val
if not f():
ans = 1
break
# print("hi")
# for k in range(n):
# for q in range(k + 1):
# stdout.write(str(mat[k][q]) + " ")
# stdout.write('\n')
if ans:
print(-1)
continue
for i in range(n):
for j in range(i+1):
stdout.write(str(mat[i][j])+" ")
stdout.write('\n')
``` | output | 1 | 17,904 | 15 | 35,809 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image> | instruction | 0 | 17,905 | 15 | 35,810 |
Tags: constructive algorithms, dfs and similar, greedy, implementation
Correct Solution:
```
import os,sys,math
from io import BytesIO, IOBase
from collections import defaultdict,deque,OrderedDict
import bisect as bi
def yes():print('YES')
def no():print('NO')
def I():return (int(input()))
def In():return(map(int,input().split()))
def ln():return list(map(int,input().split()))
def Sn():return input().strip()
BUFSIZE = 8192
#complete the main function with number of test cases to complete greater than x
def find_gt(a, x):
i = bi.bisect_left(a, x)
if i != len(a):
return i
else:
return len(a)
def solve():
n=I()
l=list(In())
ans=[[-1]*n for i in range(n)]
for i in range(n):
q=deque([(i,i)])
cnt=l[i]
while q:
x,y=q.popleft()
ans[x][y]=l[i]
cnt-=1
if cnt==0:
break
if y-1>=0 and ans[x][y-1]==-1:
q.append((x,y-1))
elif x+1<n and ans[x+1][y]==-1:
q.append((x+1,y))
elif y+1<n and ans[x][y+1]==-1:
q.append((x,y+1))
for i in range(n):
for j in range(i+1):
print(ans[i][j],end=' ')
print()
pass
def main():
T=1
for i in range(T):
solve()
M = 998244353
P = 1000000007
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == '__main__':
main()
``` | output | 1 | 17,905 | 15 | 35,811 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image> | instruction | 0 | 17,906 | 15 | 35,812 |
Tags: constructive algorithms, dfs and similar, greedy, implementation
Correct Solution:
```
import sys;input=sys.stdin.readline
n = int(input())
a = list(map(int,input().split()))
bo = []
for i in range(n):
temp = [0 for _ in range(i)]
temp.append(a[i])
bo.append(temp)
flag = 1
for i in range(n):
key = bo[i][i]
posi,posj = i,i
count = 1
while count<key:
if posj-1>=0 and bo[posi][posj-1]==0:
bo[posi][posj-1] = key
posj-=1
count+=1
elif posi+1<n and bo[posi+1][posj]==0:
bo[posi+1][posj] = key
posi+=1
count+=1
else:
flag = 0
print(-1)
if flag:
for i in range(n):
print(*bo[i])
``` | output | 1 | 17,906 | 15 | 35,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image> | instruction | 0 | 17,907 | 15 | 35,814 |
Tags: constructive algorithms, dfs and similar, greedy, implementation
Correct Solution:
```
import sys
import os.path
from collections import *
import math
import bisect
if (os.path.exists('input.txt')):
sys.stdin = open("input.txt", "r")
sys.stdout = open("output.txt", "w")
############## Code starts here ##########################
n = int(input())
arr = [int(x) for x in input().split()]
brr = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
brr[i][i] = arr[i]
for j in range(n):
y = brr[j][j] - 1
x = brr[j][j]
index1 = j
index2 = j
while y:
if index2>0 and brr[index1][index2 - 1] == 0:
y -= 1
index2 -= 1
brr[index1][index2] = x
else:
index1 += 1
y -= 1
brr[index1][index2] = x
for i in range(n):
for j in range(i + 1):
print(brr[i][j],end=" ")
print()
############## Code ends here ############################
``` | output | 1 | 17,907 | 15 | 35,815 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image> | instruction | 0 | 17,908 | 15 | 35,816 |
Tags: constructive algorithms, dfs and similar, greedy, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
def I():return input().strip()
def II():return int(input().strip())
def LI():return [*map(int,input().strip().split())]
import string, math, time, functools, random, fractions
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict, Counter, OrderedDict
from itertools import permutations, combinations, groupby
def go_left(h,v,e,l,fail):
if l==0:
return False
h-=1
arr[v][h]=e
l-=1
if h>=1 and arr[v][h-1]==0:
return go_left(h,v,e,l,fail)
elif v+1<=n-1 and arr[v+1][h]==0:
return go_down(h,v,e,l,fail)
else:
fail=1
def go_down(h,v,e,l,fail):
if l==0:
return False
v+=1
arr[v][h]=e
l-=1
if h>=1 and arr[v][h-1]==0:
return go_left(h,v,e,l,fail)
elif v+1<=n-1 and arr[v+1][h]==0:
return go_down(h,v,e,l,fail)
else:
fail=1
for _ in range(1):
n=II()
a=LI()
fail=0
arr=[0]*n
for i in range(n):
arr[i]=[0]*(i+1)
for i in range(n):
e=a[i]
arr[i][i]=e
h=i
v=i
if h>=1 and arr[v][h-1]==0:
go_left(h,v,e,e-1,fail)
else:
go_down(h,v,e,e-1,fail)
if fail==1:
print(-1)
else:
for i in range(n):
print(*arr[i])
``` | output | 1 | 17,908 | 15 | 35,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image>
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#######################################
n=int(input())
l=list(map(int,input().split()))
l1=[[0]*n for i in range(n)]
for i in range(n):
c=l[i]
x=i
y=x
while c:
for j in range(y,-1,-1):
## print(x,y,l1)
if l1[x][j]:
j+=1
break
if not c:
break
l1[x][j]=l[i]
c-=1
y=j
x+=1
l2=[]
for i in l1:
l3=[]
for j in i:
if j==0:
break
l3.append(j)
l2.append(l3)
for i in l2:
print(*i)
``` | instruction | 0 | 17,909 | 15 | 35,818 |
Yes | output | 1 | 17,909 | 15 | 35,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image>
Submitted Solution:
```
import bisect
import collections
import functools
import itertools
import math
import heapq
import random
import string
def repeat(_func=None, *, times=1):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
for _ in range(times):
func(*args, **kwargs)
return wrapper
if _func is None:
return decorator
else:
return decorator(_func)
def unpack(func=int):
return map(func, input().split())
def l_unpack(func=int):
"""list unpack"""
return list(map(func, input().split()))
def getint():
return int(input())
def getmatrix(rows):
return [list(map(int, input().split())) for _ in range(rows)]
def display_matrix(mat):
for i in range(len(mat)):
print(mat[i])
MOD = 1_000_000_007
# @repeat(times=int(input()))
def main():
n = getint()
mat = [[0] * n for _ in range(n)]
arr = l_unpack()
for i in range(n):
mat[i][i] = arr[i]
hmap = {x: x - 1 for x in arr}
def isvalid(x, y):
return 0 <= x < n and 0 <= y < n
for diag in range(n):
for p in range(n - diag):
x, y = diag+p, p
# print(x, y)
if not isvalid(x, y):
break
val = mat[x][y]
if hmap[val] == 0:
continue
(lx, ly), (dx, dy) = (x, y - 1), (x + 1, y)
if isvalid(lx, ly) and mat[lx][ly] == 0:
mat[lx][ly] = val
hmap[mat[x][y]] -= 1
elif isvalid(dx, dy) and mat[dx][dy] == 0:
mat[dx][dy] = val
hmap[mat[x][y]] -= 1
else:
# display_matrix(mat)
# print(hmap)
print(-1)
return
# display_matrix(mat)
if sum(hmap.values()):
print(-1)
return
for i in range(n):
print(*mat[i][:i + 1])
main()
``` | instruction | 0 | 17,910 | 15 | 35,820 |
Yes | output | 1 | 17,910 | 15 | 35,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image>
Submitted Solution:
```
import sys, random
# sys.stdin = open("input.txt")
n = int(input())
d = list(map(int, input().split()))
p = [[0] * n for i in range(n)]
for i in range(n):
p[i][i] = d[i]
for i in range(n - 1, -1, -1):
val = p[i][i]
kol = val - 1
j = i
while kol > 0:
if i + 1 < n and p[i + 1][j] == 0:
p[i + 1][j] = val
i += 1
kol -= 1
else:
p[i][j - 1] = val
j -= 1
kol -= 1
for i in range(n):
for j in range(i + 1):
print(p[i][j], end=' ')
print()
``` | instruction | 0 | 17,911 | 15 | 35,822 |
Yes | output | 1 | 17,911 | 15 | 35,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image>
Submitted Solution:
```
n = int(input())
P = list(map(int, input().split()))
result = [[0] * n for i in range(n)]
directions = [(-1, 0), (0, -1), (1, 0), (0, 1)]
directions.reverse()
for i in range(n):
regionIndex = P[i]
result[i][i] = regionIndex
count = regionIndex
regionStack = [(i, i)]
while count:
x, y = regionStack.pop()
result[x][y] = regionIndex
count -= 1
for dx, dy in directions:
nx = x + dx
ny = y + dy
if 0 <= nx < n and 0 <= ny < n and nx >= ny and result[nx][ny] == 0:
regionStack.append((nx, ny))
for i in range(n):
print(*(result[i][:i+1]))
``` | instruction | 0 | 17,912 | 15 | 35,824 |
Yes | output | 1 | 17,912 | 15 | 35,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image>
Submitted Solution:
```
import sys
input = sys.stdin.readline
# for _ in range(int(input())):
n = int(input())
# n, m = map(int, input().split())
A = list(map(int, input().split()))
ans = [[0] * n for _ in range(n)]
left = [0] * n
flag = 0
for i in range(n):
x = A[i]
r = x
for j in range(i, n):
k = i - left[j] + 1
if r >= k:
ans[j][left[j]: i + 1] = [x] * k
r -= k
left[j] += k
if r == 0: break
else:
ans[j][left[j]: left[j] + r] = [x] * r
left[j] += r
if j and ans[j - 1][left[j] - 1] != x: flag = 1
break
if flag:
print(-1)
sys.exit()
for i, a in enumerate(ans):
print(*a[:i + 1])
``` | instruction | 0 | 17,913 | 15 | 35,826 |
No | output | 1 | 17,913 | 15 | 35,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image>
Submitted Solution:
```
n = int(input())
l = list(map(int , input().strip().split(" ")))
l1 = []
for i in range(n , 0 , -1 ) :
l1.append(l[:i])
for i in range(len(l1)-1 ,-1 ,-1) :
for j in l1[i]:
print(j , end = " ")
print("")
``` | instruction | 0 | 17,914 | 15 | 35,828 |
No | output | 1 | 17,914 | 15 | 35,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image>
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
m=[]
for i in l:
a=[i]
m.append(a)
l.sort()
for i in range(len(m)):
k=l[i]
for j in range(k-1):
m[i].insert(0,k)
for i in m:
print(i)
``` | instruction | 0 | 17,915 | 15 | 35,830 |
No | output | 1 | 17,915 | 15 | 35,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fillomino is a classic logic puzzle. (You do not need to know Fillomino in order to solve this problem.) In one classroom in Yunqi town, some volunteers are playing a board game variant of it:
Consider an n by n chessboard. Its rows are numbered from 1 to n from the top to the bottom. Its columns are numbered from 1 to n from the left to the right. A cell on an intersection of x-th row and y-th column is denoted (x, y). The main diagonal of the chessboard is cells (x, x) for all 1 ≤ x ≤ n.
A permutation of \{1, 2, 3, ..., n\} is written on the main diagonal of the chessboard. There is exactly one number written on each of the cells. The problem is to partition the cells under and on the main diagonal (there are exactly 1+2+ … +n such cells) into n connected regions satisfying the following constraints:
1. Every region should be connected. That means that we can move from any cell of a region to any other cell of the same region visiting only cells of the same region and moving from a cell to an adjacent cell.
2. The x-th region should contain cell on the main diagonal with number x for all 1≤ x≤ n.
3. The number of cells that belong to the x-th region should be equal to x for all 1≤ x≤ n.
4. Each cell under and on the main diagonal should belong to exactly one region.
Input
The first line contains a single integer n (1≤ n ≤ 500) denoting the size of the chessboard.
The second line contains n integers p_1, p_2, ..., p_n. p_i is the number written on cell (i, i). It is guaranteed that each integer from \{1, …, n\} appears exactly once in p_1, ..., p_n.
Output
If no solution exists, output -1.
Otherwise, output n lines. The i-th line should contain i numbers. The j-th number on the i-th line should be x if cell (i, j) belongs to the the region with x cells.
Examples
Input
3
2 3 1
Output
2
2 3
3 3 1
Input
5
1 2 3 4 5
Output
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5
Note
The solutions to the examples are illustrated in the following pictures: <image> <image>
Submitted Solution:
```
from sys import stdin
# input = stdin.readline
n = int(input())
lst = list(map(int, input().split()))
ans = [[0] * i for i in range(1, n + 1)]
lst = [list(i) for i in zip(lst, lst)]
# print(lst)
for i in range(n):
for j in range(i + 1):
ans[i][j] = lst[0][0]
lst[0][1] -= 1
if lst[0][1] == 0:
lst.pop(0)
flag = 1
for i in range(n):
if flag:
for j in range(i):
if ans[i][j] == 1:
continue
if i < n - 1:
if j < i:
if ans[i][j] == ans[i][j + 1] or ans[i][j] == ans[i + 1][j] or ans[i][j] == ans[i - 1][j]:
continue
else:
flag = 0
# print(ans[i][j])
break
else:
if ans[i][j] == ans[i + 1][j] or ans[i][j] == ans[i][j - 1] or ans[i][j] == ans[i - 1][j]:
continue
else:
flag = 0
# print(i, j, ans[i][j])
break
else:
if j < i:
if ans[i][j] == ans[i][j + 1] or ans[i][j] == ans[i - 1][j]:
continue
else:
flag = 0
# print(ans[i][j])
break
else:
break
if flag:
for i in ans:
print(*i)
else:
print(-1)
``` | instruction | 0 | 17,916 | 15 | 35,832 |
No | output | 1 | 17,916 | 15 | 35,833 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations. | instruction | 0 | 17,917 | 15 | 35,834 |
Tags: combinatorics, math
Correct Solution:
```
# region fastio # from https://codeforces.com/contest/1333/submission/75948789
import sys, io, os
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = io.BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#endregion
class Combination:
def __init__(self, n_max, mod=10**9+7):
# O(n_max + log(mod))
self.mod = mod
f = 1
self.fac = fac = [f]
for i in range(1, n_max+1):
f = f * i % mod
fac.append(f)
f = pow(f, mod-2, mod)
self.facinv = facinv = [f]
for i in range(n_max, 0, -1):
f = f * i % mod
facinv.append(f)
facinv.reverse()
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def C(self, n, r):
if not 0 <= r <= n: return 0
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def P(self, n, r):
if not 0 <= r <= n: return 0
return self.fac[n] * self.facinv[n-r] % self.mod
def H(self, n, r):
if (n == 0 and r > 0) or r < 0: return 0
return self.fac[n+r-1] * self.facinv[r] % self.mod * self.facinv[n-1] % self.mod
from itertools import groupby
mod = 998244353
comb = Combination(101010, mod)
T = int(input())
for _ in range(T):
N = int(input())
S = input()
r = 0
n_zeros = S.count("0")
for val, gr in groupby(S):
gr = list(gr)
if val == "1":
if len(gr) % 2 == 1:
r += 1
#print("N-r", N-r)
ans = comb.C((N-r+n_zeros)//2, n_zeros)
print(ans)
``` | output | 1 | 17,917 | 15 | 35,835 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations. | instruction | 0 | 17,918 | 15 | 35,836 |
Tags: combinatorics, math
Correct Solution:
```
import sys
from sys import stdin
def modfac(n, MOD):
f = 1
factorials = [1]
for m in range(1, n + 1):
f *= m
f %= MOD
factorials.append(f)
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return factorials, invs
def modnCr(n,r):
return fac[n] * inv[n-r] * inv[r] % mod
mod = 998244353
fac,inv = modfac(200000,mod)
tt = int(stdin.readline())
ANS = []
for loop in range(tt):
n = int(stdin.readline())
s = list(stdin.readline()[:-1])
c = 0
zlis = [-1]
for i in range(n):
if s[i] == '0':
zlis.append(i)
zlis.append(n)
for i in range(len(zlis)-1):
c += (zlis[i+1]-zlis[i]-1)//2
#print (zlis,c)
ANS.append( modnCr(c+len(zlis)-2,c) % mod )
print ("\n".join(map(str,ANS)))
``` | output | 1 | 17,918 | 15 | 35,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations. | instruction | 0 | 17,919 | 15 | 35,838 |
Tags: combinatorics, math
Correct Solution:
```
from sys import stdin, stdout
import heapq
from collections import defaultdict
import math
import bisect
import io, os
# for interactive problem
# n = int(stdin.readline())
# print(x, flush=True)
#input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def ncr(n, r, p):
# initialize numerator
# and denominator
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def main():
#n = int(input())
t = int(stdin.readline())
MOD = 998244353
for _ in range(t):
n = int(stdin.readline())
s = stdin.readline().strip()
z = 0
b = 0
i = 0
while i < n:
if s[i] == '0':
z += 1
i += 1
continue
elif i + 1 < n and s[i] == s[i + 1] == '1':
b += 1
i += 2
continue
i += 1
ans = ncr(z+b, z, MOD)
stdout.write(str(ans)+"\n")
main()
``` | output | 1 | 17,919 | 15 | 35,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations. | instruction | 0 | 17,920 | 15 | 35,840 |
Tags: combinatorics, math
Correct Solution:
```
import sys
input = sys.stdin.readline
t = int(input())
mod = 998244353
l = 114514
fact = [1] * (l + 1)
for i in range(1, l + 1):
fact[i] = i * fact[i - 1] % mod
inv = [1] * (l + 1)
inv[l] = pow(fact[l], mod - 2, mod)
for i in range(l - 1, -1, -1):
inv[i] = (i + 1) * inv[i + 1] % mod
def comb(n, r):
return fact[n] * inv[r] * inv[n - r] % mod if n >= r >= 0 else 0
for _ in range(t):
n = int(input())
s = list(input().rstrip())
now, cnt = int(s[0]), 0
m, r = 0, 0
for i in s:
if int(i) == now:
cnt += 1
else:
if now == 0:
m += cnt
r += cnt
else:
m += cnt // 2
now ^= 1
cnt = 1
if now == 0:
m += cnt
r += cnt
else:
m += cnt // 2
ans = comb(m, r)
print(ans)
``` | output | 1 | 17,920 | 15 | 35,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations. | instruction | 0 | 17,921 | 15 | 35,842 |
Tags: combinatorics, math
Correct Solution:
```
def ncr(n,r,p):
num,den=1,1
for i in range(r):
num=(num*(n-i))%p
den=(den*(i+1))%p
return (num*pow(den,p-2,p))%p
p=998244353
t=int(input())
for i in range(t):
n=int(input())
zoz=input()
z=zoz.count("0")
k=0
j=1
while j<n:
if zoz[j]=="1" and zoz[j-1]=="1":
k+=1
j+=2
else:
j+=1
print(ncr(z+k,z,p))
``` | output | 1 | 17,921 | 15 | 35,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations. | instruction | 0 | 17,922 | 15 | 35,844 |
Tags: combinatorics, math
Correct Solution:
```
mod = 998244353
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
# comb init
nmax = 10 ** 5 + 10 # change here
fac = [0] * nmax
finv = [0] * nmax
inv = [0] * nmax
fac[0] = 1
fac[1] = 1
finv[0] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, nmax):
fac[i] = fac[i - 1] * i % mod
inv[i] = mod - inv[mod % i] * (mod // i) % mod
finv[i] = finv[i - 1] * inv[i] % mod
def comb(n, r):
if n < r:
return 0
else:
return (fac[n] * ((finv[r] * finv[n - r]) % mod)) % mod
for _ in range(int(input())):
N = int(input())
S = input().rstrip('\n')
x = y = 0
cnt = 0
prev = "!"
for i, s in enumerate(S):
if s == "1":
cnt += 1
else:
y += 1
if prev == "1":
x += cnt // 2
cnt = 0
prev = s
x += cnt // 2
print(comb(x+y, x))
if __name__ == '__main__':
main()
``` | output | 1 | 17,922 | 15 | 35,845 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations. | instruction | 0 | 17,923 | 15 | 35,846 |
Tags: combinatorics, math
Correct Solution:
```
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
from bisect import bisect_left as lower_bound, bisect_right as upper_bound
def so(): return int(input())
def st(): return input()
def mj(): return map(int,input().strip().split(" "))
def msj(): return map(str,input().strip().split(" "))
def le(): return list(map(int,input().split()))
def lebe():return list(map(int, input()))
def dmain():
sys.setrecursionlimit(1000000)
threading.stack_size(1024000)
thread = threading.Thread(target=main)
thread.start()
def joro(L):
return(''.join(map(str, L)))
def decimalToBinary(n): return bin(n).replace("0b","")
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def npr(n, r):
return factorial(n) // factorial(n - r) if n >= r else 0
def ncr(n, r):
return factorial(n) // (factorial(r) * factorial(n - r)) if n >= r else 0
def lower_bound(li, num):
answer = -1
start = 0
end = len(li) - 1
while (start <= end):
middle = (end + start) // 2
if li[middle] >= num:
answer = middle
end = middle - 1
else:
start = middle + 1
return answer # min index where x is not less than num
def upper_bound(li, num):
answer = -1
start = 0
end = len(li) - 1
while (start <= end):
middle = (end + start) // 2
if li[middle] <= num:
answer = middle
start = middle + 1
else:
end = middle - 1
return answer # max index where x is not greater than num
def tir(a,b,c):
if(0==c):
return 1
if(len(a)<=b):
return 0
if(c!=-1):
return (tir(a,1+b,c+a[b]) or tir(a,b+1,c-a[b]) or tir(a,1+b,c))
else:
return (tir(a,1+b,a[b]) or tir(a,b+1,-a[b]) or tir(a,1+b,-1))
def abs(x):
return x if x >= 0 else -x
def binary_search(li, val, lb, ub):
# print(lb, ub, li)
ans = -1
while (lb <= ub):
mid = (lb + ub) // 2
# print('mid is',mid, li[mid])
if li[mid] > val:
ub = mid - 1
elif val > li[mid]:
lb = mid + 1
else:
ans = mid # return index
break
return ans
def kadane(x): # maximum sum contiguous subarray
sum_so_far = 0
current_sum = 0
for i in x:
current_sum += i
if current_sum < 0:
current_sum = 0
else:
sum_so_far = max(sum_so_far, current_sum)
return sum_so_far
def pref(li):
pref_sum = [0]
for i in li:
pref_sum.append(pref_sum[-1] + i)
return pref_sum
def SieveOfEratosthenes(n):
prime = [True for i in range(n + 1)]
p = 2
li = []
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n + 1, p):
prime[i] = False
p += 1
for p in range(2, len(prime)):
if prime[p]:
li.append(p)
return li
def primefactors(n):
factors = []
while (n % 2 == 0):
factors.append(2)
n //= 2
for i in range(3, int(sqrt(n)) + 1, 2): # only odd factors left
while n % i == 0:
factors.append(i)
n //= i
if n > 2: # incase of prime
factors.append(n)
return factors
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def tr(n):
return n*(n+1)//2
boi=998244353
yr=boi-2
d=[]
p=int(10+1e5)
for i in range( p):
d.append(-1)
d[0]=1
d[1]=1
for i in range(2,p,1):
d[i]=d[i-1]*i
d[i]=d[i]%boi
def iu():
import sys
input = sys.stdin.readline
import math as my
m=so()
t=st()
op=t.count('0')
z,i=0,0
while(m>i):
if(t[i]=='0'):
i=1+i
continue
if(m-i>1 and t[1+i]=='1'):
z=1+z
i=1+i
i=1+i
bec=d[op+z]*pow(d[op],yr,boi)*pow(d[z],yr,boi)%boi
print(bec)
def main():
for i in range(so()):
iu()
# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
main()
#dmain()
# Comment Read()
``` | output | 1 | 17,923 | 15 | 35,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations. | instruction | 0 | 17,924 | 15 | 35,848 |
Tags: combinatorics, math
Correct Solution:
```
import sys
input=sys.stdin.buffer.readline
mod=998244353
def cmb(n,r):
if r<0 or r>n:
return 0
return (g1[n]*g2[r]*g2[n-r])%mod
N=300000
g1=[1]*(N+3)
for i in range(2,N+3):
g1[i]=g1[i-1]*i%mod
g2=[0]*len(g1)
g2[-1]=pow(g1[-1],mod-2,mod)
for i in range(N+1,-1,-1):
g2[i]=g2[i+1]*(i+1)%mod
inv=[0]*(N+3)
for i in range(1,N+3):
inv[i]=g2[i]*g1[i-1]%mod
for t in range(int(input())):
N=int(input())
A=list(input())[:N]
for i in range(N):
A[i]-=48
X=[0]
for i in range(N):
if A[i]:
if X[-1]==2:
X.append(0)
X[-1]+=1
else:
if X[-1]!=0:
X.append(0)
X.append(0)
if max(X)<=1:
print(1)
continue
if A[-1]^1:
del X[-1]
V=X.count(2)
W=X.count(0)
print(cmb(W+V,V))
``` | output | 1 | 17,924 | 15 | 35,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations.
Submitted Solution:
```
def comb(n, k, MOD):
if k > n // 2:
k = n - k
answer = 1
for i in range(k):
answer *= (n - i)
answer //= (i + 1)
return answer % MOD
def putin():
return map(int, input().split())
def sol():
n = int(input())
# n = 10 ** 5 - 1
A = list(input())
# A = ['0', '1', '1'] * (n // 3)
num_zeros = 0
num_pairs = 0
first = 0
for i in range(n):
if A[i] == '0':
first = 0
num_zeros += 1
else:
if first == 0:
first = 1
else:
num_pairs += 1
first = 0
print(comb(num_zeros + num_pairs, num_zeros, 998244353))
for itr in range(int(input())):
sol()
``` | instruction | 0 | 17,925 | 15 | 35,850 |
Yes | output | 1 | 17,925 | 15 | 35,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
import math
from queue import Queue
import collections
import itertools
import bisect
import heapq
# sys.setrecursionlimit(100000)
# ^^^TAKE CARE FOR MEMORY LIMIT^^^
import random
def main():
pass
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def binary(n):
return (bin(n).replace("0b", ""))
def decimal(s):
return (int(s, 2))
def pow2(n):
p = 0
while (n > 1):
n //= 2
p += 1
return (p)
def primeFactors(n):
cnt = []
while n % 2 == 0:
cnt.append(2)
n = n / 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
cnt.append(i)
n = n / i
if n > 2:
cnt.append(int(n))
return (cnt)
def primeFactorsCount(n):
cnt=0
while n % 2 == 0:
cnt+=1
n = n // 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
cnt+=1
n = n // i
if n > 2:
cnt+=1
return (cnt)
def isPrime(n):
if (n == 1):
return (False)
else:
root = int(n ** 0.5)
root += 1
for i in range(2, root):
if (n % i == 0):
return (False)
return (True)
def maxPrimeFactors(n):
maxPrime = -1
while n % 2 == 0:
maxPrime = 2
n >>= 1
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
maxPrime = i
n = n / i
if n > 2:
maxPrime = n
return int(maxPrime)
def countcon(s, i):
c = 0
ch = s[i]
for i in range(i, len(s)):
if (s[i] == ch):
c += 1
else:
break
return (c)
def lis(arr):
n = len(arr)
lis = [1] * n
for i in range(1, n):
for j in range(0, i):
if arr[i] > arr[j] and lis[i] < lis[j] + 1:
lis[i] = lis[j] + 1
maximum = 0
for i in range(n):
maximum = max(maximum, lis[i])
return maximum
def isSubSequence(str1, str2):
m = len(str1)
n = len(str2)
j = 0
i = 0
while j < m and i < n:
if str1[j] == str2[i]:
j = j + 1
i = i + 1
return j == m
def maxfac(n):
root = int(n ** 0.5)
for i in range(2, root + 1):
if (n % i == 0):
return (n // i)
return (n)
def p2(n):
c = 0
while (n % 2 == 0):
n //= 2
c += 1
return c
def seive(n):
primes = [True] * (n + 1)
primes[1] = primes[0] = False
i = 2
while (i * i <= n):
if (primes[i] == True):
for j in range(i * i, n + 1, i):
primes[j] = False
i += 1
pr = []
for i in range(0, n + 1):
if (primes[i]):
pr.append(i)
return pr
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def denofactinverse(n, m):
fac = 1
for i in range(1, n + 1):
fac = (fac * i) % m
return (pow(fac, m - 2, m))
def numofact(n, m):
fac = 1
for i in range(1, n + 1):
fac = (fac * i) % m
return (fac)
def sod(n):
s = 0
while (n > 0):
s += n % 10
n //= 10
return s
for xyz in range(0,int(input())):
mod=998244353
n=int(input())
s=input()
zc=s.count("0")
i=0
pc=0
while(i<n-1):
if(s[i]==s[i+1]=="1"):
i+=1
pc+=1
i+=1
print(ncr(zc+pc,pc,mod))
``` | instruction | 0 | 17,926 | 15 | 35,852 |
Yes | output | 1 | 17,926 | 15 | 35,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations.
Submitted Solution:
```
import sys
input = sys.stdin.readline
MX = 10**5 + 10
MOD_NUM = 998244353
F = [-1]*MX
F[0] = F[1] = 1
for x in range(2,MX):
F[x] = x * F[x-1]
F[x] %= MOD_NUM
def choose(a,b):
return F[a] * pow(F[b], MOD_NUM-2, MOD_NUM) * pow(F[a-b], MOD_NUM-2, MOD_NUM) % MOD_NUM
for _ in range(int(input())):
n = int(input())
s = input().strip()
k = 0
i = 0
while i < n:
if s[i] == "0":
i += 1
continue
if i+1 < n and s[i+1] == "1" :
k += 1
i += 1
i += 1
z = s.count("0")
print(choose(z+k,z))
``` | instruction | 0 | 17,927 | 15 | 35,854 |
Yes | output | 1 | 17,927 | 15 | 35,855 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations.
Submitted Solution:
```
def powerMod(a, b, MOD):
if b == 0:
return 1
c = powerMod(a, b//2, MOD)
c_squared = c*c % MOD
if b % 2 == 1:
return c_squared*a % MOD
else:
return c_squared
t = int(input())
MOD = 998244353
# print(t)
for d in range(t):
n = int(input())
s = input()
i = 0
zeroes = 0
pairs_of_ones = 0
# print(s, flush=True)
while i < n:
if s[i] == '0':
zeroes += 1
i += 1
elif i+1 < n and s[i+1] == '1':
pairs_of_ones += 1
i += 2
else:
i += 1
result = 1
for j in range(zeroes+1, zeroes+pairs_of_ones+1):
result = result*j % MOD
for j in range(2, pairs_of_ones+1):
result = result*powerMod(j, MOD-2, MOD) % MOD
print(result)
``` | instruction | 0 | 17,928 | 15 | 35,856 |
Yes | output | 1 | 17,928 | 15 | 35,857 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations.
Submitted Solution:
```
import math
t=int(input())
fin=0
for i in range(t):
n=int(input())
zoz=input()
k=0
z=0
c=0
j=0
while j+c<=n-1:
if zoz[j+c]=="0":
z+=1
elif j+c+1<=n-1:
if zoz[j+c+1]=="1":
k+=1
c+=1
else:
z+=1
c+=1
j+=1
print(int(math.factorial(k+z)/(math.factorial(k)*math.factorial(z))%998244353))
``` | instruction | 0 | 17,929 | 15 | 35,858 |
No | output | 1 | 17,929 | 15 | 35,859 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.